def runRawTransaction(operation, args):
invocation_tx = InvocationTransaction()
smartcontract_scripthash = UInt160.ParseString(CONTRACT_HASH)
sb = ScriptBuilder()
sb.EmitAppCallWithOperationAndArgs(
smartcontract_scripthash,
operation,
args)
invocation_tx.Script = binascii.unhexlify(sb.ToArray())
wallet = UserWallet.Create(
'neo-privnet.wallet', to_aes_key('coz'), generate_default_key=False)
private_key = KeyPair.PrivateKeyFromWIF(
"KxDgvEKzgSBPPfuVfw67oPQBSjidEiqTHURKSDL1R7yGaGYAeYnr")
wallet.CreateKey(private_key)
context = ContractParametersContext(invocation_tx)
wallet.Sign(context)
invocation_tx.scripts = context.GetScripts()
raw_tx = invocation_tx.ToArray()
payload = {"jsonrpc": "2.0", "id": 1,
"method": "sendrawtransaction",
"params": [raw_tx.decode("ascii")]}
res = requests.post(
"http://neo-nodes:30333/testNeoConnection", json=payload)
print("received POST result")
print(res.status_code)
result = res.text
print(result)
return result
def create_raw_sc_method_call_tx(
source_address,
source_address_wif,
smartcontract_scripthash,
smartcontract_method,
smartcontract_method_args,
):
source_script_hash = address_to_scripthash(source_address)
# start by creating a base InvocationTransaction
# the inputs, outputs and Type do not have to be set anymore.
invocation_tx = InvocationTransaction()
# often times smart contract developers use the function ``CheckWitness`` to determine if the transaction is signed by somebody eligible of calling a certain method
# in order to pass that check you want to add the corresponding script_hash as a transaction attribute (this is generally the script_hash of the public key you use for signing)
# Note that for public functions like the NEP-5 'getBalance' and alike this would not be needed, but it doesn't hurt either
invocation_tx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=source_script_hash))
smartcontract_scripthash = UInt160.ParseString(smartcontract_scripthash)
# next we need to build a 'script' that gets executed against the smart contract.
# this is basically the script that calls the entry point of the contract with the necessary parameters
sb = ScriptBuilder()
# call the method on the contract (assumes contract address is a NEP-5 token)
sb.EmitAppCallWithOperationAndArgs(
smartcontract_scripthash,
smartcontract_method,
smartcontract_method_args,
)
invocation_tx.Script = binascii.unhexlify(sb.ToArray())
# at this point we've build our unsigned transaction and it's time to sign it before we get the raw output that we can send to the network via RPC
# we need to create a Wallet instance for helping us with signing
wallet = UserWallet.Create('path',
to_aes_key('mypassword'),
generate_default_key=False)
# if you have a WIF use the following
# this WIF comes from the `neo-test1-w.wallet` fixture wallet
private_key = KeyPair.PrivateKeyFromWIF(source_address_wif)
# if you have a NEP2 encrypted key use the following instead
# private_key = KeyPair.PrivateKeyFromNEP2("NEP2 key string", "password string")
# we add the key to our wallet
wallet.CreateKey(private_key)
# and now we're ready to sign
context = ContractParametersContext(invocation_tx)
wallet.Sign(context)
invocation_tx.scripts = context.GetScripts()
raw_tx = invocation_tx.ToArray()
print(raw_tx)
return raw_tx.decode()
def test_check_invocation_tx_size(self):
""" See original test here
https://github.com/neo-project/neo/blob/master/neo.UnitTests/UT_InvocationTransaction.cs#L52-L69
"""
i_tx = InvocationTransaction()
val = GetByteArray(32, 0x42)
i_tx.Script = val
self.assertEqual(i_tx.Version, 0)
self.assertEqual(len(i_tx.Script), 32)
self.assertEqual(GetVarSize(i_tx.Script), 33)
self.assertEqual(i_tx.Size(), 39)
def example2():
source_address = "AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3"
source_script_hash = address_to_scripthash(source_address)
# start by creating a base InvocationTransaction
# the inputs, outputs and Type do not have to be set anymore.
invocation_tx = InvocationTransaction()
# Since we are building a raw transaction, we will add the raw_tx flag
invocation_tx.raw_tx = True
# often times smart contract developers use the function ``CheckWitness`` to determine if the transaction is signed by somebody eligible of calling a certain method
# in order to pass that check you want to add the corresponding script_hash as a transaction attribute (this is generally the script_hash of the public key you use for signing)
# Note that for public functions like the NEP-5 'getBalance' and alike this would not be needed, but it doesn't hurt either
invocation_tx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=source_script_hash))
# next we need to build a 'script' that gets executed against the smart contract.
# this is basically the script that calls the entry point of the contract with the necessary parameters
smartcontract_scripthash = UInt160.ParseString(
"31730cc9a1844891a3bafd1aa929a4142860d8d3")
sb = ScriptBuilder()
# call the NEP-5 `name` method on the contract (assumes contract address is a NEP-5 token)
sb.EmitAppCallWithOperation(smartcontract_scripthash, 'name')
invocation_tx.Script = binascii.unhexlify(sb.ToArray())
# at this point we've build our unsigned transaction and it's time to sign it before we get the raw output that we can send to the network via RPC
# we need to create a Wallet instance for helping us with signing
wallet = UserWallet.Create('path',
to_aes_key('mypassword'),
generate_default_key=False)
# if you have a WIF use the following
# this WIF comes from the `neo-test1-w.wallet` fixture wallet
private_key = KeyPair.PrivateKeyFromWIF(
"Ky94Rq8rb1z8UzTthYmy1ApbZa9xsKTvQCiuGUZJZbaDJZdkvLRV")
# if you have a NEP2 encrypted key use the following instead
# private_key = KeyPair.PrivateKeyFromNEP2("NEP2 key string", "password string")
# we add the key to our wallet
wallet.CreateKey(private_key)
# and now we're ready to sign
context = ContractParametersContext(invocation_tx)
wallet.Sign(context)
invocation_tx.scripts = context.GetScripts()
raw_tx = invocation_tx.ToArray()
return raw_tx
def create_tx(contract_hash, address_from, address_to, tnc_amount, gas_change,
input_txid, preIndex):
nep5TokenId = get_nep5token_id(contract_hash)
scripthash_from = ToScriptHash(address_from)
scripthash_to = ToScriptHash(address_to)
f8amount = amount_from_string(nep5TokenId, tnc_amount)
f8amount_change = Fixed8.TryParse(gas_change, require_positive=True)
assetId = get_asset_id("gas")
preHash = UInt256(data=binascii.unhexlify(hex_reverse(input_txid)))
input = TransactionInput(prevHash=preHash, prevIndex=preIndex)
output = TransactionOutput(AssetId=assetId,
Value=f8amount_change,
script_hash=scripthash_from)
tx = InvocationTransaction(outputs=[output], inputs=[input])
tx.Version = 1
context = ContractParametersContext(tx)
tx.scripts = context.GetScripts()
invoke_args = [
nep5TokenId.ScriptHash, 'transfer',
[
bytearray.fromhex(hex_reverse(scripthash_from.ToString())),
bytearray.fromhex(hex_reverse(scripthash_to.ToString())),
BigInteger(f8amount)
]
]
sb = ScriptBuilder()
invoke_args.reverse()
for item in invoke_args[:2]:
if type(item) is list:
item.reverse()
listlength = len(item)
for listitem in item:
sb.push(listitem)
sb.push(listlength)
sb.Emit(PACK)
else:
sb.push(binascii.hexlify(item.encode()))
sb.EmitAppCall(nep5TokenId.ScriptHash.ToArray())
op_data = sb.ToArray().decode()
tx.Script = binascii.unhexlify(op_data)
tx_data = get_tx_data(tx)[:-2]
print("tx_data:", tx_data)
signstr = binascii.hexlify(
Crypto.Sign(message=tx_data, private_key=private_key)).decode()
rawtx_data = tx_data + "014140" + signstr + "2321" + public_key + "ac"
return rawtx_data
def test_check_invocation_tx_ToJson(self):
""" See original test here
https://github.com/neo-project/neo/blob/master/neo.UnitTests/UT_InvocationTransaction.cs#L93-L121
"""
i_tx = InvocationTransaction()
val = GetByteArray(32, 0x42)
i_tx.Script = val
gasVal = Fixed8.FromDecimal(42)
i_tx.Gas = gasVal
jsn = i_tx.ToJson()
self.assertTrue(jsn)
self.assertEqual(jsn['txid'], "0x8258b950487299376f89ad2d09598b7acbc5cde89b161b3dd73c256f9e2a94b1")
self.assertEqual(jsn['size'], 39)
self.assertEqual(jsn['type'], "InvocationTransaction")
self.assertEqual(jsn['version'], 0)
self.assertEqual(len(jsn['attributes']), 0)
self.assertEqual(len(jsn['vin']), 0)
self.assertEqual(len(jsn['vout']), 0)
self.assertEqual(jsn['sys_fee'], "42")
self.assertEqual(jsn['net_fee'], "-42")
self.assertEqual(len(jsn['scripts']), 0)
self.assertEqual(jsn['script'], "4220202020202020202020202020202020202020202020202020202020202020")
self.assertEqual(jsn['gas'], "42")
def test_deploy_and_invoke(deploy_script,
invoke_args,
wallet,
from_addr=None,
min_fee=DEFAULT_MIN_FEE,
invocation_test_mode=True,
debug_map=None,
invoke_attrs=None,
owners=None):
bc = GetBlockchain()
accounts = DBCollection(bc._db, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, DBPrefix.ST_Storage, StorageItem)
if settings.USE_DEBUG_STORAGE:
debug_storage = DebugStorage.instance()
storages = DBCollection(debug_storage.db, DBPrefix.ST_Storage,
StorageItem)
storages.DebugStorage = True
dtx = InvocationTransaction()
dtx.Version = 1
dtx.outputs = []
dtx.inputs = []
dtx.scripts = []
dtx.Script = binascii.unhexlify(deploy_script)
if from_addr is not None:
from_addr = PromptUtils.lookup_addr_str(wallet, from_addr)
try:
dtx = wallet.MakeTransaction(tx=dtx, from_addr=from_addr)
except (ValueError, TXFeeError):
pass
context = ContractParametersContext(dtx)
wallet.Sign(context)
dtx.scripts = context.GetScripts()
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
contract = wallet.GetDefaultContract()
dtx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script,
unhex=False))
]
dtx.Attributes = make_unique_script_attr(dtx.Attributes)
to_dispatch = []
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=dtx,
table=script_table,
service=service,
gas=dtx.Gas,
testMode=True)
engine.LoadScript(dtx.Script)
# first we will execute the test deploy
# then right after, we execute the test invoke
d_success = engine.Execute()
if d_success:
items = engine.ResultStack.Items
contract_state = None
for i in items:
if type(i) is ContractState:
contract_state = i
break
elif type(i) is InteropInterface:
item = i.GetInterface()
if type(item) is ContractState:
contract_state = item
break
shash = contract_state.Code.ScriptHash()
invoke_args, neo_to_attach, gas_to_attach = PromptUtils.get_asset_attachments(
invoke_args)
invoke_args, no_parse_addresses = PromptUtils.get_parse_addresses(
invoke_args)
invoke_args.reverse()
if '--i' in invoke_args:
invoke_args = []
for index, iarg in enumerate(contract_state.Code.ParameterList):
param, abort = PromptUtils.gather_param(index, iarg)
if abort:
return None, [], 0, None
else:
invoke_args.append(param)
invoke_args.reverse()
sb = ScriptBuilder()
for p in invoke_args:
item = PromptUtils.parse_param(p,
wallet,
parse_addr=no_parse_addresses)
if type(item) is list:
item.reverse()
listlength = len(item)
for listitem in item:
subitem = PromptUtils.parse_param(
listitem, wallet, parse_addr=no_parse_addresses)
if type(subitem) is list:
subitem.reverse()
for listitem2 in subitem:
subsub = PromptUtils.parse_param(
listitem2,
wallet,
parse_addr=no_parse_addresses)
sb.push(subsub)
sb.push(len(subitem))
sb.Emit(PACK)
else:
sb.push(subitem)
sb.push(listlength)
sb.Emit(PACK)
else:
sb.push(item)
sb.EmitAppCall(shash.Data)
out = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract_state.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract_state.Code.ScriptHash())
outputs.append(output)
itx = InvocationTransaction()
itx.Version = 1
itx.outputs = outputs
itx.inputs = []
itx.scripts = []
itx.Attributes = deepcopy(invoke_attrs) if invoke_attrs else []
itx.Script = binascii.unhexlify(out)
if len(outputs) < 1 and not owners:
contract = wallet.GetDefaultContract()
itx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=contract.ScriptHash))
itx.Attributes = make_unique_script_attr(itx.Attributes)
try:
itx = wallet.MakeTransaction(tx=itx, from_addr=from_addr)
except (ValueError, TXFeeError):
pass
context = ContractParametersContext(itx)
wallet.Sign(context)
if owners:
owners = list(owners)
for owner in owners:
itx.Attributes.append(
TransactionAttribute(
usage=TransactionAttributeUsage.Script, data=owner))
itx.Attributes = make_unique_script_attr(itx.Attributes)
context = ContractParametersContext(itx, isMultiSig=True)
if context.Completed:
itx.scripts = context.GetScripts()
else:
logger.warn(
"Not gathering signatures for test build. For a non-test invoke that would occur here."
)
# if not gather_signatures(context, itx, owners):
# return None, [], 0, None
# print("gathered signatures %s " % itx.scripts)
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=itx,
table=script_table,
service=service,
gas=itx.Gas,
testMode=invocation_test_mode)
engine.invocation_args = invoke_args
engine.LoadScript(itx.Script)
engine.LoadDebugInfoForScriptHash(debug_map, shash.Data)
i_success = engine.Execute()
service.ExecutionCompleted(engine, i_success)
to_dispatch = to_dispatch + service.events_to_dispatch
for event in to_dispatch:
events.emit(event.event_type, event)
if i_success:
service.TestCommit()
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
logger.info("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
if consumed <= Fixed8.Zero():
consumed = min_fee
total_ops = engine.ops_processed
# set the amount of gas the tx will need
itx.Gas = consumed
itx.Attributes = []
result = engine.ResultStack.Items
return itx, result, total_ops, engine
else:
print("error executing invoke contract...")
else:
print("error executing deploy contract.....")
service.ExecutionCompleted(engine, False, 'error')
return None, [], 0, None
def test_invoke(script,
wallet,
outputs,
withdrawal_tx=None,
from_addr=None,
min_fee=DEFAULT_MIN_FEE,
invoke_attrs=None,
owners=None):
# print("invoke script %s " % script)
if from_addr is not None:
from_addr = PromptUtils.lookup_addr_str(wallet, from_addr)
bc = GetBlockchain()
accounts = DBCollection(bc._db, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, DBPrefix.ST_Storage, StorageItem)
# if we are using a withdrawal tx, don't recreate the invocation tx
# also, we don't want to reset the inputs / outputs
# since those were already calculated
if withdrawal_tx is not None:
tx = withdrawal_tx
else:
tx = InvocationTransaction()
tx.outputs = outputs
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(script)
tx.Attributes = [] if invoke_attrs is None else deepcopy(invoke_attrs)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
tx.Attributes.append(
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=contract.ScriptHash))
tx.Attributes = make_unique_script_attr(tx.Attributes)
# same as above. we don't want to re-make the transaction if it is a withdrawal tx
if withdrawal_tx is not None:
wallet_tx = tx
else:
try:
wallet_tx = wallet.MakeTransaction(tx=tx,
from_addr=from_addr,
skip_fee_calc=True)
except ValueError:
pass
context = ContractParametersContext(wallet_tx)
wallet.Sign(context)
if owners:
owners = list(owners)
for owner in owners:
# print("contract %s %s" % (wallet.GetDefaultContract().ScriptHash, owner))
if wallet.GetDefaultContract().ScriptHash != owner:
wallet_tx.Attributes.append(
TransactionAttribute(
usage=TransactionAttributeUsage.Script, data=owner))
wallet_tx.Attributes = make_unique_script_attr(tx.Attributes)
context = ContractParametersContext(wallet_tx, isMultiSig=True)
if context.Completed:
wallet_tx.scripts = context.GetScripts()
else:
logger.warning(
"Not gathering signatures for test build. For a non-test invoke that would occur here."
)
# if not gather_signatures(context, wallet_tx, owners):
# return None, [], 0, None
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=wallet_tx,
table=script_table,
service=service,
gas=wallet_tx.Gas,
testMode=True)
engine.LoadScript(wallet_tx.Script)
try:
success = engine.Execute()
service.ExecutionCompleted(engine, success)
for event in service.events_to_dispatch:
events.emit(event.event_type, event)
if success:
# this will be removed in favor of neo.EventHub
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
# print("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = min_fee
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
# set the amount of gas the tx will need
wallet_tx.Gas = tx_gas
# reset the wallet outputs
wallet_tx.outputs = outputs
wallet_tx.Attributes = [] if invoke_attrs is None else deepcopy(
invoke_attrs)
# calculate the required network fee for the tx and compare to fee
if wallet_tx.Size() > settings.MAX_FREE_TX_SIZE:
req_fee = Fixed8.FromDecimal(
settings.FEE_PER_EXTRA_BYTE *
(wallet_tx.Size() - settings.MAX_FREE_TX_SIZE))
if req_fee < settings.LOW_PRIORITY_THRESHOLD:
req_fee = settings.LOW_PRIORITY_THRESHOLD
if net_fee < req_fee:
net_fee = req_fee
return wallet_tx, net_fee, engine.ResultStack.Items, engine.ops_processed, success
# this allows you to to test invocations that fail
else:
wallet_tx.outputs = outputs
wallet_tx.Attributes = [] if invoke_attrs is None else deepcopy(
invoke_attrs)
return wallet_tx, min_fee, [], engine.ops_processed, success
except Exception as e:
service.ExecutionCompleted(engine, False, e)
return None, None, None, None, False
def test_invoke(script, wallet, outputs):
# print("invoke script %s " % script)
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator,
ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
tx = InvocationTransaction()
tx.Version = 1
tx.outputs = outputs
tx.inputs = []
tx.scripts = []
tx.Script = binascii.unhexlify(script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
tx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(
contract.Script).Data)
]
wallet_tx = wallet.MakeTransaction(tx=tx)
if wallet_tx:
context = ContractParametersContext(wallet_tx)
wallet.Sign(context)
if context.Completed:
wallet_tx.scripts = context.GetScripts()
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=wallet_tx,
table=script_table,
service=service,
gas=wallet_tx.Gas,
testMode=True)
engine.LoadScript(wallet_tx.Script, False)
try:
# drum roll?
success = engine.Execute()
if success:
service.TestCommit()
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed.value = int(consumed.value)
net_fee = None
tx_gas = None
if consumed < Fixed8.One():
net_fee = Fixed8.FromDecimal(.001)
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
#set the amount of gas the tx will need
wallet_tx.Gas = tx_gas
#reset the wallet outputs
wallet_tx.outputs = outputs
wallet_tx.Attributes = []
return wallet_tx, net_fee, engine.EvaluationStack.Items, engine.ops_processed
else:
print("error executing contract.....")
# tx.Gas = Fixed8.One()
# tx.Attributes = []
# return tx, []
return None, []
except Exception as e:
print("COULD NOT EXECUTE %s " % e)
return None, []
def test_deploy_and_invoke(deploy_script,
invoke_args,
wallet,
from_addr=None,
min_fee=DEFAULT_MIN_FEE,
invocation_test_mode=True,
debug_map=None):
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator,
ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
if settings.USE_DEBUG_STORAGE:
debug_storage = DebugStorage.instance()
debug_sn = debug_storage.db.snapshot()
storages = DBCollection(debug_storage.db, debug_sn,
DBPrefix.ST_Storage, StorageItem)
storages.DebugStorage = True
dtx = InvocationTransaction()
dtx.Version = 1
dtx.outputs = []
dtx.inputs = []
dtx.scripts = []
dtx.Script = binascii.unhexlify(deploy_script)
if from_addr is not None:
from_addr = lookup_addr_str(wallet, from_addr)
dtx = wallet.MakeTransaction(tx=dtx, from_addr=from_addr)
context = ContractParametersContext(dtx)
wallet.Sign(context)
dtx.scripts = context.GetScripts()
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
contract = wallet.GetDefaultContract()
dtx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script,
unhex=False))
]
to_dispatch = []
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=dtx,
table=script_table,
service=service,
gas=dtx.Gas,
testMode=True)
engine.LoadScript(dtx.Script, False)
# first we will execute the test deploy
# then right after, we execute the test invoke
d_success = engine.Execute()
if d_success:
items = engine.EvaluationStack.Items
contract_state = None
for i in items:
if type(i) is ContractState:
contract_state = i
break
elif type(i) is InteropInterface:
item = i.GetInterface()
if type(item) is ContractState:
contract_state = item
break
shash = contract_state.Code.ScriptHash()
invoke_args, neo_to_attach, gas_to_attach = get_asset_attachments(
invoke_args)
invoke_args.reverse()
# print("neo, gas %s %s " % (neo_to_attach,gas_to_attach.ToString()))
sb = ScriptBuilder()
for p in invoke_args:
item = parse_param(p, wallet)
if type(item) is list:
item.reverse()
listlength = len(item)
for listitem in item:
subitem = parse_param(listitem, wallet)
sb.push(subitem)
sb.push(listlength)
sb.Emit(PACK)
else:
sb.push(item)
sb.EmitAppCall(shash.Data)
out = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract_state.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract_state.Code.ScriptHash())
outputs.append(output)
itx = InvocationTransaction()
itx.Version = 1
itx.outputs = outputs
itx.inputs = []
itx.scripts = []
itx.Attributes = []
itx.Script = binascii.unhexlify(out)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
itx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(
contract.Script, unhex=False).Data)
]
itx = wallet.MakeTransaction(tx=itx, from_addr=from_addr)
context = ContractParametersContext(itx)
wallet.Sign(context)
itx.scripts = context.GetScripts()
# print("tx: %s " % json.dumps(itx.ToJson(), indent=4))
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=itx,
table=script_table,
service=service,
gas=itx.Gas,
testMode=invocation_test_mode)
engine.LoadScript(itx.Script, False)
engine.LoadDebugInfo(debug_map)
# call execute in its own blocking thread
# reactor.stop()
i_success = engine.Execute()
service.ExecutionCompleted(engine, i_success)
to_dispatch = to_dispatch + service.events_to_dispatch
for event in to_dispatch:
events.emit(event.event_type, event)
if i_success:
service.TestCommit()
if len(service.notifications) > 0:
for n in service.notifications:
# print("NOTIFICATION : %s " % n)
Blockchain.Default().OnNotify(n)
logger.info("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
if consumed <= Fixed8.Zero():
consumed = min_fee
total_ops = engine.ops_processed
# set the amount of gas the tx will need
itx.Gas = consumed
itx.Attributes = []
result = engine.EvaluationStack.Items
return itx, result, total_ops, engine
else:
print("error executing invoke contract...")
else:
print("error executing deploy contract.....")
service.ExecutionCompleted(engine, False, 'error')
return None, [], 0, None
def test_invoke(script,
wallet,
outputs,
withdrawal_tx=None,
from_addr=None,
min_fee=DEFAULT_MIN_FEE):
# print("invoke script %s " % script)
if from_addr is not None:
from_addr = lookup_addr_str(wallet, from_addr)
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator,
ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
# if we are using a withdrawal tx, don't recreate the invocation tx
# also, we don't want to reset the inputs / outputs
# since those were already calculated
if withdrawal_tx is not None:
tx = withdrawal_tx
else:
tx = InvocationTransaction()
tx.outputs = outputs
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
tx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script,
unhex=False).Data)
]
# same as above. we don't want to re-make the transaction if it is a withdrawal tx
if withdrawal_tx is not None:
wallet_tx = tx
else:
wallet_tx = wallet.MakeTransaction(tx=tx, from_addr=from_addr)
if wallet_tx:
context = ContractParametersContext(wallet_tx)
wallet.Sign(context)
if context.Completed:
wallet_tx.scripts = context.GetScripts()
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=wallet_tx,
table=script_table,
service=service,
gas=wallet_tx.Gas,
testMode=True)
engine.LoadScript(wallet_tx.Script, False)
try:
# drum roll?
success = engine.Execute()
service.ExecutionCompleted(engine, success)
for event in service.events_to_dispatch:
events.emit(event.event_type, event)
if success:
# this will be removed in favor of neo.EventHub
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
print("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = min_fee
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
# set the amount of gas the tx will need
wallet_tx.Gas = tx_gas
# reset the wallet outputs
wallet_tx.outputs = outputs
wallet_tx.Attributes = []
return wallet_tx, net_fee, engine.EvaluationStack.Items, engine.ops_processed
except Exception as e:
service.ExecutionCompleted(engine, False, e)
# print("COULD NOT EXECUTE %s " % e)
return None, None, None, None
def test_deploy_and_invoke(deploy_script, invoke_args, wallet,
from_addr=None, min_fee=DEFAULT_MIN_FEE, invocation_test_mode=True,
debug_map=None, invoke_attrs=None, owners=None, enable_debugger=False, snapshot=None):
if settings.USE_DEBUG_STORAGE:
debug_storage = DebugStorage.instance()
storages = DBInterface(debug_storage.db, DBPrefix.ST_Storage, StorageItem)
storages.DebugStorage = True
dtx = InvocationTransaction()
dtx.Version = 1
dtx.outputs = []
dtx.inputs = []
dtx.scripts = []
dtx.Script = binascii.unhexlify(deploy_script)
if from_addr is not None:
from_addr = PromptUtils.lookup_addr_str(wallet, from_addr)
try:
dtx = wallet.MakeTransaction(tx=dtx, from_addr=from_addr)
except (ValueError):
pass
context = ContractParametersContext(dtx)
wallet.Sign(context)
dtx.scripts = context.GetScripts()
contract = wallet.GetDefaultContract()
dtx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash(contract.Script, unhex=False))]
dtx.Attributes = make_unique_script_attr(dtx.Attributes)
to_dispatch = []
if snapshot is None:
snapshot = GetBlockchain()._db.createSnapshot().Clone()
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=dtx,
snapshot=snapshot,
gas=dtx.Gas,
testMode=True
)
engine.LoadScript(dtx.Script)
# first we will execute the test deploy
# then right after, we execute the test invoke
if enable_debugger:
debugger = Debugger(engine)
d_success = debugger.Execute()
else:
d_success = engine.Execute()
# the old setup provided the same StateMachine object to the ApplicationEngine for deploy and invoke
# this allowed for a single dispatch of events at the end of the function. Now a new StateMachine is automatically
# created when creating an ApplicationEngine, thus we have to dispatch events after the deploy to not lose them as
# testcases expect them
to_dispatch = to_dispatch + engine._Service.events_to_dispatch
for event in to_dispatch:
events.emit(event.event_type, event)
to_dispatch = []
if d_success:
items = engine.ResultStack.Items
contract_state = None
for i in items:
if type(i) is ContractState:
contract_state = i
break
elif type(i) is InteropInterface:
item = i.GetInterface()
if type(item) is ContractState:
contract_state = item
break
shash = contract_state.Code.ScriptHash()
invoke_args, neo_to_attach, gas_to_attach = PromptUtils.get_asset_attachments(invoke_args)
invoke_args, no_parse_addresses = PromptUtils.get_parse_addresses(invoke_args)
invoke_args.reverse()
if '--i' in invoke_args:
invoke_args = []
for index, iarg in enumerate(contract_state.Code.ParameterList):
param, abort = PromptUtils.gather_param(index, iarg)
if abort:
return None, [], 0, None
else:
invoke_args.append(param)
invoke_args.reverse()
sb = ScriptBuilder()
for p in invoke_args:
process_params(sb, p, wallet, no_parse_addresses)
sb.EmitAppCall(shash.Data)
out = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract_state.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract_state.Code.ScriptHash())
outputs.append(output)
itx = InvocationTransaction()
itx.Version = 1
itx.outputs = outputs
itx.inputs = []
itx.scripts = []
itx.Attributes = deepcopy(invoke_attrs) if invoke_attrs else []
itx.Script = binascii.unhexlify(out)
if len(outputs) < 1 and not owners:
contract = wallet.GetDefaultContract()
itx.Attributes.append(TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=contract.ScriptHash))
itx.Attributes = make_unique_script_attr(itx.Attributes)
try:
itx = wallet.MakeTransaction(tx=itx, from_addr=from_addr)
except (ValueError):
pass
context = ContractParametersContext(itx)
wallet.Sign(context)
if owners:
owners = list(owners)
for owner in owners:
itx.Attributes.append(TransactionAttribute(usage=TransactionAttributeUsage.Script, data=owner))
itx.Attributes = make_unique_script_attr(itx.Attributes)
context = ContractParametersContext(itx, isMultiSig=True)
if context.Completed:
itx.scripts = context.GetScripts()
else:
logger.warn("Not gathering signatures for test build. For a non-test invoke that would occur here.")
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=itx,
snapshot=snapshot,
gas=itx.Gas,
testMode=invocation_test_mode
)
engine.invocation_args = invoke_args
engine.LoadScript(itx.Script)
engine.LoadDebugInfoForScriptHash(debug_map, shash.Data)
if enable_debugger:
debugger = Debugger(engine)
i_success = debugger.Execute()
else:
i_success = engine.Execute()
engine._Service.ExecutionCompleted(engine, i_success)
to_dispatch = to_dispatch + engine._Service.events_to_dispatch
for event in to_dispatch:
events.emit(event.event_type, event)
if i_success:
if len(engine._Service.notifications) > 0:
for n in engine._Service.notifications:
Blockchain.Default().OnNotify(n)
logger.info("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
if consumed <= Fixed8.Zero():
consumed = min_fee
total_ops = engine.ops_processed
# set the amount of gas the tx will need
itx.Gas = consumed
itx.Attributes = []
result = engine.ResultStack.Items
return itx, result, total_ops, engine
else:
print("error executing invoke contract...")
else:
print("error executing deploy contract.....")
# service.ExecutionCompleted(engine, False, 'error')
return None, [], 0, None
def test_invoke(script, wallet, outputs, withdrawal_tx=None,
from_addr=None, min_fee=DEFAULT_MIN_FEE,
invoke_attrs=None, owners=None):
# print("invoke script %s " % script)
if from_addr is not None:
from_addr = PromptUtils.lookup_addr_str(wallet, from_addr)
# if we are using a withdrawal tx, don't recreate the invocation tx
# also, we don't want to reset the inputs / outputs
# since those were already calculated
if withdrawal_tx is not None:
tx = withdrawal_tx
else:
tx = InvocationTransaction()
tx.outputs = outputs
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(script)
tx.Attributes = [] if invoke_attrs is None else deepcopy(invoke_attrs)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
tx.Attributes.append(TransactionAttribute(usage=TransactionAttributeUsage.Script, data=contract.ScriptHash))
tx.Attributes = make_unique_script_attr(tx.Attributes)
# same as above. we don't want to re-make the transaction if it is a withdrawal tx
if withdrawal_tx is not None:
wallet_tx = tx
else:
try:
wallet_tx = wallet.MakeTransaction(tx=tx, from_addr=from_addr)
except ValueError:
pass
context = ContractParametersContext(wallet_tx)
wallet.Sign(context)
if owners:
owners = list(owners)
for owner in owners:
# print("contract %s %s" % (wallet.GetDefaultContract().ScriptHash, owner))
if wallet.GetDefaultContract().ScriptHash != owner:
wallet_tx.Attributes.append(TransactionAttribute(usage=TransactionAttributeUsage.Script, data=owner))
wallet_tx.Attributes = make_unique_script_attr(tx.Attributes)
context = ContractParametersContext(wallet_tx, isMultiSig=True)
if context.Completed:
wallet_tx.scripts = context.GetScripts()
else:
logger.warning("Not gathering signatures for test build. For a non-test invoke that would occur here.")
snapshot = GetBlockchain()._db.createSnapshot().Clone()
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=wallet_tx,
snapshot=snapshot,
gas=wallet_tx.Gas,
testMode=True
)
engine.LoadScript(wallet_tx.Script)
try:
success = engine.Execute()
engine._Service.ExecutionCompleted(engine, success)
for event in engine._Service.events_to_dispatch:
events.emit(event.event_type, event)
if success:
# this will be removed in favor of neo.EventHub
if len(engine._Service.notifications) > 0:
for n in engine._Service.notifications:
Blockchain.Default().OnNotify(n)
# print("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = min_fee
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
# set the amount of gas the tx will need
wallet_tx.Gas = tx_gas
# reset the wallet outputs
wallet_tx.outputs = outputs
wallet_tx.Attributes = [] if invoke_attrs is None else deepcopy(invoke_attrs)
return wallet_tx, net_fee, engine.ResultStack.Items, engine.ops_processed, success
# this allows you to to test invocations that fail
else:
wallet_tx.outputs = outputs
wallet_tx.Attributes = [] if invoke_attrs is None else deepcopy(invoke_attrs)
return wallet_tx, min_fee, [], engine.ops_processed, success
except Exception as e:
engine._Service.ExecutionCompleted(engine, False, e)
return None, None, None, None, False
def construct_deploy_tx(wallet, params):
params = params[0]
from_addr = params['from_addr']
# load_smart_contract
contract_params = bytearray(binascii.unhexlify(params['contract_params']))
return_type = bytearray(binascii.unhexlify(params['return_type']))
contract_properties = 0
if params.get('needs_storage', True):
contract_properties += ContractPropertyState.HasStorage
if params.get('needs_dynamic_invoke', False):
contract_properties += ContractPropertyState.HasDynamicInvoke
script = binascii.unhexlify(params['bin'])
function_code = FunctionCode(
script = script,
param_list = contract_params,
return_type = return_type,
contract_properties = contract_properties,
)
if Blockchain.Default().GetContract(function_code.ScriptHash().To0xString()):
raise Exception('contract already exists')
# GatherContractDetails
details = params['details']
name = details['name']
version = details['version']
author = details['author']
email = details['email']
description = details['description']
contract_script = generate_deploy_script(
function_code.Script,
name,
version,
author,
email,
description,
function_code.ContractProperties,
function_code.ReturnType,
function_code.ParameterList,
)
# test_invoke
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, DBPrefix.ST_Storage, StorageItem)
tx = InvocationTransaction()
tx.outputs = []
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(contract_script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages, None)
contract = wallet.GetDefaultContract()
tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash(contract.Script, unhex=False).Data)]
tx = wallet.MakeTransaction(tx=tx)
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=tx,
table=script_table,
service=service,
gas=tx.Gas,
testMode=True
)
engine.LoadScript(tx.Script, False)
success = engine.Execute()
if not success:
raise Exception('exec failed')
service.ExecutionCompleted(engine, success)
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = Fixed8.FromDecimal(.0001)
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
tx.Gas = tx_gas
tx.outputs = []
tx.Attributes = []
# InvokeContract
from_addr = lookup_addr_str(wallet, from_addr)
tx = wallet.MakeTransaction(tx=tx, fee=net_fee, use_standard=True, from_addr=from_addr)
if tx is None:
raise Exception("no gas")
context = ContractParametersContext(tx)
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
tx.Serialize(writer)
ms.flush()
binary_tx = ms.ToArray()
return {'context': context.ToJson(), 'tx': binary_tx.decode(), 'hash': function_code.ScriptHash().To0xString()}
def test_invoke(script, wallet):
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator,
ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
tx = InvocationTransaction()
tx.Version = 0
tx.scripts = []
tx.Script = binascii.unhexlify(script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
contract = wallet.GetDefaultContract()
tx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script))
]
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=tx,
table=script_table,
service=service,
gas=tx.Gas,
testMode=True)
engine.LoadScript(tx.Script, False)
try:
# drum roll?
success = engine.Execute()
if success:
service.TestCommit()
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
if consumed < Fixed8.One():
consumed = Fixed8.One()
#set the amount of gas the tx will need
tx.Gas = consumed
#remove the attributes that are used to add a verification script to the tx
tx.Attributes = []
return tx, engine.EvaluationStack.Items
except Exception as e:
print("COULD NOT EXECUTE %s " % e)
return None, []
def test_deploy_and_invoke(deploy_script, invoke_args, wallet, from_addr=None, min_fee=DEFAULT_MIN_FEE, invocation_test_mode=True, debug_map=None):
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
if settings.USE_DEBUG_STORAGE:
debug_storage = DebugStorage.instance()
debug_sn = debug_storage.db.snapshot()
storages = DBCollection(debug_storage.db, debug_sn, DBPrefix.ST_Storage, StorageItem)
storages.DebugStorage = True
dtx = InvocationTransaction()
dtx.Version = 1
dtx.outputs = []
dtx.inputs = []
dtx.scripts = []
dtx.Script = binascii.unhexlify(deploy_script)
if from_addr is not None:
from_addr = lookup_addr_str(wallet, from_addr)
dtx = wallet.MakeTransaction(tx=dtx, from_addr=from_addr)
context = ContractParametersContext(dtx)
wallet.Sign(context)
dtx.scripts = context.GetScripts()
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages, None)
contract = wallet.GetDefaultContract()
dtx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash(contract.Script, unhex=False))]
to_dispatch = []
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=dtx,
table=script_table,
service=service,
gas=dtx.Gas,
testMode=True
)
engine.LoadScript(dtx.Script, False)
# first we will execute the test deploy
# then right after, we execute the test invoke
d_success = engine.Execute()
if d_success:
items = engine.EvaluationStack.Items
contract_state = None
for i in items:
if type(i) is ContractState:
contract_state = i
break
elif type(i) is InteropInterface:
item = i.GetInterface()
if type(item) is ContractState:
contract_state = item
break
shash = contract_state.Code.ScriptHash()
invoke_args, neo_to_attach, gas_to_attach = get_asset_attachments(invoke_args)
invoke_args.reverse()
sb = ScriptBuilder()
for p in invoke_args:
item = parse_param(p, wallet)
if type(item) is list:
item.reverse()
listlength = len(item)
for listitem in item:
subitem = parse_param(listitem, wallet)
sb.push(subitem)
sb.push(listlength)
sb.Emit(PACK)
else:
sb.push(item)
sb.EmitAppCall(shash.Data)
out = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract_state.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract_state.Code.ScriptHash())
outputs.append(output)
itx = InvocationTransaction()
itx.Version = 1
itx.outputs = outputs
itx.inputs = []
itx.scripts = []
itx.Attributes = []
itx.Script = binascii.unhexlify(out)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
itx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script, unhex=False).Data)]
itx = wallet.MakeTransaction(tx=itx, from_addr=from_addr)
context = ContractParametersContext(itx)
wallet.Sign(context)
itx.scripts = context.GetScripts()
# print("tx: %s " % json.dumps(itx.ToJson(), indent=4))
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=itx,
table=script_table,
service=service,
gas=itx.Gas,
testMode=invocation_test_mode
)
engine.LoadScript(itx.Script, False)
engine.LoadDebugInfoForScriptHash(debug_map, shash.Data)
# call execute in its own blocking thread
# reactor.stop()
i_success = engine.Execute()
service.ExecutionCompleted(engine, i_success)
to_dispatch = to_dispatch + service.events_to_dispatch
for event in to_dispatch:
events.emit(event.event_type, event)
if i_success:
service.TestCommit()
if len(service.notifications) > 0:
for n in service.notifications:
# print("NOTIFICATION : %s " % n)
Blockchain.Default().OnNotify(n)
logger.info("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
if consumed <= Fixed8.Zero():
consumed = min_fee
total_ops = engine.ops_processed
# set the amount of gas the tx will need
itx.Gas = consumed
itx.Attributes = []
result = engine.EvaluationStack.Items
return itx, result, total_ops, engine
else:
print("error executing invoke contract...")
else:
print("error executing deploy contract.....")
service.ExecutionCompleted(engine, False, 'error')
return None, [], 0, None
def test_invoke(script, wallet, outputs, withdrawal_tx=None, from_addr=None, min_fee=DEFAULT_MIN_FEE):
# print("invoke script %s " % script)
if from_addr is not None:
from_addr = lookup_addr_str(wallet, from_addr)
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
# if we are using a withdrawal tx, don't recreate the invocation tx
# also, we don't want to reset the inputs / outputs
# since those were already calculated
if withdrawal_tx is not None:
tx = withdrawal_tx
else:
tx = InvocationTransaction()
tx.outputs = outputs
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages, None)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash(contract.Script, unhex=False).Data)]
# same as above. we don't want to re-make the transaction if it is a withdrawal tx
if withdrawal_tx is not None:
wallet_tx = tx
else:
wallet_tx = wallet.MakeTransaction(tx=tx, from_addr=from_addr)
if wallet_tx:
context = ContractParametersContext(wallet_tx)
wallet.Sign(context)
if context.Completed:
wallet_tx.scripts = context.GetScripts()
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=wallet_tx,
table=script_table,
service=service,
gas=wallet_tx.Gas,
testMode=True
)
engine.LoadScript(wallet_tx.Script, False)
try:
# drum roll?
success = engine.Execute()
service.ExecutionCompleted(engine, success)
for event in service.events_to_dispatch:
events.emit(event.event_type, event)
if success:
# this will be removed in favor of neo.EventHub
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
print("Used %s Gas " % engine.GasConsumed().ToString())
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = min_fee
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
# set the amount of gas the tx will need
wallet_tx.Gas = tx_gas
# reset the wallet outputs
wallet_tx.outputs = outputs
wallet_tx.Attributes = []
return wallet_tx, net_fee, engine.EvaluationStack.Items, engine.ops_processed
# this allows you to to test invocations that fail
else:
wallet_tx.outputs = outputs
wallet_tx.Attributes = []
return wallet_tx, min_fee, [], engine.ops_processed
except Exception as e:
service.ExecutionCompleted(engine, False, e)
# print("COULD NOT EXECUTE %s " % e)
return None, None, None, None
def json_rpc_method_handler(self, method, params):
if method == "getaccountstate":
acct = Blockchain.Default().GetAccountState(params[0])
if acct is None:
try:
acct = AccountState(script_hash=Helper.AddrStrToScriptHash(params[0]))
except Exception as e:
raise JsonRpcError(-2146233033, "One of the identified items was in an invalid format.")
return acct.ToJson()
elif method == "getassetstate":
asset_id = UInt256.ParseString(params[0])
asset = Blockchain.Default().GetAssetState(asset_id.ToBytes())
if asset:
return asset.ToJson()
raise JsonRpcError(-100, "Unknown asset")
elif method == "getbestblockhash":
return '0x%s' % Blockchain.Default().CurrentHeaderHash.decode('utf-8')
elif method == "getblock":
# this should work for either str or int
block = Blockchain.Default().GetBlock(params[0])
if not block:
raise JsonRpcError(-100, "Unknown block")
return self.get_block_output(block, params)
elif method == "getblockcount":
return Blockchain.Default().Height + 1
elif method == "getblockhash":
height = params[0]
if height >= 0 and height <= Blockchain.Default().Height:
return '0x%s' % Blockchain.Default().GetBlockHash(height).decode('utf-8')
else:
raise JsonRpcError(-100, "Invalid Height")
elif method == "getblocksysfee":
height = params[0]
if height >= 0 and height <= Blockchain.Default().Height:
return Blockchain.Default().GetSysFeeAmountByHeight(height)
else:
raise JsonRpcError(-100, "Invalid Height")
elif method == "getconnectioncount":
return len(NodeLeader.Instance().Peers)
elif method == "getcontractstate":
script_hash = UInt160.ParseString(params[0])
contract = Blockchain.Default().GetContract(script_hash.ToBytes())
if contract is None:
raise JsonRpcError(-100, "Unknown contract")
return contract.ToJson()
elif method == "getrawmempool":
return list(map(lambda hash: "0x%s" % hash.decode('utf-8'), NodeLeader.Instance().MemPool.keys()))
elif method == "getversion":
return {
"port": self.port,
"nonce": NodeLeader.Instance().NodeId,
"useragent": settings.VERSION_NAME
}
elif method == "getrawtransaction":
tx_id = UInt256.ParseString(params[0])
tx, height = Blockchain.Default().GetTransaction(tx_id)
if not tx:
raise JsonRpcError(-100, "Unknown Transaction")
return self.get_tx_output(tx, height, params)
elif method == "getLastBlog":
if len(params) > 0:
height = params[0]
else:
height = Blockchain.Default().Height + 1
data = self.get_blog_content(height, "")
return data;
elif method == "getLastBlogByTag":
if len(params) > 1:
height = params[1]
tag = params[0]
elif len(params) > 0:
tag = params[0]
height = Blockchain.Default().Height + 1
else:
raise JsonRpcError(-100, "no enough param")
data = self.get_blog_content(height, tag)
return data;
elif method == "getLastBlogBySender":
if len(params) > 1:
height = params[1]
sender = params[0]
elif len(params) > 0:
sender = params[0]
height = Blockchain.Default().Height + 1
else:
raise JsonRpcError(-100, "no enough param")
data = self.get_blog_content(height, "", sender)
return data;
elif method == "getBlogContent":
tx_id = UInt256.ParseString(params[0])
tx, height = Blockchain.Default().GetTransaction(tx_id)
if not tx:
raise JsonRpcError(-100, "Unknown Transaction")
for attr in tx.Attributes:
item = attr.ToJson;
if item['usage'] == 240:
item['content'] = binascii.a2b_hex(item['data']).decode("utf8")
return item;
raise JsonRpcError(-100, "no blog content")
elif method == "getstorage":
script_hash = UInt160.ParseString(params[0])
key = binascii.unhexlify(params[1].encode('utf-8'))
storage_key = StorageKey(script_hash=script_hash, key=key)
storage_item = Blockchain.Default().GetStorageItem(storage_key)
if storage_item:
return storage_item.Value.hex()
return None
elif method == "gettxout":
hash = params[0].encode('utf-8')
index = params[1]
utxo = Blockchain.Default().GetUnspent(hash, index)
if utxo:
return utxo.ToJson(index)
else:
return None
elif method == "gettxout":
hash = params[0].encode('utf-8')
index = params[1]
utxo = Blockchain.Default().GetUnspent(hash, index)
if utxo:
return utxo.ToJson(index)
else:
return None
elif method == "createAddress":
private_key = bytes(Random.get_random_bytes(32))
key = KeyPair(priv_key=private_key)
self.wallet._keys[key.PublicKeyHash.ToBytes()] = key
self.wallet.OnCreateAccount(key)
contract = WalletContract.CreateSignatureContract(key.PublicKey)
self.wallet.AddContract(contract)
if key :
result = {'privateKey': key.Export(),'address':contract.Address}
return result;
else:
return None
elif method == "invoke":
shash = UInt160.ParseString(params[0])
contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
sb = ScriptBuilder()
sb.EmitAppCallWithJsonArgs(shash, contract_parameters)
return self.get_invoke_result(sb.ToArray())
# elif method == "sendBlog":
# shash = UInt160.ParseString(params[0])
# contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
# sb = ScriptBuilder()
# sb.EmitAppCallWithJsonArgs(shash, contract_parameters)
# script = sb.ToArray();
# tx = ContractTransaction()
# tx.inputs = []
# tx.outputs = []
# attribute = TransactionAttribute(240, params[2].encode('utf-8'))
# standard_contract = self.wallet.GetStandardAddress()
# data = standard_contract.Data
# tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script,
# data=data)]
#
# tx.Attributes.append(attribute)
# tx.Version = 1
# tx.scripts = []
# BC = GetBlockchain()
# contract = BC.GetContract(params[0])
# output = TransactionOutput(AssetId=Blockchain.SystemShare().Hash,
# Value=Fixed8.FromDecimal(float(1)),
# script_hash=contract.Code.ScriptHash(),
# )
# tx.outputs.append(output)
# logger.info("output %s" % output.ToJson(0))
# tx.Script = binascii.unhexlify(script)
# print("percentage %s %s" % (self.wallet.WalletHeight, Blockchain.Default().Height))
# scripthash_from = None
# if not self.wallet.IsSynced:
# raise JsonRpcError.invalidRequest("wallet not synced")
# private_key = None
# if len(params) > 3:
# from_address = params[3]
# if from_address is not None:
# scripthash_from = lookup_addr_str(self.wallet, from_address)
# if len(params) > 4:
# private_key = params[4]
# wallet_tx = SendBlog(self.wallet, tx, from_addr=scripthash_from, privatekey=private_key)
# if wallet_tx != False:
# return wallet_tx.ToJson();
# self.wallet.Rebuild()
# raise JsonRpcError.invalidRequest("Field 'no enough asset")
elif method == 'postblog':
try:
if len(params) > 3:
from_address = params[3]
assetId =Blockchain.SystemShare().Hash
if len(params) > 4:
private_key = params[4]
if assetId is None:
print("Asset id not found")
return False
contract_parameters = [ContractParameter.FromJson(p) for p in params[1]]
sb = ScriptBuilder()
sb.EmitAppCallWithJsonArgs(UInt160.ParseString(params[0]), contract_parameters)
script = sb.ToArray();
scripthash_from = None
if from_address is not None:
scripthash_from = lookup_addr_str(self.wallet, from_address)
# f8amount = Fixed8.TryParse(0, require_positive=True)
# if f8amount is None:
# print("invalid amount format")
# return False
#
# if type(assetId) is UInt256 and f8amount.value % pow(10, 8 - Blockchain.Default().GetAssetState(
# assetId.ToBytes()).Precision) != 0:
# print("incorrect amount precision")
# return False
#
fee = Fixed8.Zero()
#
# output = TransactionOutput(AssetId=assetId, Value=f8amount, script_hash=contract.Code.ScriptHash())
tx = InvocationTransaction()
ttx = self.wallet.MakeTransaction(tx=tx,
change_address=None,
fee=fee,
from_addr=scripthash_from)
if ttx is None:
print("insufficient funds")
return False
standard_contract = self.wallet.GetStandardAddress()
if scripthash_from is not None:
signer_contract = self.wallet.GetContract(scripthash_from)
else:
signer_contract = self.wallet.GetContract(standard_contract)
if not signer_contract.IsMultiSigContract:
data = scripthash_from.Data
print(data)
tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=data),TransactionAttribute(usage=TransactionAttributeUsage.Remark1,
data=from_address.encode('utf-8'))]
# insert any additional user specified tx attributes
tx.Attributes.append(TransactionAttribute(240, params[2].encode('utf-8')))
tx.Script = binascii.unhexlify(script)
context = ContractParametersContext(tx, isMultiSig=signer_contract.IsMultiSigContract)
if private_key is not None:
prikey = KeyPair.PrivateKeyFromWIF(private_key)
kp = KeyPair(prikey)
self.wallet.Sign(context,kp)
attributes = [attr.ToJson() for attr in tx.Attributes]
print("attributes %s" %attributes)
if context.Completed:
tx.scripts = context.GetScripts()
# print("will send tx: %s " % json.dumps(tx.ToJson(),indent=4))
relayed = NodeLeader.Instance().Relay(tx)
if relayed:
self.wallet.SaveTransaction(tx)
print("Relayed Tx: %s " % tx.Hash.ToString())
return tx.ToJson()
else:
print("Could not relay tx %s " % tx.Hash.ToString())
else:
print("Transaction initiated, but the signature is incomplete")
print(json.dumps(context.ToJson(), separators=(',', ':')))
return False
except Exception as e:
print("could not send: %s " % e)
return False
elif method == "invokefunction":
contract_parameters = []
if len(params) > 2:
contract_parameters = [ContractParameter.FromJson(p).ToVM() for p in params[2]]
sb = ScriptBuilder()
sb.EmitAppCallWithOperationAndArgs(UInt160.ParseString(params[0]), params[1], contract_parameters)
return self.get_invoke_result(sb.ToArray())
elif method == "invokescript":
script = params[0].encode('utf-8')
return self.get_invoke_result(script)
elif method == "sendrawtransaction":
tx_script = binascii.unhexlify(params[0].encode('utf-8'))
transaction = Transaction.DeserializeFromBufer(tx_script)
result = NodeLeader.Instance().Relay(transaction)
return result
elif method == "submitblock":
raise NotImplementedError()
elif method == "validateaddress":
return self.validateaddress(params)
elif method == "getpeers":
raise NotImplementedError()
raise JsonRpcError.methodNotFound()
def construct_invoke_tx(wallet, params):
params = params[0]
from_addr = params['from_addr']
BC = GetBlockchain()
contract = BC.GetContract(params['addr'])
if not contract:
raise Exception('no such contract')
neo_to_attach = params.get('neo_to_attach', 0)
gas_to_attach = params.get('gas_to_attach', 0)
sb = ScriptBuilder()
contract_parameters = [ContractParameter.FromJson(p) for p in params['contract_params']]
sb.EmitAppCallWithJsonArgs(contract.Code.ScriptHash(), contract_parameters)
invoke_script = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract.Code.ScriptHash(),
)
outputs.append(output)
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, DBPrefix.ST_Validator, ValidatorState)
contracts = DBCollection(bc._db, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, DBPrefix.ST_Storage, StorageItem)
tx = InvocationTransaction()
tx.outputs = outputs
tx.inputs = []
tx.Version = 1
tx.scripts = []
tx.Script = binascii.unhexlify(invoke_script)
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages, None)
contract = wallet.GetDefaultContract()
tx.Attributes = [TransactionAttribute(usage=TransactionAttributeUsage.Script, data=Crypto.ToScriptHash(contract.Script, unhex=False).Data)]
tx = wallet.MakeTransaction(tx=tx)
engine = ApplicationEngine(
trigger_type=TriggerType.Application,
container=tx,
table=script_table,
service=service,
gas=tx.Gas,
testMode=True
)
engine.LoadScript(tx.Script, False)
success = engine.Execute()
if not success:
raise Exception('exec failed')
service.ExecutionCompleted(engine, success)
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed = consumed.Ceil()
net_fee = None
tx_gas = None
if consumed <= Fixed8.Zero():
net_fee = Fixed8.FromDecimal(.0001)
tx_gas = Fixed8.Zero()
else:
tx_gas = consumed
net_fee = Fixed8.Zero()
tx.Gas = tx_gas
tx.outputs = outputs
tx.Attributes = []
# InvokeContract
from_addr = lookup_addr_str(wallet, from_addr)
tx = wallet.MakeTransaction(tx=tx, fee=net_fee, use_standard=True, from_addr=from_addr)
if tx is None:
raise Exception("no gas")
context = ContractParametersContext(tx)
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
tx.Serialize(writer)
ms.flush()
binary_tx = ms.ToArray()
return {'context': context.ToJson(), 'tx': binary_tx.decode()}
def test_deploy_and_invoke(deploy_script, invoke_args, wallet):
bc = GetBlockchain()
sn = bc._db.snapshot()
accounts = DBCollection(bc._db, sn, DBPrefix.ST_Account, AccountState)
assets = DBCollection(bc._db, sn, DBPrefix.ST_Asset, AssetState)
validators = DBCollection(bc._db, sn, DBPrefix.ST_Validator,
ValidatorState)
contracts = DBCollection(bc._db, sn, DBPrefix.ST_Contract, ContractState)
storages = DBCollection(bc._db, sn, DBPrefix.ST_Storage, StorageItem)
dtx = InvocationTransaction()
dtx.Version = 1
dtx.outputs = []
dtx.inputs = []
dtx.scripts = []
dtx.Script = binascii.unhexlify(deploy_script)
dtx = wallet.MakeTransaction(tx=dtx)
context = ContractParametersContext(dtx)
wallet.Sign(context)
dtx.scripts = context.GetScripts()
script_table = CachedScriptTable(contracts)
service = StateMachine(accounts, validators, assets, contracts, storages,
None)
contract = wallet.GetDefaultContract()
dtx.Attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script))
]
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=dtx,
table=script_table,
service=service,
gas=dtx.Gas,
testMode=True)
engine.LoadScript(dtx.Script, False)
# first we will execute the test deploy
# then right after, we execute the test invoke
try:
d_success = engine.Execute()
if d_success:
items = engine.EvaluationStack.Items
contract_state = None
for i in items:
if type(i) is ContractState:
contract_state = i
break
elif type(i) is InteropInterface:
item = i.GetInterface('neo.whatever')
if type(item) is ContractState:
contract_state = item
break
shash = contract_state.Code.ScriptHash()
invoke_args, neo_to_attach, gas_to_attach = get_asset_attachments(
invoke_args)
invoke_args.reverse()
sb = ScriptBuilder()
# print("neo, gas %s %s " % (neo_to_attach,gas_to_attach.ToString()))
sb = ScriptBuilder()
for p in invoke_args:
item = parse_param(p)
if type(item) is list:
item.reverse()
listlength = len(item)
for listitem in item:
sb.push(listitem)
sb.push(listlength)
sb.Emit(PACK)
else:
sb.push(item)
sb.EmitAppCall(shash.Data)
out = sb.ToArray()
outputs = []
if neo_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemShare().Hash,
Value=neo_to_attach,
script_hash=contract_state.Code.ScriptHash(),
)
outputs.append(output)
if gas_to_attach:
output = TransactionOutput(
AssetId=Blockchain.SystemCoin().Hash,
Value=gas_to_attach,
script_hash=contract_state.Code.ScriptHash())
outputs.append(output)
itx = InvocationTransaction()
itx.Version = 1
itx.outputs = outputs
itx.inputs = []
itx.scripts = []
itx.Attributes = []
itx.Script = binascii.unhexlify(out)
if len(outputs) < 1:
contract = wallet.GetDefaultContract()
itx.Attributes = [
TransactionAttribute(
usage=TransactionAttributeUsage.Script,
data=Crypto.ToScriptHash(contract.Script).Data)
]
itx = wallet.MakeTransaction(tx=itx)
context = ContractParametersContext(itx)
wallet.Sign(context)
itx.scripts = context.GetScripts()
# print("tx: %s " % json.dumps(itx.ToJson(), indent=4))
engine = ApplicationEngine(trigger_type=TriggerType.Application,
container=itx,
table=script_table,
service=service,
gas=itx.Gas,
testMode=True)
engine.LoadScript(itx.Script, False)
i_success = engine.Execute()
if i_success:
service.TestCommit()
if len(service.notifications) > 0:
for n in service.notifications:
Blockchain.Default().OnNotify(n)
consumed = engine.GasConsumed() - Fixed8.FromDecimal(10)
consumed.value = int(consumed.value)
if consumed < Fixed8.One():
consumed = Fixed8.FromDecimal(.001)
total_ops = engine.ops_processed
# set the amount of gas the tx will need
itx.Gas = consumed
itx.Attributes = []
result = engine.ResultsForCode(contract_state.Code)
return itx, result, total_ops
else:
print("error executing invoke contract...")
else:
print("error executing deploy contract.....")
except Exception as e:
print("COULD NOT EXECUTE %s " % e)
traceback.print_stack()
traceback.print_exc()
return None, [], 0