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 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 DeserializeFrom(reader):
"""
Deserialize full object.
Args:
reader (neo.IO.BinaryReader):
Returns:
Transaction:
"""
ttype = reader.ReadByte()
tx = None
from neo.Core.TX.RegisterTransaction import RegisterTransaction
from neo.Core.TX.IssueTransaction import IssueTransaction
from neo.Core.TX.ClaimTransaction import ClaimTransaction
from neo.Core.TX.MinerTransaction import MinerTransaction
from neo.Core.TX.PublishTransaction import PublishTransaction
from neo.Core.TX.InvocationTransaction import InvocationTransaction
from neo.Core.TX.EnrollmentTransaction import EnrollmentTransaction
from neo.Core.TX.StateTransaction import StateTransaction
if ttype == int.from_bytes(TransactionType.RegisterTransaction, 'little'):
tx = RegisterTransaction()
elif ttype == int.from_bytes(TransactionType.MinerTransaction, 'little'):
tx = MinerTransaction()
elif ttype == int.from_bytes(TransactionType.IssueTransaction, 'little'):
tx = IssueTransaction()
elif ttype == int.from_bytes(TransactionType.ClaimTransaction, 'little'):
tx = ClaimTransaction()
elif ttype == int.from_bytes(TransactionType.PublishTransaction, 'little'):
tx = PublishTransaction()
elif ttype == int.from_bytes(TransactionType.InvocationTransaction, 'little'):
tx = InvocationTransaction()
elif ttype == int.from_bytes(TransactionType.EnrollmentTransaction, 'little'):
tx = EnrollmentTransaction()
elif ttype == int.from_bytes(TransactionType.StateTransaction, 'little'):
tx = StateTransaction()
else:
tx = Transaction()
tx.Type = ttype
tx.DeserializeUnsignedWithoutType(reader)
tx.scripts = []
byt = reader.ReadVarInt()
if byt > 0:
for i in range(0, byt):
witness = Witness()
witness.Deserialize(reader)
tx.scripts.append(witness)
tx.OnDeserialized()
return tx
def construct_contract_withdrawal_request(wallet,
arguments,
fee=Fixed8.FromDecimal(.001),
check_holds=False):
if len(arguments) < 4:
print("not enough arguments")
return False
# AG5xbb6QqHSUgDw8cHdyU73R1xy4qD7WEE neo AdMDZGto3xWozB1HSjjVv27RL3zUM8LzpV 20
from_address = get_arg(arguments, 0)
to_send = get_arg(arguments, 1)
to_address = get_arg(arguments, 2)
amount = get_arg(arguments, 3)
assetId = get_asset_id(wallet, to_send)
f8amount = get_asset_amount(amount, assetId)
scripthash_to = wallet.ToScriptHash(to_address)
scripthash_from = wallet.ToScriptHash(from_address)
withdraw_from_watch_only = get_withdraw_from_watch_only(
wallet, scripthash_from)
if f8amount is None or scripthash_to is None or withdraw_from_watch_only is None:
print("Could not process to or from addr or amount")
return False
output = TransactionOutput(AssetId=assetId,
Value=f8amount,
script_hash=scripthash_to)
withdraw_tx = InvocationTransaction(outputs=[output])
exclude_vin = None
if check_holds:
exclude_vin = lookup_contract_holds(wallet, scripthash_from)
withdraw_constructed_tx = wallet.MakeTransaction(
tx=withdraw_tx,
change_address=scripthash_from,
fee=fee,
from_addr=scripthash_from,
use_standard=False,
watch_only_val=withdraw_from_watch_only,
exclude_vin=exclude_vin)
if withdraw_constructed_tx is not None:
return withdraw_constructed_tx
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 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 construct_withdrawal_tx(wallet, args):
from_address = get_arg(args, 0)
assetId = get_asset_id(wallet, get_arg(args, 1))
to_address = get_arg(args, 2)
f8amount = get_asset_amount(get_arg(args, 3), assetId)
scripthash_to = wallet.ToScriptHash(to_address)
scripthash_from = wallet.ToScriptHash(from_address)
withdraw_from_watch_only = get_withdraw_from_watch_only(
wallet, scripthash_from)
if f8amount is None or scripthash_to is None or withdraw_from_watch_only is None:
print("Could not process to or from addr or amount")
return False
requested_vins = get_contract_holds_for_address(wallet, scripthash_from,
scripthash_to)
use_vins_for_asset = [requested_vins, assetId]
output = TransactionOutput(AssetId=assetId,
Value=f8amount,
script_hash=scripthash_to)
withdraw_tx = InvocationTransaction(outputs=[output])
withdraw_constructed_tx = wallet.MakeTransaction(
tx=withdraw_tx,
change_address=scripthash_from,
fee=Fixed8.FromDecimal(.001),
from_addr=scripthash_from,
use_standard=False,
watch_only_val=withdraw_from_watch_only,
use_vins_for_asset=use_vins_for_asset)
if withdraw_constructed_tx is not None:
return withdraw_constructed_tx
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 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 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 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
