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
logger.Infof("Sending Transaction =>\t\t%s:%s:%s\n", send.Source, send.Destination, send.Amount)
tx, err := core.Send(do.Chain, do.Signer, do.PublicKey, send.Source, send.Destination, send.Amount, send.Nonce)
if err != nil {
logger.Errorf("ERROR =>\n")
return "", 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
rebond.Account, _ = util.PreProcess(rebond.Account, do)
rebond.Height, _ = util.PreProcess(rebond.Height, do)
// 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
logger.Infof("Rebond Transaction =>\t\t%s:%s\n", rebond.Account, rebond.Height)
tx, err := core.Rebond(rebond.Account, rebond.Height)
if err != nil {
logger.Errorf("ERROR =>\n")
return "", 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 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 QueryContractJob(query *definitions.QueryContract, do *definitions.Do) (string, 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)
// Set the from and the to
fromAddrBytes, err := hex.DecodeString(query.Source)
if err != nil {
return "", err
}
toAddrBytes, err := hex.DecodeString(query.Destination)
if err != nil {
return "", err
}
// Get the packed data from the ABI functions
data, err := util.ReadAbiFormulateCall(query.Destination, query.Data, do)
if err != nil {
return "", err
}
dataBytes, err := hex.DecodeString(data)
if err != nil {
return "", err
}
// Call the client
client := cclient.NewClient(do.Chain, "HTTP")
retrn, err := client.Call(fromAddrBytes, toAddrBytes, dataBytes)
if err != nil {
return "", err
}
// Preprocess return
result, err := util.FormatOutput([]string{"return"}, 0, retrn)
if err != nil {
return "", err
}
result, err = strconv.Unquote(result)
if err != nil {
return "", err
}
// Formally process the return
logger.Debugf("Decoding Raw Result =>\t\t%s\n", result)
result, err = util.ReadAndDecodeContractReturn(query.Destination, query.Data, result, do)
if err != nil {
return "", err
}
// Finalize
logger.Printf("Return Value =>\t\t\t%s\n", result)
return result, nil
}
func QueryNameJob(query *definitions.QueryName, do *definitions.Do) (string, error) {
// Preprocess variables
query.Name, _ = util.PreProcess(query.Name, do)
query.Field, _ = util.PreProcess(query.Field, do)
// Peform query
logger.Infof("Querying Name =>\t\t%s:%s\n", query.Name, query.Field)
result, err := util.NamesInfo(query.Name, query.Field, do)
if err != nil {
return "", err
}
logger.Printf("Return Value =>\t\t\t%s\n", result)
return result, nil
}
func SetAccountJob(account *definitions.Account, do *definitions.Do) (string, error) {
var result string
var err error
// Preprocess
account.Address, _ = util.PreProcess(account.Address, do)
// Set the Account in the Package & Announce
do.Package.Account = account.Address
log.WithField("=>", do.Package.Account).Info("Setting Account")
// Set the public key from eris-keys
keys.DaemonAddr = do.Signer
log.WithField("from", keys.DaemonAddr).Info("Getting Public Key")
do.PublicKey, err = keys.Call("pub", map[string]string{"addr": do.Package.Account, "name": ""})
if _, ok := err.(keys.ErrConnectionRefused); ok {
keys.ExitConnectErr(err)
}
if err != nil {
return util.KeysErrorHandler(do, err)
}
// Set result and return
result = account.Address
return result, nil
}
func SetValJob(set *definitions.Set, do *definitions.Do) (string, error) {
var result string
set.Value, _ = util.PreProcess(set.Value, do)
logger.Infof("Setting Variable =>\t\t%s\n", set.Value)
result = set.Value
return result, nil
}
func QueryAccountJob(query *definitions.QueryAccount, do *definitions.Do) (string, error) {
// Preprocess variables
query.Account, _ = util.PreProcess(query.Account, do)
query.Field, _ = util.PreProcess(query.Field, do)
// Perform Query
logger.Infof("Querying Account =>\t\t%s:%s\n", query.Account, query.Field)
result, err := util.AccountsInfo(query.Account, query.Field, do)
if err != nil {
return "", err
}
// Result
logger.Printf("Return Value =>\t\t\t%s\n", result)
return result, nil
}
func SetValJob(set *definitions.Set, do *definitions.Do) (string, error) {
var result string
set.Value, _ = util.PreProcess(set.Value, do)
log.WithField("=>", set.Value).Info("Setting Variable")
result = set.Value
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 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
logger.Infof("Bond Transaction =>\t\t%s:%s\n", do.PublicKey, bond.Amount)
tx, err := core.Bond(do.Chain, do.Signer, do.PublicKey, bond.Account, bond.Amount, bond.Nonce)
if err != nil {
logger.Errorf("ERROR =>\n")
return "", err
}
// Sign, broadcast, display
return txFinalize(do, tx, bond.Wait)
}
func QueryAccountJob(query *definitions.QueryAccount, do *definitions.Do) (string, error) {
// Preprocess variables
query.Account, _ = util.PreProcess(query.Account, do)
query.Field, _ = util.PreProcess(query.Field, do)
// Perform Query
arg := fmt.Sprintf("%s:%s", query.Account, query.Field)
log.WithField("=>", arg).Info("Querying Account")
result, err := util.AccountsInfo(query.Account, query.Field, do)
if err != nil {
return "", err
}
// Result
if result != "" {
log.WithField("=>", result).Warn("Return Value")
} else {
log.Debug("No return.")
}
return result, nil
}
func QueryNameJob(query *definitions.QueryName, do *definitions.Do) (string, error) {
// Preprocess variables
query.Name, _ = util.PreProcess(query.Name, do)
query.Field, _ = util.PreProcess(query.Field, do)
// Peform query
log.WithFields(log.Fields{
"name": query.Name,
"field": query.Field,
}).Info("Querying")
result, err := util.NamesInfo(query.Name, query.Field, do)
if err != nil {
return "", err
}
if result != "" {
log.WithField("=>", result).Warn("Return Value")
} else {
log.Debug("No return.")
}
return result, nil
}
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)
}
// 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
logger.Infof("NameReg Transaction =>\t\t%s:%s:%s\n", name.Name, name.Data, name.Amount)
tx, err := core.Name(do.Chain, do.Signer, do.PublicKey, name.Source, name.Amount, name.Nonce, name.Fee, name.Name, name.Data)
if err != nil {
logger.Errorf("ERROR =>\n")
return "", 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 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 QueryValsJob(query *definitions.QueryVals, do *definitions.Do) (string, error) {
var result string
// Preprocess variables
query.Field, _ = util.PreProcess(query.Field, do)
// Peform query
logger.Infof("Querying Vals =>\t\t%s\n", query.Field)
result, err := util.ValidatorsInfo(query.Field, do)
if err != nil {
return "", err
}
logger.Printf("Return Value =>\t\t\t%s\n", result)
return result, nil
}
func QueryValsJob(query *definitions.QueryVals, do *definitions.Do) (string, error) {
var result string
// Preprocess variables
query.Field, _ = util.PreProcess(query.Field, do)
// Peform query
log.WithField("=>", query.Field).Info("Querying Vals")
result, err := util.ValidatorsInfo(query.Field, do)
if err != nil {
return "", err
}
if result != "" {
log.WithField("=>", result).Warn("Return Value")
} else {
log.Debug("No return.")
}
return result, 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)
// 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
logger.Infof("Setting Permissions =>\t\t%s:%v\n", perm.Action, args)
tx, err := core.Permissions(do.Chain, do.Signer, do.PublicKey, perm.Source, perm.Nonce, perm.Action, args)
if err != nil {
logger.Errorf("ERROR =>\n")
return "", err
}
// 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 CallJob(call *definitions.Call, do *definitions.Do) (string, error) {
// Preprocess variables
call.Source, _ = util.PreProcess(call.Source, do)
call.Destination, _ = util.PreProcess(call.Destination, 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)
// 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)
var err error
call.Data, err = util.ReadAbiFormulateCall(call.Destination, call.Data, do)
if err != nil {
logger.Errorf("Error Formulating Call from ABI.\n")
return "", err
}
// Don't use pubKey if account override
var oldKey string
if call.Source != do.Package.Account {
oldKey = do.PublicKey
do.PublicKey = ""
}
logger.Infof("Calling =>\t\t\t%s:%v\n", call.Destination, call.Data)
tx, err := core.Call(do.Chain, do.Signer, do.PublicKey, call.Source, call.Destination, call.Amount, call.Nonce, call.Gas, call.Fee, call.Data)
if err != nil {
return "", err
}
// Don't use pubKey if account override
if call.Source != do.Package.Account {
do.PublicKey = oldKey
}
// Sign, broadcast, display
return txFinalize(do, tx, call.Wait)
}
func DeployJob(deploy *definitions.Deploy, do *definitions.Do) (string, error) {
// Preprocess variables
deploy.Source, _ = util.PreProcess(deploy.Source, do)
deploy.Contract, _ = util.PreProcess(deploy.Contract, do)
deploy.Amount, _ = util.PreProcess(deploy.Amount, do)
deploy.Nonce, _ = util.PreProcess(deploy.Nonce, do)
deploy.Fee, _ = util.PreProcess(deploy.Fee, do)
deploy.Gas, _ = util.PreProcess(deploy.Gas, do)
// Use default
deploy.Source = useDefault(deploy.Source, do.Package.Account)
deploy.Amount = useDefault(deploy.Amount, do.DefaultAmount)
deploy.Fee = useDefault(deploy.Fee, do.DefaultFee)
deploy.Gas = useDefault(deploy.Gas, do.DefaultGas)
// assemble contract
var p string
if _, err := os.Stat(deploy.Contract); err == nil {
p = deploy.Contract
} else {
p = filepath.Join(do.ContractsPath, deploy.Contract)
}
logger.Debugf("Contract path =>\t\t%s\n", p)
// use the proper compiler
if do.Compiler != "" {
logger.Debugf("Setting compiler path =>\t%s\n", do.Compiler)
if err := setCompiler(do, p); err != nil {
return "", err
}
}
// compile
bytecode, abiSpec, err := compilers.Compile(p)
if err != nil {
return "", err
}
logger.Debugf("Abi spec =>\t\t\t%s\n", string(abiSpec))
contractCode := hex.EncodeToString(bytecode)
// Don't use pubKey if account override
var oldKey string
if deploy.Source != do.Package.Account {
oldKey = do.PublicKey
do.PublicKey = ""
}
// 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 != "" {
splitout := strings.Split(deploy.Data, " ")
for _, s := range splitout {
s, _ = util.PreProcess(s, do)
addOns := common.LeftPadString(common.StripHex(common.Coerce2Hex(s)), 64)
logger.Debugf("Contract Code =>\t\t%s\n", contractCode)
logger.Debugf("\tAdditional Data =>\t%s\n", addOns)
contractCode = contractCode + addOns
}
}
// Deploy contract
logger.Infof("Deploying Contract =>\t\t%s:%v\n", deploy.Source, contractCode)
tx, err := core.Call(do.Chain, do.Signer, do.PublicKey, deploy.Source, "", deploy.Amount, deploy.Nonce, deploy.Gas, deploy.Fee, contractCode)
if err != nil {
return "", fmt.Errorf("Error deploying contract %s: %v", p, err)
}
// Sign, broadcast, display
var result string
result, err = deployFinalize(do, tx, deploy.Wait)
// Save ABI
if _, err := os.Stat(do.ABIPath); os.IsNotExist(err) {
if err := os.Mkdir(do.ABIPath, 0775); err != nil {
return "", err
}
}
abiLocation := filepath.Join(do.ABIPath, result)
logger.Debugf("Saving ABI =>\t\t\t%s\n", abiLocation)
if err := ioutil.WriteFile(abiLocation, []byte(abiSpec), 0664); err != nil {
return "", err
}
// Don't use pubKey if account override
if deploy.Source != do.Package.Account {
do.PublicKey = oldKey
}
return result, nil
}
func AssertJob(assertion *definitions.Assert, do *definitions.Do) (string, error) {
var result string
// Preprocess variables
assertion.Key, _ = util.PreProcess(assertion.Key, do)
assertion.Relation, _ = util.PreProcess(assertion.Relation, do)
assertion.Value, _ = util.PreProcess(assertion.Value, do)
// Switch on relation
log.WithFields(log.Fields{
"key": assertion.Key,
"relation": assertion.Relation,
"value": assertion.Value,
}).Info("Assertion =>")
switch assertion.Relation {
case "==", "eq":
/*log.Debug("Compare", strings.Compare(assertion.Key, assertion.Value))
log.Debug("UTF8?: ", utf8.ValidString(assertion.Key))
log.Debug("UTF8?: ", utf8.ValidString(assertion.Value))
log.Debug("UTF8?: ", utf8.RuneCountInString(assertion.Key))
log.Debug("UTF8?: ", utf8.RuneCountInString(assertion.Value))*/
if assertion.Key == assertion.Value {
return assertPass("==", assertion.Key, assertion.Value)
} else {
return assertFail("==", assertion.Key, assertion.Value)
}
case "!=", "ne":
if assertion.Key != assertion.Value {
return assertPass("!=", assertion.Key, assertion.Value)
} else {
return assertFail("!=", assertion.Key, assertion.Value)
}
case ">", "gt":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k > v {
return assertPass(">", assertion.Key, assertion.Value)
} else {
return assertFail(">", assertion.Key, assertion.Value)
}
case ">=", "ge":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k >= v {
return assertPass(">=", assertion.Key, assertion.Value)
} else {
return assertFail(">=", assertion.Key, assertion.Value)
}
case "<", "lt":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k < v {
return assertPass("<", assertion.Key, assertion.Value)
} else {
return assertFail("<", assertion.Key, assertion.Value)
}
case "<=", "le":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k <= v {
return assertPass("<=", assertion.Key, assertion.Value)
} else {
return assertFail("<=", assertion.Key, assertion.Value)
}
}
return result, 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
}
func AssertJob(assertion *definitions.Assert, do *definitions.Do) (string, error) {
var result string
// Preprocess variables
assertion.Key, _ = util.PreProcess(assertion.Key, do)
assertion.Relation, _ = util.PreProcess(assertion.Relation, do)
assertion.Value, _ = util.PreProcess(assertion.Value, do)
// Switch on relation
logger.Infof("Assertion =>\t\t\t%s:%s:%s\n", assertion.Key, assertion.Relation, assertion.Value)
switch assertion.Relation {
case "==", "eq":
if assertion.Key == assertion.Value {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
case "!=", "ne":
if assertion.Key != assertion.Value {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
case ">", "gt":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k > v {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
case ">=", "ge":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k >= v {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
case "<", "lt":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k < v {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
case "<=", "le":
k, v, err := bulkConvert(assertion.Key, assertion.Value)
if err != nil {
return convFail()
}
if k <= v {
return assertPass()
} else {
return assertFail(assertion.Key, assertion.Value)
}
}
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 DeployJob(deploy *definitions.Deploy, do *definitions.Do) (result string, err error) {
// Preprocess variables
deploy.Source, _ = util.PreProcess(deploy.Source, do)
deploy.Contract, _ = util.PreProcess(deploy.Contract, do)
deploy.Instance, _ = util.PreProcess(deploy.Instance, do)
deploy.Libraries, _ = util.PreProcessLibs(deploy.Libraries, do)
deploy.Amount, _ = util.PreProcess(deploy.Amount, do)
deploy.Nonce, _ = util.PreProcess(deploy.Nonce, do)
deploy.Fee, _ = util.PreProcess(deploy.Fee, do)
deploy.Gas, _ = util.PreProcess(deploy.Gas, do)
// trim the extension
contractName := strings.TrimSuffix(deploy.Contract, filepath.Ext(deploy.Contract))
// Use defaults
deploy.Source = useDefault(deploy.Source, do.Package.Account)
deploy.Instance = useDefault(deploy.Instance, contractName)
deploy.Amount = useDefault(deploy.Amount, do.DefaultAmount)
deploy.Fee = useDefault(deploy.Fee, do.DefaultFee)
deploy.Gas = useDefault(deploy.Gas, do.DefaultGas)
// assemble contract
var p string
if _, err := os.Stat(deploy.Contract); err == nil {
p = deploy.Contract
} else {
p = filepath.Join(do.ContractsPath, deploy.Contract)
}
log.WithField("=>", p).Info("Contract path")
// use the proper compiler
if do.Compiler != "" {
log.WithField("=>", do.Compiler).Info("Setting compiler path")
}
// Don't use pubKey if account override
var oldKey string
if deploy.Source != do.Package.Account {
oldKey = do.PublicKey
do.PublicKey = ""
}
// compile
if filepath.Ext(deploy.Contract) == ".bin" {
log.Info("Binary file detected. Using binary deploy sequence.")
// binary deploy sequence
contractCode, err := ioutil.ReadFile(p)
if err != nil {
result := "could not read binary file"
return result, err
}
tx, err := deployRaw(do, deploy, contractName, string(contractCode))
if err != nil {
result := "could not deploy binary contract"
return result, err
}
result, err := deployFinalize(do, tx, deploy.Wait)
if err != nil {
return "", fmt.Errorf("Error finalizing contract deploy %s: %v", p, err)
}
return result, err
} else {
// normal compilation/deploy sequence
resp, err := compilers.BeginCompile(do.Compiler, p, false, deploy.Libraries)
if err != nil {
log.Errorln("Error compiling contracts: Compilers error:")
return "", err
} else if resp.Error != "" {
log.Errorln("Error compiling contracts: Language error:")
return "", fmt.Errorf("%v", resp.Error)
}
// loop through objects returned from compiler
switch {
case len(resp.Objects) == 1:
log.WithField("path", p).Info("Deploying the only contract in file")
r := resp.Objects[0]
if r.Bytecode != "" {
result, err = deployContract(deploy, do, r, p)
if err != nil {
return "", err
}
}
case deploy.Instance == "all":
log.WithField("path", p).Info("Deploying all contracts")
var baseObj string
for _, r := range resp.Objects {
if r.Bytecode == "" {
continue
}
result, err = deployContract(deploy, do, r, p)
if err != nil {
return "", err
}
if strings.ToLower(r.Objectname) == strings.ToLower(strings.TrimSuffix(filepath.Base(deploy.Contract), filepath.Ext(filepath.Base(deploy.Contract)))) {
baseObj = result
}
}
if baseObj != "" {
result = baseObj
}
default:
log.WithField("contract", deploy.Instance).Info("Deploying a single contract")
for _, r := range resp.Objects {
if r.Bytecode == "" {
continue
}
if strings.ToLower(r.Objectname) == strings.ToLower(deploy.Instance) {
result, err = deployContract(deploy, do, r, p)
if err != nil {
return "", err
}
}
}
}
}
// Don't use pubKey if account override
if deploy.Source != do.Package.Account {
do.PublicKey = oldKey
}
return result, nil
}
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
}