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 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 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 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 RebondJob(rebond *definitions.Rebond, do *definitions.Do) (string, error) {
// Process Variables
var err error
rebond.Account, err = util.PreProcess(rebond.Account, do)
rebond.Height, err = util.PreProcess(rebond.Height, do)
if err != nil {
return "", err
}
// Use defaults
rebond.Account = useDefault(rebond.Account, do.Package.Account)
// Don't use pubKey if account override
var oldKey string
if rebond.Account != do.Package.Account {
oldKey = do.PublicKey
do.PublicKey = ""
}
// Formulate tx
log.WithFields(log.Fields{
"account": rebond.Account,
"height": rebond.Height,
}).Info("Rebond Transaction")
tx, err := core.Rebond(rebond.Account, rebond.Height)
if err != nil {
return util.MintChainErrorHandler(do, err)
}
// Don't use pubKey if account override
if rebond.Account != do.Package.Account {
do.PublicKey = oldKey
}
// Sign, broadcast, display
return txFinalize(do, tx, rebond.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
}