Привет!
У меня возникла идея разработать надеюсь простое решение, для ручного тестирования смарт контрактов Ethereum. Стало интересно сделать, что-то похожее на функционал вкладки Run в Remix.
Что умеет приложение:
Получился простой всё же backend, на Golang, который умеет:
- генерировать на своих эндпоинтах статические html станицы и отдавать их в браузер;
- брать настройки из toml конфига;
- подключаться к Ethereum ноде по RPC;
- превращаться в симулятор Ethereum;
- компилировать .sol файлы;
- разворачивать контракты;
- писать в контракт и читать из контракта информацию;
- делать трансфер ETH на любой Ethereum адрес;
- получать информацию о Ethereum сети, информацию из последнего блока;
- подгружать для работы несколько контрактов из одной директории, затем можно выбрать с каким конкретно контрактом вы хотите работать;
- сохраняет в куках не зашифрованную информацию;
- раз в 15 минут запрашивает приватный ключ и от имени этого пользователя выполняются операции;
- показывать информацию о текущем сеансе: текущей адрес, текущий баланс, выбранный sol файл и контракт в нем;
- строить таблицу из всех методов контракта;
Теперь по порядку:
Выбор пал на Golang из-за того, что очень понравилась кодовая база go-ethereum, на которой строится Geth.
Для генерации статических html используется стандартный Golang пакет "html/template". Тут я расписывать ничего не буду, все шаблоны можно найти в пакете templates проекта.
Для работы с Ethereum, как я написал выше, я выбрал кодовую базу go-ethereum версии 1.7.3.
Очень хотелось использовать пакет mobile из go-ethereum, но mobile какое-то время не обновлялся и в данный момент некорректно работает с текущим форматом Abi. При обработке данных вы получите похожую ошибку:
abi: cannot unmarshal *big.Int in to []interface {}Ошибку уже поправили, но в основную ветку исправление на момент когда я это пишу еще не добавили.
Я всё же выбрал другое решение, безобёрточное, т.к. функции в пакете mobile это по сути удобная обёртка над основным функционалом.
В итоге я забрал пакет для работы с abi (+ еще несколько пакетов которые зависят от abi) из go-ethereum себе в проект и добавил код из pull request.
Так как мне нужно было работать с любыми смарт контрактами, то утилита abigen, которая может формировать go пакет для работы с конкретным контрактом из sol файла, мне не подошла.
Я создал структуру, и методы для которых эта структура является приёмником (если не ошибаюсь в терминологии Golang):
type EthWorker struct {
Container string // имя файла sol, в котором находится контракт
Contract string //имя контракта
Endpoint string //метод в контракте
Key string // приватный ключ
ContractAddress string //адрес контракта
FormValues url.Values //map которая ничто иное , как POST form
New bool //разворачивается ли новый контракт
}Полный интерфейс выглядит так:
type ReadWriterEth interface {
Transact() (string, error) // писать в контракт
Call() (string, error) // читать из контракта
Deploy() (string, string, error) //развернуть контракт в сети
Info() (*Info, error) // информация об аккаунте, адрес формируется из приватного ключа
ParseInput() ([]interface{}, error) //парсить из POST формы входящие параметры для метода в слайс интерфейсов
ParseOutput([]interface{}) (string, error) //пасить из слайса интерфейсов в стоку
}Функция для записи в контракт информации:
Transact
func (w *EthWorker) Transact() (string, error) {
//парсит POST форму, метод описан ниже в статье
inputs, err := w.ParseInput()
if err != nil {
return "", errors.Wrap(err, "parse input")
}
// извлекает информацию из EthWorker и преобразует ее в правильный формат
pk := strings.TrimPrefix(w.Key, "0x")
key, err := crypto.HexToECDSA(pk)
if err != nil {
return "", errors.Wrap(err, "hex to ECDSA")
}
auth := bind.NewKeyedTransactor(key)
if !common.IsHexAddress(w.ContractAddress) {
return "", errors.New("New Address From Hex")
}
addr := common.HexToAddress(w.ContractAddress)
// создаёт инстанс контракта
contract := bind.NewBoundContract(
addr,
Containers.Containers[w.Container].Contracts[w.Contract].Abi,
Client,
Client,
)
// узнает сколько стоит Gas
gasprice, err := Client.SuggestGasPrice(context.Background())
if err != nil {
return "", errors.Wrap(err, "suggest gas price")
}
// Собирает всё в одно место
opt := &bind.TransactOpts{
From: auth.From,
Signer: auth.Signer,
GasPrice: gasprice,
GasLimit: GasLimit,
Value: auth.Value,
}
// Создает транзакцию
tr, err := contract.Transact(opt, w.Endpoint, inputs...)
if err != nil {
return "", errors.Wrap(err, "transact")
}
var receipt *types.Receipt
// в зависимости от того, используется эмулятор или реальный коннект к сети, ждем пока транзакция запишется в блок
switch v := Client.(type) {
case *backends.SimulatedBackend:
v.Commit()
receipt, err = v.TransactionReceipt(context.Background(), tr.Hash())
if err != nil {
return "", errors.Wrap(err, "transaction receipt")
}
case *ethclient.Client:
receipt, err = bind.WaitMined(context.Background(), v, tr)
if err != nil {
return "", errors.Wrap(err, "transaction receipt")
}
}
if err != nil {
return "", errors.Errorf("error transact %s: %s",
tr.Hash().String(),
err.Error(),
)
}
// собирает всё в строку
responce := fmt.Sprintf(templates.WriteResult,
tr.Nonce(),
auth.From.String(),
tr.To().String(),
tr.Value().String(),
tr.GasPrice().String(),
receipt.GasUsed.String(),
new(big.Int).Mul(receipt.GasUsed, tr.GasPrice()),
receipt.Status,
receipt.TxHash.String(),
)
return responce, nil
}Функция для чтения информации из контракта:
Call
func (w *EthWorker) Call() (string, error) {
inputs, err := w.ParseInput()
if err != nil {
return "", errors.Wrap(err, "parse input")
}
key, _ := crypto.GenerateKey()
auth := bind.NewKeyedTransactor(key)
contract := bind.NewBoundContract(
common.HexToAddress(w.ContractAddress),
Containers.Containers[w.Container].Contracts[w.Contract].Abi,
Client,
Client,
)
opt := &bind.CallOpts{
Pending: true,
From: auth.From,
}
outputs := Containers.Containers[w.Container].Contracts[w.Contract].OutputsInterfaces[w.Endpoint]
if err := contract.Call(
opt,
&outputs,
w.Endpoint,
inputs...,
); err != nil {
return "", errors.Wrap(err, "call contract")
}
result, err := w.ParseOutput(outputs)
if err != nil {
return "", errors.Wrap(err, "parse output")
}
return result, err
}Функция для развертывания контрактов:
Deploy
func (w *EthWorker) Deploy() (string, string, error) {
inputs, err := w.ParseInput()
if err != nil {
return "", "", errors.Wrap(err, "parse input")
}
pk := strings.TrimPrefix(w.Key, "0x")
key, err := crypto.HexToECDSA(pk)
if err != nil {
return "", "", errors.Wrap(err, "hex to ECDSA")
}
auth := bind.NewKeyedTransactor(key)
current_bytecode := Containers.Containers[w.Container].Contracts[w.Contract].Bin
current_abi := Containers.Containers[w.Container].Contracts[w.Contract].Abi
addr, tr, _, err := bind.DeployContract(auth, current_abi, common.FromHex(current_bytecode), Client, inputs...)
if err != nil {
log.Printf("error %s", err.Error())
return "", "", errors.Wrap(err, "deploy contract")
}
var receipt *types.Receipt
switch v := Client.(type) {
case *backends.SimulatedBackend:
v.Commit()
receipt, err = v.TransactionReceipt(context.Background(), tr.Hash())
if err != nil {
return "", "", errors.Wrap(err, "transaction receipt")
}
case *ethclient.Client:
receipt, err = bind.WaitMined(context.Background(), v, tr)
if err != nil {
return "", "", errors.Wrap(err, "transaction receipt")
}
}
if err != nil {
return "", "", errors.Errorf("error transact %s: %s",
tr.Hash().String(),
err.Error(),
)
}
responce := fmt.Sprintf(templates.DeployResult,
tr.Nonce(),
auth.From.String(),
addr.String(),
tr.GasPrice().String(),
receipt.GasUsed.String(),
new(big.Int).Mul(receipt.GasUsed, tr.GasPrice()).String(),
receipt.Status,
receipt.TxHash.String(),
)
return responce, addr.String(), nil
}Нужно было решить вопрос с тем, как из данных, введенных пользователем в форму на веб странице, получить данные, которые можно передать в функцию Call и Transact.
Я не придумал ничего лучше, как узнавать из abi метода контракта нужный тип данных для конкретного поля, и приводить к нему то, что пользователь ввел в форму на веб странице. Т.е. если какой-то тип данных я забыл, то мое решение с этим типом данных работать не будет. Нужно вносить изменения в код. Реализовал в функции ParseInput
ParseInput
func (w *EthWorker) ParseInput() ([]interface{}, error) {
// если предполагается развертывание контракта и в конструкторе контракта нет входящих параметров, то выйти из функции с нулевой ошибкой
if w.New && len(Containers.Containers[w.Container].Contracts[w.Contract].Abi.Constructor.Inputs) == 0 {
return nil, nil
}
// если не предполагается развертывание контракта и в методе нет входящих параметров, то выйти из функции с нулевой ошибкой
if !w.New && len(Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Inputs) == 0 {
return nil, nil
}
// парсим Form Values
inputsMap := make(map[int]string)
var inputsArray []int
var inputsSort []string
for k, v := range w.FormValues {
if k == "endpoint" {
continue
}
if len(v) != 1 {
return nil, errors.Errorf("incorrect %s field", k)
}
i, err := strconv.Atoi(k)
if err != nil {
continue
//return nil, errors.Wrap(err, "incorrect inputs: strconv.Atoi")
}
inputsMap[i] = v[0]
}
// если входящих параметров меньше, чем должно быть, выходим с ошибкой
if Containers.Containers[w.Container] == nil || Containers.Containers[w.Container].Contracts[w.Contract] == nil {
return nil, errors.New("input values incorrect")
}
// дополнительная проверка, т.к. структура Containers строится динамически. Наверно можно этой проверкой приберечь
if !w.New && len(Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Inputs) != 0 && Containers.Containers[w.Container].Contracts[w.Contract].InputsInterfaces[w.Endpoint] == nil {
return nil, errors.New("input values incorrect")
}
// приводим каждый входящий параметр к правильному типу. Тип данных ужнаём из ABI
var inputs_args []abi.Argument
if w.New {
inputs_args = Containers.Containers[w.Container].Contracts[w.Contract].Abi.Constructor.Inputs
} else {
inputs_args = Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Inputs
}
if len(inputsMap) != len(inputs_args) {
return nil, errors.New("len inputs_args != inputsMap: incorrect inputs")
}
for k := range inputsMap {
inputsArray = append(inputsArray, k)
}
sort.Ints(inputsArray)
for k := range inputsArray {
inputsSort = append(inputsSort, inputsMap[k])
}
var inputs_interfaces []interface{}
for i := 0; i < len(inputs_args); i++ {
arg_value := inputsMap[i]
switch inputs_args[i].Type.Type.String() {
case "bool":
var result bool
result, err := strconv.ParseBool(arg_value)
if err != nil {
return nil, errors.New("incorrect inputs")
}
inputs_interfaces = append(inputs_interfaces, result)
case "[]bool":
var result []bool
result_array := strings.Split(arg_value, ",")
for _, bool_value := range result_array {
item, err := strconv.ParseBool(bool_value)
if err != nil {
return nil, errors.Wrap(err, "incorrect inputs")
}
result = append(result, item)
}
inputs_interfaces = append(inputs_interfaces, result)
case "string":
inputs_interfaces = append(inputs_interfaces, arg_value)
case "[]string":
result_array := strings.Split(arg_value, ",") //TODO: NEED REF
inputs_interfaces = append(inputs_interfaces, result_array)
case "[]byte":
inputs_interfaces = append(inputs_interfaces, []byte(arg_value))
case "[][]byte":
var result [][]byte
result_array := strings.Split(arg_value, ",")
for _, byte_value := range result_array {
result = append(result, []byte(byte_value))
}
inputs_interfaces = append(inputs_interfaces, result)
case "common.Address":
if !common.IsHexAddress(arg_value) {
return nil, errors.New("incorrect inputs: arg_value is not address")
}
inputs_interfaces = append(inputs_interfaces, common.HexToAddress(arg_value))
case "[]common.Address":
var result []common.Address
result_array := strings.Split(arg_value, ",")
for _, addr_value := range result_array {
if !common.IsHexAddress(arg_value) {
return nil, errors.New("incorrect inputs: arg_value is not address")
}
addr := common.HexToAddress(addr_value)
result = append(result, addr)
}
inputs_interfaces = append(inputs_interfaces, result)
case "common.Hash":
if !common.IsHex(arg_value) {
return nil, errors.New("incorrect inputs: arg_value is not hex")
}
inputs_interfaces = append(inputs_interfaces, common.HexToHash(arg_value))
case "[]common.Hash":
var result []common.Hash
result_array := strings.Split(arg_value, ",")
for _, addr_value := range result_array {
if !common.IsHex(arg_value) {
return nil, errors.New("incorrect inputs: arg_value is not hex")
}
hash := common.HexToHash(addr_value)
result = append(result, hash)
}
inputs_interfaces = append(inputs_interfaces, result)
case "int8":
i, err := strconv.ParseInt(arg_value, 10, 8)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not int8")
}
inputs_interfaces = append(inputs_interfaces, int8(i))
case "int16":
i, err := strconv.ParseInt(arg_value, 10, 16)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not int16")
}
inputs_interfaces = append(inputs_interfaces, int16(i))
case "int32":
i, err := strconv.ParseInt(arg_value, 10, 32)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not int32")
}
inputs_interfaces = append(inputs_interfaces, int32(i))
case "int64":
i, err := strconv.ParseInt(arg_value, 10, 64)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not int64")
}
inputs_interfaces = append(inputs_interfaces, int64(i))
case "uint8":
i, err := strconv.ParseInt(arg_value, 10, 8)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not uint8")
}
inputs_interfaces = append(inputs_interfaces, big.NewInt(i))
case "uint16":
i, err := strconv.ParseInt(arg_value, 10, 16)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not uint16")
}
inputs_interfaces = append(inputs_interfaces, big.NewInt(i))
case "uint32":
i, err := strconv.ParseInt(arg_value, 10, 32)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not uint32")
}
inputs_interfaces = append(inputs_interfaces, big.NewInt(i))
case "uint64":
i, err := strconv.ParseInt(arg_value, 10, 64)
if err != nil {
return nil, errors.New("incorrect inputs: arg_value is not uint64")
}
inputs_interfaces = append(inputs_interfaces, big.NewInt(i))
case "*big.Int":
bi := new(big.Int)
bi, _ = bi.SetString(arg_value, 10)
if bi == nil {
return nil, errors.New("incorrect inputs: " + arg_value + " not " + inputs_args[i].Type.String())
}
inputs_interfaces = append(inputs_interfaces, bi)
case "[]*big.Int":
var result []*big.Int
result_array := strings.Split(arg_value, ",")
for _, big_value := range result_array {
bi := new(big.Int)
bi, _ = bi.SetString(big_value, 10)
if bi == nil {
return nil, errors.New("incorrect inputs: " + arg_value + " not " + inputs_args[i].Type.String())
}
result = append(result, bi)
}
inputs_interfaces = append(inputs_interfaces, result)
}
}
// возвращаем слайс интерфейсов
return inputs_interfaces, nil
}подобное преобразование я сделал для данных, которые мы получаем из Ethereum в функции ParseOutput
ParseOutput
func (w *EthWorker) ParseOutput(outputs []interface{}) (string, error) {
if len(Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Outputs) == 0 {
return "", nil
}
if Containers.Containers[w.Container] == nil || Containers.Containers[w.Container].Contracts[w.Contract] == nil {
return "", errors.New("input values incorrect")
}
if len(Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Outputs) != 0 && Containers.Containers[w.Container].Contracts[w.Contract].OutputsInterfaces[w.Endpoint] == nil {
return "", errors.New("input values incorrect")
}
output_args := Containers.Containers[w.Container].Contracts[w.Contract].Abi.Methods[w.Endpoint].Outputs
if len(outputs) != len(output_args) {
return "", errors.New("incorrect inputs")
}
var item_array []string
for i := 0; i < len(outputs); i++ {
switch output_args[i].Type.Type.String() {
case "bool":
item := strconv.FormatBool(*outputs[i].(*bool))
item_array = append(item_array, item)
case "[]bool":
boolArray := *outputs[i].(*[]bool)
var boolItems []string
for _, bool_value := range boolArray {
item := strconv.FormatBool(bool_value)
boolItems = append(boolItems, item)
}
item := "[ " + strings.Join(boolItems, ",") + " ]"
item_array = append(item_array, item)
case "string":
item_array = append(item_array, *outputs[i].(*string))
case "[]string":
array := *outputs[i].(*[]string)
var items []string
for _, value := range array {
items = append(items, value)
}
item := "[ " + strings.Join(items, ",") + " ]"
item_array = append(item_array, item)
case "[]byte":
array := *outputs[i].(*[]byte)
var items []string
for _, value := range array {
items = append(items, string(value))
}
item := "[ " + strings.Join(items, ",") + " ]"
item_array = append(item_array, item)
case "[][]byte":
array := *outputs[i].(*[][]byte)
var items string
for _, array2 := range array {
var items2 []string
for _, value := range array2 {
items2 = append(items2, string(value))
}
item2 := "[ " + strings.Join(items2, ",") + " ]"
items = items + "," + item2
}
item_array = append(item_array, items)
case "common.Address":
item := *outputs[i].(*common.Address)
item_array = append(item_array, item.String())
case "[]common.Address":
addrArray := *outputs[i].(*[]common.Address)
var addrItems []string
for _, value := range addrArray {
addrItems = append(addrItems, value.String())
}
item := "[ " + strings.Join(addrItems, ",") + " ]"
item_array = append(item_array, item)
case "common.Hash":
item := *outputs[i].(*common.Hash)
item_array = append(item_array, item.String())
case "[]common.Hash":
hashArray := *outputs[i].(*[]common.Hash)
var hashItems []string
for _, value := range hashArray {
hashItems = append(hashItems, value.String())
}
item := "[ " + strings.Join(hashItems, ",") + " ]"
item_array = append(item_array, item)
case "int8":
item := *outputs[i].(*int8)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "int16":
item := *outputs[i].(*int16)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "int32":
item := *outputs[i].(*int32)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "int64":
item := *outputs[i].(*int64)
str := strconv.FormatInt(item, 10)
item_array = append(item_array, str)
case "uint8":
item := *outputs[i].(*uint8)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "uint16":
item := *outputs[i].(*uint16)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "uint32":
item := *outputs[i].(*uint32)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "uint64":
item := *outputs[i].(*uint64)
str := strconv.FormatInt(int64(item), 10)
item_array = append(item_array, str)
case "*big.Int":
item := *outputs[i].(**big.Int)
item_array = append(item_array, item.String())
case "[]*big.Int":
bigArray := *outputs[i].(*[]*big.Int)
var items []string
for _, v := range bigArray {
items = append(items, v.String())
}
item := "[ " + strings.Join(items, ",") + " ]"
item_array = append(item_array, item)
}
}
return strings.Join(item_array, " , "), nil
}Из кодовой базы утилиты abigen, упомянутой мной ранее, я выдрал функционал по работе с Solidity компилятором. В итоге я получил abi и байткод для почти любого контракта. Реализовал в функции Bind.
Bind
func Bind(dirname, solcfile string) (*ContractContainers, error) {
result := &ContractContainers{
Containers: make(map[string]*ContractContainer),
}
allfiles, err := ioutil.ReadDir(dirname)
if err != nil {
return nil, errors.Wrap(err, "error ioutil.ReadDir")
}
for _, v := range allfiles {
if v.IsDir() {
continue
}
if hasSuffixCaseInsensitive(v.Name(), ".sol") {
contracts, err := compiler.CompileSolidity(solcfile, dirname+string(os.PathSeparator)+v.Name())
if err != nil {
return nil, errors.Wrap(err, "CompileSolidity")
}
c := &ContractContainer{
ContainerName: v.Name(),
Contracts: make(map[string]*Contract),
}
for name, contract := range contracts {
a, _ := json.Marshal(contract.Info.AbiDefinition)
ab, err := abi.JSON(strings.NewReader(string(a)))
if err != nil {
return nil, errors.Wrap(err, "abi.JSON")
}
nameParts := strings.Split(name, ":")
var ab_keys []string
ouputs_map := make(map[string][]interface{})
inputs_map := make(map[string][]interface{})
for key, method := range ab.Methods {
ab_keys = append(ab_keys, key)
var o []interface{}
var i []interface{}
for _, v := range method.Outputs {
var ar interface{}
switch v.Type.Type.String() {
case "bool":
ar = new(bool)
case "[]bool":
ar = new([]bool)
case "string":
ar = new(string)
case "[]string":
ar = new([]string)
case "[]byte":
ar = new([]byte)
case "[][]byte":
ar = new([][]byte)
case "common.Address":
ar = new(common.Address)
case "[]common.Address":
ar = new([]common.Address)
case "common.Hash":
ar = new(common.Hash)
case "[]common.Hash":
ar = new([]common.Hash)
case "int8":
ar = new(int8)
case "int16":
ar = new(int16)
case "int32":
ar = new(int32)
case "int64":
ar = new(int64)
case "uint8":
ar = new(uint8)
case "uint16":
ar = new(uint16)
case "uint32":
ar = new(uint32)
case "uint64":
ar = new(uint64)
case "*big.Int":
ar = new(*big.Int)
case "[]*big.Int":
ar = new([]*big.Int)
default:
return nil, errors.Errorf("unsupported type: %s", v.Type.Type.String())
}
o = append(o, ar)
}
ouputs_map[method.Name] = o
for _, v := range method.Inputs {
var ar interface{}
switch v.Type.Type.String() {
case "bool":
ar = new(bool)
case "[]bool":
ar = new([]bool)
case "string":
ar = new(string)
case "[]string":
ar = new([]string)
case "[]byte":
ar = new([]byte)
case "[][]byte":
ar = new([][]byte)
case "common.Address":
ar = new(common.Address)
case "[]common.Address":
ar = new([]common.Address)
case "common.Hash":
ar = new(common.Hash)
case "[]common.Hash":
ar = new([]common.Hash)
case "int8":
ar = new(int8)
case "int16":
ar = new(int16)
case "int32":
ar = new(int32)
case "int64":
ar = new(int64)
case "uint8":
ar = new(uint8)
case "uint16":
ar = new(uint16)
case "uint32":
ar = new(uint32)
case "uint64":
ar = new(uint64)
case "*big.Int":
ar = new(*big.Int)
case "[]*big.Int":
ar = new([]*big.Int)
default:
return nil, errors.Errorf("unsupported type: %s", v.Type.Type.String())
}
i = append(i, ar)
}
inputs_map[method.Name] = i
}
sort.Strings(ab_keys)
con := &Contract{
Name: nameParts[len(nameParts)-1],
Abi: ab,
AbiJson: string(a),
Bin: contract.Code,
SortKeys: ab_keys,
OutputsInterfaces: ouputs_map,
InputsInterfaces: inputs_map,
}
c.ContractNames = append(c.ContractNames, nameParts[len(nameParts)-1])
c.Contracts[nameParts[len(nameParts)-1]] = con
}
sort.Strings(c.ContractNames)
result.ContainerNames = append(result.ContainerNames, c.ContainerName)
result.Containers[c.ContainerName] = c
}
}
sort.Strings(result.ContainerNames)
return result, err
}В функции остался большой блок кода от экспериментов с пакетом mobile, удалять который я пока не стал, а просто сделал рефактор.
Я создал довольно большую структуру ContractContainers, в которую я поместил всю информация о текущих контрактах, в дальнейшем приложение берет всю информацию именно из неё.
Наконец расскажу как это работает:
Я запускал программу только на Linux. Других операционных систем рядом у меня нет.
Хотя собрал исполняемые файлы для Windows и Mac.
Для начала нужен Solidity компилятор для вашей платформы. Это наверное самый непростой пункт.
Можно Взять скомпилированный бинарник или исходники тут или посмотреть подробности вот тут. Версии 0.4.18 и 0.4.19 для linux и Windows я положил в директорию solc проекта. Так же можно воспользоваться уже установленным в системе компилятором. Чтобы проверить, есть ли в системе компилятор Solidity наберите в командной строке:
solc —versionЕсли ответ будет таким:
solc, the solidity compiler commandline interface Version: 0.4.18+commit.9cf6e910.Linux.g++, то всё хорошо.
Если будет требовать каких-то библиотек, то просто установите их, например, если Ubuntu просит это:
./solc: error while loading shared libraries: libz3.so.4: cannot open shared object file: No such file or directory, то ставим libz3-dev
Далее нужно решить в каком режиме мы будем работать с Ethereum. Есть два пути:
- подключаемся по RPC к ноде Ethereum и работаем через нее с той сетью с которой синхронизирована нода. Это удобно если у вас приватная сеть Ethereum или уже есть синхронизированная нода;
- эмулятор цепочки блоков Ethereum. Если работать в режиме эмулятора, то обязательно нужно положит в директорию keystore файлы формата UTC JSON Keystore File, где пароли для расшифровки этих файлов будут пустые;
Можно конечно сделать гораздо красивее, но для примера вполне подойдет существующее решение. Из этих файлов приложение берет Ethereum адреса и делает для них ненулевой баланс.
Я положил в директорию keystore 5 файлов для примера. Ими вполне можно пользоваться в тестовой среде.
Заполняем конфиг config.yaml:
- connect_url — url для подключения к rpc серверу Ethereum ноды. Если это поле оставить пустым, то приложение запустится в режиме эмуляции Ethereum, это как раз то, о чем я писал выше;
- sol_path — это папка со смарт контрактами, в которой приложение будет их искать. Приложение будет искать .sol файлы, которые будут находится в коревой директории. Поддиректории игнорируются. Но если ваши контракты с которыми вы будите работать ссылаются на контракты в поддиректориях, то ничего страшного, они тоже будут добавлены через контракты верхнего уровня;
- keystore_path — директория с файлами формата UTC JSON Keystore File. Напомню, что пароли для расшифровки должны быть пустыми;
- gaslimit — Лимит газа для транзакции или деплоя контракта;
- port — порт для локального http сервера;
- solc — путь до компилятора Solidity, если оставить пустым, то приложение возьмет компилятор установленный в системе;
Запускаем приложение. Путь до директории с конфигурационным файлом можно указать через флаг -config
./efront-v0.0.1-linux-amd64 -config $GOPATH/src/ethereum-front/Переходим по ссылке в браузере: по умолчанию это http://localhost:8085
Нужно ввести приватный ключ. Приватные ключи для пяти тестовых адресов можно найти в keys.txt. Этот приватный ключ будет жить в куках башего браузера 15 минут. Далее будет новый запрос. Сейчас ничего не шифруется.
select-ом выбираем контейнер (.sol файл) и контракт, который приложение в нем нашло.
Далее, можно ввести адрес уже когда-то развернутого контракта или развернуть новый, отметив соответствующий checkbox. Если checkbox Deploy в положении on, то поле с адресом игнорируется.
Если всё прошло успешно то в браузере вы увидите, подобную картину.
Если будут ошибки, то они будут выведены в textarea в верхней части интерфейса.
В верхней части страницы две ссылки login и upload.
Login перенаправляет на ввод нового приватного ключа. Upload перенаправляет на выбор контракта.
Далее идет информация о текущем сеансе:
- you address: — Ethereum адрес, который соответствует текущему приватному ключу
- balance — баланс Eth на этом адресе в текущей сети. Запрашивается при каждом обновлении страницы
- file и contract — это соответственно выбранный sol файл и контракт в нём. Сохраняется в куках и берется от туда же
- Contract address — это адрес развернутого контракта в текущей сети. Сохраняется в куках и берется от туда же
Далее идут две таблицы:
Левая таблица для работы с методами текущего контракта. Она меняется динамически, в зависимости от выбранного контракта.
Правая таблица — это общие функции для работы с Ethereum:
- Balance — поверить баланс на выбранном Ethereum адресе в текущей сети;
- Gas price — текущия цена Gas в Wei;
- Last block — номер текущего блока. Не работает в симуляторе;
- Ethereum network gas limit — Лимит gas в последнем блоке. Не работает в симуляторе;
- Ethereum network time — Время майнинга последнего блока. Не работает в симуляторе;
- Ethereum network difficulty — сложность последнего блока. Не работает в симуляторе;
- Transfer — кому и сколько Wai перевести;
- Adjust time — Управление временем в симуляторе. Нужно вводить положительное число. И именно на столько секунд увеличится время в в симуляторе;
Примечание: Когда выполняете транзакции (операции на запись в блокчейн), ждите пока загрузится страница, это может длится несколько секунд. Потому что приложение ждет пока транзакция запишется в блок.
При успешном деплое контракта, приложение в поле textarea выдаст примерно такую информацию (деплой контракта это практически обычная транзакция):
- Nonce — номер транзакции
- From — адрес инициатор транзакции
- Contract Address — адрес нового контракта
- Gas price — цена Gas
- Gas Used — цена транзакции в Gas
- Cost/Fee: цена транзакции в Wai
- Status — если статус 1, то транзакция успешно записалась в блок и выполнилась успешно, если 0, то с выполнением транзакции возникли проблемы и нужно разбиратьсяв причинах.
- Transaction Hash — хеш транзакции
Вывод информации о транзакциях при работе с контрактом примерно такой же как я описал выше.
Cделал исполняемые файлы для популярных OS. Они лежат в папке bin.
Из явных минусов хочу отметить:
- на верстку html потратил минут 5. Заранее извиняюсь перед любителями прекрасного
- в пакете front использовал функционал для работы с Ethereum, хотя его нужно было бы перенести в пакет ether, в котором как раз этот функционал и находится
- не делал тесты и не писал коментарии в коде, из-за экономии времени
Исходный код
Всем спасибо.
