class BoaTest(WalletFixtureTestCase): dirname = None FIXTURE_REMOTE_LOC = 'https://s3.us-east-2.amazonaws.com/cityofzion/fixtures/fixtures_v7.tar.gz' FIXTURE_FILENAME = 'fixtures/empty_fixture.tar.gz' wallet_1_script_hash = UInt160( data=b'S\xefB\xc8\xdf!^\xbeZ|z\xe8\x01\xcb\xc3\xac/\xacI)') wallet_1_addr = 'APRgMZHZubii29UXF9uFa6sohrsYupNAvx' _wallet1 = None @classmethod def setUpClass(cls): cls.dirname = '/'.join(os.path.abspath(__file__).split('/')[:-3]) super(BoaTest, cls).setUpClass() @classmethod def GetWallet1(cls, recreate=False): if cls._wallet1 is None or recreate: cls._wallet1 = UserWallet.Open(BoaTest.wallet_1_dest(), to_aes_key(BoaTest.wallet_1_pass())) return cls._wallet1
def hex2address(input): try: output = Crypto.ToAddress( UInt160(data=binascii.unhexlify(bytearray(input.encode("utf8"))))) except: output = None return output
def Blockchain_GetAccount(self, engine): hash = UInt160(data=engine.EvaluationStack.Pop().GetByteArray()) address = Crypto.ToAddress(hash).encode('utf-8') account = self.Accounts.GetOrAdd(address, new_instance=AccountState(script_hash=hash)) engine.EvaluationStack.PushT(StackItem.FromInterface(account)) return True
def CheckDynamicInvoke(self): cx = self.CurrentContext if cx.InstructionPointer >= len(cx.Script): return True opcode = cx.NextInstruction if opcode == APPCALL: opreader = cx.OpReader # read the current position of the stream start_pos = opreader.stream.tell() # normal app calls are stored in the op reader # we read ahead past the next instruction 1 the next 20 bytes script_hash = opreader.ReadBytes(21)[1:] # then reset the position opreader.stream.seek(start_pos) for b in script_hash: # if any of the bytes are greater than 0, this is a normal app call if b > 0: return True # if this is a dynamic app call, we will arrive here # get the current executing script hash current = UInt160(data=cx.ScriptHash()) current_contract_state = self._Table.GetContractState(current.ToBytes()) # if current contract state cant do dynamic calls, return False return current_contract_state.HasDynamicInvoke return True
def Contract_Destroy(self, engine): hash = UInt160(data=engine.CurrentContext.ScriptHash()) contract = self._contracts.TryGet(hash.ToBytes()) if contract is not None: self._contracts.Remove(hash.ToBytes()) if contract.HasStorage: for pair in self._storages.Find(hash.ToBytes()): self._storages.Remove(pair.Key) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.CONTRACT_DESTROY, ContractParameter( ContractParameterType.InteropInterface, contract), hash, Blockchain.Default().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) return True
def execute(self, arguments): wallet = PromptData.Wallet if len(arguments) != 1: print("Please specify the required parameter") return False hash_string = arguments[0] try: script_hash = UInt160.ParseString(hash_string) except Exception: # because UInt160 throws a generic exception. Should be fixed in the future print("Invalid script hash") return False # try to find token and collect some data try: token = ModelNEP5Token.get(ContractHash=script_hash) except peewee.DoesNotExist: print(f"Could not find a token with script_hash {arguments[0]}") return False success = wallet.DeleteNEP5Token(script_hash) if success: print(f"Token {token.Symbol} with script_hash {arguments[0]} deleted") else: # probably unreachable to due token check earlier. Better safe than sorrow print(f"Could not find a token with script_hash {arguments[0]}") return success
def execute(self, arguments): item = get_arg(arguments) if item is not None: if item.lower() == "all": contracts = Blockchain.Default().ShowAllContracts() contractlist = [] for contract in contracts: state = Blockchain.Default().GetContract(contract.decode('utf-8')).ToJson() contract_dict = {state['name']: state['hash']} contractlist.append(contract_dict) print(json.dumps(contractlist, indent=4)) return contractlist try: hash = UInt160.ParseString(item).ToBytes() except Exception: print("Could not find contract from args: %s" % arguments) return contract = Blockchain.Default().GetContract(hash) if contract is not None: contract.DetermineIsNEP5() print(json.dumps(contract.ToJson(), indent=4)) return contract.ToJson() else: print("Contract %s not found" % item) return else: print('Please specify the required parameter') return
def get_by_contract(self, contract_hash): """ Look up a set of notifications by the contract they are associated with Args: contract_hash (UInt160 or str): hash of contract for notifications to be retreived Returns: list: a list of notifications """ hash = contract_hash if isinstance(contract_hash, str) and len(contract_hash) == 40: hash = UInt160.ParseString(contract_hash) if not isinstance(hash, UInt160): raise Exception("Incorrect address format") contractlist_snapshot = self.db.prefixed_db( NotificationPrefix.PREFIX_CONTRACT).snapshot() results = [] for val in contractlist_snapshot.iterator(prefix=bytes(hash.Data), include_key=False): if len(val) > 4: try: event = SmartContractEvent.FromByteArray(val) results.append(event) except Exception as e: logger.error("could not parse event: %s %s" % (e, val)) return results
def Storage_Delete(self, engine): context = engine.EvaluationStack.Pop().GetInterface() if not self.CheckStorageContext(context): return False key = engine.EvaluationStack.Pop().GetByteArray() storage_key = StorageKey(script_hash=context.ScriptHash, key=key) keystr = key if len(key) == 20: keystr = Crypto.ToAddress(UInt160(data=key)) self.events_to_dispatch.append( SmartContractEvent(SmartContractEvent.STORAGE_DELETE, [keystr], context.ScriptHash, Blockchain.Default().Height + 1, engine.ScriptContainer.Hash if engine.ScriptContainer else None, test_mode=engine.testMode)) self._storages.Remove(storage_key.ToArray()) return True
def Runtime_Notify(self, engine): state = engine.EvaluationStack.Pop() # Build and emit smart contract event state_py = stack_item_to_py(state) payload = state_py if isinstance(state_py, list) else [ state_py ] # Runtime.Notify payload must be a list args = NotifyEventArgs( engine.ScriptContainer, UInt160(data=engine.CurrentContext.ScriptHash()), payload) message = payload[0] if len(payload) > 0 else payload engine.write_log(str(message)) self.notifications.append(args) if settings.emit_notify_events_on_sc_execution_error: # emit Notify events even if the SC execution might fail. tx_hash = engine.ScriptContainer.Hash height = Blockchain.Default().Height success = None self.events_to_dispatch.append( NotifyEvent(SmartContractEvent.RUNTIME_NOTIFY, args.State, args.ScriptHash, height, tx_hash, success, engine.testMode)) return True
def ToScriptHash(self, address): """ Retrieve the script_hash based from an address. Args: address (str): a base58 encoded address. Raises: ValuesError: if an invalid address is supplied or the coin version is incorrect Exception: if the address string does not start with 'A' or the checksum fails Returns: UInt160: script hash. """ if len(address) == 34: if address[0] == 'A': data = b58decode(address) if data[0] != self.AddressVersion: raise ValueError('Not correct Coin Version') checksum = Crypto.Default().Hash256(data[:21])[:4] if checksum != data[21:]: raise Exception('Address format error') return UInt160(data=data[1:21]) else: raise Exception('Address format error') else: raise ValueError('Not correct Address, wrong length.')
def ImportWatchAddr(wallet, addr): if wallet is None: print("Please open a wallet") return False script_hash = None try: script_hash = wallet.ToScriptHash(addr) except Exception as e: pass if not script_hash: try: data = bytearray(binascii.unhexlify(addr.encode('utf-8'))) data.reverse() script_hash = UInt160(data=data) except Exception as e: pass if script_hash: wallet.AddWatchOnly(script_hash) print("added watch address") else: print("incorrect format for watch address")
class UserWalletTestCaseBase(WalletFixtureTestCase): wallet_1_script_hash = UInt160(data=b'\x1c\xc9\xc0\\\xef\xff\xe6\xcd\xd7\xb1\x82\x81j\x91R\xec!\x8d.\xc0') wallet_1_addr = 'AJQ6FoaSXDFzA6wLnyZ1nFN7SGSN2oNTc3' _wallet1 = None wallet_2_script_hash = UInt160(data=b'\x08t/\\P5\xac-\x0b\x1c\xb4\x94tIyBu\x7f1*') wallet_2_addr = 'AGYaEi3W6ndHPUmW7T12FFfsbQ6DWymkEm' _wallet2 = None import_watch_addr = UInt160(data=b'\x08t/\\P5\xac-\x0b\x1c\xb4\x94tIyBu\x7f1*') watch_addr_str = 'AGYaEi3W6ndHPUmW7T12FFfsbQ6DWymkEm' @property def GAS(self): return Blockchain.Default().SystemCoin().Hash @property def NEO(self): return Blockchain.Default().SystemShare().Hash @classmethod def GetWallet1(cls, recreate=False): if cls._wallet1 is None or recreate: shutil.copyfile(cls.wallet_1_path(), cls.wallet_1_dest()) cls._wallet1 = UserWallet.Open(UserWalletTestCase.wallet_1_dest(), to_aes_key(UserWalletTestCase.wallet_1_pass())) return cls._wallet1 @classmethod def GetWallet2(cls, recreate=False): if cls._wallet2 is None or recreate: shutil.copyfile(cls.wallet_2_path(), cls.wallet_2_dest()) cls._wallet2 = UserWallet.Open(UserWalletTestCase.wallet_2_dest(), to_aes_key(UserWalletTestCase.wallet_2_pass())) return cls._wallet2 @classmethod def OpenWallet1(cls): PromptData.Wallet = cls.GetWallet1(recreate=True) @classmethod def OpenWallet2(cls): PromptData.Wallet = cls.GetWallet2(recreate=True) @classmethod def tearDown(cls): PromptData.Wallet = None
class BoaFixtureTest(WalletFixtureTestCase): dirname = None FIXTURE_REMOTE_LOC = 'https://s3.us-east-2.amazonaws.com/cityofzion/fixtures/fixtures_v5.tar.gz' FIXTURE_FILENAME = './fixtures/fixtures_v5.tar.gz' wallet_1_script_hash = UInt160(data=b'S\xefB\xc8\xdf!^\xbeZ|z\xe8\x01\xcb\xc3\xac/\xacI)') wallet_1_addr = 'APRgMZHZubii29UXF9uFa6sohrsYupNAvx' _wallet1 = None wallet_2_script_hash = UInt160(data=b'4\xd0=k\x80TF\x9e\xa8W\x83\xfa\x9eIv\x0b\x9bs\x9d\xb6') wallet_2_addr = 'ALb8FEhEmtSqv97fuNVuoLmcmrSKckffRf' _wallet2 = None wallet_3_script_hash = UInt160(data=b'\xa6\xc5\x9d\xeb\xf0\xd7(\xbd\x14\x89\xcd\xb9\xd9{\xd1\x90\xcb\x0b\xdch') wallet_3_addr = 'AWygZ1B5c3GDiLL6u5bHSVU45Ya1SVGX9P' _wallet3 = None @classmethod def setUpClass(cls): super(BoaFixtureTest, cls).setUpClass() cls.dirname = '/'.join(os.path.abspath(__file__).split('/')[:-3]) @classmethod def GetWallet1(cls, recreate=False): if cls._wallet1 is None or recreate: cls._wallet1 = UserWallet.Open(BoaFixtureTest.wallet_1_dest(), to_aes_key(BoaFixtureTest.wallet_1_pass())) return cls._wallet1 @classmethod def GetWallet2(cls, recreate=False): if cls._wallet2 is None or recreate: cls._wallet2 = UserWallet.Open(BoaFixtureTest.wallet_2_dest(), to_aes_key(BoaFixtureTest.wallet_2_pass())) return cls._wallet2 @classmethod def GetWallet3(cls, recreate=False): if cls._wallet3 is None or recreate: cls._wallet3 = UserWallet.Open(BoaFixtureTest.wallet_3_dest(), to_aes_key(BoaFixtureTest.wallet_3_pass())) return cls._wallet3
def create_raw_sc_method_call_tx( source_address, source_address_wif, smartcontract_scripthash, smartcontract_method, smartcontract_method_args, ): source_script_hash = address_to_scripthash(source_address) # start by creating a base InvocationTransaction # the inputs, outputs and Type do not have to be set anymore. invocation_tx = InvocationTransaction() # often times smart contract developers use the function ``CheckWitness`` to determine if the transaction is signed by somebody eligible of calling a certain method # in order to pass that check you want to add the corresponding script_hash as a transaction attribute (this is generally the script_hash of the public key you use for signing) # Note that for public functions like the NEP-5 'getBalance' and alike this would not be needed, but it doesn't hurt either invocation_tx.Attributes.append( TransactionAttribute(usage=TransactionAttributeUsage.Script, data=source_script_hash)) smartcontract_scripthash = UInt160.ParseString(smartcontract_scripthash) # next we need to build a 'script' that gets executed against the smart contract. # this is basically the script that calls the entry point of the contract with the necessary parameters sb = ScriptBuilder() # call the method on the contract (assumes contract address is a NEP-5 token) sb.EmitAppCallWithOperationAndArgs( smartcontract_scripthash, smartcontract_method, smartcontract_method_args, ) invocation_tx.Script = binascii.unhexlify(sb.ToArray()) # at this point we've build our unsigned transaction and it's time to sign it before we get the raw output that we can send to the network via RPC # we need to create a Wallet instance for helping us with signing wallet = UserWallet.Create('path', to_aes_key('mypassword'), generate_default_key=False) # if you have a WIF use the following # this WIF comes from the `neo-test1-w.wallet` fixture wallet private_key = KeyPair.PrivateKeyFromWIF(source_address_wif) # if you have a NEP2 encrypted key use the following instead # private_key = KeyPair.PrivateKeyFromNEP2("NEP2 key string", "password string") # we add the key to our wallet wallet.CreateKey(private_key) # and now we're ready to sign context = ContractParametersContext(invocation_tx) wallet.Sign(context) invocation_tx.scripts = context.GetScripts() raw_tx = invocation_tx.ToArray() print(raw_tx) return raw_tx.decode()
def ReadUInt160(self): """ Read a UInt160 value from the stream. Returns: UInt160: """ return UInt160(data=bytearray(self.ReadBytes(20)))
def test_get_contract_state_0x(self): contract_hash = '0x%s' % UInt160(data=bytearray( b'\x11\xc4\xd1\xf4\xfb\xa6\x19\xf2b\x88p\xd3n:\x97s\xe8tp[') ).ToString() req = self._gen_rpc_req("getcontractstate", params=[contract_hash]) mock_req = mock_request(json.dumps(req).encode("utf-8")) res = json.loads(self.app.home(mock_req)) self.assertEqual(res['result']['code_version'], '3')
def Storage_GetReadOnlyContext(self, engine: ExecutionEngine): hash = UInt160(data=engine.CurrentContext.ScriptHash()) context = StorageContext(script_hash=hash, read_only=True) engine.CurrentContext.EvaluationStack.PushT( StackItem.FromInterface(context)) return True
def Blockchain_GetContract(self, engine): hash = UInt160(data=engine.EvaluationStack.Pop().GetByteArray()) contract = self.Contracts.TryGet(hash.ToBytes()) if contract is None: engine.EvaluationStack.PushT(bytearray(0)) else: engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) return True
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 Storage_GetContext(self, engine): hash = UInt160(data=engine.CurrentContext.ScriptHash()) context = StorageContext(script_hash=hash) engine.EvaluationStack.PushT(StackItem.FromInterface(context)) return True
def get_by_contract(self, request, contract_hash): request.setHeader('Content-Type', 'application/json') try: hash = UInt160.ParseString(contract_hash) notifications = self.notif.get_by_contract(hash) except Exception as e: logger.info("Could not get notifications for contract %s " % contract_hash) return self.format_message("Could not get notifications for contract hash %s because %s" % (contract_hash, e)) return self.format_notifications(request, notifications)
def test_accountstate_ToJson(self): hash = UInt160(data=self.ac2_h) account = AccountState(script_hash=hash) res = account.ToJson() self.assertEqual(res['address'], account.Address) self.assertEqual(res['script_hash'], str(hash))
def Blockchain_GetContract(self, engine): hash = UInt160(data=engine.EvaluationStack.Pop().GetByteArray()) contract = None if Blockchain.Default() is not None: contract = Blockchain.Default().GetContract(hash) engine.EvaluationStack.PushT(StackItem.FromInterface(contract)) return True
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_wallet_import_contract_addr(self): # test with no wallet open with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr', 'contract_hash', 'pubkey'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("open a wallet", mock_print.getvalue()) self.OpenWallet1() # test with not enough arguments (must have 2 arguments) with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("specify the required parameters", mock_print.getvalue()) # test with too many arguments (must have 2 arguments) with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr', 'arg1', 'arg2', 'arg3'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("specify the required parameters", mock_print.getvalue()) # test with invalid contract hash with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr', 'invalid_contract_hash', '03cbb45da6072c14761c9da545749d9cfd863f860c351066d16df480602a2024c6'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("Invalid contract hash", mock_print.getvalue()) # test with valid contract hash but that doesn't exist with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr', '31730cc9a1844891a3bafd1aa929000000000000', '03cbb45da6072c14761c9da545749d9cfd863f860c351066d16df480602a2024c6'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("Could not find contract", mock_print.getvalue()) # test with invalid pubkey with patch('sys.stdout', new=StringIO()) as mock_print: args = ['import', 'contract_addr', '31730cc9a1844891a3bafd1aa929a4142860d8d3', 'invalid_pubkey'] res = CommandWallet().execute(args) self.assertIsNone(res) self.assertIn("Invalid pubkey", mock_print.getvalue()) # test with valid arguments contract_hash = UInt160.ParseString('31730cc9a1844891a3bafd1aa929a4142860d8d3') with patch('sys.stdout', new=StringIO()) as mock_print: self.assertIsNone(PromptData.Wallet.GetContract(contract_hash)) args = ['import', 'contract_addr', '31730cc9a1844891a3bafd1aa929a4142860d8d3', '03cbb45da6072c14761c9da545749d9cfd863f860c351066d16df480602a2024c6'] res = CommandWallet().execute(args) self.assertIsInstance(res, Contract) self.assertTrue(PromptData.Wallet.GetContract(contract_hash)) self.assertIn("Added contract address", mock_print.getvalue())
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 process_hold_created_event(self, payload): if len(payload) == 4: vin = payload[0] from_addr = UInt160(data=payload[1]) to_addr = UInt160(data=payload[2]) amount = int.from_bytes(payload[3], 'little') v_index = int.from_bytes(vin[32:], 'little') v_txid = UInt256(data=vin[0:32]) if to_addr.ToBytes() in self._contracts.keys( ) and from_addr in self._watch_only: hold, created = VINHold.get_or_create( Index=v_index, Hash=v_txid.ToBytes(), FromAddress=from_addr.ToBytes(), ToAddress=to_addr.ToBytes(), Amount=amount, IsComplete=False) if created: self.LoadHolds()
def test_5_addr_conv(self): wallet = self.GetWallet1() addr = UInt160(data=b'\xec\xa8\xfc\xf9Nz*\x7f\xc3\xfdT\xae\x0e\xd3\xd3MR\xec%\x90') addr_str = 'AdMDZGto3xWozB1HSjjVv27RL3zUM8LzpV' to_uint = wallet.ToScriptHash(addr_str) self.assertEqual(to_uint, addr)
def address_to_scripthash(address): data = b58decode(address) if len(data) != 25: raise ValueError('Not correct Address, wrong length.') if data[0] != settings.ADDRESS_VERSION: raise ValueError('Not correct Coin Version') checksum = Crypto.Default().Hash256(data[:21])[:4] if checksum != data[21:]: raise Exception('Address format error') return UInt160(data=data[1:21]).ToBytes()