opentxs::OTWallet Class Reference

#include <OTWallet.hpp>

Collaboration diagram for opentxs::OTWallet:

Public Member Functions
EXPORT	OTWallet ()
	~OTWallet ()
EXPORT bool	IsNymOnCachedKey (const OTIdentifier &needle) const
EXPORT bool	ConvertNymToCachedKey (OTPseudonym &theNym)
EXPORT OTPseudonym *	GetOrLoadNym (const OTIdentifier &NYM_ID, bool bChecking=false, const char *szFuncName=nullptr, const OTPasswordData *pPWData=nullptr)
EXPORT OTPseudonym *	GetOrLoadPublicNym (const OTIdentifier &NYM_ID, const char *szFuncName=nullptr)
EXPORT OTPseudonym *	GetOrLoadPrivateNym (const OTIdentifier &NYM_ID, bool bChecking=false, const char *szFuncName=nullptr, const OTPasswordData *pPWData=nullptr, const OTPassword *pImportPassword=nullptr)
EXPORT OTAccount *	LoadAccount (const OTPseudonym &theNym, const OTIdentifier &ACCT_ID, const OTIdentifier &SERVER_ID, const char *szFuncName=nullptr)
EXPORT OTAccount *	GetOrLoadAccount (const OTPseudonym &theNym, const OTIdentifier &ACCT_ID, const OTIdentifier &SERVER_ID, const char *szFuncName=nullptr)
EXPORT int32_t	GetNymCount ()
EXPORT int32_t	GetServerCount ()
EXPORT int32_t	GetAssetTypeCount ()
EXPORT int32_t	GetAccountCount ()
EXPORT bool	GetNym (int32_t iIndex, OTIdentifier &NYM_ID, OTString &NYM_NAME)
EXPORT bool	GetServer (int32_t iIndex, OTIdentifier &THE_ID, OTString &THE_NAME)
EXPORT bool	GetAssetType (int32_t iIndex, OTIdentifier &THE_ID, OTString &THE_NAME)
EXPORT bool	GetAccount (int32_t iIndex, OTIdentifier &THE_ID, OTString &THE_NAME)
EXPORT void	DisplayStatistics (OTString &strOutput)
EXPORT OTPseudonym *	GetNymByID (const OTIdentifier &NYM_ID)
EXPORT OTPseudonym *	GetNymByIDPartialMatch (std::string PARTIAL_ID)
EXPORT void	AddServerContract (const OTServerContract &theContract)
EXPORT OTServerContract *	GetServerContract (const OTIdentifier &SERVER_ID)
EXPORT OTServerContract *	GetServerContractPartialMatch (std::string PARTIAL_ID)
EXPORT void	AddNym (const OTPseudonym &theNym)
EXPORT void	AddAccount (const OTAccount &theAcct)
EXPORT void	AddAssetContract (const OTAssetContract &theContract)
EXPORT OTAssetContract *	GetAssetContract (const OTIdentifier &theContractID)
EXPORT OTAssetContract *	GetAssetContractPartialMatch (std::string PARTIAL_ID)
bool	VerifyAssetAccount (const OTPseudonym &theNym, OTAccount &theAcct, const OTIdentifier &SERVER_ID, const OTString &strAcctID, const char *szFuncName=nullptr)
EXPORT OTAccount *	GetAccount (const OTIdentifier &theAccountID)
EXPORT OTAccount *	GetAccountPartialMatch (std::string PARTIAL_ID)
EXPORT OTAccount *	GetIssuerAccount (const OTIdentifier &theAssetTypeID)
EXPORT void	AddPendingWithdrawal (const Purse &thePurse)
void	RemovePendingWithdrawal ()
Purse *	GetPendingWithdrawal () const
EXPORT bool	LoadWallet (const char *szFilename=nullptr)
EXPORT bool	SaveWallet (const char *szFilename=nullptr)
bool	SaveContract (OTString &strContract)
EXPORT bool	SignContractWithFirstNymOnList (OTContract &theContract)
EXPORT bool	ChangePassphrasesOnExtraKeys (const OTPassword &oldPassphrase, const OTPassword &newPassphrase)
EXPORT bool	Encrypt_ByKeyID (const std::string &key_id, const OTString &strPlaintext, OTString &strOutput, const OTString *pstrDisplay=nullptr, bool bBookends=true)
EXPORT bool	Decrypt_ByKeyID (const std::string &key_id, const OTString &strCiphertext, OTString &strOutput, const OTString *pstrDisplay=nullptr)
EXPORT std::shared_ptr < OTSymmetricKey >	getOrCreateExtraKey (const std::string &str_KeyID, const std::string *pReason=nullptr)
EXPORT std::shared_ptr < OTSymmetricKey >	getExtraKey (const std::string &str_id)
EXPORT bool	addExtraKey (const std::string &str_id, std::shared_ptr< OTSymmetricKey > pKey)
EXPORT bool	RemoveAssetContract (const OTIdentifier &theTargetID)
EXPORT bool	RemoveServerContract (const OTIdentifier &theTargetID)
EXPORT bool	RemoveAccount (const OTIdentifier &theTargetID)
EXPORT bool	RemoveNym (const OTIdentifier &theTargetID)

Public Attributes
OTString	m_strFilename
OTString	m_strDataFolder

Detailed Description

Definition at line 167 of file OTWallet.hpp.

Constructor & Destructor Documentation

opentxs::OTWallet::OTWallet

(

)

Definition at line 157 of file OTWallet.cpp.

    : m_strDataFolder(OTDataFolder::Get())
{
    m_pWithdrawalPurse = nullptr;
}

opentxs::OTWallet::~OTWallet

(

)

Definition at line 163 of file OTWallet.cpp.

{
    Release();
}

Member Function Documentation

void opentxs::OTWallet::AddAccount

(

const OTAccount &

theAcct

)

Definition at line 561 of file OTWallet.cpp.

{
    const OTIdentifier ACCOUNT_ID(theAcct);

    // See if there is already an account object on this wallet with the same ID
    // (Otherwise if we don't delete it, this would be a memory leak.)
    // Should use a smart pointer.
    OTIdentifier anAccountID;

    for (auto it(m_mapAccounts.begin()); it != m_mapAccounts.end(); ++it) {
        OTAccount* pAccount = it->second;
        OT_ASSERT(nullptr != pAccount);

        pAccount->GetIdentifier(anAccountID);

        if (anAccountID == ACCOUNT_ID) {
            OTString strName;
            pAccount->GetName(strName);

            if (strName.Exists()) ((OTAccount&)theAcct).SetName(strName);

            m_mapAccounts.erase(it);
            delete pAccount;
            pAccount = nullptr;

            break;
        }
    }

    const OTString strAcctID(ACCOUNT_ID);
    m_mapAccounts[strAcctID.Get()] = (OTAccount*)&theAcct;
}

void opentxs::OTWallet::AddAssetContract

(

const OTAssetContract &

theContract

)

Definition at line 752 of file OTWallet.cpp.

{
    OTIdentifier CONTRACT_ID(theContract);
    OTString STR_CONTRACT_ID(CONTRACT_ID);

    OTAssetContract* pContract = GetAssetContract(CONTRACT_ID);

    if (pContract) {
        otErr << "Error: Attempt to add Asset Contract but it is already in "
                 "the wallet.\n";

        delete &theContract; // I have to do this, since the return value is
                             // void, the caller MUST assume I took ownership.
    }
    else {
        m_mapContracts[STR_CONTRACT_ID.Get()] =
            &(const_cast<OTAssetContract&>(theContract));

        otInfo << "Saving asset contract to disk...\n";
        (const_cast<OTAssetContract&>(theContract)).SaveToContractFolder();

        SaveWallet();
    }
}

bool opentxs::OTWallet::addExtraKey	(	const std::string &	str_id,
		std::shared_ptr< OTSymmetricKey >	pKey
	)

Definition at line 1546 of file OTWallet.cpp.

{
    if (str_id.empty() || !pKey) return false;

    auto it = m_mapExtraKeys.find(str_id);

    if (it != m_mapExtraKeys.end()) // It's already there (can't add it.)
        return false;

    m_mapExtraKeys.insert(
        std::pair<std::string, std::shared_ptr<OTSymmetricKey>>(str_id, pKey));

    return true;
}

void opentxs::OTWallet::AddNym

(

const OTPseudonym &

theNym

)

Definition at line 523 of file OTWallet.cpp.

{
    const OTIdentifier NYM_ID(theNym);
    OTIdentifier aNymID;

    OTString strName;

    for (auto it(m_mapNyms.begin()); it != m_mapNyms.end(); ++it) {
        OTPseudonym* pNym = it->second;
        OT_ASSERT(nullptr != pNym);

        pNym->GetIdentifier(aNymID);

        if (aNymID == NYM_ID) {
            OTString strTemp(pNym->GetNymName());
            strName = strTemp; // todo optimize. currently am fixing "blank nym
                               // name" bug.

            m_mapNyms.erase(it);

            // Don't delete it if they are physically the same object.
            // (Versus each being separate copies of the same object.)
            //
            if (&theNym != pNym) delete pNym;
            pNym = nullptr;

            break;
        }
    }

    const OTString strNymID(NYM_ID);
    m_mapNyms[strNymID.Get()] =
        (OTPseudonym*)&theNym; // Insert to wallet's list of Nyms.

    if (strName.Exists())
        (const_cast<OTPseudonym&>(theNym)).SetNymName(strName);
}

void opentxs::OTWallet::AddPendingWithdrawal

(

const Purse &

thePurse

)

Definition at line 232 of file OTWallet.cpp.

{
    // TODO maintain a list here (I don't know why, the server response is
    // nearly
    // instant and then it's done.)

    // TODO notice I don't check the pointer here to see if it's already set, I
    // just start using it.. Fix that.
    m_pWithdrawalPurse = (Purse*)&thePurse;
} // TODO WARNING: If this data is lost before the transaction is completed,

void opentxs::OTWallet::AddServerContract

(

const OTServerContract &

theContract

)

Definition at line 725 of file OTWallet.cpp.

{
    OTIdentifier CONTRACT_ID(theContract);
    OTString STR_CONTRACT_ID(CONTRACT_ID);

    OTServerContract* pContract = GetServerContract(CONTRACT_ID);

    if (pContract) {
        otErr << "Error: Attempt to add Server Contract but it is already in "
                 "the wallet.\n";

        delete &theContract; // I have to do this, since the return value is
                             // void, the caller MUST assume I took ownership.
    }
    else {
        m_mapServers[STR_CONTRACT_ID.Get()] =
            &(const_cast<OTServerContract&>(theContract));

        otInfo << "Saving server contract to disk...\n";
        (const_cast<OTServerContract&>(theContract)).SaveToContractFolder();

        SaveWallet();
    }
}

bool opentxs::OTWallet::ChangePassphrasesOnExtraKeys	(	const OTPassword &	oldPassphrase,
		const OTPassword &	newPassphrase
	)

Definition at line 1427 of file OTWallet.cpp.

{
    // First we copy all the keys over to a new map, since we aren't going
    // to copy the changed ones back to the actual map unless EVERYTHING
    // succeeds.
    //
    mapOfSymmetricKeys mapChanged;

    for (auto& it : m_mapExtraKeys) {
        const std::string str_id = it.first;
        std::shared_ptr<OTSymmetricKey> pOldKey = it.second;

        OTPayload thePayload;

        if (pOldKey && pOldKey->SerializeTo(thePayload)) {
            std::shared_ptr<OTSymmetricKey> pNewKey(new OTSymmetricKey);

            if (pNewKey && pNewKey->SerializeFrom(thePayload))
                mapChanged.insert(
                    std::pair<std::string, std::shared_ptr<OTSymmetricKey>>(
                        str_id, pNewKey));
            else
                return false;
        }
        else
            return false;
    }

    // We're still here? Must have been a success so far.
    // Next we'll loop through mapChanged, and change the passphrase
    // on each key in there. If they all succeed, we'll clear the old
    // map and copy mapChanged into it.
    //
    for (auto& it : mapChanged) {
        std::shared_ptr<OTSymmetricKey> pNewKey = it.second;

        if (pNewKey) {
            if (!pNewKey->ChangePassphrase(oldPassphrase, newPassphrase))
                return false;
        }
        else
            return false;
    }

    // Still here? Must have been successful changing the passphrases
    // on all the various extra symmetric keys. So let's clear the main
    // map and copy the changed map into it.
    //
    m_mapExtraKeys.clear();
    m_mapExtraKeys = mapChanged;

    return true;
}

bool opentxs::OTWallet::ConvertNymToCachedKey

(

OTPseudonym &

theNym

)

Definition at line 2066 of file OTWallet.cpp.

{
    // If he's not ALREADY on the master key...
    //
    if (!IsNymOnCachedKey(theNym.GetConstID())) {
        bool bConverted = false;
        // The Nym has credentials.
        //
        if (theNym.GetMasterCredentialCount() > 0) {
            OTString strNymID, strCredList, strOutput;
            OTString::Map mapCredFiles;

            theNym.GetIdentifier(strNymID);
            theNym.GetPrivateCredentials(strCredList, &mapCredFiles);

            OTString strFilename;
            strFilename.Format("%s.cred", strNymID.Get());

            OTASCIIArmor ascArmor(strCredList);
            if (ascArmor.Exists() &&
                ascArmor.WriteArmoredString(
                    strOutput,
                    "CREDENTIAL LIST") && // bEscaped=false by default.
                strOutput.Exists()) {
                if (!OTDB::StorePlainString(strOutput.Get(),
                                            OTFolders::Credential().Get(),
                                            strFilename.Get())) {
                    otErr << __FUNCTION__ << ": Failure trying to store "
                          << (theNym.HasPrivateKey() ? "private" : "public")
                          << " credential list for Nym: " << strNymID << "\n";
                    return false;
                }
            }

            // Here we do the actual credentials.
            for (auto& it : mapCredFiles) {
                std::string str_cred_id = it.first;
                OTString strCredential(it.second);

                strOutput.Release();
                OTASCIIArmor ascLoopArmor(strCredential);
                if (ascLoopArmor.Exists() &&
                    ascLoopArmor.WriteArmoredString(
                        strOutput,
                        "CREDENTIAL") && // bEscaped=false by default.
                    strOutput.Exists()) {
                    if (false ==
                        OTDB::StorePlainString(strOutput.Get(),
                                               OTFolders::Credential().Get(),
                                               strNymID.Get(), str_cred_id)) {
                        otErr << __FUNCTION__ << ": Failure trying to store "
                              << (theNym.HasPrivateKey() ? "private" : "public")
                              << " credential for Nym: " << strNymID << "\n";
                        return false;
                    }
                }
            }
            bConverted = true;
        }
        else // Kicking it old-school. (No credentials.)
        {
            OTString strReason("Converting Nym to cached master key.");
            bConverted = theNym.Savex509CertAndPrivateKey(true, &strReason);
        }

        if (bConverted) {
            m_setNymsOnCachedKey.insert(theNym.GetConstID());
        }

        return bConverted;
    } // This block only occurs if Nym is not ALREADY on the wallet's list of
      // Nym using the wallet's cached master key.

    return false;
}

bool opentxs::OTWallet::Decrypt_ByKeyID	(	const std::string &	key_id,
		const OTString &	strCiphertext,
		OTString &	strOutput,
		const OTString *	pstrDisplay = nullptr
	)

Definition at line 1508 of file OTWallet.cpp.

{
    if (key_id.empty() || !strCiphertext.Exists()) return false;

    std::shared_ptr<OTSymmetricKey> pKey = OTWallet::getExtraKey(key_id);

    if (pKey) {
        std::shared_ptr<OTCachedKey> pMasterKey(OTCachedKey::It());

        if (pMasterKey) {
            OTPassword master_password;

            if (pMasterKey->GetMasterPassword(pMasterKey, master_password))
                return OTSymmetricKey::Decrypt(*pKey, strCiphertext, strOutput,
                                               pstrDisplay, &master_password);
        }
    }
    return false;
}

void opentxs::OTWallet::DisplayStatistics

(

OTString &

strOutput

)

Definition at line 457 of file OTWallet.cpp.

{
    strOutput.Concatenate(
        "\n-------------------------------------------------\n");
    strOutput.Concatenate("WALLET STATISTICS:\n");

    strOutput.Concatenate("\nPSEUDONYM(s):\n\n");

    for (auto& it : m_mapNyms) {
        OTPseudonym* pNym = it.second;
        OT_ASSERT_MSG((nullptr != pNym), "nullptr pseudonym pointer in "
                                         "OTWallet::m_mapNyms, "
                                         "OTWallet::DisplayStatistics.");

        pNym->DisplayStatistics(strOutput);
    }

    strOutput.Concatenate(
        "\n-------------------------------------------------\n");
    strOutput.Concatenate("ASSET CONTRACTS:\n\n");

    for (auto& it : m_mapContracts) {
        OTContract* pContract = it.second;
        OT_ASSERT_MSG(nullptr != pContract, "nullptr contract pointer in "
                                            "OTWallet::m_mapContracts, "
                                            "OTWallet::DisplayStatistics");

        pContract->DisplayStatistics(strOutput);
    }

    strOutput.Concatenate(
        "-------------------------------------------------\n");
    strOutput.Concatenate("SERVER CONTRACTS:\n\n");

    for (auto& it : m_mapServers) {
        OTContract* pServer = it.second;
        OT_ASSERT_MSG(nullptr != pServer, "nullptr server pointer in "
                                          "OTWallet::m_mapServers, "
                                          "OTWallet::DisplayStatistics");

        pServer->DisplayStatistics(strOutput);
    }

    strOutput.Concatenate(
        "-------------------------------------------------\n");
    strOutput.Concatenate("ACCOUNTS:\n\n");

    for (auto& it : m_mapAccounts) {
        OTAccount* pAccount = it.second;
        OT_ASSERT_MSG(nullptr != pAccount, "nullptr account pointer in "
                                           "OTWallet::m_mapAccounts, "
                                           "OTWallet::DisplayStatistics");

        pAccount->DisplayStatistics(strOutput);

        strOutput.Concatenate(
            "-------------------------------------------------\n\n");
    }
}

bool opentxs::OTWallet::Encrypt_ByKeyID	(	const std::string &	key_id,
		const OTString &	strPlaintext,
		OTString &	strOutput,
		const OTString *	pstrDisplay = nullptr,
		bool	bBookends = true
	)

Definition at line 1482 of file OTWallet.cpp.

{
    if (key_id.empty() || !strPlaintext.Exists()) return false;

    std::string str_Reason((nullptr != pstrDisplay) ? pstrDisplay->Get() : "");

    std::shared_ptr<OTSymmetricKey> pKey =
        OTWallet::getOrCreateExtraKey(key_id, &str_Reason);

    if (pKey) {
        std::shared_ptr<OTCachedKey> pMasterKey(OTCachedKey::It());

        if (pMasterKey) {
            OTPassword master_password;

            if (pMasterKey->GetMasterPassword(pMasterKey, master_password))
                return OTSymmetricKey::Encrypt(*pKey, strPlaintext, strOutput,
                                               pstrDisplay, bBookends,
                                               &master_password);
        }
    }
    return false;
}

bool opentxs::OTWallet::GetAccount	(	int32_t	iIndex,
		OTIdentifier &	THE_ID,
		OTString &	THE_NAME
	)

Definition at line 431 of file OTWallet.cpp.

{
    // if iIndex is within proper bounds (0 through count minus 1)
    if (iIndex < GetAccountCount() && iIndex >= 0) {
        int32_t iCurrentIndex = (-1);

        for (auto& it : m_mapAccounts) {
            OTAccount* pAccount = it.second;
            OT_ASSERT(nullptr != pAccount);

            iCurrentIndex++; // On first iteration, this becomes 0 here. (For 0
                             // index.) Increments thereafter.

            if (iIndex == iCurrentIndex) // if not null
            {
                pAccount->GetIdentifier(THE_ID);
                pAccount->GetName(THE_NAME);
                return true;
            }
        }
    }

    return false;
}

OTAccount * opentxs::OTWallet::GetAccount

(

const OTIdentifier &

theAccountID

)

Definition at line 596 of file OTWallet.cpp.

{
    // loop through the accounts and find one with a specific ID.
    //
    for (auto& it : m_mapAccounts) {
        OTAccount* pAccount = it.second;
        OT_ASSERT(nullptr != pAccount);

        OTIdentifier anAccountID;
        pAccount->GetIdentifier(anAccountID);

        if (anAccountID == theAccountID) return pAccount;
    }

    return nullptr;
}

int32_t opentxs::OTWallet::GetAccountCount

(

void

)

Definition at line 346 of file OTWallet.cpp.

{
    return static_cast<int32_t>(m_mapAccounts.size());
}

OTAccount * opentxs::OTWallet::GetAccountPartialMatch

(

std::string

PARTIAL_ID

)

Definition at line 613 of file OTWallet.cpp.

{
    // loop through the accounts and find one with a specific ID.
    for (auto& it : m_mapAccounts) {
        OTAccount* pAccount = it.second;
        OT_ASSERT(nullptr != pAccount);

        OTIdentifier anAccountID;
        pAccount->GetIdentifier(anAccountID);
        OTString strTemp(anAccountID);
        std::string strIdentifier = strTemp.Get();

        if (strIdentifier.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pAccount;
    }

    // Okay, let's try it by name, then...
    //
    for (auto& it : m_mapAccounts) {
        OTAccount* pAccount = it.second;
        OT_ASSERT(nullptr != pAccount);

        OTString strName;
        pAccount->GetName(strName);
        std::string str_Name = strName.Get();

        if (str_Name.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pAccount;
    }

    return nullptr;
}

OTAssetContract * opentxs::OTWallet::GetAssetContract

(

const OTIdentifier &

theContractID

)

Definition at line 1203 of file OTWallet.cpp.

{
    for (auto& it : m_mapContracts) {
        OTAssetContract* pContract = it.second;
        OT_ASSERT(nullptr != pContract);

        OTIdentifier aContractID;
        pContract->GetIdentifier(aContractID);

        if (aContractID == theContractID) return pContract;
    }

    return nullptr;
}

OTAssetContract * opentxs::OTWallet::GetAssetContractPartialMatch

(

std::string

PARTIAL_ID

)

Definition at line 1218 of file OTWallet.cpp.

{
    for (auto& it : m_mapContracts) {
        OTAssetContract* pContract = it.second;
        OT_ASSERT(nullptr != pContract);

        OTIdentifier aContractID;
        pContract->GetIdentifier(aContractID);

        OTString strTemp(aContractID);
        std::string strIdentifier = strTemp.Get();

        if (strIdentifier.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pContract;
    }

    // Okay, let's try it by the name, then...
    //
    for (auto& it : m_mapContracts) {
        OTAssetContract* pContract = it.second;
        OT_ASSERT(nullptr != pContract);

        OTString strName;
        pContract->GetName(strName);
        std::string str_Name = strName.Get();

        if (str_Name.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pContract;
    }

    return nullptr;
}

bool opentxs::OTWallet::GetAssetType	(	int32_t	iIndex,
		OTIdentifier &	THE_ID,
		OTString &	THE_NAME
	)

Definition at line 404 of file OTWallet.cpp.

{
    // if iIndex is within proper bounds (0 through count minus 1)
    if (iIndex < GetAssetTypeCount() && iIndex >= 0) {
        int32_t iCurrentIndex = (-1);

        for (auto& it : m_mapContracts) {
            OTAssetContract* pAssetType = it.second;
            OT_ASSERT(nullptr != pAssetType);

            iCurrentIndex++; // On first iteration, this becomes 0 here. (For 0
                             // index.) Increments thereafter.

            if (iIndex == iCurrentIndex) // if not null
            {
                pAssetType->GetIdentifier(THE_ID);
                pAssetType->GetName(THE_NAME);
                return true;
            }
        }
    }

    return false;
}

int32_t opentxs::OTWallet::GetAssetTypeCount

(

void

)

Definition at line 341 of file OTWallet.cpp.

{
    return static_cast<int32_t>(m_mapContracts.size());
}

std::shared_ptr< OTSymmetricKey > opentxs::OTWallet::getExtraKey

(

const std::string &

str_id

)

Definition at line 1530 of file OTWallet.cpp.

{
    if (str_id.empty()) return std::shared_ptr<OTSymmetricKey>();

    auto it = m_mapExtraKeys.find(str_id);

    if (it != m_mapExtraKeys.end()) // It's already there (can't add it.)
    {
        std::shared_ptr<OTSymmetricKey> pKey = it->second;

        return pKey;
    }

    return std::shared_ptr<OTSymmetricKey>();
}

OTAccount * opentxs::OTWallet::GetIssuerAccount

(

const OTIdentifier &

theAssetTypeID

)

Definition at line 649 of file OTWallet.cpp.

{
    // loop through the accounts and find one with a specific asset type ID.
    // (And with the issuer type set.)
    //
    for (auto& it : m_mapAccounts) {
        OTAccount* pIssuerAccount = it.second;
        OT_ASSERT(nullptr != pIssuerAccount);

        if ((pIssuerAccount->GetAssetTypeID() == theAssetTypeID) &&
            (pIssuerAccount->IsIssuer()))
            return pIssuerAccount;
    }

    return nullptr;
}

bool opentxs::OTWallet::GetNym	(	int32_t	iIndex,
		OTIdentifier &	NYM_ID,
		OTString &	NYM_NAME
	)

Definition at line 352 of file OTWallet.cpp.

{
    // if iIndex is within proper bounds (0 through count minus 1)
    if (iIndex < GetNymCount() && iIndex >= 0) {
        int32_t iCurrentIndex = (-1);

        for (auto& it : m_mapNyms) {
            OTPseudonym* pNym = it.second;
            OT_ASSERT(nullptr != pNym);

            iCurrentIndex++; // On first iteration, this becomes 0 here. (For 0
                             // index.) Increments thereafter.

            if (iIndex == iCurrentIndex) {
                pNym->GetIdentifier(NYM_ID);
                NYM_NAME.Set(pNym->GetNymName());
                return true;
            }
        }
    }

    return false;
}

OTPseudonym * opentxs::OTWallet::GetNymByID

(

const OTIdentifier &

NYM_ID

)

Definition at line 275 of file OTWallet.cpp.

{
    for (auto& it : m_mapNyms) {
        OTPseudonym* pNym = it.second;
        OT_ASSERT_MSG((nullptr != pNym),
                      "nullptr pseudonym pointer in OTWallet::GetNymByID.");

        OTIdentifier id_CurrentNym;
        pNym->GetIdentifier(id_CurrentNym);

        if (id_CurrentNym == NYM_ID) return pNym;
    }

    return nullptr;
}

OTPseudonym * opentxs::OTWallet::GetNymByIDPartialMatch

(

std::string

PARTIAL_ID

)

Definition at line 291 of file OTWallet.cpp.

{
    for (auto& it : m_mapNyms) {
        OTPseudonym* pNym = it.second;
        OT_ASSERT_MSG(
            (nullptr != pNym),
            "nullptr pseudonym pointer in OTWallet::GetNymByIDPartialMatch.");

        OTString strTemp;
        pNym->GetIdentifier(strTemp);

        std::string strIdentifier = strTemp.Get();

        if (strIdentifier.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pNym;
    }

    // OK, let's try it by the name, then...
    //
    for (auto& it : m_mapNyms) {
        OTPseudonym* pNym = it.second;
        OT_ASSERT_MSG(
            (nullptr != pNym),
            "nullptr pseudonym pointer in OTWallet::GetNymByIDPartialMatch.");

        OTString strNymName;
        strNymName.Set(pNym->GetNymName());
        std::string str_NymName = strNymName.Get();

        if (str_NymName.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return pNym;
    }

    return nullptr;
}

int32_t opentxs::OTWallet::GetNymCount

(

void

)

Definition at line 331 of file OTWallet.cpp.

{
    return static_cast<int32_t>(m_mapNyms.size());
}

std::shared_ptr< OTSymmetricKey > opentxs::OTWallet::getOrCreateExtraKey	(	const std::string &	str_KeyID,
		const std::string *	pReason = nullptr
	)

Definition at line 1368 of file OTWallet.cpp.

{
    //  const std::string str_KeyID("mc_sql_lite");

    // Get the appropriate symmetric key from the wallet.
    // (Which we will decrypt using pMaster.)
    // Once it's decrypted, we'll use this key for encrypting/decrypting
    // the sql*lite DB data on the client side.
    //
    std::shared_ptr<OTSymmetricKey> pExtraKey = getExtraKey(str_KeyID);

    // (If it doesn't exist, let's just create it here.)
    //
    if (!pExtraKey) {
        // The extra keys, like the Nyms, are all encrypted to the master key
        // for the wallet.
        // Thus, to create a new extra symmetrical key, we need to get the
        // master key from OTCachedKey...
        //
        std::shared_ptr<OTCachedKey> pMasterKey(OTCachedKey::It());

        if (pMasterKey) {
            OTPassword master_password;
            const bool bGotMasterPW = pMasterKey->GetMasterPassword(
                pMasterKey, master_password,
                (nullptr == pReason) ? "" : pReason->c_str());
            OTString strNewKeyOutput;

            if (bGotMasterPW &&
                OTSymmetricKey::CreateNewKey(strNewKeyOutput, nullptr,
                                             &master_password)) {
                std::shared_ptr<OTSymmetricKey> pNewExtraKey(
                    new OTSymmetricKey);

                if (pNewExtraKey &&
                    pNewExtraKey->SerializeFrom(strNewKeyOutput) &&
                    addExtraKey(str_KeyID, pNewExtraKey)) {

                    pExtraKey = pNewExtraKey;

                    SaveWallet();
                }
            } // if (bGotMasterPW)
        }     // if (pMasterKey)
    }

    // Then:
    //
    if (pExtraKey) return pExtraKey; // <======== SUCCESS.

    return std::shared_ptr<OTSymmetricKey>();
}

OTAccount * opentxs::OTWallet::GetOrLoadAccount	(	const OTPseudonym &	theNym,
		const OTIdentifier &	ACCT_ID,
		const OTIdentifier &	SERVER_ID,
		const char *	szFuncName = nullptr
	)

Definition at line 822 of file OTWallet.cpp.

{
    const char* szFunc =
        (nullptr != szFuncName) ? szFuncName : "OTWallet::GetOrLoadAccount";

    const OTString strAcctID(ACCT_ID);

    OTAccount* pAccount = GetAccount(ACCT_ID);

    if (nullptr ==
        pAccount) // It wasn't there already, so we'll have to load it...
    {
        otOut << "OTWallet::GetOrLoadAccount " << szFunc
              << ": There's no asset account in the wallet with that ID ("
              << strAcctID << "). "
                              "Attempting to load it from storage...\n";
        pAccount = LoadAccount(theNym, ACCT_ID, SERVER_ID, szFuncName);
    } // pAccount == nullptr.

    // It either was already there, or it loaded successfully...
    //
    if (nullptr == pAccount) // pAccount EXISTS...
    {
        otErr << "OTWallet::GetOrLoadAccount " << szFunc
              << ": Error loading Asset Account: " << strAcctID << "\n";
        return nullptr;
    }

    return pAccount;
}

OTPseudonym * opentxs::OTWallet::GetOrLoadNym	(	const OTIdentifier &	NYM_ID,
		bool	bChecking = false,
		const char *	szFuncName = nullptr,
		const OTPasswordData *	pPWData = nullptr
	)

Definition at line 1073 of file OTWallet.cpp.

{
    OTPseudonym* pNym = GetOrLoadPublicNym(NYM_ID, szFuncName);

    // It tries to load as public Nym first, so as not to force the user to
    // enter his passphrase unnecessarily.
    // However, if this fails, then it tries the private one, just to see
    // if it can be found.
    //
    OTPasswordData thePWData(OT_PW_DISPLAY);

    if (nullptr == pNym)
        pNym = GetOrLoadPrivateNym(NYM_ID, bChecking, szFuncName,
                                   nullptr == pPWData ? &thePWData : pPWData);

    return pNym;
}

OTPseudonym * opentxs::OTWallet::GetOrLoadPrivateNym	(	const OTIdentifier &	NYM_ID,
		bool	bChecking = false,
		const char *	szFuncName = nullptr,
		const OTPasswordData *	pPWData = nullptr,
		const OTPassword *	pImportPassword = nullptr
	)

Definition at line 956 of file OTWallet.cpp.

{
    if (NYM_ID.IsEmpty()) {
        otErr << __FUNCTION__ << ":" << szFuncName
              << ": Error: NYM_ID passed in empty, returning null";
        return nullptr;
    }

    const OTString strNymID(NYM_ID);
    OTPasswordData thePWData(OT_PW_DISPLAY);
    if (nullptr == pPWData) pPWData = &thePWData;

    szFuncName = (szFuncName == nullptr) ? "" : szFuncName;

    // See if it's already there. (Could be the public version
    // though :P Still might have to reload it.)
    //
    OTPseudonym* pNym = GetNymByID(NYM_ID); // <===========

    if (nullptr ==
        pNym) // Wasn't already in the wallet. Let's try loading it...
    {
        otWarn << __FUNCTION__ << " " << szFuncName
               << ": There's no Nym already loaded with that ID. "
                  "Attempting to load private key...\n";
        pNym = OTPseudonym::LoadPrivateNym(NYM_ID, bChecking, nullptr,
                                           szFuncName, // <===========
                                           pPWData, pImportPassword);
        // It worked!
        if (nullptr !=
            pNym)          // LoadPublicNym has plenty of error logging already.
            AddNym(*pNym); // <===========
        else {
            OTLogStream& otLog = bChecking ? otWarn : otOut;
            otLog << __FUNCTION__ << ": " << szFuncName << ": ("
                  << "bChecking"
                  << ": is " << (bChecking ? "true" : "false")
                  << ").  Unable to load Private Nym for: " << strNymID << "\n";
        }
    }

    // If pNym EXISTS, then let's make sure he has a public AND a
    // private key, as he should. (He might be already loaded on the
    // wallet, without his private key, necessitating a reload.)
    //
    if (nullptr != pNym) // pNym definitely NOT nullptr (it exists)...
    {

        // ...yet he doesn't have a public key (Weird!)
        if (!pNym->HasPublicKey())
            otErr << __FUNCTION__ << " " << szFuncName
                  << ": Found nym, but he has no public key: " << strNymID
                  << "\n";

        // ...hmm, he doesn't have a private key. Possible! If the wallet
        // already had
        // my public key loaded (without the private one) from some earlier
        // action.
        //
        if (!pNym->HasPrivateKey()) {
            otWarn
                << __FUNCTION__ << " " << szFuncName
                << ": Found nym in wallet (" << strNymID
                << "), "
                   "but he currently has no private key loaded. Reloading...\n";

            // ASSUMPTION: The Nym is always saved right after some important
            // change,
            // to avoid the risk of losing it. Therefore I don't have to save
            // the
            // current Nym here--I can just remove it from the wallet now, and
            // then
            // reload it (as a private key this time, of course.)
            //

            // Let's save the Name, in case that is already set, so we don't
            // blank it out...
            //
            OTString strName =
                pNym->GetNymName().Get(); // Get returns "" if string is empty.

            if (RemoveNym(NYM_ID)) {
                pNym = OTPseudonym::LoadPrivateNym(NYM_ID, false, &strName,
                                                   szFuncName, // <===========
                                                   pPWData, pImportPassword);
                // It worked!
                if (nullptr !=
                    pNym) // LoadPrivateNym has plenty of error logging already.
                    AddNym(*pNym); // <===========
                else
                    otOut << __FUNCTION__ << " " << szFuncName
                          << ": Unable to load private Nym for: " << strNymID
                          << " \n";
            }
            else
                otErr << __FUNCTION__ << " " << szFuncName << ": Found nym ("
                      << strNymID << "), but he had no private key. Then tried "
                                     "to remove him from wallet (in order "
                                     "to reload him with private key) and then "
                                     "the removal failed. Sorry.\n";
        }
    }
    return pNym;
}

OTPseudonym * opentxs::OTWallet::GetOrLoadPublicNym	(	const OTIdentifier &	NYM_ID,
		const char *	szFuncName = nullptr
	)

Definition at line 910 of file OTWallet.cpp.

{
    const OTString strNymID(NYM_ID);
    const char* szFunc = "OTWallet::GetOrLoadPublicNym";

    szFuncName = (szFuncName == nullptr) ? "" : szFuncName;

    OTPseudonym* pNym = GetNymByID(NYM_ID); // <===========

    if (nullptr == pNym) // Wasn't already in the wallet. Try loading it.
    {
        otWarn << szFunc << " " << szFuncName
               << ": There's no Nym already loaded with that ID. "
                  "Attempting to load public key...\n";
        pNym = OTPseudonym::LoadPublicNym(NYM_ID); // <===========
        // It worked!
        if (nullptr !=
            pNym) // LoadPublicNym has plenty of error logging already.
        {
            if (pNym->HasPrivateKey()) // We don't auto-add public Nyms -- only
                                       // private ones.
                AddNym(*pNym);         // <===========
        }
        else
            otOut << szFunc << " " << szFuncName
                  << ": Unable to load public Nym for: " << strNymID << " \n";
    }

    // If pNym exists, yet he doesn't have a public key (weird!)
    // Though we log the error, we still return pNym, since it exists.
    //
    if ((nullptr != pNym) && (false == pNym->HasPublicKey()))
        otErr << szFunc << " " << szFuncName << ": Found nym (" << strNymID
              << "), but he has no public key. "
                 "(Still returning the Nym, since it exists.)\n";
    return pNym;
}

Purse* opentxs::OTWallet::GetPendingWithdrawal ( ) const

inline

Definition at line 249 of file OTWallet.hpp.

    {
        return m_pWithdrawalPurse;
    }

bool opentxs::OTWallet::GetServer	(	int32_t	iIndex,
		OTIdentifier &	THE_ID,
		OTString &	THE_NAME
	)

Definition at line 377 of file OTWallet.cpp.

{
    // if iIndex is within proper bounds (0 through count minus 1)
    if (iIndex < GetServerCount() && iIndex >= 0) {
        int32_t iCurrentIndex = (-1);

        for (auto& it : m_mapServers) {
            OTServerContract* pServer = it.second;
            OT_ASSERT(nullptr != pServer);

            iCurrentIndex++; // On first iteration, this becomes 0 here. (For 0
                             // index.) Increments thereafter.

            if (iIndex == iCurrentIndex) // if not null
            {
                pServer->GetIdentifier(THE_ID);
                pServer->GetName(THE_NAME);
                return true;
            }
        }
    }

    return false;
}

OTServerContract * opentxs::OTWallet::GetServerContract

(

const OTIdentifier &

SERVER_ID

)

Definition at line 667 of file OTWallet.cpp.

{
    for (auto& it : m_mapServers) {
        OTContract* pServer = it.second;
        OT_ASSERT_MSG((nullptr != pServer), "nullptr server pointer in "
                                            "OTWallet::m_mapServers, "
                                            "OTWallet::GetServerContract");

        OTIdentifier id_CurrentContract;
        pServer->GetIdentifier(id_CurrentContract);

        if (id_CurrentContract == SERVER_ID)
            return dynamic_cast<OTServerContract*>(pServer);
    }

    return nullptr;
}

OTServerContract * opentxs::OTWallet::GetServerContractPartialMatch

(

std::string

PARTIAL_ID

)

Definition at line 685 of file OTWallet.cpp.

{
    for (auto& it : m_mapServers) {
        OTContract* pServer = it.second;
        OT_ASSERT_MSG((nullptr != pServer), "nullptr server pointer in "
                                            "OTWallet::m_mapServers, "
                                            "OTWallet::GetServerContract");

        OTIdentifier id_CurrentContract;
        pServer->GetIdentifier(id_CurrentContract);

        OTString strTemp(id_CurrentContract);
        std::string strIdentifier = strTemp.Get();

        if (strIdentifier.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return dynamic_cast<OTServerContract*>(pServer);
    }

    // Okay, let's try it by the name, then.
    //
    for (auto& it : m_mapServers) {
        OTContract* pServer = it.second;
        OT_ASSERT_MSG((nullptr != pServer), "nullptr server pointer in "
                                            "OTWallet::m_mapServers, "
                                            "OTWallet::GetServerContract");

        OTString strName;
        pServer->GetName(strName);
        std::string str_Name = strName.Get();

        if (str_Name.compare(0, PARTIAL_ID.length(), PARTIAL_ID) == 0)
            return dynamic_cast<OTServerContract*>(pServer);
    }

    return nullptr;
}

int32_t opentxs::OTWallet::GetServerCount

(

void

)

Definition at line 336 of file OTWallet.cpp.

{
    return static_cast<int32_t>(m_mapServers.size());
}

bool opentxs::OTWallet::IsNymOnCachedKey

(

const OTIdentifier &

needle

)

const

Definition at line 2147 of file OTWallet.cpp.

{
    for (const auto& it : m_setNymsOnCachedKey) {
        if (needle == it) return true;
    }
    return false;
}

OTAccount * opentxs::OTWallet::LoadAccount	(	const OTPseudonym &	theNym,
		const OTIdentifier &	ACCT_ID,
		const OTIdentifier &	SERVER_ID,
		const char *	szFuncName = nullptr
	)

Definition at line 863 of file OTWallet.cpp.

{
    const char* szFunc =
        (nullptr != szFuncName) ? szFuncName : "OTWallet::LoadAccount";

    const OTString strAcctID(ACCT_ID);
    OTAccount* pAccount = OTAccount::LoadExistingAccount(ACCT_ID, SERVER_ID);

    // It loaded successfully...
    //
    if (nullptr != pAccount) // pAccount EXISTS...
    {
        bool bVerified =
            VerifyAssetAccount(theNym, *pAccount, SERVER_ID, strAcctID, szFunc);

        if (!bVerified) {
            delete pAccount;
            pAccount = nullptr;
            return nullptr; // No need to log, since VerifyAssetAccount()
                            // already
                            // logs.
        }

        // If I had to load it myself, that means I need to add it to the
        // wallet.
        // (Whereas if GetAccount() had worked, then it would ALREADY be in the
        // wallet,
        // and thus I shouldn't add it twice...)
        //
        AddAccount(*pAccount);

    }
    else {
        otErr << "OTWallet::LoadAccount " << szFunc
              << ": Failed loading Asset Account: " << strAcctID << "\n";
        return nullptr;
    }

    return pAccount;
}

bool opentxs::OTWallet::LoadWallet

(

const char *

szFilename = nullptr

)

Definition at line 1617 of file OTWallet.cpp.

{
    OT_ASSERT_MSG(m_strFilename.Exists() || (nullptr != szFilename),
                  "OTWallet::LoadWallet: nullptr filename.\n");

    Release();

    // The directory is "." because unlike every other OT file, the wallet file
    // doesn't go into a subdirectory, but it goes into the main data_folder
    // itself.
    // Every other file, however, needs to specify its folder AND filename (and
    // both
    // of those will be appended to the local path to form the complete file
    // path.)
    //
    if (!m_strFilename.Exists()) // If it's not already set, then set it.
        m_strFilename.Set(
            szFilename); // (We know nullptr wasn't passed in, in this case.)

    if (nullptr ==
        szFilename) // If nullptr was passed in, then set the pointer to
                    // existing string.
        szFilename = m_strFilename.Get(); // (We know existing string is there,
                                          // in this case.)

    if (!OTDB::Exists(".", szFilename)) {
        otErr << __FUNCTION__ << ": Wallet file does not exist: " << szFilename
              << ". Creating...\n";

        const char* szContents = "<?xml version=\"1.0\"?>\n"
                                 "<wallet name=\"\" version=\"1.0\">\n"
                                 "\n"
                                 "</wallet>\n";

        if (!OTDB::StorePlainString(szContents, ".", szFilename)) {
            otErr << __FUNCTION__
                  << ": Error: Unable to create blank wallet file.\n";
            OT_FAIL;
        }
    }

    OTString strFileContents(OTDB::QueryPlainString(
        ".", szFilename)); // <=== LOADING FROM DATA STORE.

    if (!strFileContents.Exists()) {
        otErr << __FUNCTION__ << ": Error reading wallet file: " << szFilename
              << "\n";
        return false;
    }

    bool bNeedToSaveAgain = false;

    {
        OTStringXML xmlFileContents(strFileContents);

        if (!xmlFileContents.DecodeIfArmored()) {
            otErr << __FUNCTION__
                  << ": Input string apparently was encoded and then failed "
                     "decoding. Filename: " << szFilename << " \n"
                                                             "Contents: \n"
                  << strFileContents << "\n";
            return false;
        }

        irr::io::IrrXMLReader* xml =
            irr::io::createIrrXMLReader(xmlFileContents);

        // parse the file until end reached
        while (xml && xml->read()) {
            // strings for storing the data that we want to read out of the file
            OTString NymName;
            OTString NymID;

            OTString AssetName;
            OTString AssetContract;
            OTString AssetID;

            OTString ServerName;
            OTString ServerContract;
            OTString ServerID;

            OTString AcctName;
            OTString AcctFile;
            OTString AcctID;

            const OTString strNodeName(xml->getNodeName());

            switch (xml->getNodeType()) {
            case irr::io::EXN_NONE:
            case irr::io::EXN_TEXT:
            case irr::io::EXN_COMMENT:
            case irr::io::EXN_ELEMENT_END:
            case irr::io::EXN_CDATA:
                // in this xml file, the only text which occurs is the
                // messageText
                // messageText = xml->getNodeData();
                break;
            case irr::io::EXN_ELEMENT: {
                if (strNodeName.Compare("wallet")) {
                    OTASCIIArmor ascWalletName = xml->getAttributeValue("name");

                    if (ascWalletName.Exists())
                        ascWalletName.GetString(m_strName,
                                                false); // linebreaks == false

                    //                      m_strName            =
                    // xml->getAttributeValue("name");
                    //                      OTLog::OTPath        =
                    // xml->getAttributeValue("path");
                    m_strVersion = xml->getAttributeValue("version");

                    otWarn << "\nLoading wallet: " << m_strName
                           << ", version: " << m_strVersion << "\n";
                }

                // todo: Remove the masterKey after a while. It's here for now
                // so people's data files can get
                // converted over. After a while, just remove it.
                else if (strNodeName.Compare("masterKey") ||
                         strNodeName.Compare("cachedKey")) {
                    OTASCIIArmor ascCachedKey;

                    if (OTContract::LoadEncodedTextField(xml, ascCachedKey)) {
                        // We successfully loaded the cachedKey from file, so
                        // let's SET it
                        // as the cached key globally...
                        //
                        OTCachedKey::It()->SetCachedKey(ascCachedKey);

                        if (!OTCachedKey::It()->HasHashCheck()) {
                            OTPassword tempPassword;
                            tempPassword.zeroMemory();

                            std::shared_ptr<OTCachedKey> sharedPtr(
                                OTCachedKey::It());

                            bNeedToSaveAgain = sharedPtr->GetMasterPassword(
                                sharedPtr, tempPassword,
                                "We do not have a check hash yet for this "
                                "password, please enter your password",
                                true);
                        }
                    }

                    otWarn << "Loading cachedKey:\n" << ascCachedKey << "\n";
                }

                // todo: Remove the nymUsingMasterKey after a while. It's here
                // for now so people's data files can get
                // converted over. After a while, just remove it.
                else if (strNodeName.Compare("nymUsingMasterKey") ||
                         strNodeName.Compare("nymUsingCachedKey")) {
                    NymID = xml->getAttributeValue("id"); // message digest from
                                                          // hash of x.509 cert
                                                          // or public key.

                    otWarn << "NymID using Cached Key: " << NymID << "\n";
                    if (!NymID.Exists()) {
                        otErr << __FUNCTION__ << ": NymID using Cached Key was "
                                                 "empty when loading wallet!\n";
                        OT_FAIL;
                    }

                    const OTIdentifier theNymID(NymID);

                    m_setNymsOnCachedKey.insert(theNymID);
                }
                else if (strNodeName.Compare("symmetricKey")) {
                    OTString strKeyID;
                    OTASCIIArmor ascKeyID = xml->getAttributeValue("id");
                    OTASCIIArmor ascSymmetricKey;

                    if (!ascKeyID.Exists() ||
                        !ascKeyID.GetString(strKeyID, false)) // linebreaks ==
                                                              // false (true by
                                                              // default.)
                        otErr << __FUNCTION__ << ": Failed loading "
                                                 "symmetricKey ID (it was "
                                                 "blank.)\n";

                    else if (OTContract::LoadEncodedTextField(
                                 xml, ascSymmetricKey)) {
                        std::shared_ptr<OTSymmetricKey> pKey(
                            new OTSymmetricKey);

                        if (!pKey || !pKey->SerializeFrom(ascSymmetricKey))
                            otErr << __FUNCTION__
                                  << ": Failed serializing symmetricKey from "
                                     "string (id: " << strKeyID << ")\n";
                        else {
                            const std::string str_id(strKeyID.Get());

                            if (!addExtraKey(str_id, pKey))
                                otErr << __FUNCTION__
                                      << ": Failed adding serialized "
                                         "symmetricKey to wallet (id: "
                                      << strKeyID << ")\n";
                        }
                    }
                }
                else if (strNodeName.Compare("pseudonym")) {
                    OTASCIIArmor ascNymName = xml->getAttributeValue("name");
                    if (ascNymName.Exists())
                        ascNymName.GetString(NymName,
                                             false); // linebreaks == false

                    NymID = xml->getAttributeValue("nymID"); // message digest
                                                             // from hash of
                                                             // x.509 cert or
                                                             // public key.

                    otInfo << "\n\n** Pseudonym ** (wallet listing): "
                           << NymName << "\nID: " << NymID << "\n";
                    if (!NymID.Exists()) {
                        otErr << __FUNCTION__ << ": NymID dosn't Exist!\n";
                        OT_FAIL;
                    }

                    const OTIdentifier theNymID(NymID);

                    // What's going on here? We need to see if the MASTER KEY
                    // exists at this point. If it's GENERATED.
                    // If not, that means the Nyms are all still encrypted to
                    // their own passphrases, not to the master key.
                    // In which case we need to generate one and re-encrypt each
                    // private key to that new master key.
                    //
                    //                  bool OTWallet::IsNymOnCachedKey(const
                    // OTIdentifier& needle) const // needle and haystack.

                    const bool bIsOldStyleNym =
                        (false == IsNymOnCachedKey(theNymID));

                    if (bIsOldStyleNym && !(OTCachedKey::It()->isPaused()))
                    //                  if (m_strVersion.Compare("1.0")) //
                    // This means this Nym has not been converted yet to
                    // master password.
                    {
                        OTCachedKey::It()->Pause();
                    }

                    OTPseudonym* pNym =
                        OTPseudonym::LoadPrivateNym(theNymID, false, &NymName);
                    // If it fails loading as a private Nym, then maybe it's a
                    // public one...
                    if (nullptr == pNym)
                        pNym = OTPseudonym::LoadPublicNym(theNymID, &NymName);

                    if (nullptr == pNym) // STILL null ??
                        otOut << __FUNCTION__ << ": Failed loading Nym ("
                              << NymName << ") with ID: " << NymID << "\n";
                    else
                        AddNym(*pNym); // Nym loaded. Insert to wallet's
                                       // list of Nyms.

                    if (bIsOldStyleNym && OTCachedKey::It()->isPaused()) {
                        OTCachedKey::It()->Unpause();
                    }
                    // (Here we set it back again, so any new-style Nyms will
                    // still load properly, when they come around.)
                }

                // NOTE: It's only by THIS point (assetType) that we KNOW we
                // loaded all the Nyms.
                // If we are version 1.0, NOW we should convert them all to the
                // new master key!!
                else if (strNodeName.Compare("assetType")) {

                    OTASCIIArmor ascAssetName = xml->getAttributeValue("name");

                    if (ascAssetName.Exists())
                        ascAssetName.GetString(AssetName,
                                               false); // linebreaks == false

                    //                    AssetName        =
                    // xml->getAttributeValue("name");
                    AssetID = xml->getAttributeValue(
                        "assetTypeID"); // hash of contract itself

                    otInfo << "\n\n****Asset Contract**** (wallet listing)\n  "
                              "Asset Name: " << AssetName
                           << "\n Contract ID: " << AssetID << "\n";

                    OTString strContractPath;
                    strContractPath.Format(OTFolders::Contract().Get());
                    OTAssetContract* pContract = new OTAssetContract(
                        AssetName, strContractPath, AssetID, AssetID);

                    OT_ASSERT_MSG(nullptr != pContract,
                                  "Error allocating memory "
                                  "for Asset Contract in "
                                  "OTWallet::LoadWallet\n");

                    if (pContract->LoadContract()) {
                        if (pContract->VerifyContract()) {
                            otWarn << "** Asset Contract Verified "
                                      "**\n------------------------------------"
                                      "----------------------------------------"
                                      "-\n\n";

                            pContract->SetName(AssetName);

                            m_mapContracts[AssetID.Get()] = pContract;
                        }
                        else {
                            delete pContract;
                            pContract = nullptr;
                            otOut << "Contract FAILED to verify.\n";
                        }
                    }
                    else {
                        delete pContract;
                        pContract = nullptr;
                        otErr << __FUNCTION__
                              << ": Error reading file for Asset Contract.\n";
                    }

                }
                else if (strNodeName.Compare("notaryProvider")) {
                    OTASCIIArmor ascServerName = xml->getAttributeValue("name");

                    if (ascServerName.Exists())
                        ascServerName.GetString(ServerName,
                                                false); // linebreaks == false

                    //                    ServerName =
                    // xml->getAttributeValue("name");
                    ServerID =
                        xml->getAttributeValue("serverID"); // hash of contract

                    otInfo << "\n\n\n****Server Contract**** (wallet "
                              "listing):\n Server Name: " << ServerName
                           << "\n   Server ID: " << ServerID << "\n";

                    OTString strContractPath(OTFolders::Contract().Get());

                    OTServerContract* pContract = new OTServerContract(
                        ServerName, strContractPath, ServerID, ServerID);

                    OT_ASSERT_MSG(nullptr != pContract,
                                  "Error allocating memory "
                                  "for Server Contract in "
                                  "OTWallet::LoadWallet\n");

                    if (pContract->LoadContract()) {
                        if (pContract->VerifyContract()) {
                            pContract->SetName(ServerName); // This isn't
                                                            // needed, but it's
                                                            // proper.

                            otWarn << "** Server Contract Verified "
                                      "**\n------------------------------------"
                                      "----------------------------------------"
                                      "-\n\n";
                            // Uncomment : Move these lines back above the 'if'
                            // block to regenerate some newly-signed contracts.
                            // (for testing only.) Otherwise leave here where it
                            // belongs.
                            m_mapServers[ServerID.Get()] = pContract;
                        }
                        else {
                            delete pContract;
                            pContract = nullptr;
                            otOut << __FUNCTION__
                                  << ": Server contract failed to verify.\n";
                        }
                    }
                    else {
                        delete pContract;
                        pContract = nullptr;
                        otErr
                            << __FUNCTION__
                            << ": Error reading file for Transaction Server.\n";
                    }
                }
                else if (strNodeName.Compare("assetAccount")) {
                    OTASCIIArmor ascAcctName = xml->getAttributeValue("name");

                    if (ascAcctName.Exists())
                        ascAcctName.GetString(AcctName,
                                              false); // linebreaks == false

                    AcctID = xml->getAttributeValue("accountID");
                    ServerID = xml->getAttributeValue("serverID");

                    otInfo << "\n----------------------------------------------"
                              "----------------------------\n"
                              "****Account**** (wallet listing)\n"
                              " Account Name: " << AcctName
                           << "\n   Account ID: " << AcctID
                           << "\n    Server ID: " << ServerID << "\n";

                    const OTIdentifier ACCOUNT_ID(AcctID), SERVER_ID(ServerID);

                    OTAccount* pAccount =
                        OTAccount::LoadExistingAccount(ACCOUNT_ID, SERVER_ID);

                    if (pAccount) {
                        pAccount->SetName(AcctName);
                        AddAccount(*pAccount);
                    }
                    else {
                        otErr << __FUNCTION__
                              << ": Error loading existing Asset Account.\n";
                    }
                }
                else {
                    // unknown element type
                    otErr << __FUNCTION__
                          << ": unknown element type: " << xml->getNodeName()
                          << "\n";
                }
            } break;
            default:
                otLog5 << __FUNCTION__
                       << ": Unknown XML type: " << xml->getNodeName() << "\n";
                break;
            }
        } // while xml->read()

        // After we've loaded all the old-format Nyms that don't use the master
        // key,
        // NOW we can go through and convert them all, now that they're all
        // loaded.

        for (auto& it : m_mapNyms) {
            OTPseudonym* pNym = it.second;
            OT_ASSERT_MSG(
                (nullptr != pNym),
                "ASSERT: OTWallet::LoadWallet: nullptr pseudonym pointer.");

            if (pNym->HasPrivateKey() &&
                ConvertNymToCachedKey(*pNym)) // Internally this is smart
                                              // enough to only convert
                                              // the unconverted.
                bNeedToSaveAgain = true;
        }

        //
        // delete the xml parser after usage
        if (xml) delete xml;
    }

    // In case we converted any of the Nyms to the new "master key" encryption.
    if (bNeedToSaveAgain) SaveWallet(szFilename);

    return true;
}

bool opentxs::OTWallet::RemoveAccount

(

const OTIdentifier &

theTargetID

)

Definition at line 1182 of file OTWallet.cpp.

{
    // loop through the accounts and find one with a specific ID.
    OTIdentifier anAccountID;

    for (auto it(m_mapAccounts.begin()); it != m_mapAccounts.end(); ++it) {
        OTAccount* pAccount = it->second;
        OT_ASSERT(nullptr != pAccount);

        pAccount->GetIdentifier(anAccountID);

        if (anAccountID == theTargetID) {
            m_mapAccounts.erase(it);
            delete pAccount;
            return true;
        }
    }

    return false;
}

bool opentxs::OTWallet::RemoveAssetContract

(

const OTIdentifier &

theTargetID

)

Definition at line 1131 of file OTWallet.cpp.

{
    // loop through the items that make up this transaction and print them out
    // here, base64-encoded, of course.
    OTIdentifier aContractID;

    for (auto it(m_mapContracts.begin()); it != m_mapContracts.end(); ++it) {
        OTAssetContract* pContract = it->second;
        OT_ASSERT(nullptr != pContract);

        pContract->GetIdentifier(aContractID);

        if (aContractID == theTargetID) {
            m_mapContracts.erase(it);

            delete pContract;

            return true;
        }
    }

    return false;
}

bool opentxs::OTWallet::RemoveNym

(

const OTIdentifier &

theTargetID

)

Definition at line 1101 of file OTWallet.cpp.

{
    for (auto it(m_mapNyms.begin()); it != m_mapNyms.end(); ++it) {
        OTPseudonym* pNym = it->second;
        OT_ASSERT_MSG((nullptr != pNym),
                      "nullptr pseudonym pointer in OTWallet::RemoveNym.");

        if (pNym->CompareID(theTargetID)) {

            // We have a set of NymIDs for Nyms in the wallet who are using the
            // Master key.
            // So if we're removing the Nym from the wallet, we also remove its
            // ID from that set.
            //
            for (const auto& it_master : m_setNymsOnCachedKey) {
                const OTIdentifier& theNymID = it_master;
                if (theTargetID == theNymID) {
                    m_setNymsOnCachedKey.erase(it_master);
                    break;
                }
            }

            m_mapNyms.erase(it);
            delete pNym;
            return true;
        }
    }
    return false;
}

void opentxs::OTWallet::RemovePendingWithdrawal

(

)

Definition at line 245 of file OTWallet.cpp.

{
    if (m_pWithdrawalPurse) delete m_pWithdrawalPurse;

    m_pWithdrawalPurse = nullptr;
}

bool opentxs::OTWallet::RemoveServerContract

(

const OTIdentifier &

theTargetID

)

Definition at line 1155 of file OTWallet.cpp.

{
    for (auto it(m_mapServers.begin()); it != m_mapServers.end(); ++it) {
        OTContract* pServer = it->second;
        OT_ASSERT_MSG((nullptr != pServer), "nullptr server pointer in "
                                            "OTWallet::m_mapServers, "
                                            "OTWallet::RemoveServerContract");

        OTIdentifier id_CurrentContract;
        pServer->GetIdentifier(id_CurrentContract);

        if (id_CurrentContract == theTargetID) {
            m_mapServers.erase(it);

            OTServerContract* pServerContract =
                static_cast<OTServerContract*>(pServer);
            delete pServerContract;

            return true;
        }
    }

    return false;
}

bool opentxs::OTWallet::SaveContract

(

OTString &

strContract

)

Definition at line 1252 of file OTWallet.cpp.

{
    OTASCIIArmor ascName;

    if (m_strName.Exists()) // name is in the clear in memory, and base64 in
                            // storage.
    {
        ascName.SetString(m_strName, false); // linebreaks == false
    }

    strContract.Concatenate(
        "<?xml version=\"1.0\"?>\n<wallet name=\"%s\" version=\"%s\">\n\n",
        ascName.Get(),
        OTCachedKey::It()->IsGenerated() ? "2.0" : m_strVersion.Get());

    if (OTCachedKey::It()->IsGenerated()) // If it exists, then serialize it.
    {
        OTASCIIArmor ascMasterContents;

        if (OTCachedKey::It()->SerializeTo(ascMasterContents)) {
            strContract.Concatenate("<cachedKey>\n%s</cachedKey>\n\n",
                                    ascMasterContents.Get());
        }
        else
            otErr << "OTWallet::SaveContract: Failed trying to write master "
                     "key to wallet.\n";
    }

    // Save the extra symmetric keys. (The ones the client app might use to
    // encrypt his local sql-lite DB's record of his Bitmessage connect string,
    // or any other local data.)
    //
    for (auto& it : m_mapExtraKeys) {
        const std::string str_id = it.first;
        std::shared_ptr<OTSymmetricKey> pKey = it.second;

        OTString strKeyID(str_id.c_str());
        OTASCIIArmor ascKeyID;

        ascKeyID.SetString(strKeyID,
                           false); // linebreaks=false (true by default.)

        OTASCIIArmor ascKeyContents;

        if (pKey && pKey->SerializeTo(ascKeyContents)) {
            strContract.Concatenate(
                "<symmetricKey id=\"%s\">\n%s</symmetricKey>\n\n",
                ascKeyID.Get(), ascKeyContents.Get());
        }
        else
            otErr << "OTWallet::SaveContract: Failed trying to serialize "
                     "symmetric keys to wallet.\n";
    }

    //
    // We want to save the NymIDs for the Nyms on the master key. I save those
    // before the Nyms themselves, so that they are all loaded up and available
    // in LoadWallet before the Nyms themselves are loaded.
    //
    for (const auto& it : m_setNymsOnCachedKey) {
        const OTIdentifier& theNymID = it;
        OTString strNymID(theNymID);

        strContract.Concatenate("<nymUsingCachedKey id=\"%s\" />\n\n",
                                strNymID.Get());
    }

    for (auto& it : m_mapNyms) {
        OTPseudonym* pNym = it.second;
        OT_ASSERT_MSG(nullptr != pNym, "nullptr pseudonym pointer in "
                                       "OTWallet::m_mapNyms, "
                                       "OTWallet::SaveContract");

        pNym->SavePseudonymWallet(strContract);
    }

    for (auto& it : m_mapContracts) {
        OTContract* pContract = it.second;
        OT_ASSERT_MSG(nullptr != pContract, "nullptr contract pointer in "
                                            "OTWallet::m_mapContracts, "
                                            "OTWallet::SaveContract");

        pContract->SaveContractWallet(strContract);
    }

    for (auto& it : m_mapServers) {
        OTContract* pServer = it.second;
        OT_ASSERT_MSG(nullptr != pServer, "nullptr server pointer in "
                                          "OTWallet::m_mapServers, "
                                          "OTWallet::SaveContract");

        pServer->SaveContractWallet(strContract);
    }

    for (auto& it : m_mapAccounts) {
        OTContract* pAccount = it.second;
        OT_ASSERT_MSG(nullptr != pAccount, "nullptr account pointer in "
                                           "OTWallet::m_mapAccounts, "
                                           "OTWallet::SaveContract");

        pAccount->SaveContractWallet(strContract);
    }

    strContract.Concatenate("%s", "</wallet>\n");

    return true;
}

bool opentxs::OTWallet::SaveWallet

(

const char *

szFilename = nullptr

)

Definition at line 1566 of file OTWallet.cpp.

{
    if (nullptr != szFilename) m_strFilename.Set(szFilename);

    if (!m_strFilename.Exists()) {
        otErr << __FUNCTION__ << ": Filename Dosn't Exist!\n";
        OT_FAIL;
    }

    bool bSuccess = false;
    OTString strContract;

    if (SaveContract(strContract)) {

        // Try to save the wallet to local storage.
        //
        OTString strFinal;
        OTASCIIArmor ascTemp(strContract);

        if (false ==
            ascTemp.WriteArmoredString(strFinal, "WALLET")) // todo hardcoding.
        {
            otErr << "OTWallet::SaveWallet: Error saving wallet (failed "
                     "writing armored string):\n" << m_strDataFolder
                  << OTLog::PathSeparator() << m_strFilename << "\n";
            return false;
        }

        // Wallet file is the only one in data_folder (".") and not a subfolder
        // of that.
        bSuccess = OTDB::StorePlainString(
            strFinal.Get(), ".",
            m_strFilename.Get()); // <==== Store Plain String
    }

    return bSuccess;
}

bool opentxs::OTWallet::SignContractWithFirstNymOnList

(

OTContract &

theContract

)

Definition at line 252 of file OTWallet.cpp.

{
    if (GetNymCount() > 0) {
        OTIdentifier NYM_ID;
        OTString NYM_NAME;

        if (GetNym(0, // index 0
                   NYM_ID, NYM_NAME)) {
            OTPseudonym* pNym = GetNymByID(NYM_ID);

            if (nullptr != pNym) {
                theContract.SignContract(*pNym);
                return true;
            }
        }
    }

    return false;
}

bool opentxs::OTWallet::VerifyAssetAccount	(	const OTPseudonym &	theNym,
		OTAccount &	theAcct,
		const OTIdentifier &	SERVER_ID,
		const OTString &	strAcctID,
		const char *	szFuncName = nullptr
	)

Definition at line 777 of file OTWallet.cpp.

{
    const char* szFunc =
        (nullptr != szFuncName) ? szFuncName : "OTWallet::VerifyAssetAccount";

    if (SERVER_ID != theAcct.GetRealServerID()) {
        const OTString s1(SERVER_ID), s2(theAcct.GetRealServerID());
        otOut << "OTWallet::VerifyAssetAccount " << szFunc
              << ": Server ID passed in (" << s1 << ") didn't match the one "
                                                    "on the account (" << s2
              << "). Acct ID: " << strAcctID << "\n";
        return false;
    }

    const OTIdentifier theNymID(theNym);
    const OTString strNymID(theNymID);

    if (!theAcct.VerifyOwner(theNym)) // Verifies Ownership.
    {
        otOut << "OTWallet::VerifyAssetAccount " << szFunc
              << ": Nym (ID: " << strNymID
              << ") is not the owner of the account: " << strAcctID << "\n";
        return false;
    }

    if (false ==
        theAcct.VerifyAccount(theNym)) // Verifies ContractID and Signature.
    {
        otOut << "OTWallet::VerifyAssetAccount " << szFunc
              << ": Account signature or AccountID fails to verify. "
                 "NymID: " << strNymID << "  AcctID: " << strAcctID << "\n";
        return false;
    }
    // By this point, I know that everything checks out. Signature and Account
    // ID,
    // Nym is owner, etc.

    return true;
}

Member Data Documentation

OTString opentxs::OTWallet::m_strDataFolder

Definition at line 361 of file OTWallet.hpp.

OTString opentxs::OTWallet::m_strFilename

Definition at line 360 of file OTWallet.hpp.

---

The documentation for this class was generated from the following files:

• /usr/local/src/opentxs/include/opentxs/client/OTWallet.hpp
• /usr/local/src/opentxs/src/client/OTWallet.cpp