def testDumpprivkey(self):
testPrivKey = self.privKey.toBinStr()
hash160 = convertKeyDataToAddress(testPrivKey)
addr58 = hash160_to_addrStr(hash160)
# Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
result = self.jsonServer.jsonrpc_dumpprivkey('bogus', 'hex')
self.assertEqual(result['Error Type'],'InvalidBitcoinAddress')
result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
self.assertEqual(result['Error Type'],'PrivateKeyNotFound')
# verify that the first private key can be found
firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
firstAddr58 = hash160_to_addrStr(firstHash160)
actualPrivateKeyHex = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
'hex')
actualPrivateKeyB58 = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
'base58')
self.privKey = self.wallet.getAddrByHash160(firstHash160).serializePlainPrivateKey()
expectedPrivateKeyHex = binary_to_hex(self.privKey)
expectedPrivateKeyB58 = privKey_to_base58(self.privKey)
self.assertEqual(actualPrivateKeyHex, expectedPrivateKeyHex)
self.assertEqual(actualPrivateKeyB58, expectedPrivateKeyB58)
# Verify that a locked wallet Raises WalletUnlockNeeded Exception
kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
self.wallet.changeKdfParams(*kdfParams)
self.wallet.changeWalletEncryption( securePassphrase=self.passphrase )
self.wallet.lock()
result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
self.assertEqual(result['Error Type'],'WalletUnlockNeeded')
def testDumpprivkey(self):
testPrivKey = self.privKey.toBinStr()
hash160 = convertKeyDataToAddress(testPrivKey)
addr58 = hash160_to_addrStr(hash160)
# Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
result = self.jsonServer.jsonrpc_dumpprivkey('bogus', 'hex')
self.assertEqual(result['Error Type'], 'InvalidBitcoinAddress')
result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
self.assertEqual(result['Error Type'], 'PrivateKeyNotFound')
# verify that the first private key can be found
firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
firstAddr58 = hash160_to_addrStr(firstHash160)
actualPrivateKeyHex = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
'hex')
actualPrivateKeyB58 = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
'base58')
self.privKey = self.wallet.getAddrByHash160(
firstHash160).serializePlainPrivateKey()
expectedPrivateKeyHex = binary_to_hex(self.privKey)
expectedPrivateKeyB58 = privKey_to_base58(self.privKey)
self.assertEqual(actualPrivateKeyHex, expectedPrivateKeyHex)
self.assertEqual(actualPrivateKeyB58, expectedPrivateKeyB58)
# Verify that a locked wallet Raises WalletUnlockNeeded Exception
kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
self.wallet.changeKdfParams(*kdfParams)
self.wallet.changeWalletEncryption(securePassphrase=self.passphrase)
self.wallet.lock()
result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
self.assertEqual(result['Error Type'], 'WalletUnlockNeeded')
def testDumpprivkey(self):
testPrivKey = self.privKey.toBinStr()
hash160 = convertKeyDataToAddress(testPrivKey)
addr58 = hash160_to_addrStr(hash160)
# Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
self.assertRaises(InvalidBitcoinAddress,
self.jsonServer.jsonrpc_dumpprivkey, 'bogus')
# verify that the root private key is not found
self.assertRaises(PrivateKeyNotFound,
self.jsonServer.jsonrpc_dumpprivkey, addr58)
# verify that the first private key can be found
firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
firstAddr58 = hash160_to_addrStr(firstHash160)
actualPrivateKey = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58)
expectedPrivateKey = self.wallet.getAddrByHash160(
firstHash160).serializePlainPrivateKey()
self.assertEqual(actualPrivateKey, expectedPrivateKey)
# Verify that a locked wallet Raises WalletUnlockNeeded Exception
kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
self.wallet.changeKdfParams(*kdfParams)
self.wallet.changeWalletEncryption(securePassphrase=self.passphrase)
self.wallet.lock()
self.assertRaises(WalletUnlockNeeded,
self.jsonServer.jsonrpc_dumpprivkey, addr58)
def testDumpprivkey(self):
testPrivKey = self.privKey.toBinStr()
hash160 = convertKeyDataToAddress(testPrivKey)
addr58 = hash160_to_addrStr(hash160)
# Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
self.assertRaises(InvalidBitcoinAddress, self.jsonServer.jsonrpc_dumpprivkey, 'bogus')
# verify that the root private key is not found
self.assertRaises(PrivateKeyNotFound, self.jsonServer.jsonrpc_dumpprivkey, addr58)
# verify that the first private key can be found
firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
firstAddr58 = hash160_to_addrStr(firstHash160)
actualPrivateKey = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58)
expectedPrivateKey = self.wallet.getAddrByHash160(firstHash160).serializePlainPrivateKey()
self.assertEqual(actualPrivateKey, expectedPrivateKey)
# Verify that a locked wallet Raises WalletUnlockNeeded Exception
kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
self.wallet.changeKdfParams(*kdfParams)
self.wallet.changeWalletEncryption( securePassphrase=self.passphrase )
self.wallet.lock()
self.assertRaises(WalletUnlockNeeded, self.jsonServer.jsonrpc_dumpprivkey, addr58)
def testPyBtcWallet(self):
self.wlt.addrPoolSize = 5
# No block chain loaded so this should return -1
# self.assertEqual(self.wlt.detectHighestUsedIndex(True), -1)
self.assertEqual(self.wlt.kdfKey, None)
self.assertEqual(binary_to_hex(self.wlt.addrMap['ROOT'].addrStr20), WALLET_ROOT_ADDR )
#############################################################################
# (1) Getting a new address:
newAddr = self.wlt.getNextUnusedAddress()
self.wlt.pprint(indent=' '*5)
self.assertEqual(binary_to_hex(newAddr.addrStr20), NEW_UNUSED_ADDR)
# (1) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# (2)Testing unencrypted wallet import-address'
originalLength = len(self.wlt.linearAddr160List)
self.wlt.importExternalAddressData(privKey=self.privKey2)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength+1)
# (2) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
self.assertTrue(self.wlt.isEqualTo(wlt2))
# (2a)Testing deleteImportedAddress
# Wallet size before delete:', os.path.getsize(self.wlt.walletPath)
# Addresses before delete:', len(self.wlt.linearAddr160List)
toDelete160 = convertKeyDataToAddress(self.privKey2)
self.wlt.deleteImportedAddress(toDelete160)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength)
# (2a) Reimporting address for remaining tests
# Wallet size before reimport:', os.path.getsize(self.wlt.walletPath)
self.wlt.importExternalAddressData(privKey=self.privKey2)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength+1)
# (2b)Testing ENCRYPTED wallet import-address
privKey3 = SecureBinaryData('\xbb'*32)
privKey4 = SecureBinaryData('\x44'*32)
self.chainstr2 = SecureBinaryData('\xdd'*32)
theIV2 = SecureBinaryData(hex_to_binary('66'*16))
self.passphrase2= SecureBinaryData('hello')
wltE = PyBtcWallet().createNewWallet(withEncrypt=True, \
plainRootKey=privKey3, \
securePassphrase=self.passphrase2, \
chaincode=self.chainstr2, \
IV=theIV2, \
shortLabel=self.shortlabel)
# We should have thrown an error about importing into a locked wallet...
self.assertRaises(WalletLockError, wltE.importExternalAddressData, privKey=self.privKey2)
wltE.unlock(securePassphrase=self.passphrase2)
wltE.importExternalAddressData(privKey=self.privKey2)
# (2b) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(wltE.walletPath)
self.assertTrue(wltE.isEqualTo(wlt2))
# (2b) Unlocking wlt2 after re-reading locked-import-wallet
wlt2.unlock(securePassphrase=self.passphrase2)
self.assertFalse(wlt2.isLocked)
#############################################################################
# Now play with encrypted wallets
# *********************************************************************'
# (3)Testing conversion to encrypted wallet
kdfParams = self.wlt.computeSystemSpecificKdfParams(0.1)
self.wlt.changeKdfParams(*kdfParams)
self.assertEqual(self.wlt.kdf.getSalt(), kdfParams[2])
self.wlt.changeWalletEncryption( securePassphrase=self.passphrase )
self.assertEqual(self.wlt.kdf.getSalt(), kdfParams[2])
# (3) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
# NOTE: this isEqual operation compares the serializations
# of the wallet addresses, which only contains the
# encrypted versions of the private keys. However,
# self.wlt is unlocked and contains the plaintext keys, too
# while wlt2 does not.
self.wlt.lock()
for key in self.wlt.addrMap:
self.assertTrue(self.wlt.addrMap[key].isLocked)
self.assertEqual(self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
#############################################################################
# (4)Testing changing self.passphrase on encrypted wallet',
self.wlt.unlock( securePassphrase=self.passphrase )
for key in self.wlt.addrMap:
self.assertFalse(self.wlt.addrMap[key].isLocked)
self.assertNotEqual(self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# ...to same self.passphrase'
origKdfKey = self.wlt.kdfKey
self.wlt.changeWalletEncryption( securePassphrase=self.passphrase )
self.assertEqual(origKdfKey, self.wlt.kdfKey)
# (4)And now testing new self.passphrase...'
self.wlt.changeWalletEncryption( securePassphrase=self.passphrase2 )
self.assertNotEqual(origKdfKey, self.wlt.kdfKey)
# (4) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# (5)Testing changing KDF on encrypted wallet'
self.wlt.unlock( securePassphrase=self.passphrase2 )
MEMORY_REQT_BYTES = 1024
NUM_ITER = 999
SALT_ALL_0 ='00'*32
self.wlt.changeKdfParams(MEMORY_REQT_BYTES, NUM_ITER, hex_to_binary(SALT_ALL_0), self.passphrase2)
self.assertEqual(self.wlt.kdf.getMemoryReqtBytes(), MEMORY_REQT_BYTES)
self.assertEqual(self.wlt.kdf.getNumIterations(), NUM_ITER)
self.assertEqual(self.wlt.kdf.getSalt().toHexStr(), SALT_ALL_0)
self.wlt.changeWalletEncryption( securePassphrase=self.passphrase2 )
# I don't know why this shouldn't be ''
# Commenting out because it's a broken assertion
# self.assertNotEqual(origKdfKey.toHexStr(), '')
# (5) Get new address from locked wallet'
# Locking wallet'
self.wlt.lock()
for i in range(10):
self.wlt.getNextUnusedAddress()
self.assertEqual(len(self.wlt.addrMap), originalLength+13)
# (5) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# !!! #forkOnlineWallet()
# (6)Testing forking encrypted wallet for online mode'
self.wlt.forkOnlineWallet('OnlineVersionOfEncryptedWallet.bin')
wlt2.readWalletFile('OnlineVersionOfEncryptedWallet.bin')
for key in wlt2.addrMap:
self.assertTrue(self.wlt.addrMap[key].isLocked)
self.assertEqual(self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# (6)Getting a new addresses from both wallets'
for i in range(self.wlt.addrPoolSize*2):
self.wlt.getNextUnusedAddress()
wlt2.getNextUnusedAddress()
newaddr1 = self.wlt.getNextUnusedAddress()
newaddr2 = wlt2.getNextUnusedAddress()
self.assertTrue(newaddr1.getAddr160() == newaddr2.getAddr160())
self.assertEqual(len(wlt2.addrMap), 3*originalLength+14)
# (6) Re-reading wallet from file, compare the two wallets
wlt3 = PyBtcWallet().readWalletFile('OnlineVersionOfEncryptedWallet.bin')
self.assertTrue(wlt3.isEqualTo(wlt2))
#############################################################################
# (7)Testing removing wallet encryption'
# Wallet is locked? ', self.wlt.isLocked
self.wlt.unlock(securePassphrase=self.passphrase2)
self.wlt.changeWalletEncryption( None )
for key in self.wlt.addrMap:
self.assertFalse(self.wlt.addrMap[key].isLocked)
self.assertNotEqual(self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# (7) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# \n'
# *********************************************************************'
# (8)Doing interrupt tests to test wallet-file-update recovery'
def hashfile(fn):
f = open(fn,'r')
d = hash256(f.read())
f.close()
return binary_to_hex(d[:8])
def verifyFileStatus(fileAExists = True, fileBExists = True, \
fileAupdExists = True, fileBupdExists = True):
self.assertEqual(os.path.exists(self.fileA), fileAExists)
self.assertEqual(os.path.exists(self.fileB), fileBExists)
self.assertEqual(os.path.exists(self.fileAupd), fileAupdExists)
self.assertEqual(os.path.exists(self.fileBupd), fileBupdExists)
correctMainHash = hashfile(self.fileA)
try:
self.wlt.interruptTest1 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest1 = False
# (8a)Interrupted getNextUnusedAddress on primary file update'
verifyFileStatus(True, True, False, True)
# (8a)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(correctMainHash, hashfile(self.fileA))
try:
self.wlt.interruptTest2 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest2 = False
# (8b)Interrupted getNextUnusedAddress on between primary/backup update'
verifyFileStatus(True, True, True, True)
# (8b)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(hashfile(self.fileA), hashfile(self.fileB))
# (8c) Try interrupting at state 3'
verifyFileStatus(True, True, False, False)
try:
self.wlt.interruptTest3 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest3 = False
# (8c)Interrupted getNextUnusedAddress on backup file update'
verifyFileStatus(True, True, True, False)
# (8c)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(hashfile(self.fileA), hashfile(self.fileB))
#############################################################################
# \n'
# *********************************************************************'
# (9)Checksum-based byte-error correction tests!'
# (9)Start with a good primary and backup file...'
# (9a)Open primary wallet, change second byte in KDF'
wltfile = open(self.wlt.walletPath,'r+b')
wltfile.seek(326)
wltfile.write('\xff')
wltfile.close()
# (9a)Byte changed, file hashes:'
verifyFileStatus(True, True, False, False)
# (9a)Try to read wallet from file, should correct KDF error, write fix'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9b)Change a byte in each checksummed field in root addr'
wltfile = open(self.wlt.walletPath,'r+b')
wltfile.seek(838); wltfile.write('\xff')
wltfile.seek(885); wltfile.write('\xff')
wltfile.seek(929); wltfile.write('\xff')
wltfile.seek(954); wltfile.write('\xff')
wltfile.seek(1000); wltfile.write('\xff')
wltfile.close()
# (9b) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9b)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9c)Change a byte in each checksummed field, of first non-root addr'
wltfile = open(self.wlt.walletPath,'r+b')
wltfile.seek(1261+21+838); wltfile.write('\xff')
wltfile.seek(1261+21+885); wltfile.write('\xff')
wltfile.seek(1261+21+929); wltfile.write('\xff')
wltfile.seek(1261+21+954); wltfile.write('\xff')
wltfile.seek(1261+21+1000); wltfile.write('\xff')
wltfile.close()
# (9c) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9c)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9d)Now butcher the CHECKSUM, see if correction works'
wltfile = open(self.wlt.walletPath,'r+b')
wltfile.seek(977); wltfile.write('\xff')
wltfile.close()
# (9d) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9d)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# *******'
# (9z) Test comment I/O'
comment1 = 'This is my normal unit-testing address.'
comment2 = 'This is fake tx... no tx has this hash.'
comment3 = comment1 + ' Corrected!'
hash1 = '\x1f'*20 # address160
hash2 = '\x2f'*32 # tx hash
self.wlt.setComment(hash1, comment1)
self.wlt.setComment(hash2, comment2)
self.wlt.setComment(hash1, comment3)
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
c3 = wlt2.getComment(hash1)
c2 = wlt2.getComment(hash2)
self.assertEqual(c3, comment3)
self.assertEqual(c2, comment2)
def testPyBtcWallet(self):
self.wlt.addrPoolSize = 5
# No block chain loaded so this should return -1
# self.assertEqual(self.wlt.detectHighestUsedIndex(True), -1)
self.assertEqual(self.wlt.kdfKey, None)
self.assertEqual(binary_to_hex(self.wlt.addrMap['ROOT'].addrStr20),
WALLET_ROOT_ADDR)
#############################################################################
# (1) Getting a new address:
newAddr = self.wlt.getNextUnusedAddress()
self.wlt.pprint(indent=' ' * 5)
self.assertEqual(binary_to_hex(newAddr.addrStr20), NEW_UNUSED_ADDR)
# (1) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# (2)Testing unencrypted wallet import-address'
originalLength = len(self.wlt.linearAddr160List)
self.wlt.importExternalAddressData(privKey=self.privKey2)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength + 1)
# (2) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
self.assertTrue(self.wlt.isEqualTo(wlt2))
# (2a)Testing deleteImportedAddress
# Wallet size before delete:', os.path.getsize(self.wlt.walletPath)
# Addresses before delete:', len(self.wlt.linearAddr160List)
toDelete160 = convertKeyDataToAddress(self.privKey2)
self.wlt.deleteImportedAddress(toDelete160)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength)
# (2a) Reimporting address for remaining tests
# Wallet size before reimport:', os.path.getsize(self.wlt.walletPath)
self.wlt.importExternalAddressData(privKey=self.privKey2)
self.assertEqual(len(self.wlt.linearAddr160List), originalLength + 1)
# (2b)Testing ENCRYPTED wallet import-address
privKey3 = SecureBinaryData('\xbb' * 32)
privKey4 = SecureBinaryData('\x44' * 32)
self.chainstr2 = SecureBinaryData('\xdd' * 32)
theIV2 = SecureBinaryData(hex_to_binary('66' * 16))
self.passphrase2 = SecureBinaryData('hello')
wltE = PyBtcWallet().createNewWallet(withEncrypt=True, \
plainRootKey=privKey3, \
securePassphrase=self.passphrase2, \
chaincode=self.chainstr2, \
IV=theIV2, \
shortLabel=self.shortlabel)
# We should have thrown an error about importing into a locked wallet...
self.assertRaises(WalletLockError,
wltE.importExternalAddressData,
privKey=self.privKey2)
wltE.unlock(securePassphrase=self.passphrase2)
wltE.importExternalAddressData(privKey=self.privKey2)
# (2b) Re-reading wallet from file, compare the two wallets
wlt2 = PyBtcWallet().readWalletFile(wltE.walletPath)
self.assertTrue(wltE.isEqualTo(wlt2))
# (2b) Unlocking wlt2 after re-reading locked-import-wallet
wlt2.unlock(securePassphrase=self.passphrase2)
self.assertFalse(wlt2.isLocked)
#############################################################################
# Now play with encrypted wallets
# *********************************************************************'
# (3)Testing conversion to encrypted wallet
kdfParams = self.wlt.computeSystemSpecificKdfParams(0.1)
self.wlt.changeKdfParams(*kdfParams)
self.assertEqual(self.wlt.kdf.getSalt(), kdfParams[2])
self.wlt.changeWalletEncryption(securePassphrase=self.passphrase)
self.assertEqual(self.wlt.kdf.getSalt(), kdfParams[2])
# (3) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
# NOTE: this isEqual operation compares the serializations
# of the wallet addresses, which only contains the
# encrypted versions of the private keys. However,
# self.wlt is unlocked and contains the plaintext keys, too
# while wlt2 does not.
self.wlt.lock()
for key in self.wlt.addrMap:
self.assertTrue(self.wlt.addrMap[key].isLocked)
self.assertEqual(
self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
#############################################################################
# (4)Testing changing self.passphrase on encrypted wallet',
self.wlt.unlock(securePassphrase=self.passphrase)
for key in self.wlt.addrMap:
self.assertFalse(self.wlt.addrMap[key].isLocked)
self.assertNotEqual(
self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# ...to same self.passphrase'
origKdfKey = self.wlt.kdfKey
self.wlt.changeWalletEncryption(securePassphrase=self.passphrase)
self.assertEqual(origKdfKey, self.wlt.kdfKey)
# (4)And now testing new self.passphrase...'
self.wlt.changeWalletEncryption(securePassphrase=self.passphrase2)
self.assertNotEqual(origKdfKey, self.wlt.kdfKey)
# (4) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# (5)Testing changing KDF on encrypted wallet'
self.wlt.unlock(securePassphrase=self.passphrase2)
MEMORY_REQT_BYTES = 1024
NUM_ITER = 999
SALT_ALL_0 = '00' * 32
self.wlt.changeKdfParams(MEMORY_REQT_BYTES, NUM_ITER,
hex_to_binary(SALT_ALL_0), self.passphrase2)
self.assertEqual(self.wlt.kdf.getMemoryReqtBytes(), MEMORY_REQT_BYTES)
self.assertEqual(self.wlt.kdf.getNumIterations(), NUM_ITER)
self.assertEqual(self.wlt.kdf.getSalt().toHexStr(), SALT_ALL_0)
self.wlt.changeWalletEncryption(securePassphrase=self.passphrase2)
# I don't know why this shouldn't be ''
# Commenting out because it's a broken assertion
# self.assertNotEqual(origKdfKey.toHexStr(), '')
# (5) Get new address from locked wallet'
# Locking wallet'
self.wlt.lock()
for i in range(10):
self.wlt.getNextUnusedAddress()
self.assertEqual(len(self.wlt.addrMap), originalLength + 13)
# (5) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# !!! #forkOnlineWallet()
# (6)Testing forking encrypted wallet for online mode'
self.wlt.forkOnlineWallet('OnlineVersionOfEncryptedWallet.bin')
wlt2.readWalletFile('OnlineVersionOfEncryptedWallet.bin')
for key in wlt2.addrMap:
self.assertTrue(self.wlt.addrMap[key].isLocked)
self.assertEqual(
self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# (6)Getting a new addresses from both wallets'
for i in range(self.wlt.addrPoolSize * 2):
self.wlt.getNextUnusedAddress()
wlt2.getNextUnusedAddress()
newaddr1 = self.wlt.getNextUnusedAddress()
newaddr2 = wlt2.getNextUnusedAddress()
self.assertTrue(newaddr1.getAddr160() == newaddr2.getAddr160())
self.assertEqual(len(wlt2.addrMap), 3 * originalLength + 14)
# (6) Re-reading wallet from file, compare the two wallets
wlt3 = PyBtcWallet().readWalletFile(
'OnlineVersionOfEncryptedWallet.bin')
self.assertTrue(wlt3.isEqualTo(wlt2))
#############################################################################
# (7)Testing removing wallet encryption'
# Wallet is locked? ', self.wlt.isLocked
self.wlt.unlock(securePassphrase=self.passphrase2)
self.wlt.changeWalletEncryption(None)
for key in self.wlt.addrMap:
self.assertFalse(self.wlt.addrMap[key].isLocked)
self.assertNotEqual(
self.wlt.addrMap[key].binPrivKey32_Plain.toHexStr(), '')
# (7) Re-reading wallet from file, compare the two wallets'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.getWalletPath())
self.assertTrue(self.wlt.isEqualTo(wlt2))
#############################################################################
# \n'
# *********************************************************************'
# (8)Doing interrupt tests to test wallet-file-update recovery'
def hashfile(fn):
f = open(fn, 'r')
d = hash256(f.read())
f.close()
return binary_to_hex(d[:8])
def verifyFileStatus(fileAExists = True, fileBExists = True, \
fileAupdExists = True, fileBupdExists = True):
self.assertEqual(os.path.exists(self.fileA), fileAExists)
self.assertEqual(os.path.exists(self.fileB), fileBExists)
self.assertEqual(os.path.exists(self.fileAupd), fileAupdExists)
self.assertEqual(os.path.exists(self.fileBupd), fileBupdExists)
correctMainHash = hashfile(self.fileA)
try:
self.wlt.interruptTest1 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest1 = False
# (8a)Interrupted getNextUnusedAddress on primary file update'
verifyFileStatus(True, True, False, True)
# (8a)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(correctMainHash, hashfile(self.fileA))
try:
self.wlt.interruptTest2 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest2 = False
# (8b)Interrupted getNextUnusedAddress on between primary/backup update'
verifyFileStatus(True, True, True, True)
# (8b)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(hashfile(self.fileA), hashfile(self.fileB))
# (8c) Try interrupting at state 3'
verifyFileStatus(True, True, False, False)
try:
self.wlt.interruptTest3 = True
self.wlt.getNextUnusedAddress()
except InterruptTestError:
# Interrupted!'
pass
self.wlt.interruptTest3 = False
# (8c)Interrupted getNextUnusedAddress on backup file update'
verifyFileStatus(True, True, True, False)
# (8c)Do consistency check on the wallet'
self.wlt.doWalletFileConsistencyCheck()
verifyFileStatus(True, True, False, False)
self.assertEqual(hashfile(self.fileA), hashfile(self.fileB))
#############################################################################
# \n'
# *********************************************************************'
# (9)Checksum-based byte-error correction tests!'
# (9)Start with a good primary and backup file...'
# (9a)Open primary wallet, change second byte in KDF'
wltfile = open(self.wlt.walletPath, 'r+b')
wltfile.seek(326)
wltfile.write('\xff')
wltfile.close()
# (9a)Byte changed, file hashes:'
verifyFileStatus(True, True, False, False)
# (9a)Try to read wallet from file, should correct KDF error, write fix'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9b)Change a byte in each checksummed field in root addr'
wltfile = open(self.wlt.walletPath, 'r+b')
wltfile.seek(838)
wltfile.write('\xff')
wltfile.seek(885)
wltfile.write('\xff')
wltfile.seek(929)
wltfile.write('\xff')
wltfile.seek(954)
wltfile.write('\xff')
wltfile.seek(1000)
wltfile.write('\xff')
wltfile.close()
# (9b) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9b)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9c)Change a byte in each checksummed field, of first non-root addr'
wltfile = open(self.wlt.walletPath, 'r+b')
wltfile.seek(1261 + 21 + 838)
wltfile.write('\xff')
wltfile.seek(1261 + 21 + 885)
wltfile.write('\xff')
wltfile.seek(1261 + 21 + 929)
wltfile.write('\xff')
wltfile.seek(1261 + 21 + 954)
wltfile.write('\xff')
wltfile.seek(1261 + 21 + 1000)
wltfile.write('\xff')
wltfile.close()
# (9c) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9c)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# \n'
# *********************************************************************'
# (9d)Now butcher the CHECKSUM, see if correction works'
wltfile = open(self.wlt.walletPath, 'r+b')
wltfile.seek(977)
wltfile.write('\xff')
wltfile.close()
# (9d) New file hashes...'
verifyFileStatus(True, True, False, False)
# (9d)Try to read wallet from file, should correct address errors'
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
verifyFileStatus(True, True, False, False)
self.assertNotEqual(hashfile(self.fileA), hashfile(self.fileB))
# *******'
# (9z) Test comment I/O'
comment1 = 'This is my normal unit-testing address.'
comment2 = 'This is fake tx... no tx has this hash.'
comment3 = comment1 + ' Corrected!'
hash1 = '\x1f' * 20 # address160
hash2 = '\x2f' * 32 # tx hash
self.wlt.setComment(hash1, comment1)
self.wlt.setComment(hash2, comment2)
self.wlt.setComment(hash1, comment3)
wlt2 = PyBtcWallet().readWalletFile(self.wlt.walletPath)
c3 = wlt2.getComment(hash1)
c2 = wlt2.getComment(hash2)
self.assertEqual(c3, comment3)
self.assertEqual(c2, comment2)