def test_1_initial_setup(self):
wallet = self.GetWallet1()
jsn = wallet.ToJson()
addr = jsn['addresses'][0]
self.assertEqual(self.wallet_1_addr, addr['address'])
self.assertEqual(str(Helper.AddrStrToScriptHash(self.wallet_1_addr)),
addr['script_hash'])
gas_balance_should_be = Fixed8.FromDecimal(13.9998)
gas_balance = wallet.GetBalance(self.GAS)
self.assertEqual(gas_balance_should_be, gas_balance)
neo_balance_should_be = Fixed8.FromDecimal(50)
neo_balance = wallet.GetBalance(self.NEO)
self.assertEqual(neo_balance_should_be, neo_balance)
self.assertEqual(wallet.WalletHeight, 12351)
def test_ICOTemplate_4_attachments(self):
output = Compiler.instance().load(
'%s/boa_test/example/demo/ICO_Template.py' %
TestContract.dirname).default
out = output.write()
snapshot = self.snapshot
# test mint tokens without being kyc verified
tx, results, total_ops, engine = TestBuild(
out, ['get_attachments', '[]', '--attach-neo=10'],
self.GetWallet3(),
'0705',
'05',
snapshot=snapshot)
self.assertEqual(len(results), 1)
attachments = results[0].GetArray()
self.assertEqual(len(attachments), 4)
fn = FunctionCode(out, '0705', '05')
self.assertEqual(attachments[0].GetByteArray(), fn.ScriptHash().Data)
self.assertEqual(attachments[1].GetByteArray(),
self.wallet_3_script_hash.Data)
self.assertEqual(attachments[2].GetBigInteger(),
Fixed8.FromDecimal(10).value)
self.assertEqual(attachments[3].GetBigInteger(), 0)
tx, results, total_ops, engine = TestBuild(out,
['get_attachments', '[]'],
self.GetWallet3(),
'0705',
'05',
snapshot=snapshot)
self.assertEqual(len(results), 1)
attachments = results[0].GetArray()
self.assertEqual(len(attachments), 4)
self.assertEqual(attachments[1].GetByteArray(), bytearray())
self.assertEqual(attachments[2].GetBigInteger(), 0)
self.assertEqual(attachments[3].GetBigInteger(), 0)
tx, results, total_ops, engine = TestBuild(
out,
['get_attachments', '[]', '--attach-neo=3', '--attach-gas=3.12'],
self.GetWallet1(),
'0705',
'05',
snapshot=snapshot)
self.assertEqual(len(results), 1)
attachments = results[0].GetArray()
self.assertEqual(len(attachments), 4)
self.assertEqual(attachments[1].GetByteArray(),
self.wallet_1_script_hash.Data)
self.assertEqual(attachments[2].GetBigInteger(),
Fixed8.FromDecimal(3).value)
self.assertEqual(attachments[3].GetBigInteger(),
Fixed8.FromDecimal(3.12).value)
def test_utils_8(self):
args = [1, 2, '--attach-gas=100.0003', '--attach-neo=6']
args, neo, gas = Utils.get_asset_attachments(args)
self.assertEqual(args, [1, 2])
self.assertEqual(neo, Fixed8.FromDecimal(6))
self.assertEqual(gas, Fixed8.FromDecimal(100.0003))
def CalcChange(self, change_addr=None):
"""
Calculates the change output(s). NOTE: Assumes all other outputs have been added.
Args:
change_addr: (str, optional) specify a change address. NOTE: Defaults to the sourceAddress.
"""
if not change_addr:
change_addr = self.SOURCE_SCRIPTHASH
if change_addr != self.SOURCE_SCRIPTHASH:
change_hash = Helper.AddrStrToScriptHash(
change_addr) # also verifies if the address is valid
else:
change_hash = change_addr
if not self.outputs:
raise RawTXError(
"Please specify outputs prior to creating change output(s).")
neo = []
gas = []
for output in self.outputs:
if output.AssetId == UInt256.ParseString(self.neo_asset_id):
neo.append(output.Value.value)
elif output.AssetId == UInt256.ParseString(self.gas_asset_id):
gas.append(output.Value.value)
if self.SystemFee() > Fixed8.Zero():
gas.append(self.SystemFee().value)
if self._network_fee:
if self._network_fee > Fixed8.Zero():
gas.append(self._network_fee.value)
neo_total = 0
gas_total = 0
for asset in self.BALANCE:
if asset['asset_hash'] == self.neo_asset_id:
neo_total = asset['amount']
elif asset['asset_hash'] == self.gas_asset_id:
gas_total = asset['amount']
neo_diff = Fixed8.FromDecimal(neo_total) - Fixed8(sum(neo))
gas_diff = Fixed8.FromDecimal(gas_total) - Fixed8(sum(gas))
if neo_diff < Fixed8.Zero() or gas_diff < Fixed8.Zero():
raise AssetError('Total outputs exceed the available unspents.')
if neo_diff > Fixed8.Zero():
self.outputs.append(
TransactionOutput(AssetId=UInt256.ParseString(
self.neo_asset_id),
Value=neo_diff,
script_hash=change_hash))
if gas_diff > Fixed8.Zero() and Fixed8(sum(gas)) > Fixed8.Zero():
self.outputs.append(
TransactionOutput(AssetId=UInt256.ParseString(
self.gas_asset_id),
Value=gas_diff,
script_hash=change_hash))
def test_fixed8_ceil(self):
f8 = Fixed8.FromDecimal(4.6)
f8_ceil = f8.Ceil()
self.assertEqual(f8_ceil, Fixed8.FromDecimal(5))
f8 = Fixed8.FromDecimal(4.00000001)
f8_ceil = f8.Ceil()
self.assertEqual(f8_ceil, Fixed8.FromDecimal(5))
def test_fixed8_floor(self):
f8 = Fixed8.FromDecimal(4.9999999999)
f8_ceil = f8.Floor()
self.assertEqual(f8_ceil, Fixed8.FromDecimal(4))
f8 = Fixed8.FromDecimal(4.2)
f8_ceil = f8.Floor()
self.assertEqual(f8_ceil, Fixed8.FromDecimal(4))
def test_fixed8_tojsonstring(self):
f8 = Fixed8.FromDecimal(1.0)
self.assertEqual("1", f8.ToNeoJsonString())
f8 = Fixed8.FromDecimal(1.10)
self.assertEqual("1.1", f8.ToNeoJsonString())
f8 = Fixed8.FromDecimal(10)
self.assertEqual("10", f8.ToNeoJsonString())
f8 = Fixed8.FromDecimal(100)
self.assertEqual("100", f8.ToNeoJsonString())
f8 = Fixed8.FromDecimal(2609.997813)
self.assertEqual("2609.997813", f8.ToNeoJsonString())
def Verify(self, snapshot, mempool):
"""
Verify the transaction.
Args:
mempool:
Returns:
bool: True if verified. False otherwise.
"""
logger.debug("Verifying transaction: %s " % self.Hash.ToBytes())
# SimplePolicyPlugin
if self.Size() > self.MAX_TX_SIZE:
logger.debug(
f'Maximum transaction size exceeded: {self.Size()} > {self.MAX_TX_SIZE}'
)
return False
fee = self.NetworkFee()
if self.Size(
) > settings.MAX_FREE_TX_SIZE and not self.Type == b'\x02': # Claim Transactions are High Priority
req_fee = Fixed8.FromDecimal(
settings.FEE_PER_EXTRA_BYTE *
(self.Size() - settings.MAX_FREE_TX_SIZE))
if req_fee < settings.LOW_PRIORITY_THRESHOLD:
req_fee = settings.LOW_PRIORITY_THRESHOLD
if fee < req_fee:
logger.debug(
f'The tx size ({self.Size()}) exceeds the max free tx size ({settings.MAX_FREE_TX_SIZE}).\nA network fee of {req_fee.ToString()} GAS is required.'
)
return False
return SCHelper.Helper.VerifyWitnesses(self, snapshot)
def validate_simple_policy(tx) -> Tuple[bool, str]:
"""
Validate transaction policies
Args:
tx: Transaction object
Returns:
tuple:
result: True if it passes the policy checks. False otherwise.
error_msg: empty str if policy passes, otherwise reason for failure.
"""
# verify the maximum tx size is not exceeded
if tx.Size() > tx.MAX_TX_SIZE:
return False, f"Transaction cancelled. The tx size ({tx.Size()}) exceeds the maximum tx size ({tx.MAX_TX_SIZE})."
# calculate and verify the required network fee for the tx
fee = tx.NetworkFee()
if tx.Size(
) > settings.MAX_FREE_TX_SIZE and not tx.Type == b'\x02': # Claim Transactions are High Priority
req_fee = Fixed8.FromDecimal(settings.FEE_PER_EXTRA_BYTE *
(tx.Size() - settings.MAX_FREE_TX_SIZE))
if req_fee < settings.LOW_PRIORITY_THRESHOLD:
req_fee = settings.LOW_PRIORITY_THRESHOLD
if fee < req_fee:
return False, f'Transaction cancelled. The tx size ({tx.Size()}) exceeds the max free tx size ({settings.MAX_FREE_TX_SIZE}).\nA network fee of {req_fee.ToString()} GAS is required.'
return True, ""
def get_asset_attachments(params):
to_remove = []
neo_to_attach = None
gas_to_attach = None
for item in params:
if type(item) is str:
if '--attach-neo=' in item:
to_remove.append(item)
try:
neo_to_attach = Fixed8.TryParse(
int(item.replace('--attach-neo=', '')))
except Exception as e:
pass
if '--attach-gas=' in item:
to_remove.append(item)
try:
gas_to_attach = Fixed8.FromDecimal(
float(item.replace('--attach-gas=', '')))
except Exception as e:
pass
for item in to_remove:
params.remove(item)
return params, neo_to_attach, gas_to_attach
def test_build_contract_5(self):
"""
return from JSON-RPC is:
{'state': 'HALT, BREAK', 'script': '4d0004ababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab
abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab
abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab
abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab
abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
bababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab
abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa
babababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab046b657931057075745f356780a1a5b87921dda4603b502ada749890cb
ca3434', 'stack': [{'type': 'Integer', 'value': '1'}], 'gas_consumed': '11.151'}
"""
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/StorageTest.py", "True", "False", "True",
"070705", "05", "put_5", "key1", self.big_str
]
tx, result, total_ops, engine = BuildAndRun(arguments, wallet, False)
expected_cost = Fixed8(1046600000)
expected_gas = Fixed8.FromDecimal(1.0)
self.assertEqual(expected_cost, engine.GasConsumed())
self.assertEqual(tx.Gas, expected_gas)
def test_debug_contract_2(self):
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/BreakpointTest.py",
"True",
"False",
"True",
"02",
"01",
"4",
]
dbg = VMDebugger
dbg.start = MagicMock(return_value=None)
tx, result, total_ops, engine = BuildAndRun(
arguments,
wallet,
False,
min_fee=Fixed8.FromDecimal(.0004),
enable_debugger=True)
debugger = engine._vm_debugger
context = debugger.get_context()
context.print()
self.assertEqual(debugger.index, 157)
self.assertEqual(context.method.name, 'another_method')
self.assertEqual(context.line, 38)
def test_various_methods(self):
self.assertEqual(Fixed8.FD(), Fixed8(100000000))
self.assertEqual(Fixed8.FD(), Fixed8.One())
sat = Fixed8.Satoshi()
self.assertEqual(sat, Fixed8(1))
self.assertEqual(sat.value, 1)
negsat = Fixed8.NegativeSatoshi()
self.assertEqual(negsat, Fixed8(-1))
self.assertEqual(negsat.value, -1)
zero = Fixed8.Zero()
self.assertEqual(zero, Fixed8(0))
self.assertEqual(zero.value, 0)
decimal = 1.2
f8 = Fixed8.FromDecimal(decimal)
self.assertEqual(f8.value, f8.GetData())
f8 = Fixed8.TryParse(123.123)
f8 = Fixed8.TryParse(123)
self.assertEqual(f8.Size(), 8)
zero = Fixed8.TryParse(0)
self.assertEqual(zero, Fixed8(0))
self.assertEqual(Fixed8.TryParse("foo"), None)
self.assertEqual(Fixed8.TryParse(-1, require_positive=True), None)
def test_debug_contract_1(self):
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/BreakpointTest.py",
"True",
"False",
"True",
"02",
"01",
"1",
]
dbg = VMDebugger
# dbg.end = MagicMock(return_value=None)
dbg.start = MagicMock(return_value=None)
tx, result, total_ops, engine = BuildAndRun(
arguments, wallet, False, min_fee=Fixed8.FromDecimal(.0004))
debugger = engine._vm_debugger
context = debugger.get_context()
context.print_file()
self.assertIsInstance(debugger, VMDebugger)
self.assertIsInstance(context, DebugContext)
self.assertEqual(debugger.index, 29)
self.assertEqual(context.method.name, 'Main')
self.assertEqual(context.line, 11)
def test_utils_4(self):
args = [1, 2, '--attach-neo=100']
args, neo, gas = Utils.get_asset_attachments(args)
self.assertEqual(args, [1, 2])
self.assertEqual(neo, Fixed8.FromDecimal(100))
self.assertIsNone(gas)
def SystemFee(self):
"""
Get the system fee.
Returns:
Fixed8: currently fixed to 0.
"""
tx_name = TransactionType.ToName(self.Type)
return Fixed8.FromDecimal(settings.ALL_FEES.get(tx_name, 0))
def GetSystemFee_Validator(self):
if self.Field == "Registered":
for character in self.Value:
if character != '0':
return Fixed8.FromDecimal(1000)
return Fixed8.Zero()
raise Exception("Invalid operation")
def test_build_contract_6(self):
"""
return from JSON-RPC is:
{"state":"HALT, BREAK", "result":{"script":"05ababababab046b657931057075745f3867e2cea0ae062d6f13ce53b799e0d4fa6eaa147c38",
"gas_consumed":"9.715","stack":[{"type":"Integer","value":"1"}]}}
"""
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/StorageTest.py", "True", "False", "True",
"070705", "05", "put_9", "key1", "b'ababababab'"
]
tx, result, total_ops, engine = BuildAndRun(arguments, wallet, False)
expected_cost = Fixed8.FromDecimal(9.762)
expected_gas = Fixed8.FromDecimal(.0001)
self.assertEqual(expected_cost, engine.GasConsumed())
self.assertEqual(tx.Gas, expected_gas)
def test_2_wallet_with_claimable_gas(self):
wallet = self.GetWallet1()
unspents = wallet.FindUnspentCoinsByAsset(self.NEO)
self.assertEqual(1, len(unspents))
unavailable_bonus = wallet.GetUnavailableBonus()
self.assertEqual(Fixed8.FromDecimal(0.000601), unavailable_bonus)
unclaimed_coins = wallet.GetUnclaimedCoins()
self.assertEqual(1, len(unclaimed_coins))
available_bonus = wallet.GetAvailableClaimTotal()
self.assertEqual(Fixed8.FromDecimal(0.000288), available_bonus)
def test_enrollment_tx(self):
ms = MemoryStream(binascii.unhexlify(self.eraw))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(tx.ToArray(), self.eraw)
self.assertEqual(tx.Hash.ToBytes(), self.eid)
self.assertEqual(
Fixed8.FromDecimal(settings.ALL_FEES['EnrollmentTransaction']),
tx.SystemFee())
def test_build_contract_2(self):
"""
return from JSON-RPC is:
{'state': 'HALT, BREAK', 'script': '06abababababab046b657931057075745f356780a1a5b87921dda4603b502ada749890cbca3434',
'stack': [{'type': 'Integer', 'value': '1'}], 'gas_consumed':'6.151'}
"""
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/StorageTest.py", "True", "False", "True",
"070705", "05", "put_5", "key1", "b'abababababab'"
]
tx, result, total_ops, engine = BuildAndRun(arguments, wallet, False)
expected_cost = Fixed8.FromDecimal(5.466)
expected_fee = Fixed8.FromDecimal(.0001)
self.assertEqual(expected_cost.value, engine.GasConsumed().value)
self.assertEqual(tx.Gas.value, expected_fee.value)
self.assertEqual(bool(result), True)
def test_build_contract_4(self):
"""
return from JSON-RPC is:
{'state': 'HALT, BREAK',
'script': '06abababababab046b6579310b7075745f616e645f6765746780a1a5b87921dda4603b502ada749890cbca3434',
'stack': [{'type': 'ByteArray', 'value': 'abababababab'}], 'gas_consumed': '1.18'}
"""
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/StorageTest.py", "True", "False", "True",
"070705", "05", "put_and_get", "key1", self.big_str
]
tx, result, total_ops, engine = BuildAndRun(arguments, wallet, False)
expected_cost = Fixed8.FromDecimal(2.153)
expected_fee = Fixed8.FromDecimal(.0001)
self.assertEqual(expected_cost, engine.GasConsumed())
self.assertEqual(tx.Gas, expected_fee)
def test_testnet10412011(self):
block = Helper.AsSerializableWithType(self.block_bytes, 'neo.Core.Block.Block')
self.assertEqual(len(block.Transactions), 2)
state_tx = block.Transactions[1]
self.assertIsInstance(state_tx, StateTransaction)
self.assertEqual(len(state_tx.Descriptors), 1)
descriptor = state_tx.Descriptors[0]
self.assertIsInstance(descriptor, StateDescriptor)
self.assertEqual(descriptor.Type, StateType.Validator)
self.assertEqual(descriptor.SystemFee, Fixed8.FromDecimal(1000))
self.assertEqual(descriptor.Key, binascii.unhexlify(b'03c089d7122b840a4935234e82e26ae5efd0c2acb627239dc9f207311337b6f2c1'))
def test_verify_exceeds_free_tx_size_greater_low_priority_threshold(self):
ms = MemoryStream(binascii.unhexlify(self.vvtx))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
tx._network_fee = Fixed8.FromDecimal(0.001)
self.assertEqual(tx.ToArray(), self.vvtx)
self.assertEqual(tx.Hash.ToBytes(), self.vvtx_id)
snapshot = GetBlockchain()._db.createSnapshot()
res = tx.Verify(snapshot, [tx])
self.assertFalse(res)
tx_size = tx.Size()
self.assertGreater(tx_size, settings.MAX_FREE_TX_SIZE)
req_fee = Fixed8.FromDecimal(settings.FEE_PER_EXTRA_BYTE * (tx_size - settings.MAX_FREE_TX_SIZE))
self.assertGreater(req_fee, settings.LOW_PRIORITY_THRESHOLD)
n_fee = tx.NetworkFee()
self.assertEqual(n_fee.ToString(), "0.001")
self.assertLess(n_fee, req_fee)
def AddNetworkFee(self, fee):
"""
Specify a priority network fee.
Args:
fee: (decimal) the priority network fee
"""
if self.Type == b'\x02': # ClaimTransaction
raise RawTXError(
'Network fees are not required for ClaimTransactions.')
fee = Fixed8.FromDecimal(fee)
self._network_fee = fee
def test_6_split_unspent(self):
wallet = self.GetWallet1(recreate=True)
addr = wallet.ToScriptHash('AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3')
nodemgr = NodeManager()
nodemgr.nodes = [NeoNode(object, object)]
with patch('neo.Network.node.NeoNode.relay',
return_value=self.async_return(True)):
# bad inputs
tx = SplitUnspentCoin(None, self.NEO, addr, 0, 2)
self.assertEqual(tx, None)
tx = SplitUnspentCoin(wallet, self.NEO, addr, 3, 2)
self.assertEqual(tx, None)
tx = SplitUnspentCoin(wallet, 'bla', addr, 0, 2)
self.assertEqual(tx, None)
# should be ok
with patch('neo.Prompt.Commands.WalletAddress.prompt',
return_value=self.wallet_1_pass()):
tx = SplitUnspentCoin(wallet, self.NEO, addr, 0, 2)
self.assertIsNotNone(tx)
# rebuild wallet and try with non-even amount of neo, should be split into integer values of NEO
wallet = self.GetWallet1(True)
tx = SplitUnspentCoin(wallet, self.NEO, addr, 0, 3)
self.assertIsNotNone(tx)
self.assertEqual([
Fixed8.FromDecimal(17),
Fixed8.FromDecimal(17),
Fixed8.FromDecimal(16)
], [item.Value for item in tx.outputs])
# try with gas
wallet = self.GetWallet1(True)
tx = SplitUnspentCoin(wallet, self.GAS, addr, 0, 3)
self.assertIsNotNone(tx)
def SystemShare():
"""
Register AntShare.
Returns:
RegisterTransaction:
"""
amount = Fixed8.FromDecimal(
sum(Blockchain.GENERATION_AMOUNT) * Blockchain.DECREMENT_INTERVAL)
owner = ECDSA.secp256r1().Curve.Infinity
admin = Crypto.ToScriptHash(PUSHT)
return RegisterTransaction(
[], [], AssetType.GoverningToken,
"[{\"lang\":\"zh-CN\",\"name\":\"小蚁股\"},{\"lang\":\"en\",\"name\":\"AntShare\"}]",
amount, 0, owner, admin)
def test_build_contract(self):
"""
return from JSON-RPC is:
{'state': 'HALT, BREAK', 'script': '01ab066b6579313233037075746780a1a5b87921dda4603b502ada749890cbca3434',
'stack': [{'type': 'Integer', 'value': '1'}], 'gas_consumed': '1.056'}
"""
wallet = self.GetWallet1()
arguments = [
"neo/SmartContract/tests/StorageTest.py", "True", "False", "True",
"070705", "05", "put", "key1", "b'ab'",
"--from-addr=" + self.wallet_1_addr
]
tx, result, total_ops, engine = BuildAndRun(
arguments, wallet, False, min_fee=Fixed8.FromDecimal(.0004))
expected_cost = Fixed8(103900000)
expected_fee = Fixed8.FromDecimal(.0004)
self.assertEqual(expected_cost, engine.GasConsumed())
self.assertEqual(tx.Gas, expected_fee)
self.assertEqual(bool(result), True)
def test_register_tx(self):
ms = MemoryStream(binascii.unhexlify(self.rr))
reader = BinaryReader(ms)
tx = Transaction.DeserializeFrom(reader)
self.assertEqual(self.rrid, tx.Hash.ToBytes())
json = tx.ToJson()
asset = json['asset']
self.assertEqual(asset['admin'], 'ARFe4mTKRTETerRoMsyzBXoPt2EKBvBXFX')
self.assertEqual(asset['name'], b'[{"lang":"zh-CN","name":"TestCoin"}]')
self.assertEqual(asset['precision'], 8)
self.assertEqual(Fixed8.FromDecimal(settings.ALL_FEES['RegisterTransaction']), tx.SystemFee())
self.assertEqual(json['size'], 302)
def Query(self):
"""
Query the smart contract for its token information (name, symbol, decimals).
Args:
wallet (neo.Wallets.Wallet): a wallet instance.
Returns:
None: if the NEP5Token instance `Name` is already set.
True: if all information was retrieved.
False: if information retrieval failed.
"""
if self.name is not None:
# don't query twice
return
sb = ScriptBuilder()
sb.EmitAppCallWithOperation(self.ScriptHash, 'name')
sb.EmitAppCallWithOperation(self.ScriptHash, 'symbol')
sb.EmitAppCallWithOperation(self.ScriptHash, 'decimals')
snapshot = GetBlockchain().Default()._db.createSnapshot().Clone()
engine = None
try:
engine = ApplicationEngine.Run(snapshot,
sb.ToArray(),
exit_on_error=True,
gas=Fixed8.FromDecimal(10.0),
test_mode=False)
except Exception as e:
traceback.print_exc()
pass
if engine and len(engine.ResultStack.Items) == 3:
results = engine.ResultStack.Items
try:
self.name = results[0].GetString()
self.symbol = results[1].GetString()
self.decimals = results[2].GetBigInteger()
if len(self.name) > 1 and self.name != 'Stack Item' \
and len(self.symbol) > 1 and self.symbol != 'Stack Item' \
and self.decimals < 10:
return True
except Exception as e:
pass
return False
