def verifySignature(ontId,
keyNum,
public_key,
node_index=None,
errorcode=47001):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"method": "verifySignature",
"address": "0300000000000000000000000000000000000000",
"version": 1,
"params": [ontId, keyNum]
}
},
"RESPONSE": {
"error": errorcode
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Common.ontid_map[public_key]
request["NODE_INDEX"] = node_index
return call_contract(Task(name="verifySignature", ijson=request),
twice=True)
def getmerkleproofbytxhash(self, _hash):
task = Task(Config.BASEAPI_PATH + "/restful/get_merkle_proof.json")
task.set_type("restful")
taskrequest = task.request()
taskrequest["api"] = "/api/v1/merkleproof/" + str(_hash)
task.set_request(taskrequest)
return TaskRunner.run_single_task(task)
def getbestblockhash(self):
task = Task(Config.BASEAPI_PATH + "/rpc/getbestblockhash.json")
taskrequest = task.request()
params = []
taskrequest["params"] = params
task.set_request(taskrequest)
return TaskRunner.run_single_task(task)
def invoke_function_commitDpos(nodeIndex=0,
sig_num=ADMIN_NUM,
sig_pubkeys=ADMIN_PUBLIST):
request = {
"NODE_INDEX": nodeIndex,
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": "commitDpos",
"version": 0,
"params": []
}
},
"RESPONSE": {
"error": 0
}
}
return multi_contract(
Task(name="invoke_function_commitDpos", ijson=request), sig_num,
sig_pubkeys)
def getcontract(self, script_hash):
task = Task(Config.BASEAPI_PATH + "/restful/get_contract_state.json")
task.set_type("restful")
taskrequest = task.request()
taskrequest["api"] = "/api/v1/contract/" + str(script_hash)
task.set_request(taskrequest)
return TaskRunner.run_single_task(task)
def balanceOf(contract_address, address, node_index=None, errorcode=47001):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": "balanceOf"
}, {
"type":
"array",
"value": [{
"type":
"bytearray",
"value":
script_hash_bl_reserver(base58_to_address(address))
}]
}]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
return call_contract(Task(name="balanceOf", ijson=request), twice=True)
def invoke_function_vote(walletAddress,
voteList,
voteCount,
errorcode=0,
node_index=None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": "voteForPeer",
"version": 0,
"params": [walletAddress, voteList, voteCount]
}
},
"RESPONSE": {
"error": errorcode
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
for node in Config.NODES:
if node["address"] == walletAddress:
request["NODE_INDEX"] = Config.NODES.index(node)
break
return call_contract(Task(name="invoke_function_vote", ijson=request),
twice=True)
def invoke_function_test(contract_address, function_str, argvs = [{"type": "string","value": ""}], node_index = None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 1,
"params": [
{
"type": "string",
"value": function_str
},
{
"type": "array",
"value": argvs
}
]
}
},
"RESPONSE":{"error" : 0}
}
return call_contract(Task(name="invoke_function_test", ijson=request), twice = True)
def invoke_function_update(func_,param0,param1,param2,param3,param4,param5,param6,param7,errorcode=47001):
if(func_=="updateConfig"):
filename="vbftConfig"
else:
filename="globalParam"
getStorageConf(filename)
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": func_,
"version": 0,
"params": [
param0,
param1,
param2,
param3,
param4,
param5,
param6,
param7
]
}
},
"RESPONSE":{"error" : errorcode}
}
(result,response)= multi_contract(Task(name="invoke_function_update", ijson=request),Common.AdminNum,Common.AdminPublicKeyList)
time.sleep(5)
getStorageConf(filename)
return (result,response)
def bind_user_role(contract_address, admin_address, role_str, ontIDs, public_key="1", node_index = None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0600000000000000000000000000000000000000",
"method": "assignOntIDsToRole",
"version": 0,
"params": [
contract_address,
admin_address,
role_str,
ontIDs,
public_key
]
}
},
"RESPONSE":{"error" : 0}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Common.ontid_map[admin_address]
request["NODE_INDEX"] = node_index
return call_contract(Task(name="bind_user_role", ijson=request), twice = True)
def withdraw_user_role(contract_address, call_user, delegate_user, delegate_role, public_key="1", node_index = None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0600000000000000000000000000000000000000",
"method": "withdraw",
"version": 0,
"params": [
contract_address,
call_user,
delegate_user,
delegate_role,
public_key
]
}
},
"RESPONSE":{"error" : 0}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Common.ontid_map[call_user]
request["NODE_INDEX"] = node_index
return call_contract(Task(name="withdraw_user_role", ijson=request), twice = True)
def invoke_function_TransferPenalty(func_,
pubKey,
walletAddress,
errorcode=47001):
request = {
"NODE_INDEX": 0,
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": func_,
"version": 0,
"params": [pubKey, walletAddress]
}
},
"RESPONSE": {
"error": errorcode
}
}
return multi_contract(
Task(name="invoke_function_TransferPenalty", ijson=request),
Common.AdminNum, Common.AdminPublicKeyList)
def invoke_function_vote(func_,
walletAddress,
voteList,
voteCount,
errorcode=47001,
node_index=None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": func_,
"version": 0,
"params": [walletAddress, voteList, voteCount]
}
},
"RESPONSE": {
"error": errorcode
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
return call_contract(Task(name="invoke_function_vote", ijson=request),
twice=True)
def multi_contract(task, m, pubkeyArray):
(result,
response) = sign_transction(task) #Task(name="multi", ijson=request))
signed_tx = response["result"]["signed_tx"]
request1 = {
"REQUEST": {
"qid": "1",
"method": "sigmutilrawtx",
"params": {
"raw_tx": signed_tx,
"m": m,
"pub_keys": pubkeyArray
}
},
"RESPONSE": {}
}
print(request1)
request1["NODE_INDEX"] = task.node_index()
(result,
response) = sign_multi_transction(Task(name="multi", ijson=request1))
print(response)
signed_tx = response["result"]["signed_tx"]
print(signed_tx)
call_signed_contract(signed_tx, True)
return call_signed_contract(signed_tx, False)
def native_transfer_ong(pay_address,
get_address,
amount,
node_index=None,
errorcode=47001):
_amount = int(amount) * 1000000000
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0200000000000000000000000000000000000000",
"method": "transfer",
"version": 1,
"params": [[[pay_address, get_address,
str(_amount)]]]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
return call_contract(Task(name="transfer", ijson=request), twice=True)
def invoke_function_register(func_,pubKey,walletAddress,ontCount,ontID,user,errorcode = 47001):
request = {
"NODE_INDEX":7,
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": func_,
"version": 0,
"params": [
pubKey,
walletAddress,
ontCount,
ontID,
user
]
}
},
"RESPONSE":{"error" : errorcode}
}
return call_contract(Task(name="invoke_function_register", ijson=request), twice = True)
def getMaxBlockChangeView():
getbalance = Task("../utils/api/requests/rpc/getstorage.json")
contract_address = "0200000000000000000000000000000000000000"
key = "79626674436f6e666967"
getbalance.data()["REQUEST"]["params"] = [contract_address, key]
(result, response) = run_single_task(getbalance, True, False)
return int(response["result"]["ont"])
def native_transfer_multi(pay_address,get_address,amount, node_index = None,errorcode=47001):
amount=amount*1000000000
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0100000000000000000000000000000000000000",
"method": "transfer",
"version": 1,
"params": [[
pay_address,
get_address,
str(amount)
]]
}
},
"RESPONSE":{"error" : errorcode},
}
return call_contract(Task(name="transfer", ijson=request), twice = True)
#InResponse={}
#getStorageVoteInfo(Config.NODES[0]["pubkey"],Config.NODES[7]["address"])
#getStorageVoteInfo(Config.NODES[0]["pubkey"],Config.NODES[7]["address"])
#nodeCountCheck(InResponse,7)
#getStorageConf("vbftConfig")
#getStorageConf("globalParam")
#getStorageConf("splitCurve")
def allowance1(contract_address,
pay_address,
get_address,
node_index=None,
errorcode=47001,
errorkey="error"):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0200000000000000000000000000000000000000",
"method": "allowance",
"version": 1,
"params": [pay_address, get_address]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
if (errorkey == "error_code"):
request["SIGN_RESPONSE"] = {errorkey: errorcode}
return call_contract(Task(name="allowance", ijson=request), twice=True)
def test_004(self):
priceTest = 366780
log_path = "test_004.log"
task_name = "test_004"
self.start(log_path)
(result1, response) = rpcapiTest.getbalance(address)
print(result1)
print(response["result"])
ong1 = int(response["result"]["ong"])
ont1 = response["result"]["ont"]
task = Task(filterfile)
(result, response) = call_contract(task, pre=False)
(result1, response) = rpcapiTest.getbalance(address)
ong2 = int(response["result"]["ong"])
ont2 = response["result"]["ont"]
print(ong1 - ong2 == (priceTest))
print(priceTest)
print(ong1 - ong2)
if (ong1 - ong2 == (priceTest)):
result = True
else:
result = False
#print(ong,ont)
self.finish(task_name, log_path, result, "")
def invoke_function_register(pubKey,
walletAddress,
ontCount,
ontID,
user,
node_index=None):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": "0700000000000000000000000000000000000000",
"method": "registerCandidate",
"version": 0,
"params": [pubKey, walletAddress, ontCount, ontID, user]
}
},
"RESPONSE": {
"error": 0
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Config.ontid_map[ontID]
request["NODE_INDEX"] = node_index
return call_contract(Task(name="invoke_function_register", ijson=request),
twice=True)
def invoke_func_with_0_param(contract_address, func_name, node_index = None):
request = {
"DEPLOY" : False,
"CODE_PATH" : "tasks/neo.neo",
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 0,
"params": [
{
"type": "string",
"value": func_name
},
{
"type": "array",
"value": [{
"type": "string",
"value": ""
}]
}
]
}
},
"RESPONSE": {}
}
return call_contract(Task(name="init_admin", ijson=request), twice = True)
def getbalance(self, addr):
task = Task(Config.BASEAPI_PATH + "/restful/get_balance.json")
task.set_type("restful")
taskrequest = task.request()
taskrequest["api"] = "/api/v1/balance/" + str(addr)
task.set_request(taskrequest)
return TaskRunner.run_single_task(task)
def get_block(contract_address, block_hash, node_index = None):
request = {
"DEPLOY" : True,
"CODE_PATH" : "tasks/neo.neo",
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"address": contract_address,
"version": 0,
"params": [
{
"type": "string",
"value": "GetBlock"
},
{
"type": "array",
"value": [{
"type": "bytearray",
"value": block_hash
}]
}
]
}
},
"RESPONSE": {}
}
return call_contract(Task(name="init_admin", ijson=request), twice = True)
def getsmartcodeeventbyhash(self, txhash):
task = Task(Config.BASEAPI_PATH + "/restful/get_smtcode_evts.json")
task.set_type("restful")
taskrequest = task.request()
taskrequest["api"] = "/api/v1/smartcode/event/txhash/" + str(txhash)
task.set_request(taskrequest)
return TaskRunner.run_single_task(task)
def invoke_function_update(func_, param0, param1, param2, param3, param4,
param5, param6, param7):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
"0700000000000000000000000000000000000000",
"method":
func_,
"version":
0,
"params": [
param0, param1, param2, param3, param4, param5, param6,
param7
]
}
},
"RESPONSE": {
"error": 0
}
}
(result, response) = multi_contract(
Task(name="invoke_function_update", ijson=request), Common.AdminNum,
Common.AdminPublicKeyList)
time.sleep(5)
return (result, response)
def getKeyState(ontId,
keyNum,
public_key,
node_index=None,
errorcode=47001,
resultStr=""):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signativeinvoketx",
"Params": {
"gas_price": 0,
"gas_limit": 1000000000,
"method": "getKeyState",
"address": "0300000000000000000000000000000000000000",
"version": 1,
"params": [ontId, keyNum]
}
},
"RESPONSE": {
"error": errorcode,
"result": {
"Result": ByteToHex(resultStr.encode("utf-8"))
}
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Common.ontid_map[public_key]
request["NODE_INDEX"] = node_index
return call_contract(Task(name="getKeyState", ijson=request), twice=True)
def forNeo(contract_address,
functionName,
params,
public_key,
node_index=None,
recovery_address_Array=[]):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": functionName
}, {
"type": "array",
"value": params
}]
}
},
"RESPONSE": {
"error": 0
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Config.ontid_map[public_key]
request["NODE_INDEX"] = node_index
if functionName == "changeRecovery":
return API.contract().call_multisig_contract(
Task(name="forNeo", ijson=request), recovery_address_Array[0],
recovery_address_Array[1])
else:
return API.contract().call_contract(Task(name="forNeo", ijson=request),
twice=True,
sleep=2)
def invoke_function(self,
contract_address,
function_str,
callerOntID,
public_key="1",
argvs=[{
"type": "string",
"value": ""
}],
node_index=None,
sleep=5,
check_state=True):
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": function_str
}, {
"type":
"array",
"value": [{
"type": "bytearray",
"value": callerOntID
}, {
"type": "int",
"value": public_key
}]
}, {
"type": "array",
"value": argvs
}]
}
},
"RESPONSE": {
"error": 0
}
}
if node_index != None:
request["NODE_INDEX"] = node_index
else:
node_index = Config.ontid_map[callerOntID]
request["NODE_INDEX"] = node_index
return self.call_contract(Task(name="invoke_function", ijson=request),
twice=True,
sleep=sleep,
check_state=check_state)
def transferFrom(contract_address,
sender,
pay_address,
get_address,
amount,
node_index=None,
senderType=False,
errorcode=47001,
errorkey="error"):
if not senderType:
sender = script_hash_bl_reserver(base58_to_address(sender))
getaddress = sender
else:
getaddress = script_hash_bl_reserver(base58_to_address(get_address))
request = {
"REQUEST": {
"Qid": "t",
"Method": "signeovminvoketx",
"Params": {
"gas_price":
0,
"gas_limit":
1000000000,
"address":
contract_address,
"version":
1,
"params": [{
"type": "string",
"value": "transferFrom"
}, {
"type":
"array",
"value": [{
"type": "bytearray",
"value": sender
}, {
"type":
"bytearray",
"value":
script_hash_bl_reserver(base58_to_address(pay_address))
}, {
"type": "bytearray",
"value": getaddress
}, {
"type": "int",
"value": amount
}]
}]
}
},
"RESPONSE": {
"error": errorcode
},
"NODE_INDEX": node_index
}
if (errorkey == "error_code"):
request["SIGN_RESPONSE"] = {errorkey: errorcode}
return call_contract(Task(name="transferFrom", ijson=request), twice=True)
