func BondJob(bond *definitions.Bond, do *definitions.Do) (string, error) { // Process Variables bond.Account, _ = util.PreProcess(bond.Account, do) bond.Amount, _ = util.PreProcess(bond.Amount, do) bond.PublicKey, _ = util.PreProcess(bond.PublicKey, do) // Use Defaults bond.Account = useDefault(bond.Account, do.Package.Account) do.PublicKey = useDefault(do.PublicKey, bond.PublicKey) // Formulate tx log.WithFields(log.Fields{ "public key": do.PublicKey, "amount": bond.Amount, }).Infof("Bond Transaction") erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Bond(erisNodeClient, erisKeyClient, do.PublicKey, bond.Account, bond.Amount, bond.Nonce) if err != nil { return util.MintChainErrorHandler(do, err) } // Sign, broadcast, display return txFinalize(do, tx, bond.Wait) }
func ValidatorsInfo(field string, do *definitions.Do) (string, error) { nodeClient := client.NewErisNodeClient(do.Chain) _, bondedValidators, unbondingValidators, err := nodeClient.ListValidators() if err != nil { return "", err } vals := []string{} switch strings.ToLower(field) { case "bonded_validators": for _, v := range bondedValidators { vals = append(vals, string(v.Address())) } case "unbonding_validators": for _, v := range unbondingValidators { vals = append(vals, string(v.Address())) } default: return "", fmt.Errorf("Field %s not recognized", field) } var s string s = strings.Join(vals, ",") return s, nil }
func PermissionJob(perm *definitions.Permission, do *definitions.Do) (string, error) { // Process Variables perm.Source, _ = util.PreProcess(perm.Source, do) perm.Action, _ = util.PreProcess(perm.Action, do) perm.PermissionFlag, _ = util.PreProcess(perm.PermissionFlag, do) perm.Value, _ = util.PreProcess(perm.Value, do) perm.Target, _ = util.PreProcess(perm.Target, do) perm.Role, _ = util.PreProcess(perm.Role, do) // Set defaults perm.Source = useDefault(perm.Source, do.Package.Account) log.Debug("Target: ", perm.Target) log.Debug("Marmots Deny: ", perm.Role) log.Debug("Action: ", perm.Action) // Populate the transaction appropriately var args []string switch perm.Action { case "set_global": args = []string{perm.PermissionFlag, perm.Value} case "set_base": args = []string{perm.Target, perm.PermissionFlag, perm.Value} case "unset_base": args = []string{perm.Target, perm.PermissionFlag} case "add_role", "rm_role": args = []string{perm.Target, perm.Role} } // Don't use pubKey if account override var oldKey string if perm.Source != do.Package.Account { oldKey = do.PublicKey do.PublicKey = "" } // Formulate tx arg := fmt.Sprintf("%s:%s", args[0], args[1]) log.WithField(perm.Action, arg).Info("Setting Permissions") erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Permissions(erisNodeClient, erisKeyClient, do.PublicKey, perm.Source, perm.Nonce, perm.Action, args) if err != nil { return util.MintChainErrorHandler(do, err) } log.Debug("What are the args returned in transaction: ", tx.PermArgs) // Don't use pubKey if account override if perm.Source != do.Package.Account { do.PublicKey = oldKey } // Sign, broadcast, display return txFinalize(do, tx, perm.Wait) }
func GetBlockHeight(do *definitions.Do) (latestBlockHeight int, err error) { nodeClient := client.NewErisNodeClient(do.Chain) // NOTE: NodeInfo is no longer exposed through Status(); // other values are currentlu not used by e-pm _, _, _, latestBlockHeight, _, err = nodeClient.Status() if err != nil { return 0, err } // set return values return }
// TODO: it is unpreferable to mix static and non-static use of Do func GetChainID(do *definitions.Do) error { if do.ChainID == "" { nodeClient := client.NewErisNodeClient(do.Chain) _, chainId, _, err := nodeClient.ChainId() if err != nil { return err } do.ChainID = chainId log.WithField("=>", do.ChainID).Info("Using ChainID from Node") } 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 }
// Runs an individual nametx. func registerNameTx(name *definitions.RegisterName, do *definitions.Do) (string, error) { // Process Variables name.Source, _ = util.PreProcess(name.Source, do) name.Name, _ = util.PreProcess(name.Name, do) name.Data, _ = util.PreProcess(name.Data, do) name.Amount, _ = util.PreProcess(name.Amount, do) name.Fee, _ = util.PreProcess(name.Fee, do) // Set Defaults name.Source = useDefault(name.Source, do.Package.Account) name.Fee = useDefault(name.Fee, do.DefaultFee) name.Amount = useDefault(name.Amount, do.DefaultAmount) // Don't use pubKey if account override var oldKey string if name.Source != do.Package.Account { oldKey = do.PublicKey do.PublicKey = "" } // Formulate tx log.WithFields(log.Fields{ "name": name.Name, "data": name.Data, "amount": name.Amount, }).Info("NameReg Transaction") erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Name(erisNodeClient, erisKeyClient, do.PublicKey, name.Source, name.Amount, name.Nonce, name.Fee, name.Name, name.Data) if err != nil { return util.MintChainErrorHandler(do, err) } // Don't use pubKey if account override if name.Source != do.Package.Account { do.PublicKey = oldKey } // Sign, broadcast, display return txFinalize(do, tx, name.Wait) }
func NamesInfo(name, field string, do *definitions.Do) (string, error) { nodeClient := client.NewErisNodeClient(do.Chain) owner, data, expirationBlock, err := nodeClient.GetName(name) if err != nil { return "", err } switch strings.ToLower(field) { case "name": return name, nil case "owner": return string(owner), nil case "data": return data, nil case "expires": return strconv.Itoa(expirationBlock), nil default: return "", fmt.Errorf("Field %s not recognized", field) } }
func AccountsInfo(account, field string, do *definitions.Do) (string, error) { addrBytes, err := hex.DecodeString(account) if err != nil { return "", fmt.Errorf("Account Addr %s is improper hex: %v", account, err) } nodeClient := client.NewErisNodeClient(do.Chain) r, err := nodeClient.GetAccount(addrBytes) if err != nil { return "", err } if r == nil { return "", fmt.Errorf("Account %s does not exist", account) } var s string if strings.Contains(field, "permissions") { // TODO: [ben] resolve conflict between explicit types and json better fields := strings.Split(field, ".") if len(fields) > 1 { switch fields[1] { case "roles": s = strings.Join(r.Permissions.Roles, ",") case "base", "perms": s = strconv.Itoa(int(r.Permissions.Base.Perms)) case "set": s = strconv.Itoa(int(r.Permissions.Base.SetBit)) } } } else if field == "balance" { s = strconv.Itoa(int(r.Balance)) } if err != nil { return "", err } return s, nil }
func deployRaw(do *definitions.Do, deploy *definitions.Deploy, contractName, contractCode string) (*txs.CallTx, error) { // Deploy contract log.WithFields(log.Fields{ "name": contractName, }).Warn("Deploying Contract") log.WithFields(log.Fields{ "source": deploy.Source, "code": contractCode, }).Info() erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Call(erisNodeClient, erisKeyClient, do.PublicKey, deploy.Source, "", deploy.Amount, deploy.Nonce, deploy.Gas, deploy.Fee, contractCode) if err != nil { return &txs.CallTx{}, fmt.Errorf("Error deploying contract %s: %v", contractName, err) } return tx, err }
func SendJob(send *definitions.Send, do *definitions.Do) (string, error) { // Process Variables send.Source, _ = util.PreProcess(send.Source, do) send.Destination, _ = util.PreProcess(send.Destination, do) send.Amount, _ = util.PreProcess(send.Amount, do) // Use Default send.Source = useDefault(send.Source, do.Package.Account) // Don't use pubKey if account override var oldKey string if send.Source != do.Package.Account { oldKey = do.PublicKey do.PublicKey = "" } // Formulate tx log.WithFields(log.Fields{ "source": send.Source, "destination": send.Destination, "amount": send.Amount, }).Info("Sending Transaction") erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Send(erisNodeClient, erisKeyClient, do.PublicKey, send.Source, send.Destination, send.Amount, send.Nonce) if err != nil { return util.MintChainErrorHandler(do, err) } // Don't use pubKey if account override if send.Source != do.Package.Account { do.PublicKey = oldKey } // Sign, broadcast, display return txFinalize(do, tx, send.Wait) }
func CallJob(call *definitions.Call, do *definitions.Do) (string, []*definitions.Variable, error) { var err error var callData string var callDataArray []string // Preprocess variables call.Source, _ = util.PreProcess(call.Source, do) call.Destination, _ = util.PreProcess(call.Destination, do) //todo: find a way to call the fallback function here call.Function, callDataArray, err = util.PreProcessInputData(call.Function, call.Data, do, false) if err != nil { return "", make([]*definitions.Variable, 0), err } call.Function, _ = util.PreProcess(call.Function, do) call.Amount, _ = util.PreProcess(call.Amount, do) call.Nonce, _ = util.PreProcess(call.Nonce, do) call.Fee, _ = util.PreProcess(call.Fee, do) call.Gas, _ = util.PreProcess(call.Gas, do) call.ABI, _ = util.PreProcess(call.ABI, do) // Use default call.Source = useDefault(call.Source, do.Package.Account) call.Amount = useDefault(call.Amount, do.DefaultAmount) call.Fee = useDefault(call.Fee, do.DefaultFee) call.Gas = useDefault(call.Gas, do.DefaultGas) // formulate call var packedBytes []byte if call.ABI == "" { packedBytes, err = util.ReadAbiFormulateCall(call.Destination, call.Function, callDataArray, do) callData = hex.EncodeToString(packedBytes) } else { packedBytes, err = util.ReadAbiFormulateCall(call.ABI, call.Function, callDataArray, do) callData = hex.EncodeToString(packedBytes) } if err != nil { if call.Function == "()" { log.Warn("Calling the fallback function") } else { var str, err = util.ABIErrorHandler(do, err, call, nil) return str, make([]*definitions.Variable, 0), err } } // Don't use pubKey if account override var oldKey string if call.Source != do.Package.Account { oldKey = do.PublicKey do.PublicKey = "" } log.WithFields(log.Fields{ "destination": call.Destination, "function": call.Function, "data": callData, }).Info("Calling") erisNodeClient := client.NewErisNodeClient(do.Chain) erisKeyClient := keys.NewErisKeyClient(do.Signer) tx, err := core.Call(erisNodeClient, erisKeyClient, do.PublicKey, call.Source, call.Destination, call.Amount, call.Nonce, call.Gas, call.Fee, callData) if err != nil { return "", make([]*definitions.Variable, 0), err } // Don't use pubKey if account override if call.Source != do.Package.Account { do.PublicKey = oldKey } // Sign, broadcast, display res, err := core.SignAndBroadcast(do.ChainID, erisNodeClient, erisKeyClient, tx, true, true, call.Wait) if err != nil { var str, err = util.MintChainErrorHandler(do, err) return str, make([]*definitions.Variable, 0), err } txResult := res.Return var result string log.Debug(txResult) // Formally process the return if txResult != nil { log.WithField("=>", result).Debug("Decoding Raw Result") if call.ABI == "" { call.Variables, err = util.ReadAndDecodeContractReturn(call.Destination, call.Function, txResult, do) } else { call.Variables, err = util.ReadAndDecodeContractReturn(call.ABI, call.Function, txResult, do) } if err != nil { return "", make([]*definitions.Variable, 0), err } log.WithField("=>", call.Variables).Debug("call variables:") result = util.GetReturnValue(call.Variables) if result != "" { log.WithField("=>", result).Warn("Return Value") } else { log.Debug("No return.") } } else { log.Debug("No return from contract.") } if call.Save == "tx" { log.Info("Saving tx hash instead of contract return") result = fmt.Sprintf("%X", res.Hash) } return result, call.Variables, nil }
func QueryContractJob(query *definitions.QueryContract, do *definitions.Do) (string, []*definitions.Variable, error) { // Preprocess variables. We don't preprocess data as it is processed by ReadAbiFormulateCall query.Source, _ = util.PreProcess(query.Source, do) query.Destination, _ = util.PreProcess(query.Destination, do) query.ABI, _ = util.PreProcess(query.ABI, do) var queryDataArray []string var err error query.Function, queryDataArray, err = util.PreProcessInputData(query.Function, query.Data, do, false) if err != nil { return "", make([]*definitions.Variable, 0), err } // Set the from and the to fromAddrBytes, err := hex.DecodeString(query.Source) if err != nil { return "", make([]*definitions.Variable, 0), err } toAddrBytes, err := hex.DecodeString(query.Destination) if err != nil { return "", make([]*definitions.Variable, 0), err } // Get the packed data from the ABI functions var data string var packedBytes []byte if query.ABI == "" { packedBytes, err = util.ReadAbiFormulateCall(query.Destination, query.Function, queryDataArray, do) data = hex.EncodeToString(packedBytes) } else { packedBytes, err = util.ReadAbiFormulateCall(query.ABI, query.Function, queryDataArray, do) data = hex.EncodeToString(packedBytes) } if err != nil { var str, err = util.ABIErrorHandler(do, err, nil, query) return str, make([]*definitions.Variable, 0), err } dataBytes, err := hex.DecodeString(data) if err != nil { return "", make([]*definitions.Variable, 0), err } // Call the client nodeClient := client.NewErisNodeClient(do.Chain) result, _, err := nodeClient.QueryContract(fromAddrBytes, toAddrBytes, dataBytes) if err != nil { return "", make([]*definitions.Variable, 0), err } // Formally process the return log.WithField("res", result).Debug("Decoding Raw Result") if query.ABI == "" { log.WithField("abi", query.Destination).Debug() query.Variables, err = util.ReadAndDecodeContractReturn(query.Destination, query.Function, result, do) } else { log.WithField("abi", query.ABI).Debug() query.Variables, err = util.ReadAndDecodeContractReturn(query.ABI, query.Function, result, do) } if err != nil { return "", make([]*definitions.Variable, 0), err } result2 := util.GetReturnValue(query.Variables) // Finalize if result2 != "" { log.WithField("=>", result2).Warn("Return Value") } else { log.Debug("No return.") } return result2, query.Variables, nil }