func makeKey(keyType string, account *definitions.Account) error { log.WithFields(log.Fields{ "path": keys.DaemonAddr, "type": keyType, }).Debug("Sending Call to eris-keys server") var err error log.WithField("endpoint", "gen").Debug() account.Address, err = keys.Call("gen", map[string]string{"auth": "", "type": keyType, "name": account.Name}) // note, for now we use not password to lock/unlock keys if _, ok := err.(keys.ErrConnectionRefused); ok { return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err) } if err != nil { return err } log.WithField("endpoint", "pub").Debug() account.PubKey, err = keys.Call("pub", map[string]string{"addr": account.Address, "name": account.Name}) if _, ok := err.(keys.ErrConnectionRefused); ok { return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err) } if err != nil { return err } // log.WithField("endpoint", "to-mint").Debug() // mint, err := keys.Call("to-mint", map[string]string{"addr": account.Address, "name": account.Name}) log.WithField("endpoint", "mint").Debug() mint, err := keys.Call("mint", map[string]string{"addr": account.Address, "name": account.Name}) if _, ok := err.(keys.ErrConnectionRefused); ok { return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err) } if err != nil { return err } account.MintKey = &definitions.MintPrivValidator{} err = json.Unmarshal([]byte(mint), account.MintKey) if err != nil { log.Error(string(mint)) log.Error(account.MintKey) return err } account.MintKey.Address = account.Address return nil }
func txFinalize(do *definitions.Do, tx interface{}, wait bool) (string, error) { var result string erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) res, err := core.SignAndBroadcast(do.ChainID, erisNodeClient, erisKeyClient, tx.(txs.Tx), true, true, wait) if err != nil { return util.MintChainErrorHandler(do, err) } if err := util.ReadTxSignAndBroadcast(res, err); err != nil { log.Error("ERROR =>") return "", err } result = fmt.Sprintf("%X", res.Hash) return result, nil }
func RegisterNameJob(name *definitions.RegisterName, do *definitions.Do) (string, error) { // Process Variables name.DataFile, _ = util.PreProcess(name.DataFile, do) // If a data file is given it should be in csv format and // it will be read first. Once the file is parsed and sent // to the chain then a single nameRegTx will be sent if that // has been populated. if name.DataFile != "" { // open the file and use a reader fileReader, err := os.Open(name.DataFile) if err != nil { log.Error("ERROR =>") return "", err } defer fileReader.Close() r := csv.NewReader(fileReader) // loop through the records for { // Read the record record, err := r.Read() // Catch the errors if err == io.EOF { break } if err != nil { log.Error("ERROR =>") return "", err } // Sink the Amount into the third slot in the record if // it doesn't exist if len(record) <= 2 { record = append(record, name.Amount) } // Send an individual Tx for the record // [TODO]: move these to async using goroutines? r, err := registerNameTx(&definitions.RegisterName{ Source: name.Source, Name: record[0], Data: record[1], Amount: record[2], Fee: name.Fee, Nonce: name.Nonce, Wait: name.Wait, }, do) if err != nil { log.Error("ERROR =>") return "", err } n := fmt.Sprintf("%s:%s", record[0], record[1]) // TODO: fix this... simple and naive result just now. if err = util.WriteJobResultCSV(n, r); err != nil { log.Error("ERROR =>") return "", err } } } // If the data field is populated then there is a single // nameRegTx to send. So do that *now*. if name.Data != "" { return registerNameTx(name, do) } else { return "data_file_parsed", nil } }
func deployContract(deploy *definitions.Deploy, do *definitions.Do, r response.ResponseItem, p string) (string, error) { log.WithField("=>", string(r.ABI)).Debug("ABI Specification (From Compilers)") contractCode := r.Bytecode // Save ABI if _, err := os.Stat(do.ABIPath); os.IsNotExist(err) { if err := os.Mkdir(do.ABIPath, 0775); err != nil { return "", err } } // saving contract/library abi var abiLocation string if r.Objectname != "" { abiLocation = filepath.Join(do.ABIPath, r.Objectname) log.WithField("=>", abiLocation).Debug("Saving ABI") if err := ioutil.WriteFile(abiLocation, []byte(r.ABI), 0664); err != nil { return "", err } } else { log.Debug("Objectname from compilers is blank. Not saving abi.") } // saving binary if deploy.SaveBinary { contractDir := filepath.Dir(deploy.Contract) contractName := filepath.Join(contractDir, fmt.Sprintf("%s.bin", strings.TrimSuffix(deploy.Contract, filepath.Ext(deploy.Contract)))) log.WithField("=>", contractName).Info("Saving Binary") if err := ioutil.WriteFile(contractName, []byte(contractCode), 0664); err != nil { return "", err } } else { log.Debug("Not saving binary.") } // additional data may be sent along with the contract // these are naively added to the end of the contract code using standard // mint packing if deploy.Data != nil { _, callDataArray, err := util.PreProcessInputData(r.Objectname, deploy.Data, do, true) if err != nil { return "", err } packedBytes, err := util.ReadAbiFormulateCall(r.Objectname, "", callDataArray, do) if err != nil { return "", err } callData := hex.EncodeToString(packedBytes) contractCode = contractCode + callData } tx, err := deployRaw(do, deploy, r.Objectname, contractCode) if err != nil { return "", err } // Sign, broadcast, display result, err := deployFinalize(do, tx, deploy.Wait) if err != nil { return "", fmt.Errorf("Error finalizing contract deploy %s: %v", p, err) } // saving contract/library abi at abi/address if result != "" { abiLocation := filepath.Join(do.ABIPath, result) log.WithField("=>", abiLocation).Debug("Saving ABI") if err := ioutil.WriteFile(abiLocation, []byte(r.ABI), 0664); err != nil { return "", err } } else { // we shouldn't reach this point because we should have an error before this. log.Error("The contract did not deploy. Unable to save abi to abi/contractAddress.") } return result, err }
func SaveAccountResults(do *definitions.Do) error { addrFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "addresses.csv")) if err != nil { return fmt.Errorf("Error creating addresses file. This usually means that there was a problem with the chain making process.") } defer addrFile.Close() log.WithField("name", do.Name).Debug("Creating file") actFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "accounts.csv")) if err != nil { return fmt.Errorf("Error creating accounts file.") } log.WithField("path", filepath.Join(ChainsPath, do.Name, "accounts.csv")).Debug("File successfully created") defer actFile.Close() log.WithField("name", do.Name).Debug("Creating file") actJSONFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "accounts.json")) if err != nil { return fmt.Errorf("Error creating accounts file.") } log.WithField("path", filepath.Join(ChainsPath, do.Name, "accounts.json")).Debug("File successfully created") defer actJSONFile.Close() valFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "validators.csv")) if err != nil { return fmt.Errorf("Error creating validators file.") } defer valFile.Close() accountJsons := make(map[string]*accountInfo) for _, account := range do.Accounts { accountJsons[account.Name] = &accountInfo{ Address: account.Address, PubKey: account.PubKey, PrivKey: account.MintKey.PrivKey[1].(string), } _, err := addrFile.WriteString(fmt.Sprintf("%s,%s\n", account.Address, account.Name)) if err != nil { log.Error("Error writing addresses file.") return err } _, err = actFile.WriteString(fmt.Sprintf("%s,%d,%s,%d,%d\n", account.PubKey, account.Tokens, account.Name, account.MintPermissions.MintBase.MintPerms, account.MintPermissions.MintBase.MintSetBit)) if err != nil { log.Error("Error writing accounts file.") return err } if account.Validator { _, err = valFile.WriteString(fmt.Sprintf("%s,%d,%s,%d,%d\n", account.PubKey, account.ToBond, account.Name, account.MintPermissions.MintBase.MintPerms, account.MintPermissions.MintBase.MintSetBit)) if err != nil { log.Error("Error writing validators file.") return err } } } addrFile.Sync() actFile.Sync() valFile.Sync() j, err := json.MarshalIndent(accountJsons, "", " ") if err != nil { return err } _, err = actJSONFile.Write(j) if err != nil { return err } log.WithField("path", actJSONFile.Name()).Debug("Saving File.") log.WithField("path", addrFile.Name()).Debug("Saving File.") log.WithField("path", actFile.Name()).Debug("Saving File.") log.WithField("path", valFile.Name()).Debug("Saving File.") return nil }