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 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
}