def Blockchain_GetHeader(self, engine):
data = engine.EvaluationStack.Pop().GetByteArray()
header = None
if len(data) <= 5:
height = BigInteger.FromBytes(data)
if Blockchain.Default() is not None:
header = Blockchain.Default().GetHeaderBy(height_or_hash=height)
elif height == 0:
header = Blockchain.GenesisBlock().Header
elif len(data) == 32:
hash = UInt256(data=data)
if Blockchain.Default() is not None:
header = Blockchain.Default().GetHeaderBy(height_or_hash=hash)
elif hash == Blockchain.GenesisBlock().Hash:
header = Blockchain.GenesisBlock().Header
engine.EvaluationStack.PushT(StackItem.FromInterface(header))
return True
def GetBigInteger(self):
try:
b = BigInteger(int.from_bytes(self._value, 'little', signed=True))
return b
except Exception as e:
pass
return self._value
def GatherLoadedContractParams(args, script):
if len(args) < 5:
raise Exception(
"please specify contract properties like {params} {return_type} {needs_storage} {needs_dynamic_invoke} {is_payable}"
)
params = parse_param(args[0], ignore_int=True, prefer_hex=False)
if type(params) is str:
params = params.encode('utf-8')
return_type = BigInteger(ContractParameterType.FromString(args[1]).value)
needs_storage = bool(parse_param(args[2]))
needs_dynamic_invoke = bool(parse_param(args[3]))
is_payable = bool(parse_param(args[4]))
contract_properties = 0
if needs_storage:
contract_properties += ContractPropertyState.HasStorage
if needs_dynamic_invoke:
contract_properties += ContractPropertyState.HasDynamicInvoke
if is_payable:
contract_properties += ContractPropertyState.Payable
out = generate_deploy_script(script,
contract_properties=contract_properties,
return_type=return_type,
parameter_list=params)
return out
def generate_deploy_script(script,
name='test',
version='test',
author='test',
email='test',
description='test',
contract_properties=0,
return_type=BigInteger(255),
parameter_list=[]):
sb = ScriptBuilder()
plist = parameter_list
try:
plist = bytearray(binascii.unhexlify(parameter_list))
except Exception as e:
pass
sb.push(binascii.hexlify(description.encode('utf-8')))
sb.push(binascii.hexlify(email.encode('utf-8')))
sb.push(binascii.hexlify(author.encode('utf-8')))
sb.push(binascii.hexlify(version.encode('utf-8')))
sb.push(binascii.hexlify(name.encode('utf-8')))
sb.push(contract_properties)
sb.push(return_type)
sb.push(plist)
sb.WriteVarData(script)
sb.EmitSysCall("Neo.Contract.Create")
script = sb.ToArray()
return script
def TestBuild(script,
invoke_args,
wallet,
plist='05',
ret='05',
dynamic=False,
invoke_attrs=None,
owners=None):
properties = ContractPropertyState.HasStorage
if dynamic:
properties += ContractPropertyState.HasDynamicInvoke
if not isinstance(ret, bytearray):
ret = bytearray(binascii.unhexlify(str(ret).encode('utf-8')))
script = generate_deploy_script(script,
contract_properties=int(properties),
parameter_list=plist,
return_type=BigInteger.FromBytes(ret))
return test_deploy_and_invoke(script,
invoke_args,
wallet,
invoke_attrs=invoke_attrs,
owners=owners)
def LoadContract(args):
if len(args) < 5:
print(
"please specify contract to load like such: 'import contract {path} {params} {return_type} {needs_storage} {needs_dynamic_invoke}'"
)
return
path = args[0]
params = parse_param(args[1], ignore_int=True, prefer_hex=False)
if type(params) is str:
params = params.encode('utf-8')
return_type = BigInteger(ContractParameterType.FromString(args[2]).value)
needs_storage = bool(parse_param(args[3]))
needs_dynamic_invoke = bool(parse_param(args[4]))
contract_properties = 0
if needs_storage:
contract_properties += ContractPropertyState.HasStorage
if needs_dynamic_invoke:
contract_properties += ContractPropertyState.HasDynamicInvoke
script = None
if '.py' in path:
print("Please load a compiled .avm file")
return False
with open(path, 'rb') as f:
content = f.read()
try:
content = binascii.unhexlify(content)
except Exception as e:
pass
script = content
if script is not None:
plist = params
try:
plist = bytearray(binascii.unhexlify(params))
except Exception as e:
plist = bytearray(b'\x10')
function_code = FunctionCode(script=script,
param_list=bytearray(plist),
return_type=return_type,
contract_properties=contract_properties)
return function_code
print("error loading contract for path %s" % path)
return None
def __init__(self,
event_type,
event_payload,
contract_hash,
block_number,
tx_hash,
execution_success=False,
test_mode=False):
super(NotifyEvent, self).__init__(event_type, event_payload,
contract_hash, block_number, tx_hash,
execution_success, test_mode)
self.is_standard_notify = False
plen = len(self.event_payload)
if plen > 0:
self.notify_type = self.event_payload[0]
empty = UInt160(data=bytearray(20))
try:
if plen == 4 and self.notify_type in [
NotifyType.TRANSFER, NotifyType.APPROVE
]:
if self.event_payload[1] is None:
self.addr_from = empty
else:
self.addr_from = UInt160(
data=self.event_payload[1]) if len(
self.event_payload[1]) == 20 else empty
self.addr_to = UInt160(data=self.event_payload[2]) if len(
self.event_payload[2]) == 20 else empty
self.amount = int(BigInteger.FromBytes(
event_payload[3])) if isinstance(
event_payload[3], bytes) else int(event_payload[3])
self.is_standard_notify = True
elif plen == 3 and self.notify_type == NotifyType.REFUND:
self.addr_to = UInt160(data=self.event_payload[1]) if len(
self.event_payload[1]) == 20 else empty
self.amount = int(BigInteger.FromBytes(
event_payload[2])) if isinstance(
event_payload[2], bytes) else int(event_payload[2])
self.addr_from = self.contract_hash
self.is_standard_notify = True
except Exception as e:
logger.info("Could not determine notify event: %s %s" %
(e, self.event_payload))
def test_dunder_methods(self):
b1 = BigInteger(1)
b2 = BigInteger(2)
b3 = BigInteger(3)
self.assertEqual(abs(b1), 1)
self.assertEqual(b1 % 1, 0)
self.assertEqual(-b1, -1)
self.assertEqual(str(b1), "1")
self.assertEqual(b3 // b2, 1)
right_shift = b3 >> b1
self.assertEqual(right_shift, 1)
self.assertIsInstance(right_shift, BigInteger)
left_shift = b1 << b3
self.assertEqual(left_shift, 8)
self.assertIsInstance(left_shift, BigInteger)
def New(value):
typ = type(value)
if typ is BigInteger:
return Integer(value)
elif typ is int:
return Integer(BigInteger(value))
elif typ is float:
return Integer(BigInteger(int(value)))
elif typ is bool:
return Boolean(value)
elif typ is bytearray or typ is bytes:
return ByteArray(value)
elif typ is list:
return Array(value)
# logger.debug("Could not create stack item for vaule %s %s " % (typ, value))
return value
def __init__(self, event_type, event_payload, contract_hash, block_number, tx_hash, execution_success=False, test_mode=False):
super(NotifyEvent, self).__init__(event_type, event_payload, contract_hash, block_number, tx_hash, execution_success, test_mode)
self.is_standard_notify = False
if self.event_payload.Type == ContractParameterType.Array and len(self.event_payload.Value) > 0:
payload = self.event_payload.Value
plen = len(payload)
self.notify_type = payload[0].Value
empty = UInt160(data=bytearray(20))
try:
if plen == 4 and self.notify_type in [NotifyType.TRANSFER, NotifyType.APPROVE]:
if payload[1].Value is None:
self.addr_from = empty
logger.debug("Using contract addr from address %s " % self.event_payload)
elif payload[1].Value is False:
logger.debug("Using contract addr from address %s " % self.event_payload)
self.addr_from = empty
else:
self.addr_from = UInt160(data=payload[1].Value) if len(payload[1].Value) == 20 else empty
self.addr_to = UInt160(data=payload[2].Value) if len(payload[2].Value) == 20 else empty
self.amount = int(BigInteger.FromBytes(payload[3].Value)) if isinstance(payload[3].Value, (bytes, bytearray)) else int(payload[3].Value)
self.is_standard_notify = True
elif self.notify_type == NotifyType.REFUND and plen >= 3: # Might have more arguments
self.addr_to = UInt160(data=payload[1].Value) if len(payload[1].Value) == 20 else empty
self.amount = int(BigInteger.FromBytes(payload[2].Value)) if isinstance(payload[2].Value, (bytes, bytearray)) else int(payload[2].Value)
self.addr_from = self.contract_hash
self.is_standard_notify = True
elif self.notify_type == NotifyType.MINT and plen == 3:
self.addr_to = UInt160(data=payload[1].Value) if len(payload[1].Value) == 20 else empty
self.amount = int(BigInteger.FromBytes(payload[2].Value)) if isinstance(payload[2].Value, (bytes, bytearray)) else int(payload[2].Value)
self.addr_from = self.contract_hash
self.is_standard_notify = True
except Exception as e:
logger.debug("Could not determine notify event: %s %s" % (e, self.event_payload))
elif self.event_payload.Type == ContractParameterType.String:
self.notify_type = self.event_payload.Value
def test_1(self):
fn = FunctionCode()
self.assertEqual(fn.ReturnType, 255)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(255))
self.assertEqual(fn.ParameterList, [])
self.assertEqual(fn.HasDynamicInvoke, False)
self.assertEqual(fn.HasStorage, False)
def LoadContract(path, needs_storage, needs_dynamic_invoke, is_payable,
params_str, return_type):
params = parse_param(params_str, ignore_int=True, prefer_hex=False)
if type(params) is str:
params = params.encode('utf-8')
try:
for p in binascii.unhexlify(params):
if p == ContractParameterType.Void.value:
raise ValueError("Void is not a valid input parameter type")
except binascii.Error:
pass
rtype = BigInteger(ContractParameterType.FromString(return_type).value)
contract_properties = 0
if needs_storage:
contract_properties += ContractPropertyState.HasStorage
if needs_dynamic_invoke:
contract_properties += ContractPropertyState.HasDynamicInvoke
if is_payable:
contract_properties += ContractPropertyState.Payable
if '.avm' not in path:
raise ValueError("Please load a compiled .avm file")
script = None
with open(path, 'rb') as f:
content = f.read()
try:
content = binascii.unhexlify(content)
except Exception as e:
pass
script = content
if script:
try:
plist = bytearray(binascii.unhexlify(params))
except Exception as e:
plist = bytearray(b'\x10')
function_code = FunctionCode(script=script,
param_list=bytearray(plist),
return_type=rtype,
contract_properties=contract_properties)
return function_code
else:
raise Exception(f"Error loading contract for path {path}")
def parse_param(p, wallet=None, ignore_int=False, prefer_hex=True):
# first, we'll try to parse an array
try:
items = eval(p)
if len(items) > 0 and type(items) is list:
parsed = []
for item in items:
parsed.append(parse_param(item, wallet))
return parsed
except Exception as e:
# print("Could not eval items as array %s " % e)
pass
if not ignore_int:
try:
val = int(p)
out = BigInteger(val)
return out
except Exception as e:
pass
try:
val = eval(p)
if type(val) is bytearray:
return val.hex()
return val
except Exception as e:
pass
if type(p) is str:
if wallet is not None:
for na in wallet.NamedAddr:
if na.Title == p:
return bytearray(na.ScriptHash)
# check for address strings like 'ANE2ECgA6YAHR5Fh2BrSsiqTyGb5KaS19u' and
# convert them to a bytearray
if len(p) == 34 and p[0] == 'A':
addr = Helper.AddrStrToScriptHash(p).Data
return addr
if prefer_hex:
return binascii.hexlify(p.encode('utf-8'))
else:
return p.encode('utf-8')
return p
def test_should_persist_mint_event(self):
sc = NotifyEvent(
SmartContractEvent.RUNTIME_NOTIFY,
[b'mint', self.addr_to, BigInteger(123000)], self.contract_hash,
91349, self.event_tx, True, False)
ndb = NotificationDB.instance()
ndb.on_smart_contract_event(sc)
self.assertEqual(len(ndb.current_events), 1)
ndb.on_persist_completed(None)
def ToVM(self):
"""
Used for turning a ContractParameter item into somethnig consumable by the VM
Returns:
"""
if self.Type == ContractParameterType.String:
return str(self.Value).encode('utf-8').hex()
elif self.Type == ContractParameterType.Integer and isinstance(self.Value, int):
return BigInteger(self.Value)
return self.Value
def sc_notify(event):
logger.info("SmartContract Runtime.Notify event: %s", event)
# Make sure that the event payload list has at least one element.
if not len(event.event_payload):
return
# The event payload list has at least one element. As developer of the smart contract
# you should know what data-type is in the bytes, and how to decode it. In this example,
# it's just a string, so we decode it with utf-8:
byte_array = event.event_payload[0]
tuple = bytes(byte_array).split(b'SEPARATOR')
ts = BigInteger.FromBytes(tuple[0])
n_correct = BigInteger.FromBytes(tuple[1])
prediction = BigInteger.FromBytes(tuple[2])
logger.info("TS: {}".format(ts))
logger.info("n_correct: {}".format(n_correct))
logger.info("prediction: {}".format(prediction))
with open("../../webapp/CMC_Blockchain.txt", "w+") as f:
f.write("{},{},{}".format(ts, n_correct, prediction))
def test_6(self):
fn = FunctionCode(script=b'abcd',
param_list=[],
return_type='ByteArray')
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
fn = FunctionCode(script=b'abcd', param_list=[], return_type='05')
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'05')
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
fn = FunctionCode(script=b'abcd', param_list=[], return_type=5)
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
fn = FunctionCode(script=b'abcd', param_list=[], return_type='5')
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
fn = FunctionCode(script=b'abcd', param_list=[], return_type=b'5')
self.assertEqual(fn.ReturnType, 5)
self.assertEqual(fn.ReturnTypeBigInteger, BigInteger(5))
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_big_integer_sign(self):
b1 = BigInteger(3)
b2 = BigInteger(0)
b3 = BigInteger(-4)
self.assertEqual(b1.Sign, 1)
self.assertEqual(b2.Sign, 0)
self.assertEqual(b3.Sign, -1)
c1 = BigInteger(-100)
c1_bytes = c1.ToByteArray()
c2 = BigInteger.FromBytes(c1_bytes, signed=True)
self.assertEqual(c2.Sign, -1)
c2_unsigned = BigInteger.FromBytes(c1_bytes, signed=False)
self.assertEqual(c2_unsigned.Sign, 1)
def test_4_should_persist(self):
ndb = NotificationDB.instance()
self.assertEqual(len(ndb.current_events), 0)
sc = NotifyEvent(
SmartContractEvent.RUNTIME_NOTIFY,
[b'transfer', self.addr_to, self.addr_from,
BigInteger(123000)], self.contract_hash, 91349, self.event_tx,
True, True)
ndb.on_smart_contract_event(sc)
self.assertEqual(len(ndb.current_events), 0)
def sc_log(event):
logger.info(Wallet.AddressVersion)
logger.info("SmartContract Runtime.Notify event: %s", event)
# Make sure that the event payload list has at least one element.
if not len(event.event_payload):
return
# Make sure not test mode
if event.test_mode:
return
# The event payload list has at least one element. As developer of the smart contract
# you should know what data-type is in the bytes, and how to decode it. In this example,
# it's just a string, so we decode it with utf-8:
logger.info("- payload part 1: %s", event.event_payload[0])
game = event.event_payload[0]
#args = ['ef254dc68e36de6a3a5d2de59ae1cdff3887938f','submit',[game,2,wallet_hash]]
#x = random.randint(1, 9)
latest_price = BigInteger(float(buffer[-1][1]) * 1000)
live_ts = BigInteger(buffer[-1][0])
remainder = live_ts % normalisation
ts = live_ts - remainder
args = [
smart_contract_hash, 'submit_prediction',
[game, ts, latest_price, wallet_arr]
]
#bytearray(b'\xceG\xc5W\xb8\xb8\x906S\x06F\xa6\x18\x9b\x8c\xb1\x94\xc4\xda\xad')]]
# Start a thread with custom code
d = threading.Thread(target=test_invoke_contract, args=[args])
d.setDaemon(
True
) # daemonizing the thread will kill it when the main thread is quit
d.start()
def sc_log(event):
logger.info("SmartContract Runtime.Notify event: %s", event)
# Make sure that the event payload list has at least one element.
if not len(event.event_payload):
return
# Make sure not test mode
if event.test_mode:
return
# The event payload list has at least one element. As developer of the smart contract
# you should know what data-type is in the bytes, and how to decode it. In this example,
# it's just a string, so we decode it with utf-8:
logger.info("- payload part 1: %s", event.event_payload[0])
price = BigInteger.FromBytes(event.event_payload[0])
USD_price = float(price) / 1000.0
print(USD_price)
def construct_opdata(addressFrom,addressTo,value,assetId):
op_data=""
value=binascii.hexlify(BigInteger(value*pow(10,8)).ToByteArray()).decode()
scripthash_from=ToScriptHash(addressFrom).ToString2()
scripthash_to=ToScriptHash(addressTo).ToString2()
method=binascii.hexlify("transfer".encode()).decode()
invoke_args=[value,scripthash_to,scripthash_from]
for item in invoke_args:
op_data+="".join([int_to_hex(len(item)/2),item])
op_data+="53" #PUSH3
op_data+="c1" #PACK
op_data+=int_to_hex(len(method)/2)
op_data+=method
op_data+="67" #APPCALL
op_data+=hex_reverse(assetId)
op_data+= "f1" # maybe THROWIFNOT
return op_data
def create_opdata(address_from, address_to, value, contract_hash):
op_data = ""
value = int(value)
value = binascii.hexlify(BigInteger(value).ToByteArray()).decode()
scripthash_from = ToAddresstHash(address_from).ToString2()
scripthash_to = ToAddresstHash(address_to).ToString2()
method = binascii.hexlify("transfer".encode()).decode()
invoke_args = [value, scripthash_to, scripthash_from]
for item in invoke_args:
op_data += "".join([int_to_hex(len(item) / 2), item])
op_data += "53" # PUSH3
op_data += "c1" # PACK
op_data += int_to_hex(len(method) / 2)
op_data += method
op_data += "67" # APPCALL
op_data += hex_reverse(contract_hash)
op_data += "f1" # maybe THROWIFNOT
return op_data
def DeserializeStackItem(reader):
stype = reader.ReadUInt8()
if stype == StackItemType.ByteArray:
return ByteArray(reader.ReadVarBytes())
elif stype == StackItemType.Boolean:
return Boolean(reader.ReadByte())
elif stype == StackItemType.Integer:
return Integer(
BigInteger.FromBytes(reader.ReadVarBytes(), signed=True))
elif stype == StackItemType.Array:
stack_item = Array()
count = reader.ReadVarInt()
while count > 0:
count -= 1
stack_item.Add(StackItem.DeserializeStackItem(reader))
return stack_item
elif stype == StackItemType.Struct:
stack_item = Struct(value=None)
count = reader.ReadVarInt()
while count > 0:
count -= 1
stack_item.Add(StackItem.DeserializeStackItem(reader))
return stack_item
elif stype == StackItemType.Map:
stack_item = Map()
count = reader.ReadVarInt()
while count > 0:
count -= 1
key = StackItem.DeserializeStackItem(reader)
val = StackItem.DeserializeStackItem(reader)
stack_item.SetItem(key, val)
return stack_item
else:
logger.error("Could not deserialize stack item with type: %s " %
stype)
return None
def Blockchain_GetBlock(self, engine):
data = engine.EvaluationStack.Pop()
if data:
data = data.GetByteArray()
else:
return False
block = None
if len(data) <= 5:
height = BigInteger.FromBytes(data)
if Blockchain.Default() is not None:
block = Blockchain.Default().GetBlockByHeight(height)
elif height == 0:
block = Blockchain.GenesisBlock()
elif len(data) == 32:
hash = UInt256(data=data).ToBytes()
if Blockchain.Default() is not None:
block = Blockchain.Default().GetBlockByHash(hash=hash)
elif hash == Blockchain.GenesisBlock().Hash:
block = Blockchain.GenesisBlock().Header
engine.EvaluationStack.PushT(StackItem.FromInterface(block))
return True
def GetBigInteger(self):
return BigInteger(
int.from_bytes(self.GetByteArray(), 'little', signed=True))
def _make_tx(self, address_to):
"""
Function that creates the parameters for the NEP-5 transfer function and then calls it,
returning the transaction info
:param address_to: address to send the tokens to
:return:
transaction info
"""
drip_amount = BigInteger(10000)
amount = BigInteger(
drip_amount * 100000000
) # must multiply by Fixed8.D and must be BigInteger object
self.invoke_args.clear()
self.params.clear(
) # make sure that invoke_args and params lists are empty
scripthash_from = Helper.AddrStrToScriptHash(
address=self.faucet_wallet_addr).ToArray()
scripthash_to = address_to
self.invoke_args.append(scripthash_from)
self.invoke_args.append(scripthash_to)
self.invoke_args.append(amount)
self.params = [
self.token_script_hash.encode('utf-8'), self.OPERATION,
self.invoke_args
]
nonce = struct.pack('>i',
int(time())) # convert the int to a big endian int
# the int(time()) is the time in seconds since the epoch (01/01/1970 for UNIX systems)
# the nonce was used to append to the TransactionAttribute so that each transaction has slightly
# different data. Otherwise, each transaction would constantly be given the same transaction hash because
# all of their parameters are the same
# TransactionAttributeUsage.Remark is b'\xf0' = 240
invoke_attributes = [
TransactionAttribute(usage=TransactionAttributeUsage.Remark,
data=nonce)
]
# the following test invokes the contract (useful to ensure that noting is wrong)
tx, fee, results, num_ops = TestInvokeContract(
wallet=self.wallet,
args=self.params,
from_addr=self.faucet_wallet_addr,
min_fee=Fixed8.Zero(),
invoke_attrs=invoke_attributes)
# the following is just used for logging info
if tx is not None and results is not None:
logger.info('\n------------------------')
for item in results:
logger.info(f'Results: {str(item)}')
if not len(str(item)) % 2:
try:
logger.info(
f'Hex decode: {binascii.unhexlify(str(item))}')
except Exception:
logger.warning('Not hex encoded')
logger.info(f'Invoke TX gas cost: {(tx.Gas.value / Fixed8.D)}')
logger.info(f'Invoke TX Fee: {(fee.value / Fixed8.D)}')
logger.info('Relaying invocation tx now')
logger.info('------------------------\n')
# invoke the contract
self.sent_tx = InvokeContract(wallet=self.wallet,
tx=tx,
fee=Fixed8.Zero(),
from_addr=self.faucet_wallet_addr)
sleep(
3
) # allow a few seconds for the contract to be invoked and return the tx info is actually passed
return self.sent_tx
def parse_param(p,
wallet=None,
ignore_int=False,
prefer_hex=True,
parse_addr=True):
# first, we'll try to parse an array
try:
items = eval(p, {"__builtins__": {'list': list}}, {})
if len(items) > 0 and type(items) is list:
parsed = []
for item in items:
parsed.append(parse_param(item, wallet, parse_addr=parse_addr))
return parsed
except Exception as e:
# print("Could not eval items as array %s " % e)
pass
if not ignore_int:
try:
val = int(p)
out = BigInteger(val)
return out
except Exception as e:
pass
try:
val = eval(p, {
"__builtins__": {
'bytearray': bytearray,
'bytes': bytes,
'list': list
}
}, {})
if type(val) is bytearray:
return val
elif type(val) is bytes:
# try to unhex
try:
val = binascii.unhexlify(val)
except Exception as e:
pass
# now it should be unhexxed no matter what, and we can hex it
return val.hex().encode('utf-8')
elif type(val) is bool:
return val
except Exception as e:
pass
if type(p) is str:
if wallet is not None:
for na in wallet.NamedAddr:
if na.Title == p:
return bytearray(na.ScriptHash)
# check for address strings like 'ANE2ECgA6YAHR5Fh2BrSsiqTyGb5KaS19u' and
# convert them to a bytearray
if parse_addr and len(p) == 34 and p[0] == 'A':
addr = Helper.AddrStrToScriptHash(p).Data
return addr
if prefer_hex:
return binascii.hexlify(p.encode('utf-8'))
else:
return p.encode('utf-8')
return p
def ReturnTypeBigInteger(self):
return BigInteger(self.ReturnType)
