def breakDownWallet(walletPath, fragSize):
print 'breaking down wallet in packs of %d addresses' % fragSize
print 'reading wallet'
theWallet = PyBtcWallet().readWalletFile(walletPath)
nAddresses = len(theWallet.addrMap)
addrIndex = 0
wltIndex = 1
if walletPath[-7:] == '.wallet':
newDir = walletPath[:-7]
else:
newDir = os.path.dirname(walletPath)
if not os.path.exists(newDir):
os.mkdir(newDir)
rootAddr = theWallet.addrMap['ROOT']
withEncrypt = theWallet.useEncryption
addrIter = theWallet.addrMap.iteritems()
while nAddresses > 0:
print 'breaking down wallet from address #%d to #%d' % (
addrIndex, addrIndex + fragSize - 1)
nAddresses -= fragSize
newWalletPath = os.path.join(newDir,
'armory_wlt_%05d_.wallet' % wltIndex)
wltIndex += 1
walletFragment = PyBtcWallet()
createNewWallet(walletFragment, rootAddr, newWalletPath, withEncrypt,
theWallet.kdf)
fileData = BinaryPacker()
i = 0
try:
while i < fragSize:
addrItem = addrIter.next()[1]
addrItem.chainIndex = -2
fileData.put(
BINARY_CHUNK,
'\x00' + addrItem.addrStr20 + addrItem.serialize())
#walletFragment.walletFileSafeUpdate([[WLT_UPDATE_ADD, \
#WLT_DATATYPE_KEYDATA, addrItem.addrStr20, addrItem]])
i += 1
except StopIteration:
pass
walletFile = open(newWalletPath, 'ab')
walletFile.write(fileData.getBinaryString())
walletFile.close()
addrIndex += i
print 'Done'
def testBinaryPacker(self):
UNKNOWN_TYPE = 100
TEST_FLOAT = 1.23456789
TEST_UINT = 0xff
TEST_INT = -1
TEST_VARINT = 78
TEST_STR = 'abc'
TEST_BINARY_PACKER_STR = hex_to_binary(
'ffff00ff000000ff00000000000000ffffffffffffffffffffffffffffff4e0361626352069e3fffffffffffff00'
)
FS_FOR_3_BYTES = '\xff\xff\xff'
bp = BinaryPacker()
bp.put(UINT8, TEST_UINT)
bp.put(UINT16, TEST_UINT)
bp.put(UINT32, TEST_UINT)
bp.put(UINT64, TEST_UINT)
bp.put(INT8, TEST_INT)
bp.put(INT16, TEST_INT)
bp.put(INT32, TEST_INT)
bp.put(INT64, TEST_INT)
bp.put(VAR_INT, TEST_VARINT)
bp.put(VAR_STR, TEST_STR)
bp.put(FLOAT, TEST_FLOAT)
bp.put(BINARY_CHUNK, FS_FOR_3_BYTES)
bp.put(BINARY_CHUNK, FS_FOR_3_BYTES, 4)
self.assertRaises(PackerError, bp.put, UNKNOWN_TYPE, TEST_INT)
self.assertRaises(PackerError, bp.put, BINARY_CHUNK, FS_FOR_3_BYTES, 2)
self.assertEqual(bp.getSize(), len(TEST_BINARY_PACKER_STR))
ts = bp.getBinaryString()
self.assertEqual(ts, TEST_BINARY_PACKER_STR)
bu = BinaryUnpacker(ts)
self.assertEqual(bu.get(UINT8), TEST_UINT)
self.assertEqual(bu.get(UINT16), TEST_UINT)
self.assertEqual(bu.get(UINT32), TEST_UINT)
self.assertEqual(bu.get(UINT64), TEST_UINT)
self.assertEqual(bu.get(INT8), TEST_INT)
self.assertEqual(bu.get(INT16), TEST_INT)
self.assertEqual(bu.get(INT32), TEST_INT)
self.assertEqual(bu.get(INT64), TEST_INT)
self.assertEqual(bu.get(VAR_INT), TEST_VARINT)
self.assertEqual(bu.get(VAR_STR), TEST_STR)
self.assertAlmostEqual(bu.get(FLOAT), TEST_FLOAT, 2)
self.assertEqual(bu.get(BINARY_CHUNK, 3), FS_FOR_3_BYTES)
self.assertEqual(bu.get(BINARY_CHUNK, 4), FS_FOR_3_BYTES + "\x00")
self.assertRaises(UnpackerError, bu.get, BINARY_CHUNK, 1)
self.assertRaises(UnpackerError, bu.get, UNKNOWN_TYPE)
self.assertRaises(UnpackerError, bu.get, BINARY_CHUNK, 1)
# Running tests with "python <module name>" will NOT work for any Armory tests
# You must run tests with "python -m unittest <module name>" or run all tests with "python -m unittest discover"
# if __name__ == "__main__":
# unittest.main()
def testBinaryPacker(self):
UNKNOWN_TYPE = 100
TEST_FLOAT = 1.23456789
TEST_UINT = 0xff
TEST_INT = -1
TEST_VARINT = 78
TEST_STR = 'abc'
TEST_BINARY_PACKER_STR = hex_to_binary(
'ffff00ff000000ff00000000000000ffffffffffffffffffffffffffffff4e0361626352069e3fffffffffffff00'
)
FS_FOR_3_BYTES = '\xff\xff\xff'
bp = BinaryPacker()
bp.put(UINT8, TEST_UINT)
bp.put(UINT16, TEST_UINT)
bp.put(UINT32, TEST_UINT)
bp.put(UINT64, TEST_UINT)
bp.put(INT8, TEST_INT)
bp.put(INT16, TEST_INT)
bp.put(INT32, TEST_INT)
bp.put(INT64, TEST_INT)
bp.put(VAR_INT, TEST_VARINT)
bp.put(VAR_STR, TEST_STR)
bp.put(FLOAT, TEST_FLOAT)
bp.put(BINARY_CHUNK, FS_FOR_3_BYTES)
bp.put(BINARY_CHUNK, FS_FOR_3_BYTES, 4)
self.assertRaises(PackerError, bp.put, UNKNOWN_TYPE, TEST_INT)
self.assertRaises(PackerError, bp.put, BINARY_CHUNK, FS_FOR_3_BYTES, 2)
self.assertEqual(bp.getSize(), len(TEST_BINARY_PACKER_STR))
ts = bp.getBinaryString()
self.assertEqual(ts, TEST_BINARY_PACKER_STR)
bu = BinaryUnpacker(ts)
self.assertEqual(bu.get(UINT8), TEST_UINT)
self.assertEqual(bu.get(UINT16), TEST_UINT)
self.assertEqual(bu.get(UINT32), TEST_UINT)
self.assertEqual(bu.get(UINT64), TEST_UINT)
self.assertEqual(bu.get(INT8), TEST_INT)
self.assertEqual(bu.get(INT16), TEST_INT)
self.assertEqual(bu.get(INT32), TEST_INT)
self.assertEqual(bu.get(INT64), TEST_INT)
self.assertEqual(bu.get(VAR_INT), TEST_VARINT)
self.assertEqual(bu.get(VAR_STR), TEST_STR)
self.assertAlmostEqual(bu.get(FLOAT), TEST_FLOAT, 2)
self.assertEqual(bu.get(BINARY_CHUNK, 3), FS_FOR_3_BYTES)
self.assertEqual(bu.get(BINARY_CHUNK, 4), FS_FOR_3_BYTES + "\x00")
self.assertRaises(UnpackerError, bu.get, BINARY_CHUNK, 1)
self.assertRaises(UnpackerError, bu.get, UNKNOWN_TYPE)
self.assertRaises(UnpackerError, bu.get, BINARY_CHUNK, 1)
def createNewWallet(wlt,
rootEntry,
newWalletFilePath,
withEncrypt,
kdfParam=None):
"""
This method will create a new wallet, using as much customizability
as you want. You can enable encryption, and set the target params
of the key-derivation function (compute-time and max memory usage).
The KDF parameters will be experimentally determined to be as hard
as possible for your computer within the specified time target
(default, 0.25s). It will aim for maximizing memory usage and using
only 1 or 2 iterations of it, but this can be changed by scaling
down the kdfMaxMem parameter (default 32 MB).
If you use encryption, don't forget to supply a 32-byte passphrase,
created via SecureBinaryData(pythonStr). This method will apply
the passphrase so that the wallet is "born" encrypted.
The field plainRootKey could be used to recover a written backup
of a wallet, since all addresses are deterministically computed
from the root address. This obviously won't reocver any imported
keys, but does mean that you can recover your ENTIRE WALLET from
only those 32 plaintext bytes AND the 32-byte chaincode.
We skip the atomic file operations since we don't even have
a wallet file yet to safely update.
DO NOT CALL THIS FROM BDM METHOD. IT MAY DEADLOCK.
"""
# Create the root address object
rootAddr = rootEntry
# Update wallet object with the new data
# NEW IN WALLET VERSION 1.35: unique ID is now based on
# the first chained address: this guarantees that the unique ID
# is based not only on the private key, BUT ALSO THE CHAIN CODE
wlt.useEncryption = withEncrypt
wlt.addrMap['ROOT'] = rootAddr
wlt.uniqueIDBin = (ADDRBYTE + str(random.getrandbits(48))[:5])[::-1]
wlt.uniqueIDB58 = binary_to_base58(wlt.uniqueIDBin)
wlt.labelName = ''
wlt.labelDescr = ''
wlt.lastComputedChainAddr160 = rootAddr
wlt.lastComputedChainIndex = 0
wlt.highestUsedChainIndex = 0
wlt.wltCreateDate = long(RightNow())
wlt.kdf = kdfParam
# We don't have to worry about atomic file operations when
# creating the wallet: so we just do it naively here.
wlt.walletPath = newWalletFilePath
newfile = open(newWalletFilePath, 'wb')
fileData = BinaryPacker()
# packHeader method writes KDF params and root address
headerBytes = wlt.packHeader(fileData)
newfile.write(fileData.getBinaryString())
newfile.close()
