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