{

if (!entryPtr->needsCommit())

return SIZE_MAX;

auto&& serializedEntry = entryPtr->serialize();

auto&& dbKey = entryPtr->getDbKey();

CharacterArrayRef keyRef(dbKey.getSize(), dbKey.getPtr());

CharacterArrayRef dataRef(serializedEntry.getSize(), serializedEntry.getPtr());

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

db_->insert(keyRef, dataRef);

entryPtr->doNotCommit();

return serializedEntry.getSize();

{

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

for (auto& entryPtr : assets_)

writeAssetEntry(entryPtr.second);

updateAssetCount();

{

//asset count key

BinaryWriter bwKey;

bwKey.put_uint8_t(ASSET_COUNT_PREFIX);

bwKey.put_BinaryData(getFullID());

//asset count

BinaryWriter bwData;

bwData.put_var_int(assets_.size());

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

putData(db_, bwKey.getData(), bwData.getData());

{

//id as key

BinaryWriter bwKey;

bwKey.put_uint8_t(ASSET_ACCOUNT_PREFIX);

bwKey.put_BinaryData(getFullID());

//data

BinaryWriter bwData;

//parent key size

bwData.put_var_int(parent_id_.getSize());

//der scheme

auto&& derSchemeSerData = derScheme_->serialize();

bwData.put_var_int(derSchemeSerData.getSize());

bwData.put_BinaryData(derSchemeSerData);

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

//commit root asset if there is one

if (root_ != nullptr)

writeAssetEntry(root_);

//commit assets

for (auto asset : assets_)

writeAssetEntry(asset.second);

//commit serialized account data

putData(db_, bwKey.getData(), bwData.getData());

updateAssetCount();

updateHighestUsedIndex();

LMDB* db, const BinaryData& key, const BinaryData& data)

{

CharacterArrayRef carKey(key.getSize(), key.getCharPtr());

CharacterArrayRef carData(data.getSize(), data.getCharPtr());

db->insert(carKey, carData);

const BinaryData& key, shared_ptr<LMDBEnv> dbEnv, LMDB* db)

{

//sanity checks

if (dbEnv == nullptr || db == nullptr)

throw AccountException("invalid db pointers");

if (key.getSize() == 0)

throw AccountException("invalid key size");

if (key.getPtr()[0] != ASSET_ACCOUNT_PREFIX)

throw AccountException("unexpected prefix for AssetAccount key");

LMDBEnv::Transaction tx(dbEnv.get(), LMDB::ReadOnly);

CharacterArrayRef carKey(key.getSize(), key.getCharPtr());

auto carData = db->get_NoCopy(carKey);

BinaryRefReader brr((const uint8_t*)carData.data, carData.len);

//ids

auto parent_id_len = brr.get_var_int();

auto&& parent_id = key.getSliceCopy(1, parent_id_len);

auto&& account_id = key.getSliceCopy(

1 + parent_id_len, key.getSize() - 1 - parent_id_len);

//der scheme

auto len = brr.get_var_int();

auto derSchemeBDR = DBUtils::getDataRefForPacket(brr.get_BinaryDataRef(len));

auto derScheme = DerivationScheme::deserialize(derSchemeBDR);

//asset count

size_t assetCount = 0;

{

BinaryWriter bwKey_assetcount;

bwKey_assetcount.put_uint8_t(ASSET_COUNT_PREFIX);

bwKey_assetcount.put_BinaryDataRef(key.getSliceRef(

1, key.getSize() - 1));

CharacterArrayRef carKey_assetcount(

bwKey_assetcount.getSize(),

bwKey_assetcount.getData().getCharPtr());

auto&& car_assetcount = db->get_NoCopy(carKey_assetcount);

if (car_assetcount.len == 0)

throw AccountException("missing asset count entry");

BinaryDataRef bdr_assetcount(

(uint8_t*)car_assetcount.data, car_assetcount.len);

BinaryRefReader brr_assetcount(bdr_assetcount);

assetCount = brr_assetcount.get_var_int();

}

//last used index

size_t lastUsedIndex = 0;

{

BinaryWriter bwKey_lastusedindex;

bwKey_lastusedindex.put_uint8_t(ASSET_TOP_INDEX_PREFIX);

bwKey_lastusedindex.put_BinaryDataRef(key.getSliceRef(

1, key.getSize() - 1));

CharacterArrayRef carKey_lastusedindex(

bwKey_lastusedindex.getSize(),

bwKey_lastusedindex.getData().getCharPtr());

auto&& car_lastusedindex = db->get_NoCopy(carKey_lastusedindex);

if (car_lastusedindex.len == 0)

throw AccountException("missing last used entry");

BinaryDataRef bdr_lastusedindex(

(uint8_t*)car_lastusedindex.data, car_lastusedindex.len);

BinaryRefReader brr_lastusedindex(bdr_lastusedindex);

lastUsedIndex = brr_lastusedindex.get_var_int();

}

//asset entry prefix key

BinaryWriter bwAssetKey;

bwAssetKey.put_uint8_t(ASSETENTRY_PREFIX);

bwAssetKey.put_BinaryDataRef(key.getSliceRef(1, key.getSize() - 1));

//asset key

BinaryWriter bwRootkey;

bwRootkey.put_BinaryData(bwAssetKey.getData());

bwRootkey.put_uint32_t(ROOT_ASSETENTRY_ID); //root entry int id

CharacterArrayRef carRootKey(

bwRootkey.getSize(), bwRootkey.getData().getCharPtr());

shared_ptr<AssetEntry> rootEntry = nullptr;

map<unsigned, shared_ptr<AssetEntry>> assetMap;

//get all assets

{

auto& assetDbKey = bwAssetKey.getData();

CharacterArrayRef carAssetKey(

assetDbKey.getSize(), assetDbKey.getCharPtr());

auto dbIter = db->begin();

dbIter.seek(carAssetKey, LMDB::Iterator::Seek_GE);

while (dbIter.isValid())

{

BinaryDataRef key_bdr(

(const uint8_t*)dbIter.key().mv_data, dbIter.key().mv_size);

BinaryDataRef value_bdr(

(const uint8_t*)dbIter.value().mv_data, dbIter.value().mv_size);

//check key isnt prefix

if (key_bdr == assetDbKey)

continue;

//check key starts with prefix

if (!key_bdr.startsWith(assetDbKey))

break;

//instantiate and insert asset

auto assetPtr = AssetEntry::deserialize(

key_bdr,

DBUtils::getDataRefForPacket(value_bdr));

if (assetPtr->getIndex() != ROOT_ASSETENTRY_ID)

assetMap.insert(make_pair(assetPtr->getIndex(), assetPtr));

else

rootEntry = assetPtr;

++dbIter;

}

}

//sanity check

if (assetCount != assetMap.size())

throw AccountException("unexpected account asset count");

//instantiate object

shared_ptr<AssetAccount> accountPtr = make_shared<AssetAccount>(

account_id, parent_id,

rootEntry, derScheme,

dbEnv, db);

//fill members not covered by the ctor

accountPtr->lastUsedIndex_ = lastUsedIndex;

accountPtr->assets_ = move(assetMap);

return accountPtr;

{

if (getAssetCount() == 0)

return -1;

auto iter = assets_.rbegin();

return iter->first;

{

ReentrantLock lock(this);

//add *count* entries to address chain

if (assets_.size() == 0)

throw AccountException("empty asset map");

if (count == 0)

return;

extendPublicChain(assets_.rbegin()->second, count);

{

ReentrantLock lock(this);

//make address chain at least *count* long

auto lastComputedIndex = max(getLastComputedIndex(), 0);

if (lastComputedIndex > count)

return;

auto toCompute = count - lastComputedIndex;

extendPublicChain(toCompute);

shared_ptr<AssetEntry> assetPtr, unsigned count)

{

if (count == 0)

return;

ReentrantLock lock(this);

auto&& assetVec = extendPublicChain(assetPtr,

assetPtr->getIndex() + 1,

assetPtr->getIndex() + 1 + count);

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

{

for (auto& asset : assetVec)

{

auto id = asset->getIndex();

auto iter = assets_.find(id);

if (iter != assets_.end())

continue;

assets_.insert(make_pair(

id, asset));

}

}

updateOnDiskAssets();

updateHashMap_ = true;

shared_ptr<AssetEntry> assetPtr,

unsigned start, unsigned end)

{

vector<shared_ptr<AssetEntry>> result;

switch (derScheme_->getType())

{

case DerSchemeType_ArmoryLegacy:

{

//Armory legacy derivation operates from the last valid asset

result = move(derScheme_->extendPublicChain(assetPtr, start, end));

break;

}

case DerSchemeType_BIP32:

{

//BIP32 operates from the node's root asset

result = move(derScheme_->extendPublicChain(root_, start, end));

break;

}

default:

throw AccountException("unexpected derscheme type");

}

return result;

shared_ptr<DecryptedDataContainer> ddc,

unsigned count)

{

ReentrantLock lock(this);

auto topAsset = getLastAssetWithPrivateKey();

extendPrivateChain(ddc, topAsset, count);

shared_ptr<DecryptedDataContainer> ddc,

unsigned id)

{

ReentrantLock lock(this);

auto topAsset = getLastAssetWithPrivateKey();

auto topIndex = topAsset->getIndex();

if (id > topIndex)

{

auto count = id - topAsset->getIndex();

extendPrivateChain(ddc, topAsset, count);

}

shared_ptr<DecryptedDataContainer> ddc,

shared_ptr<AssetEntry> assetPtr, unsigned count)

{

if (count == 0)

return;

ReentrantLock lock(this);

auto privAsset = getLastAssetWithPrivateKey();

auto lastIndex = getLastComputedIndex();

auto&& assetVec = extendPrivateChain(ddc, assetPtr,

assetPtr->getIndex() + 1, assetPtr->getIndex() + 1 + count);

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

{

for (auto& asset : assetVec)

{

auto id = asset->getIndex();

auto iter = assets_.find(id);

if (iter != assets_.end())

{

//do not overwrite an existing asset that already has a privkey

if (iter->second->hasPrivateKey())

{

continue;

}

else

{

iter->second = asset;

continue;

}

}

assets_.insert(make_pair(

id, asset));

}

}

updateOnDiskAssets();

if (privAsset->getIndex() + count > lastIndex)

updateHashMap_ = true;

shared_ptr<DecryptedDataContainer> ddc,

shared_ptr<AssetEntry> assetPtr,

unsigned start, unsigned end)

{

vector<shared_ptr<AssetEntry>> result;

switch (derScheme_->getType())

{

case DerSchemeType_ArmoryLegacy:

{

//Armory legacy derivation operates from the last valid asset

result = move(derScheme_->extendPrivateChain(ddc, assetPtr, start, end));

break;

}

case DerSchemeType_BIP32:

{

//BIP32 operates from the node's root asset

result = move(derScheme_->extendPrivateChain(ddc, root_, start, end));

break;

}

default:

throw AccountException("unexpected derscheme type");

}

return result;

{

ReentrantLock lock(this);

auto assetIter = assets_.rbegin();

while (assetIter != assets_.rend())

{

if (assetIter->second->hasPrivateKey())

return assetIter->second;

++assetIter;

}

throw runtime_error("no asset with private keys");

return nullptr;

{

ReentrantLock lock(this);

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

BinaryWriter bwKey;

bwKey.put_uint8_t(ASSET_TOP_INDEX_PREFIX);

bwKey.put_BinaryData(getFullID());

BinaryWriter bwData;

bwData.put_var_int(lastUsedIndex_);

putData(db_, bwKey.getData(), bwData.getData());

{

ReentrantLock lock(this);

auto index = lastUsedIndex_++;

updateHighestUsedIndex();

return index;

{

ReentrantLock lock(this);

auto index = getAndBumpHighestUsedIndex();

auto entryIter = assets_.find(index);

if (entryIter == assets_.end())

{

extendPublicChain(DERIVATION_LOOKUP);

entryIter = assets_.find(index);

if (entryIter == assets_.end())

throw AccountException("requested index overflows max lookup");

}

return entryIter->second;

{

auto asset = getNewAsset();

return AddressEntry::instantiate(asset, aeType);

{

if (ID.getSize() < 4)

throw runtime_error("invalid asset ID");

auto id_int = READ_UINT32_BE(ID.getPtr());

return getAssetForIndex(id_int);

{

auto iter = assets_.find(id);

if (iter == assets_.end())

throw AccountException("unknown asset index");

return iter->second;

const set<AddressEntryType>& typeSet)

{

if (updateHashMap_ = false)

return;

ReentrantLock lock(this);

for (auto asset : assets_)

{

auto asset_iter = addrHashMap_.find(asset.second->getID());

if (asset_iter == addrHashMap_.end())

{

asset_iter =

addrHashMap_.insert(make_pair(

asset.second->getID(),

map<AddressEntryType, BinaryData>())).first;

}

for (auto ae_type : typeSet)

{

if (asset_iter->second.find(ae_type) != asset_iter->second.end())

continue;

auto addrPtr = AddressEntry::instantiate(asset.second, ae_type);

auto& addrHash = addrPtr->getPrefixedHash();

addrHashMap_[asset.second->getID()].insert(

make_pair(ae_type, addrHash));

}

}

updateHashMap_ = false;

shared_ptr<AccountType> accType,

shared_ptr<DecryptedDataContainer> decrData,

unique_ptr<Cypher> cypher)

{

reset();

switch (accType->type())

{

case AccountTypeEnum_ArmoryLegacy:

{

ID_ = accType->getAccountID();

auto asset_account_id = accType->getOuterAccountID();

//chaincode has to be a copy cause the derscheme ctor moves it in

auto chaincode = accType->getChaincode();

auto derScheme = make_shared<DerivationScheme_ArmoryLegacy>(

chaincode);

//first derived asset

auto&& full_account_id = ID_ + asset_account_id;

shared_ptr<AssetEntry_Single> firstAsset;

if (accType->isWatchingOnly())

{

//WO

auto& root = accType->getPublicRoot();

firstAsset = derScheme->computeNextPublicEntry(

root,

full_account_id, 0);

}

else

{

//full wallet

ReentrantLock lock(decrData.get());

auto& root = accType->getPrivateRoot();

firstAsset = derScheme->computeNextPrivateEntry(

decrData,

root, move(cypher),

full_account_id, 0);

}

//instantiate account and set first entry

auto asset_account = make_shared<AssetAccount>(

asset_account_id, ID_,

nullptr, derScheme, //no root asset for legacy derivation scheme, using first entry instead

dbEnv_, db_);

asset_account->assets_.insert(make_pair(0, firstAsset));

//add the asset account

addAccount(asset_account);

break;

}

case AccountTypeEnum_BIP32_Legacy:

case AccountTypeEnum_BIP32_SegWit:

{

ID_ = accType->getAccountID();

//asset account lambda

auto createNewAccount = [&accType, &decrData, this](

unsigned node_id,

unique_ptr<Cypher> cypher_copy)->shared_ptr<AssetAccount>

{

auto&& account_id = WRITE_UINT32_BE(node_id);

auto&& full_account_id = ID_ + account_id;

shared_ptr<AssetEntry_Single> rootAsset;

SecureBinaryData chaincode;

if (accType->isWatchingOnly())

{

//WO

auto& root = accType->getPublicRoot();

//derive to final node

auto&& derived_pair = CryptoECDSA::bip32_derive_public_key(

root, accType->getChaincode(), node_id);

chaincode = move(derived_pair.second);

rootAsset = make_shared<AssetEntry_Single>(

-1, full_account_id,

derived_pair.first, nullptr);

}

else

{

//full wallet

auto& root = accType->getPrivateRoot();

//derive to final node

auto&& derived_pair =

CryptoECDSA::bip32_derive_private_key(

root, accType->getChaincode(), node_id);

chaincode = move(derived_pair.second);

//compute pubkey

auto&& pubkey = CryptoECDSA().ComputePublicKey(derived_pair.first);

//encrypt private root

auto&& encrypted_root =

decrData->encryptData(cypher_copy.get(), derived_pair.first);

//create assets

auto priv_asset = make_shared<Asset_PrivateKey>(

-1, encrypted_root, move(cypher_copy));

rootAsset = make_shared<AssetEntry_Single>(

-1, full_account_id,

pubkey,

priv_asset);

}

//der scheme

if (chaincode.getSize() == 0)

throw AccountException("invalid chaincode");

auto derScheme = make_shared<DerivationScheme_BIP32>(

chaincode);

//instantiate account

auto asset_account = make_shared<AssetAccount>(

account_id, ID_,

rootAsset, derScheme,

dbEnv_, db_);

return asset_account;

};

auto accType_bip32 = dynamic_pointer_cast<AccountType_BIP32>(accType);

if (accType_bip32 == nullptr)

throw AccountException("unexpected bip32 account type ptr");

auto&& nodes = accType_bip32->getNodes();

for (auto& node : nodes)

{

auto account_obj = createNewAccount(

node,

move(cypher->getCopy()));

addAccount(account_obj);

}

break;

}

default:

throw AccountException("unknown account type");

}

//set the address types

addressTypes_ = accType->getAddressTypes();

//set default address type

defaultAddressEntryType_ = accType->getDefaultAddressEntryType();

//set inner and outer accounts

outerAccount_ = accType->getOuterAccountID();

innerAccount_ = accType->getInnerAccountID();

{

outerAccount_.clear();

innerAccount_.clear();

assetAccounts_.clear();

addressTypes_.clear();

addressHashes_.clear();

ID_.clear();

{

//id as key

BinaryWriter bwKey;

bwKey.put_uint8_t(ADDRESS_ACCOUNT_PREFIX);

bwKey.put_BinaryData(ID_);

//data

BinaryWriter bwData;

//outer and inner account

bwData.put_var_int(outerAccount_.getSize());

bwData.put_BinaryData(outerAccount_);

bwData.put_var_int(innerAccount_.getSize());

bwData.put_BinaryData(innerAccount_);

//address type set

bwData.put_var_int(addressTypes_.size());

for (auto& addrType : addressTypes_)

bwData.put_uint32_t(addrType);

//default address type

bwData.put_uint32_t(defaultAddressEntryType_);

//asset accounts count

bwData.put_var_int(assetAccounts_.size());

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadWrite);

//asset accounts

for (auto& account : assetAccounts_)

{

auto&& assetAccountID = account.second->getFullID();

bwData.put_var_int(assetAccountID.getSize());

bwData.put_BinaryData(assetAccountID);

account.second->commit();

}

//commit address account data to disk

CharacterArrayRef carKey(bwKey.getSize(), bwKey.getData().getCharPtr());

CharacterArrayRef carData(bwData.getSize(), bwData.getData().getCharPtr());

db_->insert(carKey, carData);

{

auto insertPair = assetAccounts_.insert(make_pair(

account->getID(), account));

if (!insertPair.second)

throw AccountException("already have this asset account");

{

//sanity checks

if (key.getSize() == 0)

throw AccountException("empty AddressAccount key");

if (key.getPtr()[0] != ADDRESS_ACCOUNT_PREFIX)

throw AccountException("unexpected key prefix for AddressAccount");

if (dbEnv_ == nullptr || db_ == nullptr)

throw AccountException("unintialized AddressAccount object");

//wipe object prior to loading from disk

reset();

//get data from disk

LMDBEnv::Transaction tx(dbEnv_.get(), LMDB::ReadOnly);

CharacterArrayRef carKey(key.getSize(), key.getCharPtr());

auto&& carData = db_->get_NoCopy(carKey);

BinaryDataRef bdr((const uint8_t*)carData.data, carData.len);

BinaryRefReader brr(bdr);

//outer and inner accounts

size_t len, count;

len = brr.get_var_int();

outerAccount_ = brr.get_BinaryData(len);

len = brr.get_var_int();

innerAccount_ = brr.get_BinaryData(len);

//address type set

count = brr.get_var_int();

for (unsigned i = 0; i < count; i++)

addressTypes_.insert(AddressEntryType(brr.get_uint32_t()));

//default address type

defaultAddressEntryType_ = AddressEntryType(brr.get_uint32_t());

//asset accounts

count = brr.get_var_int();

for (unsigned i = 0; i < count; i++)

{

len = brr.get_var_int();

BinaryWriter bw_asset_key(1 + len);

bw_asset_key.put_uint8_t(ASSET_ACCOUNT_PREFIX);

bw_asset_key.put_BinaryData(brr.get_BinaryData(len));

auto accountPtr = AssetAccount::loadFromDisk(

bw_asset_key.getData(), dbEnv_, db_);

assetAccounts_.insert(make_pair(accountPtr->id_, accountPtr));

}

ID_ = key.getSliceCopy(1, key.getSize() - 1);

{

for (auto& account : assetAccounts_)

account.second->extendPublicChain(count);

shared_ptr<DecryptedDataContainer> ddc,

unsigned count)

{

for (auto& account : assetAccounts_)

account.second->extendPrivateChain(ddc, count);

const BinaryData& accountID, unsigned count)

{

auto iter = assetAccounts_.find(accountID);

if (iter == assetAccounts_.end())

throw AccountException("unknown account");

iter->second->extendPublicChainToIndex(count);

shared_ptr<DecryptedDataContainer> ddc,

const BinaryData& accountID, unsigned count)

{

auto iter = assetAccounts_.find(accountID);

if (iter == assetAccounts_.end())

throw AccountException("unknown account");

iter->second->extendPrivateChainToIndex(ddc, count);

AddressEntryType aeType)

{

if (outerAccount_.getSize() == 0)

throw AccountException("no currently active asset account");

return getNewAddress(outerAccount_, aeType);

AddressEntryType aeType)

{

if (innerAccount_.getSize() == 0)

throw AccountException("no currently active asset account");

return getNewAddress(innerAccount_, aeType);

const BinaryData& account, AddressEntryType aeType)

{

auto iter = assetAccounts_.find(account);

if (iter == assetAccounts_.end())

throw AccountException("invalid asset account");

if (aeType == AddressEntryType_Default)

aeType = defaultAddressEntryType_;

auto aeIter = addressTypes_.find(aeType);

if (aeIter == addressTypes_.end())

throw AccountException("invalid address type for this account");

return iter->second->getNewAddress(aeType);

{

auto iter = addressTypes_.find(aeType);

return iter != addressTypes_.end();

{

if (ID.getSize() < 4)

throw AccountException("invalid asset ID");

auto accID = ID.getSliceRef(0, 4);

auto iter = assetAccounts_.find(accID);

if (iter == assetAccounts_.end())

throw AccountException("unknown account ID");

auto assetID = ID.getSliceRef(4, ID.getSize() - 4);

return iter->second->getAssetForID(assetID);