def test_tx_signed(self):
expected = {
'inputs': [{'address': Address.from_string('13Vp8Y3hD5Cb6sERfpxePz5vGJizXbWciN'),
'num_sig': 1,
'prevout_hash': 'ed6a4d07e546b677abf6ba1257c2546128c694f23f4b9ebbd822fdfe435ef349',
'prevout_n': 1,
'pubkeys': ['03b5bbebceeb33c1b61f649596b9c3611c6b2853a1f6b48bce05dd54f667fa2166'],
'scriptSig': '473044022025bdc804c6fe30966f6822dc25086bc6bb0366016e68e880cf6efd2468921f3202200e665db0404f6d6d9f86f73838306ac55bb0d0f6040ac6047d4e820f24f46885412103b5bbebceeb33c1b61f649596b9c3611c6b2853a1f6b48bce05dd54f667fa2166',
'sequence': 4294967294,
'signatures': ['3044022025bdc804c6fe30966f6822dc25086bc6bb0366016e68e880cf6efd2468921f3202200e665db0404f6d6d9f86f73838306ac55bb0d0f6040ac6047d4e820f24f4688541'],
'type': 'p2pkh',
'x_pubkeys': ['03b5bbebceeb33c1b61f649596b9c3611c6b2853a1f6b48bce05dd54f667fa2166']}],
'lockTime': 507231,
'outputs': [{'address': Address.from_string('1MYXdf4moacvaEKZ57ozerpJ3t9xSeN6LK'),
'prevout_n': 0,
'scriptPubKey': '76a914e158fb15c888037fdc40fb9133b4c1c3c688706488ac',
'type': 0,
'value': 20112408}],
'version': 1
}
tx = transaction.Transaction(signed_blob)
self.assertEqual(tx.deserialize(), expected)
self.assertEqual(tx.deserialize(), None)
self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True})
self.assertEqual(tx.serialize(), signed_blob)
tx.update_signatures(signed_blob)
self.assertEqual(tx.estimated_size(), 191)
def test_electrum_multisig_seed_standard(self, mock_write):
seed_words = 'blast uniform dragon fiscal ensure vast young utility dinosaur abandon rookie sure'
self.assertEqual(bitcoin.seed_type(seed_words), 'standard')
ks1 = keystore.from_seed(seed_words, '', True)
self._check_seeded_keystore_sanity(ks1)
self.assertTrue(isinstance(ks1, keystore.BIP32_KeyStore))
self.assertEqual(
ks1.xpub,
'xpub661MyMwAqRbcGNEPu3aJQqXTydqR9t49Tkwb4Esrj112kw8xLthv8uybxvaki4Ygt9xiwZUQGeFTG7T2TUzR3eA4Zp3aq5RXsABHFBUrq4c'
)
ks2 = keystore.from_xpub(
'xpub661MyMwAqRbcGfCPEkkyo5WmcrhTq8mi3xuBS7VEZ3LYvsgY1cCFDbenT33bdD12axvrmXhuX3xkAbKci3yZY9ZEk8vhLic7KNhLjqdh5ec'
)
self._check_xpub_keystore_sanity(ks2)
self.assertTrue(isinstance(ks2, keystore.BIP32_KeyStore))
w = self._create_multisig_wallet(ks1, ks2)
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('32ji3QkAgXNz6oFoRfakyD3ys1XXiERQYN'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('36XWwEHrrVCLnhjK5MrVVGmUHghr9oWTN1'))
def test_electrum_seed_standard(self, mock_write):
seed_words = 'cycle rocket west magnet parrot shuffle foot correct salt library feed song'
self.assertEqual(bitcoin.seed_type(seed_words), 'standard')
ks = keystore.from_seed(seed_words, '', False)
WalletIntegrityHelper.check_seeded_keystore_sanity(self, ks)
self.assertTrue(isinstance(ks, keystore.BIP32_KeyStore))
self.assertEqual(
ks.xprv,
'xprv9s21ZrQH143K2ghMCZbyreZcic8NSSuC8AG1gSTVPdvjiXufyQJyEVwUmS7EBtsH1YKdaMC17EBDrSzpe7M4k48FUYtJpzJNNptxbnpHEXL'
)
self.assertEqual(
ks.xpub,
'xpub661MyMwAqRbcFAmpJb8zDnWMGdxrqud3VPBcUps6wyTibLEpWwdDnJFxchhCazNLf4xNd3SpAEifKJoL4LSy5jBj2iqXdrfBMmxTWevpCQs'
)
w = WalletIntegrityHelper.create_standard_wallet(ks)
self.assertEqual(w.txin_type, 'p2pkh')
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('t1WuqhS6byNzoKu3LJrpfv2BGp7oiATxzyn'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('t1fvzMLWaFGdJnsJ7K5Ju1jMuC3bKexciyL'))
def createTransaction(self, password, destList):
"""Create a new transaction and send it to the RelayNode
destList is a list of tuples
Each tuples is like : (str_address, value)
The last transaction is the rest of the wallet send to the new user address
"""
self.checkUpdate()
newAddr = Address()
newAddr.encryptPrivateKey(password)
total = sum([i[1] for i in destList])
if total <= self.count:
destList.append((str(newAddr), (self.count - total)))
transac = Transaction(self.addr.public(), destList)
self.addr.decryptPrivateKey(password)
transac.sign(self.addr)
debug('valid: ' + ('True' if transac.is_signed() else 'False'))
self.addr.encryptPrivateKey(password)
if not self.relay.submit_transaction(transac):
return False
self.addrList.append(newAddr)
self.addr = newAddr
add_address(self.user_ID, self.addr, len(self.addrList) - 1)
return True
else:
return False
def test_bip39_multisig_seed_bip45_standard(self, mock_write):
seed_words = 'treat dwarf wealth gasp brass outside high rent blood crowd make initial'
self.assertEqual(keystore.bip39_is_checksum_valid(seed_words),
(True, True))
ks1 = keystore.from_bip39_seed(seed_words, '', "m/45'/0")
self.assertTrue(isinstance(ks1, keystore.BIP32_KeyStore))
self.assertEqual(
ks1.xprv,
'xprv9w8rAFAEVWArZQjheVqb3wkb2s4LzyCz8crjnsz9Le2hXbsvp6x1vxk1aC7GinLWBGkADbBnCbU9cLe7goagdHAdDYk231FK9uWp6nbVN8a'
)
self.assertEqual(
ks1.xpub,
'xpub6A8CZkh8Ksj9mtpAkXNbR5hKattqQRvqVqnLbGPktyZgQQD5MeGGUm4VRUxfX8jBebX9bcwK7V234sCqboDBxcmA9qSZpy7gnmysRWGdzoz'
)
# bip39 seed: tray machine cook badge night page project uncover ritual toward person enact
# der: m/45'/0
ks2 = keystore.from_xpub(
'xpub6Bco9vrgo8rNUSi8Bjomn8xLA41DwPXeuPcgJamNRhTTyGVHsp8fZXaGzp9ypHoei16J6X3pumMAP1u3Dy4jTSWjm4GZowL7Dcn9u4uZC9W'
)
WalletIntegrityHelper.check_xpub_keystore_sanity(self, ks2)
self.assertTrue(isinstance(ks2, keystore.BIP32_KeyStore))
w = WalletIntegrityHelper.create_multisig_wallet(ks1, ks2)
self.assertEqual(w.txin_type, 'p2sh')
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('t3YmFV8iPfehb2aVAmod4bEqFVwQTGf4j1i'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('t3ND13q6EWVnYUme5Ko6VAYxPbP6bae2RcH'))
def test_electrum_multisig_seed_standard(self, mock_write):
seed_words = 'blast uniform dragon fiscal ensure vast young utility dinosaur abandon rookie sure'
self.assertEqual(bitcoin.seed_type(seed_words), 'standard')
ks1 = keystore.from_seed(seed_words, '', True)
WalletIntegrityHelper.check_seeded_keystore_sanity(self, ks1)
self.assertTrue(isinstance(ks1, keystore.BIP32_KeyStore))
self.assertEqual(
ks1.xprv,
'xprv9s21ZrQH143K2qPRVQ1Z66ZqoNSWoyxWdBXKivnt1TCaAoe7Pa74eYxWRtpSnYrZsvoBcxJqM6H2sGrzkQDPcHKUwztcwSpkTYpAz5y3LJh'
)
self.assertEqual(
ks1.xpub,
'xpub661MyMwAqRbcFKTtbRYZTEWaMQH1DSgMzQSvXKCVZnjZ3byFw7RKCMGzH9G2U7MTTxYuaEhL3suS4HFGHb66QbiDaHPgCZoGNx2678FKe3X'
)
# electrum seed: ghost into match ivory badge robot record tackle radar elbow traffic loud
ks2 = keystore.from_xpub(
'xpub661MyMwAqRbcGfCPEkkyo5WmcrhTq8mi3xuBS7VEZ3LYvsgY1cCFDbenT33bdD12axvrmXhuX3xkAbKci3yZY9ZEk8vhLic7KNhLjqdh5ec'
)
WalletIntegrityHelper.check_xpub_keystore_sanity(self, ks2)
self.assertTrue(isinstance(ks2, keystore.BIP32_KeyStore))
w = WalletIntegrityHelper.create_multisig_wallet(ks1, ks2)
self.assertEqual(w.txin_type, 'p2sh')
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('t3eXoCQLLLZnf95PhrrQhoDTsGdR8FwLhXe'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('t3RoTuEy2FbMgP3urUmYTFpbajjbMpECh9S'))
def test_bip39_seed_bip44_standard(self, mock_write):
seed_words = 'treat dwarf wealth gasp brass outside high rent blood crowd make initial'
self.assertEqual(keystore.bip39_is_checksum_valid(seed_words),
(True, True))
ks = keystore.from_bip39_seed(seed_words, '', "m/44'/0'/0'")
self.assertTrue(isinstance(ks, keystore.BIP32_KeyStore))
self.assertEqual(
ks.xprv,
'xprv9z8mPoJhK3FiPpzM3gPVYxLkaq6QeCYpwLheSgPBHH3RURwnZYaTqxzLWnkyFMtV1vm8hGTkEjrJRoYegJwgFKEg1K9bsdf3UrpcAcnSj6w'
)
self.assertEqual(
ks.xpub,
'xpub6D87oJqb9Qp1cK4p9hvVv6HV8rvu3fGgJZdFF4nnqcaQMEGw75tiPmJpN3CQrZR9gpHe7zycB78ynLfT3v6451qoC8k3YcGyiuWyWzuXaKN'
)
w = WalletIntegrityHelper.create_standard_wallet(ks)
self.assertEqual(w.txin_type, 'p2pkh')
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('t1fiRjRCGirFb2PprWzYdXjukAAuYB89Gzz'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('t1SVeFNqPq3SzuuzWmbJjj6TX9W8kv7eWJL'))
def transfer(bc, relay, from_addr, to_addr, amount):
f = get_address(from_addr)
if f is None:
exit('no address '+str(from_addr)+' in database')
total = bc.get_amount_of_address(f)
if total < amount:
exit('not enough money for this transfer')
pwd = getpass.getpass()
while not f.decryptPrivateKey(pwd):
print('Invalid password')
pwd = getpass.getpass()
receivers = [(to_addr, amount)]
if total > amount:
new = Address()
new.encryptPrivateKey(pwd)
db.add_address('client', new, 0)
print('created new address '+str(new)+' to receive remaining funds')
receivers.append((str(new), total - amount))
t = Transaction(f, receivers)
if relay.submit_transaction(t):
print('transaction sent to the network')
else:
print('error sending transaction')
def test_bip39_multisig_seed_bip45_standard(self, mock_write):
seed_words = 'treat dwarf wealth gasp brass outside high rent blood crowd make initial'
self.assertEqual(keystore.bip39_is_checksum_valid(seed_words),
(True, True))
ks1 = keystore.from_bip39_seed(seed_words, '', "m/45'/0")
self.assertTrue(isinstance(ks1, keystore.BIP32_KeyStore))
self.assertEqual(
ks1.xpub,
'xpub69xafV4YxC6o8Yiga5EiGLAtqR7rgNgNUGiYgw3S9g9pp6XYUne1KxdcfYtxwmA3eBrzMFuYcNQKfqsXCygCo4GxQFHfywxpUbKNfYvGJka'
)
ks2 = keystore.from_xpub(
'xpub6Bco9vrgo8rNUSi8Bjomn8xLA41DwPXeuPcgJamNRhTTyGVHsp8fZXaGzp9ypHoei16J6X3pumMAP1u3Dy4jTSWjm4GZowL7Dcn9u4uZC9W'
)
self._check_xpub_keystore_sanity(ks2)
self.assertTrue(isinstance(ks2, keystore.BIP32_KeyStore))
w = self._create_multisig_wallet(ks1, ks2)
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('3H3iyACDTLJGD2RMjwKZcCwpdYZLwEZzKb'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('31hyfHrkhNjiPZp1t7oky5CGNYqSqDAVM9'))
def __init__(self, token_address, web3, end_block):
self._token_address = token_address.lower()
self._end_block = end_block
# contract
self._erc20_token = ERC20Token(web3=web3,
address=Address(token_address))
self._erc20_decimals = self._erc20_token.decimals
self._logger = logging.getLogger()
def __init__(self):
self._logger = logging.getLogger()
config.LOG_CONFIG["handlers"]["file_handler"]["filename"] = config.PAYER_LOGPATH
logging.config.dictConfig(config.LOG_CONFIG)
self._web3 = Web3(HTTPProvider(endpoint_uri=config.ETH_RPC_URL,
request_kwargs={"timeout": config.ETH_RPC_TIMEOUT}))
self._web3.middleware_onion.inject(geth_poa_middleware, layer=0)
self._gas_price = self._web3.toWei(50, "gwei")
self._get_gas_price()
self._payer_account = None
# contract
self._disperse = Disperse(
web3=self._web3, address=Address(config.DISPERSE_ADDRESS))
self._MCBToken = ERC20Token(
web3=self._web3, address=Address(config.MCB_TOKEN_ADDRESS))
def __init__(self, perpetual_address, inverse, web3):
self._perpetual_address = web3.toChecksumAddress(perpetual_address)
self._inverse = inverse
# contract
self._perpetual = Perpetual(
web3=web3, address=Address(self._perpetual_address))
self._logger = logging.getLogger()
def _check_account_from_key(self):
try:
account = Account()
acct = account.from_key(config.PAYER_KEY)
self._web3.middleware_onion.add(
construct_sign_and_send_raw_middleware(acct))
self._payer_account = Address(acct.address)
except:
self._logger.fatal(f"Account {config.PAYER_ADDRESS} register key error")
return False
return True
def loadAddressList(user_ID):
"""Load a list with all address from the user
"""
addrList = []
conn = sqlite3.connect(DB_PATH)
cursor = conn.cursor()
cursor.execute("""SELECT addr FROM addrList WHERE user_ID=? ORDER BY num""", (user_ID,))
for addr in cursor.fetchall():
addrList.append(Address.fromJson(addr[0]))
conn.close()
return addrList
def test_electrum_seed_old(self, mock_write):
seed_words = 'powerful random nobody notice nothing important anyway look away hidden message over'
self.assertEqual(bitcoin.seed_type(seed_words), 'old')
ks = keystore.from_seed(seed_words, '', False)
self._check_seeded_keystore_sanity(ks)
self.assertTrue(isinstance(ks, keystore.Old_KeyStore))
self.assertEqual(
ks.mpk,
'e9d4b7866dd1e91c862aebf62a49548c7dbf7bcc6e4b7b8c9da820c7737968df9c09d5a3e271dc814a29981f81b3faaf2737b551ef5dcc6189cf0f8252c442b3'
)
w = self._create_standard_wallet(ks)
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('1FJEEB8ihPMbzs2SkLmr37dHyRFzakqUmo'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('1KRW8pH6HFHZh889VDq6fEKvmrsmApwNfe'))
def __init__(self, user_ID, password):
"""Create a new wallet
user_ID : The ID of the user to select it's own address on the DB
password : The password is used to generate a AES_Key to ecrypt / decrypt the private key on DB
Here, we used it to load all the address or write the new address
"""
self.blockChain = Blockchain('client')
self.relay = RelayClient()
self.updater = Updater(self.blockChain, self.relay)
self.updater.update()
self.user_ID = user_ID
self.addrList = loadAddressList(self.user_ID) # list of address
self.last = len(self.addrList) - 1 #index of the actual address
if self.addrList == []: #New Wallet : Create the first Address
self.addr = Address()
self.addr.encryptPrivateKey(password)
add_address(self.user_ID, self.addr, 0)
self.addrList.append(self.addr)
else:
self.addr = self.addrList[len(self.addrList) - 1]
self.count = self.blockChain.get_amount_of_address(self.addr)
def test_bip39_seed_bip44_standard(self, mock_write):
seed_words = 'treat dwarf wealth gasp brass outside high rent blood crowd make initial'
self.assertEqual(keystore.bip39_is_checksum_valid(seed_words),
(True, True))
ks = keystore.from_bip39_seed(seed_words, '', "m/44'/0'/0'")
self.assertTrue(isinstance(ks, keystore.BIP32_KeyStore))
self.assertEqual(
ks.xpub,
'xpub6DFh1smUsyqmYD4obDX6ngaxhd53Zx7aeFjoobebm7vbkT6f9awJWFuGzBT9FQJEWFBL7UyhMXtYzRcwDuVbcxtv9Ce2W9eMm4KXLdvdbjv'
)
w = self._create_standard_wallet(ks)
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('16j7Dqk3Z9DdTdBtHcCVLaNQy9MTgywUUo'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('1GG5bVeWgAp5XW7JLCphse14QaC4qiHyWn'))
def test_electrum_seed_standard(self, mock_write):
seed_words = 'cycle rocket west magnet parrot shuffle foot correct salt library feed song'
self.assertEqual(bitcoin.seed_type(seed_words), 'standard')
ks = keystore.from_seed(seed_words, '', False)
self._check_seeded_keystore_sanity(ks)
self.assertTrue(isinstance(ks, keystore.BIP32_KeyStore))
self.assertEqual(
ks.xpub,
'xpub661MyMwAqRbcFWohJWt7PHsFEJfZAvw9ZxwQoDa4SoMgsDDM1T7WK3u9E4edkC4ugRnZ8E4xDZRpk8Rnts3Nbt97dPwT52CwBdDWroaZf8U'
)
w = self._create_standard_wallet(ks)
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('1NNkttn1YvVGdqBW4PR6zvc3Zx3H5owKRf'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('1KSezYMhAJMWqFbVFB2JshYg69UpmEXR4D'))
def test_electrum_seed_old(self, mock_write):
seed_words = 'powerful random nobody notice nothing important anyway look away hidden message over'
self.assertEqual(bitcoin.seed_type(seed_words), 'old')
ks = keystore.from_seed(seed_words, '', False)
WalletIntegrityHelper.check_seeded_keystore_sanity(self, ks)
self.assertTrue(isinstance(ks, keystore.Old_KeyStore))
self.assertEqual(
ks.mpk,
'e9d4b7866dd1e91c862aebf62a49548c7dbf7bcc6e4b7b8c9da820c7737968df9c09d5a3e271dc814a29981f81b3faaf2737b551ef5dcc6189cf0f8252c442b3'
)
w = WalletIntegrityHelper.create_standard_wallet(ks)
self.assertEqual(w.txin_type, 'p2pkh')
self.assertEqual(
w.get_receiving_addresses()[0],
Address.from_string('t1YAqEWYrfi9CbW5LgmayAvjDE5T5MgaYiD'))
self.assertEqual(
w.get_change_addresses()[0],
Address.from_string('t1cJ799hEFa5AHmB3ReeDo3Rr2X4quderf4'))
def test_tx_signed(self):
expected = {
'overwintered': False,
'inputs': [{
'type': 'p2pkh',
'address': Address.from_string('t1LvhooU7zQuqEtjZZN83EL8QSBUkd8WkHR'),
'num_sig': 1,
'prevout_hash': '3140eb24b43386f35ba69e3875eb6c93130ac66201d01c58f598defc949a5c2a',
'prevout_n': 0,
'pubkeys': ['02e61d176da16edd1d258a200ad9759ef63adf8e14cd97f53227bae35cdb84d2f6'],
'scriptSig': '493046022100a82bbc57a0136751e5433f41cf000b3f1a99c6744775e76ec764fb78c54ee100022100f9e80b7de89de861dc6fb0c1429d5da72c2b6b2ee2406bc9bfb1beedd729d985012102e61d176da16edd1d258a200ad9759ef63adf8e14cd97f53227bae35cdb84d2f6',
'sequence': 4294967295,
'signatures': ['3046022100a82bbc57a0136751e5433f41cf000b3f1a99c6744775e76ec764fb78c54ee100022100f9e80b7de89de861dc6fb0c1429d5da72c2b6b2ee2406bc9bfb1beedd729d98501'],
'x_pubkeys': ['02e61d176da16edd1d258a200ad9759ef63adf8e14cd97f53227bae35cdb84d2f6']}],
'lockTime': 0,
'outputs': [{
'address': Address.from_string('t1M4tYuzKx46ARb7hDcdnMAjkx8Acdrbd9Z'),
'prevout_n': 0,
'scriptPubKey': '76a914230ac37834073a42146f11ef8414ae929feaafc388ac',
'type': TYPE_ADDRESS,
'value': 1000000}],
'version': 1
}
tx = transaction.Transaction(signed_blob)
self.assertEqual(tx.deserialize(), expected)
self.assertEqual(tx.deserialize(), None)
self.assertEqual(tx.as_dict(), {'hex': signed_blob, 'complete': True, 'final': True})
self.assertEqual(tx.serialize(), signed_blob)
tx.update_signatures(signed_blob)
self.assertEqual(tx.estimated_total_size(), 193)
self.assertEqual(tx.estimated_base_size(), 193)
self.assertEqual(tx.estimated_weight(), 772)
self.assertEqual(tx.estimated_size(), 193)
def test_tx_unsigned(self):
expected = {
'overwintered': False,
'inputs': [{
'type': 'p2pkh',
'address': Address.from_string('t1LvhooU7zQuqEtjZZN83EL8QSBUkd8WkHR'),
'num_sig': 1,
'prevout_hash': '3140eb24b43386f35ba69e3875eb6c93130ac66201d01c58f598defc949a5c2a',
'prevout_n': 0,
'pubkeys': ['02e61d176da16edd1d258a200ad9759ef63adf8e14cd97f53227bae35cdb84d2f6'],
'scriptSig': '01ff4c53ff0488b21e03ef2afea18000000089689bff23e1e7fb2f161daa37270a97a3d8c2e537584b2d304ecb47b86d21fc021b010d3bd425f8cf2e04824bfdf1f1f5ff1d51fadd9a41f9e3fb8dd3403b1bfe00000000',
'sequence': 4294967295,
'signatures': [None],
'x_pubkeys': ['ff0488b21e03ef2afea18000000089689bff23e1e7fb2f161daa37270a97a3d8c2e537584b2d304ecb47b86d21fc021b010d3bd425f8cf2e04824bfdf1f1f5ff1d51fadd9a41f9e3fb8dd3403b1bfe00000000']}],
'lockTime': 0,
'outputs': [{
'address': Address.from_string('t1M4tYuzKx46ARb7hDcdnMAjkx8Acdrbd9Z'),
'prevout_n': 0,
'scriptPubKey': '76a914230ac37834073a42146f11ef8414ae929feaafc388ac',
'type': TYPE_ADDRESS,
'value': 1000000}],
'version': 1
}
tx = transaction.Transaction(unsigned_blob)
self.assertEqual(tx.deserialize(), expected)
self.assertEqual(tx.deserialize(), None)
self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True})
self.assertEqual(tx.get_outputs(), [(Address.from_string('t1M4tYuzKx46ARb7hDcdnMAjkx8Acdrbd9Z'), 1000000)])
self.assertEqual(tx.get_output_addresses(), [Address.from_string('t1M4tYuzKx46ARb7hDcdnMAjkx8Acdrbd9Z')])
self.assertTrue(tx.has_address(Address.from_string('t1M4tYuzKx46ARb7hDcdnMAjkx8Acdrbd9Z')))
self.assertTrue(tx.has_address(Address.from_string('t1LvhooU7zQuqEtjZZN83EL8QSBUkd8WkHR')))
self.assertFalse(tx.has_address(Address.from_string('t1VHL1RP9LS7otTAqQJqFncJvfMUkwHriZr')))
self.assertEqual(tx.serialize(), unsigned_blob)
tx.update_signatures(signed_blob)
self.assertEqual(tx.raw, signed_blob)
tx.update(unsigned_blob)
tx.raw = None
blob = str(tx)
self.assertEqual(transaction.deserialize(blob), expected)
def test_tx_unsigned(self):
expected = {
'inputs': [{'address': Address.from_string('13Vp8Y3hD5Cb6sERfpxePz5vGJizXbWciN'),
'num_sig': 1,
'prevout_hash': 'ed6a4d07e546b677abf6ba1257c2546128c694f23f4b9ebbd822fdfe435ef349',
'prevout_n': 1,
'pubkeys': ['03b5bbebceeb33c1b61f649596b9c3611c6b2853a1f6b48bce05dd54f667fa2166'],
'scriptSig': '01ff4c53ff0488b21e0000000000000000004f130d773e678a58366711837ec2e33ea601858262f8eaef246a7ebd19909c9a03c3b30e38ca7d797fee1223df1c9827b2a9f3379768f520910260220e0560014600002300',
'sequence': 4294967294,
'signatures': [None],
'type': 'p2pkh',
'value': 20112600,
'x_pubkeys': ['ff0488b21e0000000000000000004f130d773e678a58366711837ec2e33ea601858262f8eaef246a7ebd19909c9a03c3b30e38ca7d797fee1223df1c9827b2a9f3379768f520910260220e0560014600002300']}],
'lockTime': 507231,
'outputs': [{'address': Address.from_string('1MYXdf4moacvaEKZ57ozerpJ3t9xSeN6LK'),
'prevout_n': 0,
'scriptPubKey': '76a914e158fb15c888037fdc40fb9133b4c1c3c688706488ac',
'type': 0,
'value': 20112408}],
'version': 1}
tx = transaction.Transaction(unsigned_blob)
calc = tx.deserialize()
self.assertEqual(calc, expected)
self.assertEqual(tx.deserialize(), None)
self.assertEqual(tx.as_dict(), {'hex': unsigned_blob, 'complete': False, 'final': True})
self.assertEqual(tx.get_outputs(), [(Address.from_string('1MYXdf4moacvaEKZ57ozerpJ3t9xSeN6LK'), 20112408)])
self.assertEqual(tx.get_output_addresses(), [Address.from_string('1MYXdf4moacvaEKZ57ozerpJ3t9xSeN6LK')])
self.assertTrue(tx.has_address(Address.from_string('1MYXdf4moacvaEKZ57ozerpJ3t9xSeN6LK')))
self.assertTrue(tx.has_address(Address.from_string('13Vp8Y3hD5Cb6sERfpxePz5vGJizXbWciN')))
self.assertFalse(tx.has_address(Address.from_string('1CQj15y1N7LDHp7wTt28eoD1QhHgFgxECH')))
self.assertEqual(tx.serialize(), unsigned_blob)
tx.update_signatures(signed_blob)
self.assertEqual(tx.raw, signed_blob)
tx.update(unsigned_blob)
tx.raw = None
blob = str(tx)
self.assertEqual(transaction.deserialize(blob), expected)
def test_parse_xpub(self):
res = xpubkey_to_address('fe4e13b0f311a55b8a5db9a32e959da9f011b131019d4cebe6141b9e2c93edcbfc0954c358b062a9f94111548e50bde5847a3096b8b7872dcffadb0e9579b9017b01000200')
self.assertEqual(res, ('04ee98d63800824486a1cf5b4376f2f574d86e0a3009a6448105703453f3368e8e1d8d090aaecdd626a45cc49876709a3bbb6dc96a4311b3cac03e225df5f63dfc', Address.from_string('19h943e4diLc68GXW7G75QNe2KWuMu7BaJ')))
