def Blockchain_GetBlock(self, engine: ExecutionEngine): data = engine.CurrentContext.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.CurrentContext.EvaluationStack.PushT( StackItem.FromInterface(block)) return True
def AsParameterType(type: ContractParameterType, item: StackItem): """ Convert a StackItem to a ContractParameter object of a specified ContractParameterType Args: type (neo.SmartContract.ContractParameterType): The ContractParameterType to convert to item (neo.VM.InteropService.StackItem): The item to convert to a ContractParameter object Returns: """ if type == ContractParameterType.Integer: return ContractParameter(type, value=item.GetBigInteger()) elif type == ContractParameterType.Boolean: return ContractParameter(type, value=item.GetBoolean()) elif type == ContractParameterType.Array: return ContractParameter(type, value=item.GetArray()) elif type == ContractParameterType.String: return ContractParameter(type, value=item.GetString()) elif type == ContractParameterType.InteropInterface: return ContractParameter(type, value=item.GetInterface()) # all other types return a byte array else: return ContractParameter(type, value=item.GetByteArray())
def Contract_Create(self, engine): script = engine.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int(engine.EvaluationStack.Pop().GetBigInteger()) contract_properties = int(engine.EvaluationStack.Pop().GetBigInteger()) if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False name = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False code_version = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False author = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False email = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 65536: return False description = engine.EvaluationStack.Pop().GetByteArray() hash = Crypto.ToScriptHash(script, unhex=False) contract = self._contracts.TryGet(hash.ToBytes()) if contract is None: code = FunctionCode(script=script, param_list=param_list, return_type=return_type, contract_properties=contract_properties) contract = ContractState(code, contract_properties, name, code_version, author, email, description) self._contracts.GetAndChange(code.ScriptHash().ToBytes(), contract) self._contracts_created[hash.ToBytes()] = UInt160( data=engine.CurrentContext.ScriptHash()) engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.CONTRACT_CREATED, [contract], hash, Blockchain.Default().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) return True
def Storage_GetContext(self, engine): hash = UInt160(data=engine.CurrentContext.ScriptHash()) context = StorageContext(script_hash=hash) engine.EvaluationStack.PushT(StackItem.FromInterface(context)) return True
def test_serialize_map(self): map2 = Map({ StackItem.New(b'a'): StackItem.New(1), StackItem.New(b'b'): StackItem.New(2), StackItem.New(b'c'): StackItem.New(3), }) self.engine.EvaluationStack.PushT(map2) self.state_reader.Runtime_Serialize(self.engine) self.state_reader.Runtime_Deserialize(self.engine) deserialized = self.engine.EvaluationStack.Pop() self.assertEqual(deserialized, map2) map3 = Map({ StackItem.New(b'j'): StackItem.New(8), StackItem.New(b'k'): StackItem.New(2222), }) map2.SetItem(StackItem.New(b'mymap'), map3) self.engine.EvaluationStack.PushT(map2) self.state_reader.Runtime_Serialize(self.engine) self.state_reader.Runtime_Deserialize(self.engine) deserialized = self.engine.EvaluationStack.Pop() self.assertEqual(deserialized, map2)
def test_iter_map(self): my_map = Map({ StackItem.New('a'): StackItem.New(1), StackItem.New('b'): StackItem.New(3), StackItem.New('d'): StackItem.New(432) }) self.econtext.EvaluationStack.PushT(my_map) self.engine.InvocationStack.PushT(self.econtext) self.service.Iterator_Create(self.engine) iterable = self.econtext.EvaluationStack.Peek(0).GetInterface() self.assertIsInstance(iterable, MapWrapper) keys = [] values = [] while iterable.Next(): keys.append(iterable.Key()) values.append(iterable.Value()) self.assertEqual( keys, [StackItem.New('a'), StackItem.New('b'), StackItem.New('d')]) self.assertEqual(keys, my_map.Keys) self.assertEqual( values, [StackItem.New(1), StackItem.New(3), StackItem.New(432)]) self.assertEqual(values, my_map.Values)
def test_cant_deserialize_item(self): self.econtext.EvaluationStack.PushT(StackItem.New(b'abc')) self.engine.InvocationStack.PushT(self.econtext) success = self.state_reader.Runtime_Deserialize(self.engine) self.assertFalse(success)
def Asset_Create(self, engine): tx = engine.ScriptContainer asset_type = int(engine.EvaluationStack.Pop().GetBigInteger()) if asset_type not in AssetType.AllTypes() or \ asset_type == AssetType.CreditFlag or \ asset_type == AssetType.DutyFlag or \ asset_type == AssetType.GoverningToken or \ asset_type == AssetType.UtilityToken: return False if len(engine.EvaluationStack.Peek().GetByteArray()) > 1024: return False name = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') amount = Fixed8(engine.EvaluationStack.Pop().GetBigInteger()) if amount == Fixed8.Zero() or amount < Fixed8.NegativeSatoshi(): return False if asset_type == AssetType.Invoice and amount != Fixed8.NegativeSatoshi( ): return False precision = int(engine.EvaluationStack.Pop().GetBigInteger()) if precision > 8: return False if asset_type == AssetType.Share and precision != 0: return False if amount != Fixed8.NegativeSatoshi() and amount.value % pow( 10, 8 - precision) != 0: return False ownerData = engine.EvaluationStack.Pop().GetByteArray() owner = ECDSA.decode_secp256r1(ownerData, unhex=False).G if owner.IsInfinity: return False if not self.CheckWitnessPubkey(engine, owner): logger.error("check witness false...") return False admin = UInt160(data=engine.EvaluationStack.Pop().GetByteArray()) issuer = UInt160(data=engine.EvaluationStack.Pop().GetByteArray()) new_asset = AssetState(asset_id=tx.Hash, asset_type=asset_type, name=name, amount=amount, available=Fixed8.Zero(), precision=precision, fee_mode=0, fee=Fixed8.Zero(), fee_addr=UInt160(), owner=owner, admin=admin, issuer=issuer, expiration=Blockchain.Default().Height + 1 + 2000000, is_frozen=False) asset = self._assets.GetOrAdd(tx.Hash.ToBytes(), new_asset) # print("*****************************************************") # print("CREATED ASSET %s " % tx.Hash.ToBytes()) # print("*****************************************************") engine.EvaluationStack.PushT(StackItem.FromInterface(asset)) return True
def PushT(self, item): if not type(item) is StackItem and not issubclass( type(item), StackItem): item = StackItem.New(item) self._list.append(item)
def test_wallet_token_sendfrom(self): with self.OpenWallet1(): # test with no parameters with patch('sys.stdout', new=StringIO()) as mock_print: args = ['token', 'sendfrom'] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("specify the required parameter", mock_print.getvalue()) # test with insufficient parameters with patch('sys.stdout', new=StringIO()) as mock_print: args = ['token', 'sendfrom', 'arg1'] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("specify the required parameter", mock_print.getvalue()) # test with invalid token argument with patch('sys.stdout', new=StringIO()) as mock_print: args = [ 'token', 'sendfrom', 'invalid_token_name', 'arg2', 'arg3', '10' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("does not represent a known NEP5 token", mock_print.getvalue()) # test with valid token arg, but invalid from_addr with patch('sys.stdout', new=StringIO()) as mock_print: args = [ 'token', 'sendfrom', 'NXT4', 'invalid_from_addr', 'arg3', '10' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("not a valid address", mock_print.getvalue()) # test with valid token and from_addr, but invalid to_addr with patch('sys.stdout', new=StringIO()) as mock_print: args = [ 'token', 'sendfrom', 'NXT4', 'AZfFBeBqtJvaTK9JqG8uk6N7FppQY6byEg', 'invalid_to_addr', '10' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("not a valid address", mock_print.getvalue()) # test with invalid amount with patch('sys.stdout', new=StringIO()) as mock_print: args = [ 'token', 'sendfrom', 'NXT4', 'AZfFBeBqtJvaTK9JqG8uk6N7FppQY6byEg', 'AZfFBeBqtJvaTK9JqG8uk6N7FppQY6byEg', 'invalid_amount' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("not a valid amount", mock_print.getvalue()) # setup some variables that are re-used in the tests below token = list(PromptData.Wallet.GetTokens().values())[0] addr_from = PromptData.Wallet.GetDefaultContract().Address addr_to = self.watch_addr_str # test sending with invalid password with patch('sys.stdout', new=StringIO()) as mock_print: with patch('neo.Prompt.Commands.Tokens.token_get_allowance', return_value=12300000000): with patch('neo.Wallets.NEP5Token.NEP5Token.TransferFrom', return_value=(self.Approve_Allowance( PromptData.Wallet, token))): with patch('neo.Prompt.Commands.Tokens.prompt', side_effect=['blah']): args = [ 'token', 'sendfrom', 'NXT4', addr_from, addr_to, '123' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("incorrect password", mock_print.getvalue()) # test sending something where the test run fails with patch('sys.stdout', new=StringIO()) as mock_print: exception_msg = "totally not expected error" with patch('neo.Prompt.Commands.Tokens.test_token_send_from', side_effect=[Exception(exception_msg)]): error_level = 30 with self.assertLogHandler('generic', error_level) as logs: # the args don't really matter, except for the first 2 args = [ 'token', 'sendfrom', 'NXT4', addr_from, addr_to, '123' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("Something really unexpected happened", mock_print.getvalue()) self.assertIn(exception_msg, logs.output[0]) # test having the VM fail by returning None with patch('sys.stdout', new=StringIO()) as mock_print: with patch('neo.Prompt.Commands.Tokens.test_token_send_from', side_effect=[(None, None, None, None)]): # the args don't really matter, except for the first 2 args = [ 'token', 'sendfrom', 'NXT4', addr_from, addr_to, '123' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("no Transaction object or VM output", mock_print.getvalue()) # test having the VM fail by returning a result that it not 1 with patch('sys.stdout', new=StringIO()) as mock_print: bad_vm_result = [StackItem.New(0)] fake_tx = object() fake_fee = 111 with patch('neo.Prompt.Commands.Tokens.test_token_send_from', side_effect=[(None, fake_tx, fake_fee, bad_vm_result)]): # the args don't really matter, except for the first 2 args = [ 'token', 'sendfrom', 'NXT4', addr_from, addr_to, '123' ] res = CommandWallet().execute(args) self.assertFalse(res) self.assertIn("Virtual machine returned: 0", mock_print.getvalue()) # test sending with insufficient allowance with patch('sys.stdout', new=StringIO()) as mock_print: res = CommandWallet().execute([ 'token', 'sendfrom', token.symbol, addr_from, addr_to, 10000000 ]) self.assertFalse(res) self.assertIn("Insufficient allowance", mock_print.getvalue()) with patch('neo.Prompt.Commands.Tokens.token_get_allowance', return_value=12300000000): with patch('neo.Wallets.NEP5Token.NEP5Token.TransferFrom', return_value=self.Approve_Allowance( PromptData.Wallet, token)): with patch('neo.Prompt.Commands.Tokens.prompt', side_effect=[self.wallet_1_pass()]): args = [ 'token', 'sendfrom', 'NXT4', addr_from, addr_to, '123' ] res = CommandWallet().execute(args) self.assertTrue(res)
def test_op_map13(self): self.econtext.EvaluationStack.PushT(Map(dict={StackItem.New('a'): StackItem.New(4), StackItem.New('b'): StackItem.New(5)})) self.econtext.EvaluationStack.PushT(StackItem.New('c')) self.engine.ExecuteOp(OpCode.HASKEY, self.econtext) self.assertEqual(self.econtext.EvaluationStack.Items[0].GetBoolean(), False)
def Contract_Migrate(self, engine: ExecutionEngine): script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int( engine.CurrentContext.EvaluationStack.Pop().GetBigInteger()) contract_properties = engine.CurrentContext.EvaluationStack.Pop( ).GetBigInteger() if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False name = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ).decode('utf-8') if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False version = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ).decode('utf-8') if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False author = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ).decode('utf-8') if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False email = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ).decode('utf-8') if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 65536: return False description = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ).decode('utf-8') hash = Crypto.ToScriptHash(script, unhex=False) contract = self.Snapshot.Contracts.TryGet(hash.ToBytes()) if contract is None: code = FunctionCode(script=script, param_list=param_list, return_type=return_type) contract = ContractState(code=code, contract_properties=contract_properties, name=name, version=version, author=author, email=email, description=description) self.Snapshot.Contracts.Add(hash.ToBytes(), contract) cur_hash = UInt160(data=engine.CurrentContext.ScriptHash()) self._contracts_created[hash.ToBytes()] = cur_hash if contract.HasStorage: to_add = [] for key, item in self.Snapshot.Storages.Find( cur_hash.ToArray()): key = StorageKey(script_hash=hash, key=key[20:]) to_add.append((key.ToArray(), item)) for k, v in to_add: self.Snapshot.Storages.Add(k, v) engine.CurrentContext.EvaluationStack.PushT( StackItem.FromInterface(contract)) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.CONTRACT_MIGRATED, ContractParameter( ContractParameterType.InteropInterface, contract), hash, GetBlockchain().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) return self.Contract_Destroy(engine)
def Contract_Create(self, engine: ExecutionEngine): script = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int( engine.CurrentContext.EvaluationStack.Pop().GetBigInteger()) if return_type < 0 or return_type > 0xff: raise ValueError("Invalid return type data popped from stack") contract_properties = int( engine.CurrentContext.EvaluationStack.Pop().GetBigInteger()) if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False name = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False code_version = engine.CurrentContext.EvaluationStack.Pop( ).GetByteArray() if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False author = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 252: return False email = engine.CurrentContext.EvaluationStack.Pop().GetByteArray() if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray() ) > 65536: return False description = engine.CurrentContext.EvaluationStack.Pop().GetByteArray( ) hash = Crypto.ToScriptHash(script, unhex=False) contract = self.Snapshot.Contracts.TryGet(hash.ToBytes()) if contract is None: try: code = FunctionCode(script=script, param_list=param_list, return_type=return_type, contract_properties=contract_properties) except ValueError: # exception is caused by an invalid `return_type`. neo-cli accepts this , but we throw an exception # this is a dirty hack to work around the VM state difference that it causes until neo-cli hopefully fixes it # see https://github.com/neo-project/neo/issues/827 code = FunctionCode(script=script, param_list=param_list, contract_properties=contract_properties) code.ReturnType = return_type contract = ContractState(code, contract_properties, name, code_version, author, email, description) self.Snapshot.Contracts.Add(code.ScriptHash().ToBytes(), contract) self._contracts_created[hash.ToBytes()] = UInt160( data=engine.CurrentContext.ScriptHash()) engine.CurrentContext.EvaluationStack.PushT( StackItem.FromInterface(contract)) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.CONTRACT_CREATED, ContractParameter( ContractParameterType.InteropInterface, contract), hash, GetBlockchain().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) return True
def Contract_Migrate(self, engine): script = engine.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int(engine.EvaluationStack.Pop().GetBigInteger()) contract_properties = engine.EvaluationStack.Pop().GetBigInteger() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False name = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False version = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False author = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False email = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 65536: return False description = engine.EvaluationStack.Pop().GetByteArray().decode( 'utf-8') hash = Crypto.ToScriptHash(script, unhex=False) contract = self._contracts.TryGet(hash.ToBytes()) if contract is None: code = FunctionCode(script=script, param_list=param_list, return_type=return_type) contract = ContractState(code=code, contract_properties=contract_properties, name=name, version=version, author=author, email=email, description=description) self._contracts.Add(hash.ToBytes(), contract) self._contracts_created[hash.ToBytes()] = UInt160( data=engine.CurrentContext.ScriptHash()) if contract.HasStorage: for pair in self._storages.Find( engine.CurrentContext.ScriptHash()): key = StorageKey(script_hash=hash, key=pair.Key.Key) item = StorageItem(pair.Value.Value) self._storages.Add(key, item) engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.CONTRACT_MIGRATED, [contract], hash, Blockchain.Default().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) return self.Contract_Destroy(engine)
def Key(self): return StackItem.New(self.key)
def Contract_Create(self, engine): script = engine.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int(engine.EvaluationStack.Pop().GetBigInteger()) contract_properties = int(engine.EvaluationStack.Pop().GetBigInteger()) if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False name = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False code_version = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False author = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False email = engine.EvaluationStack.Pop().GetByteArray() if len(engine.EvaluationStack.Peek().GetByteArray()) > 65536: return False description = engine.EvaluationStack.Pop().GetByteArray() hash = Crypto.ToScriptHash(script, unhex=False) contract = self._contracts.TryGet(hash.ToBytes()) if contract is None: code = FunctionCode(script=script, param_list=param_list, return_type=return_type, contract_properties=contract_properties) contract = ContractState(code, contract_properties, name, code_version, author, email, description) self._contracts.GetAndChange(code.ScriptHash().ToBytes(), contract) self._contracts_created[hash.ToBytes()] = UInt160( data=engine.CurrentContext.ScriptHash()) engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) # logger.info("*****************************************************") # logger.info("CREATED CONTRACT %s " % hash.ToBytes()) # logger.info("*****************************************************") return True
def Value(self): return StackItem.New(self.value)
def Contract_Migrate(self, engine): script = engine.EvaluationStack.Pop().GetByteArray() if len(script) > 1024 * 1024: return False param_list = engine.EvaluationStack.Pop().GetByteArray() if len(param_list) > 252: return False return_type = int(engine.EvaluationStack.Pop().GetBigInteger()) needs_storage = engine.EvaluationStack.Pop().GetBoolean() if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False name = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False version = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False author = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 252: return False email = engine.EvaluationStack.Pop().GetByteArray().decode('utf-8') if len(engine.EvaluationStack.Peek().GetByteArray()) > 65536: return False description = engine.EvaluationStack.Pop().GetByteArray().decode( 'utf-8') hash = Crypto.ToScriptHash(script, unhex=False) contract = self._contracts.TryGet(hash.ToBytes()) if contract is None: code = FunctionCode(script=script, param_list=param_list, return_type=return_type) contract = ContractState(code=code, has_storage=needs_storage, name=name, version=version, author=author, email=email, description=description) self._contracts.Add(hash.ToBytes(), contract) self._contracts_created[hash.ToBytes()] = UInt160( data=engine.CurrentContext.ScriptHash) if needs_storage: for pair in self._storages.Find( engine.CurrentContext.ScriptHash()): key = StorageKey(script_hash=hash, key=pair.Key.Key) item = StorageItem(pair.Value.Value) self._storages.Add(key, item) engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) # print("*****************************************************") # print("MIGRATED CONTRACT %s " % hash.ToBytes()) # print("*****************************************************") return True
def test_cant_serialize_iop_item(self): genesis = Blockchain.GenesisBlock() self.econtext.EvaluationStack.PushT(StackItem.FromInterface(genesis)) self.engine.InvocationStack.PushT(self.econtext) cant_do = self.state_reader.Runtime_Serialize(self.engine) self.assertEqual(cant_do, False)