#include <OTPseudonym.hpp>

Public Member Functions
EXPORT void	GetPrivateCredentials (OTString &strCredList, OTString::Map *pmapCredFiles=nullptr)

EXPORT void	GetPublicCredentials (OTString &strCredList, OTString::Map *pmapCredFiles=nullptr) const

EXPORT bool	AddNewMasterCredential (OTString &strOutputMasterCredID, const OTString pstrSourceForNymID=nullptr, int32_t nBits=1024, const OTString::Map pmapPrivate=nullptr, const OTString::Map pmapPublic=nullptr, const OTPasswordData pPWData=nullptr, bool bChangeNymID=false)

EXPORT bool	AddNewSubkey (const OTIdentifier &idMasterCredential, int32_t nBits=1024, const OTString::Map pmapPrivate=nullptr, const OTPasswordData pPWData=nullptr, OTString *pstrNewID=nullptr)

EXPORT bool	AddNewSubcredential (const OTIdentifier &idMasterCredential, const OTString::Map pmapPrivate=nullptr, const OTString::Map pmapPublic=nullptr, const OTPasswordData *pPWData=nullptr)

EXPORT size_t	GetMasterCredentialCount () const

EXPORT size_t	GetRevokedCredentialCount () const

EXPORT OTCredential *	GetMasterCredential (const OTString &strID)

EXPORT OTCredential *	GetRevokedCredential (const OTString &strID)

EXPORT const OTCredential *	GetMasterCredentialByIndex (int32_t nIndex) const

EXPORT const OTCredential *	GetRevokedCredentialByIndex (int32_t nIndex) const

EXPORT const OTSubcredential *	GetSubcredential (const OTString &strMasterID, const OTString &strSubCredID) const

EXPORT const OTSubcredential *	GetRevokedSubcred (const OTString &strRevokedID, const OTString &strSubCredID) const

EXPORT bool	GetNymboxHashServerSide (const OTIdentifier &theServerID, OTIdentifier &theOutput)

EXPORT void	SetNymboxHashServerSide (const OTIdentifier &theInput)

EXPORT bool	GetNymboxHash (const std::string &server_id, OTIdentifier &theOutput) const

EXPORT bool	SetNymboxHash (const std::string &server_id, const OTIdentifier &theInput)

EXPORT bool	GetRecentHash (const std::string &server_id, OTIdentifier &theOutput) const

EXPORT bool	SetRecentHash (const std::string &server_id, const OTIdentifier &theInput)

EXPORT bool	GetInboxHash (const std::string &acct_id, OTIdentifier &theOutput) const

EXPORT bool	SetInboxHash (const std::string &acct_id, const OTIdentifier &theInput)

EXPORT bool	GetOutboxHash (const std::string &acct_id, OTIdentifier &theOutput) const

EXPORT bool	SetOutboxHash (const std::string &acct_id, const OTIdentifier &theInput)

EXPORT const int64_t &	GetUsageCredits () const

EXPORT void	SetUsageCredits (const int64_t &lUsage)

void	MarkForDeletion ()

bool	IsMarkedForDeletion () const

void	MarkAsUndeleted ()

std::set< int64_t > &	GetSetOpenCronItems ()

std::set< std::string > &	GetSetAssetAccounts ()

OTString &	GetNymName ()

void	SetNymName (const OTString &strName)

EXPORT	OTPseudonym ()

EXPORT	OTPseudonym (const OTIdentifier &nymID)

EXPORT	OTPseudonym (const OTString &strNymID)

EXPORT	OTPseudonym (const OTString &name, const OTString &filename, const OTString &nymID)

virtual EXPORT	~OTPseudonym ()

EXPORT void	Initialize ()

EXPORT void	ReleaseTransactionNumbers ()

EXPORT bool	VerifyPseudonym () const

EXPORT bool	GenerateNym (int32_t nBits=1024, bool bCreateFile=true, std::string str_id_source="", std::string str_alt_location="")

EXPORT OTItem *	GenerateTransactionStatement (const OTTransaction &theOwner)

EXPORT bool	SetPublicKey (const OTString &strKey, bool bEscaped=true)

EXPORT bool	SetCertificate (const OTString &strCert, bool bEscaped=true)

EXPORT bool	SetPublicKey (const OTASCIIArmor &strKey)

EXPORT bool	SetPrivateKey (const OTString &strKey, bool bEscaped=true)

EXPORT bool	SetPrivateKey (const OTASCIIArmor &strKey)

EXPORT bool	HasPublicKey ()

EXPORT bool	HasPrivateKey ()

EXPORT const OTAsymmetricKey &	GetPublicAuthKey () const

const OTAsymmetricKey &	GetPrivateAuthKey () const

EXPORT const OTAsymmetricKey &	GetPublicEncrKey () const

const OTAsymmetricKey &	GetPrivateEncrKey () const

EXPORT const OTAsymmetricKey &	GetPublicSignKey () const

const OTAsymmetricKey &	GetPrivateSignKey () const

EXPORT int32_t	GetPublicKeysBySignature (listOfAsymmetricKeys &listOutput, const OTSignature &theSignature, char cKeyType= '0') const

EXPORT bool	SaveCredentialList ()

EXPORT void	SaveCredentialListToString (OTString &strOutput)

EXPORT void	SaveCredentialsToString (OTString &strOutput, OTString::Map pmapPubInfo=nullptr, OTString::Map pmapPriInfo=nullptr)

EXPORT bool	LoadCredentials (bool bLoadPrivate=false, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

EXPORT bool	ReEncryptPrivateCredentials (bool bImporting, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

EXPORT bool	LoadSignedNymfile (OTPseudonym &SIGNER_NYM)

EXPORT bool	SaveSignedNymfile (OTPseudonym &SIGNER_NYM)

EXPORT bool	LoadNymfile (const char *szFilename=nullptr)

EXPORT bool	LoadFromString (const OTString &strNym, OTString::Map pMapCredentials=nullptr, OTString pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)

EXPORT bool	Server_PubKeyExists (OTString *pstrID=nullptr)

EXPORT bool	LoadPublicKey ()

EXPORT bool	CertfileExists ()

EXPORT bool	Loadx509CertAndPrivateKey (bool bChecking=false, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

EXPORT bool	Loadx509CertAndPrivateKeyFromString (const OTString &strInput, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

EXPORT bool	Savex509CertAndPrivateKey (bool bCreateFile=true, const OTString *pstrReason=nullptr)

EXPORT bool	Savex509CertAndPrivateKeyToString (OTString &strOutput, const OTString *pstrReason=nullptr)

EXPORT bool	SavePseudonymWallet (OTString &strOutput) const

EXPORT bool	SavePseudonymWallet (std::ofstream &ofs) const

EXPORT bool	SavePublicKey (const OTString &strPath) const

EXPORT bool	SavePublicKey (std::ofstream &ofs) const

EXPORT bool	SavePseudonym ()

EXPORT bool	SavePseudonym (const char szFoldername, const char szFilename)

EXPORT bool	SavePseudonym (OTString &strNym)

EXPORT bool	SavePseudonym (std::ofstream &ofs)

EXPORT bool	SetIdentifierByPubkey ()

EXPORT bool	CompareID (const OTIdentifier &theIdentifier) const

EXPORT bool	CompareID (const OTPseudonym &RHS) const

EXPORT const OTString &	GetNymIDSource () const

EXPORT const OTString &	GetAltLocation () const

EXPORT void	SetNymIDSource (const OTString &strSource)

EXPORT void	SetAltLocation (const OTString &strLocation)

EXPORT void	SerializeNymIDSource (OTString &strOutput) const

EXPORT const OTIdentifier &	GetConstID () const

EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

EXPORT void	SetIdentifier (const OTIdentifier &theIdentifier)

EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	SetIdentifier (const OTString &theIdentifier)

EXPORT void	HarvestTransactionNumbers (const OTIdentifier &theServerID, OTPseudonym &SIGNER_NYM, OTPseudonym &theOtherNym, bool bSave=true)

EXPORT void	HarvestIssuedNumbers (const OTIdentifier &theServerID, OTPseudonym &SIGNER_NYM, OTPseudonym &theOtherNym, bool bSave=false)

EXPORT bool	ClawbackTransactionNumber (const OTIdentifier &theServerID, const int64_t &lTransClawback, bool bSave=false, OTPseudonym *pSIGNER_NYM=nullptr)

EXPORT void	IncrementRequestNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID)

EXPORT void	OnUpdateRequestNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, int64_t lNewRequestNumber)

EXPORT bool	GetCurrentRequestNum (const OTString &strServerID, int64_t &lReqNum) const

EXPORT bool	GetHighestNum (const OTString &strServerID, int64_t &lHighestNum) const

EXPORT int64_t	UpdateHighestNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, std::set< int64_t > &setNumbers, std::set< int64_t > &setOutputGood, std::set< int64_t > &setOutputBad, bool bSave=false)

mapOfTransNums &	GetMapTransNum ()

mapOfTransNums &	GetMapIssuedNum ()

mapOfTransNums &	GetMapTentativeNum ()

mapOfTransNums &	GetMapAcknowledgedNum ()

EXPORT void	RemoveAllNumbers (const OTString *pstrServerID=nullptr, bool bRemoveHighestNum=true)

EXPORT void	RemoveReqNumbers (const OTString *pstrServerID=nullptr)

EXPORT bool	UnRegisterAtServer (const OTString &strServerID)

EXPORT bool	IsRegisteredAtServer (const OTString &strServerID) const

EXPORT bool	ResyncWithServer (const OTLedger &theNymbox, const OTPseudonym &theMessageNym)

EXPORT bool	AddTransactionNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, int64_t lTransNum, bool bSave)

EXPORT bool	GetNextTransactionNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, int64_t &lTransNum, bool bSave=true)

EXPORT bool	RemoveIssuedNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum, bool bSave)

bool	RemoveTentativeNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum, bool bSave)

EXPORT bool	RemoveAcknowledgedNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lRequestNum, bool bSave)

EXPORT bool	VerifyIssuedNum (const OTString &strServerID, const int64_t &lTransNum) const

EXPORT bool	VerifyTransactionNum (const OTString &strServerID, const int64_t &lTransNum) const

EXPORT bool	VerifyTentativeNum (const OTString &strServerID, const int64_t &lTransNum) const

EXPORT bool	VerifyAcknowledgedNum (const OTString &strServerID, const int64_t &lRequestNum) const

EXPORT bool	VerifyIssuedNumbersOnNym (OTPseudonym &THE_NYM)

EXPORT bool	VerifyTransactionStatementNumbersOnNym (OTPseudonym &THE_NYM)

EXPORT int32_t	GetIssuedNumCount (const OTIdentifier &theServerID) const

EXPORT int64_t	GetIssuedNum (const OTIdentifier &theServerID, int32_t nIndex) const

EXPORT bool	AddIssuedNum (const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveIssuedNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveIssuedNum (const OTString &strServerID, const int64_t &lTransNum)

EXPORT int32_t	GetTransactionNumCount (const OTIdentifier &theServerID) const

EXPORT int64_t	GetTransactionNum (const OTIdentifier &theServerID, int32_t nIndex) const

EXPORT bool	AddTransactionNum (const OTString &strServerID, int64_t lTransNum)

EXPORT bool	RemoveTransactionNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveTransactionNum (const OTString &strServerID, const int64_t &lTransNum)

EXPORT int32_t	GetTentativeNumCount (const OTIdentifier &theServerID) const

EXPORT int64_t	GetTentativeNum (const OTIdentifier &theServerID, int32_t nIndex) const

EXPORT bool	AddTentativeNum (const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveTentativeNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveTentativeNum (const OTString &strServerID, const int64_t &lTransNum)

EXPORT int32_t	GetAcknowledgedNumCount (const OTIdentifier &theServerID) const

EXPORT int64_t	GetAcknowledgedNum (const OTIdentifier &theServerID, int32_t nIndex) const

EXPORT bool	AddAcknowledgedNum (const OTString &strServerID, const int64_t &lRequestNum)

EXPORT bool	RemoveAcknowledgedNum (OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lRequestNum)

EXPORT bool	RemoveAcknowledgedNum (const OTString &strServerID, const int64_t &lRequestNum)

EXPORT bool	VerifyGenericNum (const mapOfTransNums &THE_MAP, const OTString &strServerID, const int64_t &lTransNum) const

EXPORT bool	RemoveGenericNum (mapOfTransNums &THE_MAP, OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	RemoveGenericNum (mapOfTransNums &THE_MAP, const OTString &strServerID, const int64_t &lTransNum)

EXPORT bool	AddGenericNum (mapOfTransNums &THE_MAP, const OTString &strServerID, int64_t lTransNum)

EXPORT int32_t	GetGenericNumCount (const mapOfTransNums &THE_MAP, const OTIdentifier &theServerID) const

EXPORT int64_t	GetGenericNum (const mapOfTransNums &THE_MAP, const OTIdentifier &theServerID, int32_t nIndex) const

EXPORT void	AddMail (OTMessage &theMessage)

EXPORT int32_t	GetMailCount () const
	return the number of mail items available for this Nym. More...

EXPORT OTMessage *	GetMailByIndex (int32_t nIndex) const

EXPORT bool	RemoveMailByIndex (int32_t nIndex)

EXPORT void	ClearMail ()

EXPORT void	AddOutmail (OTMessage &theMessage)

EXPORT int32_t	GetOutmailCount () const
	return the number of mail items available for this Nym. More...

EXPORT OTMessage *	GetOutmailByIndex (int32_t nIndex) const

EXPORT bool	RemoveOutmailByIndex (int32_t nIndex)

EXPORT void	ClearOutmail ()

EXPORT void	AddOutpayments (OTMessage &theMessage)

EXPORT int32_t	GetOutpaymentsCount () const
	return the number of payments items available for this Nym. More...

EXPORT OTMessage *	GetOutpaymentsByIndex (int32_t nIndex) const

EXPORT bool	RemoveOutpaymentsByIndex (int32_t nIndex, bool bDeleteIt=true)

EXPORT void	ClearOutpayments ()

void	ClearCredentials ()

void	ClearAll ()

EXPORT void	DisplayStatistics (OTString &strOutput)

Static Public Member Functions
static EXPORT OTPseudonym *	LoadPublicNym (const OTIdentifier &NYM_ID, const OTString pstrName=nullptr, const char szFuncName=nullptr)

static EXPORT OTPseudonym *	LoadPrivateNym (const OTIdentifier &NYM_ID, bool bChecking=false, const OTString pstrName=nullptr, const char szFuncName=nullptr, const OTPasswordData pPWData=nullptr, const OTPassword pImportPassword=nullptr)

static EXPORT bool	DoesCertfileExist (const OTString &strNymID)

Detailed Description

Definition at line 167 of file OTPseudonym.hpp.

Constructor & Destructor Documentation

opentxs::OTPseudonym::OTPseudonym ( )

Definition at line 6594 of file OTPseudonym.cpp.

     : m_bMarkForDeletion(false)
     , m_pkeypair(new OTKeypair)
     , m_lUsageCredits(0)
 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     Initialize();
 }

opentxs::OTPseudonym::OTPseudonym ( const OTIdentifier & nymID )

Definition at line 6625 of file OTPseudonym.cpp.

     : m_bMarkForDeletion(false)
     , m_pkeypair(new OTKeypair)
     , m_lUsageCredits(0)
 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     Initialize();
 
     m_nymID = nymID;
 }

opentxs::OTPseudonym::OTPseudonym ( const OTString & strNymID )

Definition at line 6637 of file OTPseudonym.cpp.

     : m_bMarkForDeletion(false)
     , m_pkeypair(new OTKeypair)
     , m_lUsageCredits(0)
 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     Initialize();
 
     m_nymID.SetString(strNymID);
 }

opentxs::OTPseudonym::OTPseudonym	(	const OTString &	name,
		const OTString &	filename,
		const OTString &	nymID
	)

Definition at line 6609 of file OTPseudonym.cpp.

     : m_bMarkForDeletion(false)
     , m_pkeypair(new OTKeypair)
     , m_lUsageCredits(0)
 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     Initialize();
 
     m_strName = name;
     m_strNymfile = filename;
 
     m_nymID.SetString(nymID);
 }

opentxs::OTPseudonym::~OTPseudonym ( )

virtual

Definition at line 6703 of file OTPseudonym.cpp.

 {
 
     ClearAll();
     ClearCredentials();
 
     if (nullptr != m_pkeypair) delete m_pkeypair; // todo: else error
 
     m_pkeypair = nullptr;
 }

Member Function Documentation

bool opentxs::OTPseudonym::AddAcknowledgedNum	(	const OTString &	strServerID,
		const int64_t &	lRequestNum
	)

Definition at line 2606 of file OTPseudonym.cpp.

 {
     // We're going to call AddGenericNum, but first, let's enforce a cap on the
     // total
     // number of ackNums allowed...
     //
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of transaction numbers for each server.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then we'll pop the size of the
     // deque
     // down to our max size (off the back) before then calling AddGenericNum
     // which will
     // push the new request number onto the front.
     //
     for (auto& it : m_mapAcknowledgedNum) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             while (pDeque->size() > OT_MAX_ACK_NUMS) {
                 pDeque->pop_back(); // This fixes knotwork's issue where he had
                                     // thousands of ack nums somehow never
                                     // getting cleared out. Now we have a MAX
                                     // and always keep it clean otherwise.
             }
             break;
         }
     }
 
     return AddGenericNum(m_mapAcknowledgedNum, strServerID,
                          lRequestNum); // <=== Here we finally add the new
                                        // request number, the actual purpose of
                                        // this function.
 }

bool opentxs::OTPseudonym::AddGenericNum	(	mapOfTransNums &	THE_MAP,
		const OTString &	strServerID,
		int64_t	lTransNum
	)

Definition at line 2271 of file OTPseudonym.cpp.

 {
     bool bSuccessFindingServerID = false, bSuccess = false;
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of transaction numbers for each server.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then add the transaction
     // number.
     //
     for (auto& it : THE_MAP) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             auto iter = std::find(pDeque->begin(), pDeque->end(), lTransNum);
 
             if (iter == pDeque->end()) // Only add it if it's not already there.
                                        // No duplicates!
                 pDeque->push_front(lTransNum);
 
             bSuccess = true;
             bSuccessFindingServerID = true;
 
             break;
         }
     }
 
     // Apparently there is not yet a deque stored for this specific serverID.
     // Fine. Let's create it then, and then add the transaction num to that new
     // deque.
     if (!bSuccessFindingServerID) {
         dequeOfTransNums* pDeque = new dequeOfTransNums;
 
         OT_ASSERT(nullptr != pDeque);
 
         THE_MAP[strID] = pDeque;
         pDeque->push_front(lTransNum);
         bSuccess = true;
     }
 
     return bSuccess;
 }

bool opentxs::OTPseudonym::AddIssuedNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2502 of file OTPseudonym.cpp.

 {
     return AddGenericNum(m_mapIssuedNum, strServerID, lTransNum);
 }

void opentxs::OTPseudonym::AddMail ( OTMessage & theMessage )

Though the parameter is a reference (forcing you to pass a real object), the Nym DOES take ownership of the object. Therefore it MUST be allocated on the heap, NOT the stack, or you will corrupt memory with this call.

Definition at line 1081 of file OTPseudonym.cpp.

 {
     m_dequeMail.push_front(&theMessage);
 }

bool opentxs::OTPseudonym::AddNewMasterCredential	(	OTString &	strOutputMasterCredID,
		const OTString *	pstrSourceForNymID = `nullptr`,
		int32_t	nBits = `1024`,
		const OTString::Map *	pmapPrivate = `nullptr`,
		const OTString::Map *	pmapPublic = `nullptr`,
		const OTPasswordData *	pPWData = `nullptr`,
		bool	bChangeNymID = `false`
	)

Definition at line 401 of file OTPseudonym.cpp.

 {
     const OTString* pstrSourceToUse = nullptr;
     OTString strTempSource; // Used sometimes.
 
     const OTString::Map* pmapActualPrivate = nullptr;
     const OTString::Map* pmapActualPublic = nullptr;
 
     OTString::Map mapPrivate, mapPublic; // Used sometimes.
 
     // If keys are passed in, then those are the keys we're meant to use for the
     // credential.
     //
     // Note: if the Nym is self-signed, then his "source" is his public key,
     // which can thus
     // never change (because it would change his ID.) We only allow this in the
     // case where a
     // Nym is first being created.
     //
     // But if the Nym has a real source (such as a URL, or Namecoin address,
     // etc) then he should
     // be able to create new credentials, and should BOTH be able to generate
     // keys on the spot,
     // OR pass in keys to use that were generated before this function was
     // called.
     //
     // Therefore here, we choose to use the keys passed in--if they were
     // passed--and otherwise
     // we generate the keys.
     //
     OT_ASSERT(nullptr != m_pkeypair);
 
     if (nullptr == pmapPrivate) // If no keys were passed in...
     {
         // That means to use (or generate) my existing keypair as the signing
         // key,
         // and generate the other two keypairs also.
 
         const size_t sizeMapPublic = mapPublic.size();
         const size_t sizeMapPrivate = mapPrivate.size();
 
         OTString strReason, strPublicError, strPrivateError;
 
         // Nym already has a keypair. (Use it as the signing key.)
         //
         // NOTE: We only want to do this if the Nym doesn't already have any
         // credentials.
         // Presumably if there are already credentials, then we want any NEW
         // credentials to
         // have their own keys. Only when there are none (meaning, we are
         // currently creating
         // the FIRST one) do we want to use the existing keypair. Otherwise we
         // want to generate
         // a new signing key.
         //
         // Exception: "Presumably if there are already credentials, then we want
         // any NEW credentials
         // to have their own keys" ==> If it's a self-signed Nym, then EVEN if
         // there are existing
         // credentials, we want to use the existing signing key, since in that
         // case, all credentials
         // would have the same signing key, which is also the Nym ID source (we
         // cannot ever change it,
         // since that would also change the Nym's ID. That is the drawback of
         // self-signed Nyms.)
         //
         // Therefore we need to check here to see if the Nym is self-signed:
         //
         OTIdentifier theSelfSignedNymID;
         m_pkeypair->CalculateID(theSelfSignedNymID);
 
         if ((m_mapCredentials.empty() ||
              CompareID(theSelfSignedNymID)) && // If there AREN'T any
                                                // credentials yet, or if
                                                // the Nym is self-signed,
             (HasPublicKey() || // and if we have a keypair already, use it
              LoadPublicKey())) // to create the first credential.
         {
             strReason.Set("Using existing signing key for new master "
                           "credential (preserving existing Nym keypair.)");
             strPublicError.Set("In %s, line %d: Failed using existing public "
                                "key as public signing key in "
                                "OTPseudonym::%s.\n");
             strPrivateError.Set("In %s, line %d: Failed using existing private "
                                 "key as private signing key in "
                                 "OTPseudonym::%s.\n");
         }
         else // GENERATE A NEW KEYPAIR.
         {
             const bool bCreateKeySigning = m_pkeypair->MakeNewKeypair(nBits);
             OT_ASSERT(bCreateKeySigning);
 
             m_pkeypair->SaveAndReloadBothKeysFromTempFile(); // Keys won't be
                                                              // right until this
                                                              // happens.
                                                              // (Necessary evil
                                                              // until better
                                                              // fix.) Todo:
                                                              // eliminate need
                                                              // to do this.
 
             strReason.Set("Generating signing key for new master credential.");
             strPublicError.Set("In %s, line %d: Failed creating public signing "
                                "key in OTPseudonym::%s.\n");
             strPrivateError.Set("In %s, line %d: Failed creating private "
                                 "signing key in OTPseudonym::%s.\n");
         }
 
         // SIGNING KEY
         //
         OTString strPublicKey, strPrivateCert;
 
         const bool b1 = m_pkeypair->GetPublicKey(
             strPublicKey, false); // bEscaped=true by default.
         const bool b2 = m_pkeypair->SaveCertAndPrivateKeyToString(
             strPrivateCert, &strReason);
 
         if (b1 && b2) {
             mapPublic.insert(
                 std::pair<std::string, std::string>("S", strPublicKey.Get()));
             mapPrivate.insert(
                 std::pair<std::string, std::string>("S", strPrivateCert.Get()));
         }
 
         if (!b1 || !(mapPublic.size() > sizeMapPublic)) {
             OTLog::vError(strPublicError.Get(), __FILE__, __LINE__,
                           __FUNCTION__);
             return false;
         }
 
         if (!b2 || !(mapPrivate.size() > sizeMapPrivate)) {
             OTLog::vError(strPrivateError.Get(), __FILE__, __LINE__,
                           __FUNCTION__);
             return false;
         }
         // *************************************************************************************8
         // Whether the Nym already had a keypair, and we used it as the signing
         // key,
         // or whether we generated the signing key on the spot, either way we
         // still
         // need to generate the other two keys.
         //
         // Create 2 keypairs here (for authentication and for encryption.)
         //
         // Use the public/private data for all 3 keypairs onto mapPublic and
         // mapPrivate.
         //
 
         OTKeypair keyAuth, keyEncr; // (The signing keypair already exists by
                                     // this point. These are the other two we
                                     // need.)
 
         const bool bCreateKeyAuth = keyAuth.MakeNewKeypair();
         const bool bCreateKeyEncr = keyEncr.MakeNewKeypair();
 
         OT_ASSERT(bCreateKeyAuth && bCreateKeyEncr);
 
         keyAuth.SaveAndReloadBothKeysFromTempFile(); // Keys won't be right
                                                      // until this happens.
         keyEncr.SaveAndReloadBothKeysFromTempFile(); // (Necessary evil until
                                                      // better fix.) Todo:
                                                      // eliminate need to do
                                                      // this.
 
         strPublicKey.Release();
         strPrivateCert.Release();
 
         const bool b3 = keyAuth.GetPublicKey(
             strPublicKey, false); // bEscaped=true by default.
         const bool b4 =
             keyAuth.SaveCertAndPrivateKeyToString(strPrivateCert, &strReason);
 
         if (b3 && b4) {
             mapPublic.insert(
                 std::pair<std::string, std::string>("A", strPublicKey.Get()));
             mapPrivate.insert(
                 std::pair<std::string, std::string>("A", strPrivateCert.Get()));
         }
 
         strPublicKey.Release();
         strPrivateCert.Release();
 
         const bool b5 = keyEncr.GetPublicKey(
             strPublicKey, false); // bEscaped=true by default.
         const bool b6 =
             keyEncr.SaveCertAndPrivateKeyToString(strPrivateCert, &strReason);
 
         if (b5 && b6) {
             mapPublic.insert(
                 std::pair<std::string, std::string>("E", strPublicKey.Get()));
             mapPrivate.insert(
                 std::pair<std::string, std::string>("E", strPrivateCert.Get()));
         }
 
         if (!(mapPublic.size() >= (sizeMapPublic + 3))) {
             otErr
                 << "In " << __FILE__ << ", line " << __LINE__
                 << ": Failed adding (auth or encr) public keys in OTPseudonym::"
                 << __FUNCTION__ << ".\n";
             return false;
         }
 
         if (!(mapPrivate.size() >= (sizeMapPrivate + 3))) {
             otErr << "In " << __FILE__ << ", line " << __LINE__
                   << ": Failed adding (auth or encr) private keys in "
                      "OTPseudonym::" << __FUNCTION__ << ".\n";
             return false;
         }
 
         pmapActualPrivate = &mapPrivate;
         pmapActualPublic = &mapPublic;
 
     } // A private key wasn't passed in.
 
     // A keypair WAS passed in...
     //
     else {
         // If keys were passed in, then we're going to use those to create the
         // new credential.
         //
         pmapActualPrivate = pmapPrivate;
         pmapActualPublic = pmapPublic;
 
         // Therefore in that case, the Nym had better not be self-signed, since
         // if he was,
         // he couldn't change the key (since his NymID is a hash of the public
         // key.)
         //
         // Thus the Nym should have some other source besides his own key, or at
         // least he
         // should be a new Nym being created.
     }
     //
     // SOURCE
     //
     // A source was passed in. We know it's not a public key, since its hash
     // will not match the existing
     // Nym ID. (Only the existing public key will match that when hashed, and
     // you can use that by passing nullptr
     // already, which is the following block.) Therefore it must be one of the
     // other choices: a Freenet/I2P/Tor URL,
     // or indeed any URL at all, a Bitcoin address, a Namecoin address (which is
     // actually a form of URL also.)
     // Or of course, the Issuer/Subject DN info from a traditionally-issued
     // cert. In which case we are low-level
     // enough that we will potentially change the NymID here based on that
     // option. But we won't do that for a public
     // key, unless you pass nullptr.
     //
     if ((nullptr != pstrSourceForNymID) &&
         pstrSourceForNymID->Exists()) // A source was passed in.
     {
         // -- Perhaps he already has a source, in which case he one he already
         // has should match the
         //    one that was passed in. (If one was.)
         // -- Or perhaps he doesn't have a source, in which case one SHOULD have
         // been passed in.
         // -- Assuming that's the case, that's what we'll use.
         // -- But if he doesn't have one, AND one wasn't passed in, then we will
         // just created a self-signed Nym.
         //
         pstrSourceToUse = pstrSourceForNymID;
 
         if (!bChangeNymID && m_strSourceForNymID.Exists() &&
             !pstrSourceForNymID->Compare(m_strSourceForNymID)) {
             otErr << "In " << __FILE__ << ", line " << __LINE__
                   << ", OTPseudonym::" << __FUNCTION__
                   << ": The Nym already has a source, but a different "
                      "source was passed in (they should be identical, since "
                      "you can't change a Nym's "
                      "source without changing his ID.)\n";
             return false;
         }
     }
     else // No source was passed in. That means use the existing one if it
            // exists,
     {      // or otherwise create it based on the key (self-signed Nym.)
            //
         if (m_strSourceForNymID.Exists()) // Use existing source.
             strTempSource = m_strSourceForNymID;
         // No source exists (nor was one passed in.) Thus create it based on the
         // signing key (self-signed Nym.)
         else if ((HasPublicKey() || LoadPublicKey()))
             m_pkeypair->GetPublicKey(strTempSource); // bEscaped=true by
                                                      // default. Todo: someday
                                                      // change this to false.
                                                      // (It will invalidate
                                                      // existing NymIDs.)
         else {
             otErr << "In " << __FILE__ << ", line " << __LINE__
                   << ", OTPseudonym::" << __FUNCTION__
                   << ": Error: The Nym had no ID source, nor were we able "
                      "to derive one from his (non-existent) public key.\n";
             return false;
         }
 
         pstrSourceToUse = &strTempSource;
 
         // Hash the purported source, and see if it matches the existing NymID.
         //
         OTIdentifier theTempID;
         theTempID.CalculateDigest(*pstrSourceToUse);
         //      m_pkeypair->CalculateID(theTempID);
 
         if (!bChangeNymID && !CompareID(theTempID)) {
             OTString strNymID;
             GetIdentifier(strNymID);
 
             OTIdentifier theKeypairNymID;
             m_pkeypair->CalculateID(theKeypairNymID);
 
             const OTString strKeypairNymID(theKeypairNymID),
                 strCalculatedNymID(theTempID);
 
             otOut << __FUNCTION__
                   << ": No NymID Source was passed in, so I tried to use the "
                      "existing source (or if that was missing, the existing "
                      "public key) for "
                      "the Nym, but hashing that failed to produce the Nym's "
                      "ID. Meaning the Nym must have "
                      "some other source already, which needs to be passed into "
                      "this function, for it to work on this Nym.\n"
                      "NOTE: Pass 'bChangeNymID' into this function as true, if "
                      "you want to override this behavior.\n"
                      "NYM ID: " << strNymID
                   << " \n KEY PAIR CALCULATED ID: " << strKeypairNymID
                   << " \n CONTENTS CALCULATED ID: " << strCalculatedNymID
                   << " \n NYM ID SOURCE: " << pstrSourceToUse->Get() << "\n";
             return false;
         }
     }
 
     // By this point, pstrSourceToUse is good to go, and calculates to the
     // correct ID for this Nym.
     // Also by this point, the Nym's source and ID are both definitely set and
     // correct (before this function is even called.)
     // Also by this point, pmapActualPrivate and pmapActualPublic are each set
     // with their 3 keys.
 
     OT_ASSERT(nullptr != pstrSourceToUse);
 
     // See if there are any other master credentials already. If there are, make
     // sure they have the same source string calculated above.
     //
     if (!m_mapCredentials.empty()) {
         for (auto& it : m_mapCredentials) {
             OTCredential* pCredential = it.second;
             OT_ASSERT(nullptr != pCredential);
 
             if (false ==
                 pstrSourceToUse->Compare(pCredential->GetSourceForNymID())) {
                 otOut << __FUNCTION__
                       << ": Attempt to add new master credential failed to "
                          "match the NymID Source on an existing master "
                          "credential.\n";
                 return false;
             }
         }
 
         // bChangeNymID only works if we are adding the FIRST credential. You
         // can't be changing
         // a Nym's ID if he already has credentials, since we only made that
         // possible in the first
         // place to make it possible to add the first credential.
         //
         if (bChangeNymID) {
             otErr << __FUNCTION__
                   << ": Failure: cannot change NymID for Nym who "
                      "already has credentials.\n";
             return false;
         }
     }
 
     // Can't change the NymID if it's already registered at a server somewhere.
     //
     if (bChangeNymID && (!m_mapRequestNum.empty())) {
         otErr << __FUNCTION__ << ": Failure: cannot change NymID for Nym who "
                                  "already is registered at "
                                  "transaction servers.\n";
         return false;
     }
 
     OT_ASSERT(nullptr != pmapActualPrivate);
     OT_ASSERT(nullptr != pmapActualPublic);
 
     // Create a new master credential, and set its source string (which also
     // sets
     // the NymID).
     //
     OTCredential* pMaster = OTCredential::CreateMaster(
         *pstrSourceToUse, nBits, pmapActualPrivate, pmapActualPublic, pPWData);
 
     if (nullptr == pMaster) // Below this block, pMaster must be cleaned up.
     {
         otErr << __FUNCTION__ << ": Failed trying to create a new master "
                                  "credential, while calling "
                                  "OTCredential::CreateMaster.\n";
         return false;
     }
 
     // NOTE: The only way to verify a Master Credential is to go to its source
     // (for its NymID)
     // and see if the Master Credential ID is posted at that source. And since
     // the Master Credential
     // ID cannot possibly be known before the Master Credential is created and
     // hashed, there is no
     // way that Credential's ID could have already been posted at that source.
     // Therefore it's
     // impossible for the Credential to verify against the source at this time.
     // (Although it must
     // verify by the time the credential is registered at any OT server.)
 
     // We can still verify the credential internally, however. (Everything but
     // the source.)
     //
     OTString strNymID;
     GetIdentifier(strNymID);
 
     if (!pMaster->VerifyInternally()) {
         OTIdentifier theTempID;
         theTempID.CalculateDigest(*pstrSourceToUse);
         const OTString strTempID(theTempID);
         otErr << __FUNCTION__
               << ": Failed trying to verify the new master credential.\n"
                  "Nym ID: " << strNymID << "\nHash of Source: " << strTempID
               << "\n Source: " << pstrSourceToUse->Get() << "\n";
         delete pMaster;
         pMaster = nullptr;
         return false;
     }
 
     // OTFolders::Credential() is for private credentials (I've created.)
     // OTFolders::Pubcred() is for public credentials (I've downloaded.)
     // ...(FYI.)
     //
     if (OTDB::Exists(OTFolders::Credential().Get(), strNymID.Get(),
                      pMaster->GetMasterCredID().Get())) {
         otErr << __FUNCTION__
               << ": Failure: Apparently there is already a credential stored "
                  "for this ID (even though this is a new master credential, "
                  "just generated.)\n";
         delete pMaster;
         pMaster = nullptr;
         return false;
     }
 
     // It's already signed (inside CreateMaster) but it's still not added to the
     // Nym,
     // or saved to local storage. So let's do that next...
     //
     OTString strFoldername, strFilename;
     strFoldername.Format("%s%s%s", OTFolders::Credential().Get(),
                          OTLog::PathSeparator(), strNymID.Get());
     strFilename.Format("%s", pMaster->GetMasterCredID().Get());
     const bool bSaved =
         const_cast<OTMasterkey&>(pMaster->GetMasterkey())
             .SaveContract(strFoldername.Get(), strFilename.Get());
 
     if (!bSaved) {
         otErr << __FUNCTION__ << ": Failed trying to save new master "
                                  "credential to local storage.\n";
         delete pMaster;
         pMaster = nullptr;
         return false;
     }
 
     m_mapCredentials.insert(std::pair<std::string, OTCredential*>(
         pMaster->GetMasterCredID().Get(), pMaster));
     strOutputMasterCredID = pMaster->GetMasterCredID();
 
     m_strSourceForNymID = *pstrSourceToUse; // This may be superfluous.
                                             // (Or may just go inside the
                                             // below block.)
 
     if (bChangeNymID) {
         m_nymID.CalculateDigest(m_strSourceForNymID);
     }
     //
     // Todo: someday we'll add "source" and "altLocation" to CreateNym
     // (currently the public key is just assumed to be the source.)
     // When that time comes, we'll need to set the altLocation here as
     // well, since it will be optional whenever there is a source involved.
 
     SaveCredentialList();
 
     return true;
 }

bool opentxs::OTPseudonym::AddNewSubcredential	(	const OTIdentifier &	idMasterCredential,
		const OTString::Map *	pmapPrivate = `nullptr`,
		const OTString::Map *	pmapPublic = `nullptr`,
		const OTPasswordData *	pPWData = `nullptr`
	)

Definition at line 998 of file OTPseudonym.cpp.

 {
     const OTString strMasterCredID(idMasterCredential);
 
     auto it = m_mapCredentials.find(strMasterCredID.Get());
 
     if (it == m_mapCredentials.end()) // Didn't find it.
     {
         otOut << __FUNCTION__ << ": Failed trying to add subcredential to "
                                  "nonexistent master credential.\n";
         return false;
     }
 
     OTCredential* pMaster = it->second;
     OT_ASSERT(nullptr != pMaster);
 
     OTSubcredential* pSubcredential = nullptr;
     const bool bAdded = pMaster->AddNewSubcredential(*pmapPrivate, *pmapPublic,
                                                      pPWData, &pSubcredential);
 
     if (!bAdded) {
         otOut << __FUNCTION__
               << ": Failed trying to add subcredential to master credential.\n";
         return false;
     }
     OT_ASSERT(nullptr != pSubcredential);
 
     if (!pSubcredential->VerifyInternally()) {
         otErr << __FUNCTION__
               << ": Failed trying to verify the new subcredential.\n";
         // todo: remove it again, since it failed to verify.
         return false;
     }
 
     // It's already signed (inside AddNewSubcredential) but it's still not added
     // to the Nym,
     // or saved to local storage. So let's do that next...
     //
     OTString strNymID, strSubcredentialID;
     GetIdentifier(strNymID);
     pSubcredential->GetIdentifier(strSubcredentialID);
 
     if (OTDB::Exists(OTFolders::Credential().Get(), strNymID.Get(),
                      strSubcredentialID.Get())) {
         otErr << __FUNCTION__
               << ": Failure: Apparently there is already a credential stored "
                  "for this ID (even though this is a new credential, just "
                  "generated.)\n";
         return false;
     }
 
     OTString strFoldername, strFilename;
     strFoldername.Format("%s%s%s", OTFolders::Credential().Get(),
                          OTLog::PathSeparator(), strNymID.Get());
     strFilename.Format("%s", strSubcredentialID.Get());
     const bool bSaved =
         pSubcredential->SaveContract(strFoldername.Get(), strFilename.Get());
     if (!bSaved) {
         otErr
             << __FUNCTION__
             << ": Failed trying to save new subcredential to local storage.\n";
         return false;
     }
 
     SaveCredentialList();
 
     return true;
 }

bool opentxs::OTPseudonym::AddNewSubkey	(	const OTIdentifier &	idMasterCredential,
		int32_t	nBits = `1024`,
		const OTString::Map *	pmapPrivate = `nullptr`,
		const OTPasswordData *	pPWData = `nullptr`,
		OTString *	pstrNewID = `nullptr`
	)

Definition at line 915 of file OTPseudonym.cpp.

 {
     const OTString strMasterCredID(idMasterCredential);
 
     auto it = m_mapCredentials.find(strMasterCredID.Get());
 
     if (it == m_mapCredentials.end()) // Didn't find it.
     {
         otOut << __FUNCTION__ << ": Failed trying to add key credential to "
                                  "nonexistent master credential.\n";
         return false;
     }
 
     OTCredential* pMaster = it->second;
     OT_ASSERT(nullptr != pMaster);
 
     OTSubkey* pSubkey = nullptr;
     const bool bAdded =
         pMaster->AddNewSubkey(nBits, pmapPrivate, pPWData, &pSubkey);
 
     if (!bAdded) {
         otOut
             << __FUNCTION__
             << ": Failed trying to add key credential to master credential.\n";
         return false;
     }
     OT_ASSERT(nullptr != pSubkey);
 
     if (!pSubkey->VerifyInternally()) {
 
         otErr << "NYM::ADD_NEW_SUBKEY:   2.5 \n";
 
         otErr << __FUNCTION__
               << ": Failed trying to verify the new key credential.\n";
         // todo: remove it again, since it failed to verify.
         return false;
     }
 
     // It's already signed (inside AddNewSubkey) but it's still not added to the
     // Nym,
     // or saved to local storage. So let's do that next...
     //
     OTString strNymID, strSubkeyID;
     GetIdentifier(strNymID);
     pSubkey->GetIdentifier(strSubkeyID);
 
     // OTFolders::Credential() is for private credentials (I've created.)
     // OTFolders::Pubcred() is for public credentials (I've downloaded.)
     //
     if (OTDB::Exists(OTFolders::Credential().Get(), strNymID.Get(),
                      strSubkeyID.Get())) {
         otErr << __FUNCTION__
               << ": Failure: Apparently there is already a credential stored "
                  "for this ID (even though this is a new credential, just "
                  "generated.)\n";
         return false;
     }
 
     OTString strFoldername, strFilename;
     strFoldername.Format("%s%s%s", OTFolders::Credential().Get(),
                          OTLog::PathSeparator(), strNymID.Get());
     strFilename.Format("%s", strSubkeyID.Get());
     const bool bSaved =
         pSubkey->SaveContract(strFoldername.Get(), strFilename.Get());
     if (!bSaved) {
         otErr
             << __FUNCTION__
             << ": Failed trying to save new key credential to local storage.\n";
         return false;
     }
 
     SaveCredentialList();
 
     if (nullptr != pstrNewID) *pstrNewID = strSubkeyID;
 
     return true;
 }

void opentxs::OTPseudonym::AddOutmail ( OTMessage & theMessage )

Though the parameter is a reference (forcing you to pass a real object), the Nym DOES take ownership of the object. Therefore it MUST be allocated on the heap, NOT the stack, or you will corrupt memory with this call.

Definition at line 1136 of file OTPseudonym.cpp.

 {
     m_dequeOutmail.push_front(&theMessage);
 }

void opentxs::OTPseudonym::AddOutpayments ( OTMessage & theMessage )

Though the parameter is a reference (forcing you to pass a real object), the Nym DOES take ownership of the object. Therefore it MUST be allocated on the heap, NOT the stack, or you will corrupt memory with this call.

Definition at line 1194 of file OTPseudonym.cpp.

 {
     m_dequeOutpayments.push_front(&theMessage);
 }

bool opentxs::OTPseudonym::AddTentativeNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2543 of file OTPseudonym.cpp.

 {
     return AddGenericNum(m_mapTentativeNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::AddTransactionNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		int64_t	lTransNum,
		bool	bSave
	)

Definition at line 2655 of file OTPseudonym.cpp.

 {
     bool bSuccess1 = AddTransactionNum(
         strServerID,
         lTransNum); // Add to list of available-to-use, outstanding numbers.
     bool bSuccess2 =
         AddIssuedNum(strServerID, lTransNum); // Add to list of numbers that
                                               // haven't been closed yet.
 
     if (bSuccess1 && !bSuccess2)
         RemoveGenericNum(m_mapTransNum, strServerID, lTransNum);
     else if (bSuccess2 && !bSuccess1)
         RemoveGenericNum(m_mapIssuedNum, strServerID, lTransNum);
 
     if (bSuccess1 && bSuccess2 && bSave)
         bSave = SaveSignedNymfile(SIGNER_NYM);
     else
         bSave = true; // so the return at the bottom calculates correctly.
 
     return (bSuccess1 && bSuccess2 && bSave);
 }

bool opentxs::OTPseudonym::AddTransactionNum	(	const OTString &	strServerID,
		int64_t	lTransNum
	)

Definition at line 2462 of file OTPseudonym.cpp.

 {
     return AddGenericNum(m_mapTransNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::CertfileExists ( )

Definition at line 6220 of file OTPseudonym.cpp.

 {
     const OTString strID(m_nymID);
     return OTPseudonym::DoesCertfileExist(strID);
 }

bool opentxs::OTPseudonym::ClawbackTransactionNumber	(	const OTIdentifier &	theServerID,
		const int64_t &	lTransClawback,
		bool	bSave = `false`,
		OTPseudonym *	pSIGNER_NYM = `nullptr`
	)

When a number IS already on my issued list, but NOT on my available list (because I already used it on some transaction) then this function will verify that and then add it BACK to my available list. (Like if the transaction failed and I just want to get my numbers back so I can use them on a different transaction.)

Definition at line 2951 of file OTPseudonym.cpp.

 {
     if (nullptr == pSIGNER_NYM) pSIGNER_NYM = this;
     // Below this point, pSIGNER_NYM is definitely a good pointer.
 
     const OTString strServerID(theServerID);
 
     // Only re-add the transaction number if it's already on my issued list.
     // (Otherwise, why am I "adding it back again" if I never had it in the
     // first place? Doesn't sound like a real clawback situation in that case.)
     //
     if (true == VerifyIssuedNum(strServerID, lTransClawback)) {
         AddTransactionNum(*pSIGNER_NYM, strServerID, lTransClawback, bSave);
         return true;
     }
 
     return false;
 }

void opentxs::OTPseudonym::ClearAll ( )

Definition at line 6668 of file OTPseudonym.cpp.

 {
     m_mapRequestNum.clear();
     m_mapHighTransNo.clear();
 
     ReleaseTransactionNumbers();
     //  m_mapTransNum.clear();
     //  m_mapIssuedNum.clear();
     //  m_mapTentativeNum.clear();
     //  m_mapAcknowledgedNum.clear();
 
     m_mapNymboxHash.clear();
     m_mapRecentHash.clear();
     m_mapInboxHash.clear();
     m_mapOutboxHash.clear();
 
     m_setAccounts.clear();
     m_setOpenCronItems.clear();
 
     ClearMail();
     ClearOutmail();
     ClearOutpayments();
 
     // We load the Nym twice... once just to load the credentials up from the
     // .cred file, and a second
     // time to load the rest of the Nym up from the Nymfile. LoadFromString
     // calls ClearAll before loading,
     // so there's no possibility of duplicated data on the Nym. And when that
     // happens, we don't want the
     // credentials to get cleared, since we want them to still be there after
     // the rest of the Nym is
     // loaded. So this is commented out.
     //  ClearCredentials();
 }

void opentxs::OTPseudonym::ClearCredentials ( )

Definition at line 6649 of file OTPseudonym.cpp.

 {
     m_listRevokedIDs.clear();
 
     while (!m_mapCredentials.empty()) {
         OTCredential* pCredential = m_mapCredentials.begin()->second;
         m_mapCredentials.erase(m_mapCredentials.begin());
         delete pCredential;
         pCredential = nullptr;
     }
 
     while (!m_mapRevoked.empty()) {
         OTCredential* pCredential = m_mapRevoked.begin()->second;
         m_mapRevoked.erase(m_mapRevoked.begin());
         delete pCredential;
         pCredential = nullptr;
     }
 }

void opentxs::OTPseudonym::ClearMail ( )

Definition at line 1127 of file OTPseudonym.cpp.

 {
     while (GetMailCount() > 0) RemoveMailByIndex(0);
 }

void opentxs::OTPseudonym::ClearOutmail ( )

Definition at line 1185 of file OTPseudonym.cpp.

 {
     while (GetOutmailCount() > 0) RemoveOutmailByIndex(0);
 }

void opentxs::OTPseudonym::ClearOutpayments ( )

Definition at line 1248 of file OTPseudonym.cpp.

 {
     while (GetOutpaymentsCount() > 0) RemoveOutpaymentsByIndex(0);
 }

EXPORT bool opentxs::OTPseudonym::CompareID ( const OTIdentifier & theIdentifier ) const

inline

Definition at line 635 of file OTPseudonym.hpp.

     {
         return (theIdentifier == m_nymID);
     }

bool opentxs::OTPseudonym::CompareID ( const OTPseudonym & RHS ) const

Definition at line 3666 of file OTPseudonym.cpp.

 {
     return RHS.CompareID(m_nymID);
 }

void opentxs::OTPseudonym::DisplayStatistics ( OTString & strOutput )

Definition at line 3920 of file OTPseudonym.cpp.

 {
     for (auto& it : m_mapRequestNum) {
         std::string strServerID = it.first;
         int64_t lRequestNumber = it.second;
 
         // Now we can log BOTH, before and after...
         strOutput.Concatenate("Req# is %lld for server ID: %s\n",
                               lRequestNumber, strServerID.c_str());
     }
 
     for (auto& it : m_mapHighTransNo) {
         std::string strServerID = it.first;
         const int64_t lHighestNum = it.second;
 
         strOutput.Concatenate("Highest trans# was %lld for server: %s\n",
                               lHighestNum, strServerID.c_str());
     }
 
     for (auto& it : m_mapIssuedNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         if (!(pDeque->empty())) {
             strOutput.Concatenate(
                 "---- Transaction numbers still signed out from server: %s\n",
                 strServerID.c_str());
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 int64_t lTransactionNumber = pDeque->at(i);
 
                 strOutput.Concatenate(0 == i ? "%lld" : ", %lld",
                                       lTransactionNumber);
             }
             strOutput.Concatenate("\n");
         }
     } // for
 
     for (auto& it : m_mapTransNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         if (!(pDeque->empty())) {
             strOutput.Concatenate(
                 "---- Transaction numbers still usable on server: %s\n",
                 strServerID.c_str());
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 int64_t lTransactionNumber = pDeque->at(i);
                 strOutput.Concatenate(0 == i ? "%lld" : ", %lld",
                                       lTransactionNumber);
             }
             strOutput.Concatenate("\n");
         }
     } // for
 
     for (auto& it : m_mapAcknowledgedNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         if (!(pDeque->empty())) {
             strOutput.Concatenate("---- Request numbers for which Nym has "
                                   "already received a reply from server: %s\n",
                                   strServerID.c_str());
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 int64_t lRequestNumber = pDeque->at(i);
                 strOutput.Concatenate(0 == i ? "%lld" : ", %lld",
                                       lRequestNumber);
             }
             strOutput.Concatenate("\n");
         }
     } // for
 
     strOutput.Concatenate("Source for ID:\n%s\n", m_strSourceForNymID.Get());
     strOutput.Concatenate("Alt. location: %s\n\n", m_strAltLocation.Get());
 
     const size_t nMasterCredCount = GetMasterCredentialCount();
     if (nMasterCredCount > 0) {
         for (int32_t iii = 0; iii < static_cast<int64_t>(nMasterCredCount);
              ++iii) {
             const OTCredential* pCredential = GetMasterCredentialByIndex(iii);
             if (nullptr != pCredential) {
                 strOutput.Concatenate("Credential ID: %s \n",
                                       pCredential->GetMasterCredID().Get());
                 const size_t nSubcredentialCount =
                     pCredential->GetSubcredentialCount();
 
                 if (nSubcredentialCount > 0) {
                     for (size_t vvv = 0; vvv < nSubcredentialCount; ++vvv) {
                         const std::string str_subcred_id(
                             pCredential->GetSubcredentialIDByIndex(vvv));
 
                         strOutput.Concatenate("   Subcredential: %s  \n",
                                               str_subcred_id.c_str());
                     }
                 }
             }
         }
         strOutput.Concatenate("%s", "\n");
     }
 
     strOutput.Concatenate("==>      Name: %s   %s\n", m_strName.Get(),
                           m_bMarkForDeletion ? "(MARKED FOR DELETION)" : "");
     strOutput.Concatenate("      Version: %s\n", m_strVersion.Get());
 
     // This is used on server-side only. (Client side sees this value
     // by querying the server.)
     // Therefore since m_lUsageCredits is unused on client side, why display
     // it in the client API? Makes no sense.
     //    strOutput.Concatenate("Usage Credits: %lld\n", m_lUsageCredits);
 
     strOutput.Concatenate("       Mail count: %d\n", m_dequeMail.size());
     strOutput.Concatenate("    Outmail count: %d\n", m_dequeOutmail.size());
     strOutput.Concatenate("Outpayments count: %d\n", m_dequeOutpayments.size());
 
     OTString theStringID;
     GetIdentifier(theStringID);
     strOutput.Concatenate("Nym ID: %s\n", theStringID.Get());
 }

bool opentxs::OTPseudonym::DoesCertfileExist ( const OTString & strNymID )

static

Definition at line 6208 of file OTPseudonym.cpp.

 {
     OTString strCredListFile;
     strCredListFile.Format("%s.cred", strNymID.Get());
 
     return OTDB::Exists(OTFolders::Cert().Get(),
                         strNymID.Get()) || // Old-school.
            OTDB::Exists(OTFolders::Credential().Get(),
                         strCredListFile.Get()); // New-school.
 }

bool opentxs::OTPseudonym::GenerateNym	(	int32_t	nBits = `1024`,
		bool	bCreateFile = `true`,
		std::string	str_id_source = `""`,
		std::string	str_alt_location = `""`
	)

Definition at line 1418 of file OTPseudonym.cpp.

 {
 
     OT_ASSERT(nullptr != m_pkeypair);
 
     if (m_pkeypair->MakeNewKeypair(nBits)) {
         OTString strSource(str_id_source), strAltLocation(str_alt_location);
 
         SetNymIDSource(strSource);
         SetAltLocation(strAltLocation);
 
         OTString strReason("Creating new Nym."); // NOTE:
                                                  // Savex509CertAndPrivateKey
                                                  // sets the ID and sometimes if
                                                  // necessary, the source.
         bool bSaved = Savex509CertAndPrivateKey(
             bCreateFile,
             &strReason); // Todo: remove this. Credentials code will supercede.
 
         if (bSaved && bCreateFile) {
             bSaved = SaveSignedNymfile(*this); // Now we'll generate the
                                                // NymFile as well!
                                                // (bCreateFile will be
                                                // false for temp Nyms..)
         }
 
         if (bCreateFile && !bSaved)
             otErr << __FUNCTION__
                   << ": Failed trying to save new Nym's cert or nymfile.\n";
         else {
             // NEW CREDENTIALS CODE!
             // We've added a parameter to this function so you can pass in the
             // SOURCE for
             // the Nym (which is what is hashed to produce the NymID.) The
             // source could be a Bitcoin
             // address, a URL, the Subject/Issuer DN info from a
             // traditionally-issued certificate authority,
             // or a public key. (OT originally was written to hash a public key
             // to form the NymID -- so we
             // will just continue to support that as an option.)
             //
             // If the SOURCE parameter is not passed, we will assume by default
             // that the Nym has an existing one,
             // or uses its own public key as its source. This will become the
             // first master credential, which can
             // then be used to issue keyCredentials and other types of
             // subCredentials.
             //
             // UPDATE: Huh? I STILL need to be able to pass in a source, and
             // STILL have it generate the key,
             // so I can't have it ONLY pass in the source when there's no key --
             // because sometimes I want to
             // pass the source and ALSO use the key that was generated. (Just,
             // in that case, we want it to
             // use the hash of that source as the NymID, instead of the hash of
             // the public key.)
             // (I will update AddNewMasterCredential so it allows that.)
             //
             OTString strMasterCredID;
 
             const bool bAddedMaster = AddNewMasterCredential(
                 strMasterCredID,
                 (str_id_source.size() > 0) ? &strSource : nullptr, nBits);
 
             if (bAddedMaster && strMasterCredID.Exists() &&
                 (GetMasterCredentialCount() > 0)) {
                 const OTIdentifier theMasterCredID(strMasterCredID);
                 const bool bAddedSubkey = AddNewSubkey(theMasterCredID);
 
                 if (bAddedSubkey) {
                     bSaved = SaveCredentialList();
                 }
                 else {
                     bSaved = false;
                     otErr << __FUNCTION__ << ": Failed trying to add new "
                                              "keyCredential to new Master "
                                              "credential.\n";
                 }
             }
             else {
                 bSaved = false;
                 otErr << __FUNCTION__ << ": Failed trying to add new master "
                                          "credential to new Nym.\n";
             }
         }
 
         return bSaved;
     }
 
     return false;
 }

OTItem * opentxs::OTPseudonym::GenerateTransactionStatement ( const OTTransaction & theOwner )

Definition at line 1272 of file OTPseudonym.cpp.

 {
     if ((theOwner.GetUserID() != m_nymID)) {
         otErr << "OTPseudonym::" << __FUNCTION__
               << ": Transaction has wrong owner (expected to match nym).\n";
         return nullptr;
     }
 
     // theOwner is the depositPaymentPlan, activateSmartContract, or marketOffer
     // that triggered the need for this transaction statement.
     // since it uses up a transaction number, I will be sure to remove that one
     // from my list before signing the list.
     OTItem* pBalanceItem = OTItem::CreateItemFromTransaction(
         theOwner, OTItem::transactionStatement); // <=== transactionStatement
                                                  // type, with user ID, server
                                                  // ID, transaction ID.
 
     // The above has an ASSERT, so this this will never actually happen.
     if (nullptr == pBalanceItem) return nullptr;
 
     // COPY THE ISSUED TRANSACTION NUMBERS FROM THE NYM
 
     OTPseudonym theMessageNym;
 
     theMessageNym.HarvestIssuedNumbers(
         theOwner.GetPurportedServerID(),
         *this /*unused in this case, not saving to disk*/, *this,
         false); // bSave = false;
 
     switch (theOwner.GetType()) {
     case OTTransaction::cancelCronItem:
         if (theOwner.GetTransactionNum() > 0) {
             theMessageNym.RemoveIssuedNum(
                 theOwner.GetRealServerID(),
                 theOwner.GetTransactionNum()); // a transaction number is being
                                                // used, and REMOVED from my list
                                                // of responsibility,
             theMessageNym.RemoveTransactionNum(
                 theOwner.GetRealServerID(),
                 theOwner.GetTransactionNum()); // so I want the new signed list
                                                // to reflect that number has
                                                // been REMOVED.
         }
         break;
 
     // Transaction Statements usually only have a transaction number in the case
     // of market offers and
     // payment plans, in which case the number should NOT be removed, and
     // remains in play until
     // final closure from Cron.
     case OTTransaction::marketOffer:
     case OTTransaction::paymentPlan:
     case OTTransaction::smartContract:
     default:
         break;
     }
 
     // What about cases where no number is being used? (Such as processNymbox)
     // Perhaps then if this function is even called, it's with a 0-number
     // transaction, in which
     // case the above Removes probably won't hurt anything.  Todo.
 
     OTString strMessageNym(theMessageNym); // Okay now we have the transaction
                                            // numbers in this MessageNym string.
 
     pBalanceItem->SetAttachment(strMessageNym); // <======== This is where the
                                                 // server will read the
                                                 // transaction numbers from (A
                                                 // nym in item.m_ascAttachment)
 
     pBalanceItem->SignContract(*this); // <=== Sign, save, and return.
                                        // OTTransactionType needs to weasel in a
                                        // "date signed" variable.
     pBalanceItem->SaveContract();
 
     return pBalanceItem;
 }

int64_t opentxs::OTPseudonym::GetAcknowledgedNum	(	const OTIdentifier &	theServerID,
		int32_t	nIndex
	)		const

Definition at line 2420 of file OTPseudonym.cpp.

 {
     return GetGenericNum(m_mapAcknowledgedNum, theServerID, nIndex);
 }

int32_t opentxs::OTPseudonym::GetAcknowledgedNumCount ( const OTIdentifier & theServerID ) const

Definition at line 2594 of file OTPseudonym.cpp.

 {
     return GetGenericNumCount(m_mapAcknowledgedNum, theServerID);
 }

EXPORT const OTString& opentxs::OTPseudonym::GetAltLocation ( ) const

inline

Definition at line 645 of file OTPseudonym.hpp.

     {
         return m_strAltLocation;
     } // Alternate download location for Nym's credential IDs. (Primary location

EXPORT const OTIdentifier& opentxs::OTPseudonym::GetConstID ( ) const

inline

Definition at line 661 of file OTPseudonym.hpp.

     {
         return m_nymID;
     } // CONST VERSION

bool opentxs::OTPseudonym::GetCurrentRequestNum	(	const OTString &	strServerID,
		int64_t &	lReqNum
	)		const

Definition at line 3318 of file OTPseudonym.cpp.

 {
     bool bRetVal = false;
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a map of the request numbers for different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then send out the request
     // number.
     for (auto& it : m_mapRequestNum) {
         if (strID == it.first) {
             // Setup return value.
             lReqNum = (it.second);
             // The call has succeeded
             bRetVal = true;
             break;
         }
     }
 
     return bRetVal;
 }

int64_t opentxs::OTPseudonym::GetGenericNum	(	const mapOfTransNums &	THE_MAP,
		const OTIdentifier &	theServerID,
		int32_t	nIndex
	)		const

Definition at line 2358 of file OTPseudonym.cpp.

 {
     int64_t lRetVal = 0;
 
     const OTString strServerID(theServerID);
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of numbers for each server.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // maps matches the Server ID that was passed in, then find the number on
     // that list, and then return it.
     //
     for (auto& it : THE_MAP) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             if (!(pDeque->empty())) // there are some numbers for that server ID
             {
                 // Let's loop through them and see if the culprit is there
                 for (uint32_t i = 0; i < pDeque->size(); i++) {
                     // Found it!
                     if ((uint32_t)nIndex == i) {
                         lRetVal = pDeque->at(i); // <==== Got the number here.
                         break;
                     }
                 }
             }
             break;
         }
     }
 
     return lRetVal;
 }

int32_t opentxs::OTPseudonym::GetGenericNumCount	(	const mapOfTransNums &	THE_MAP,
		const OTIdentifier &	theServerID
	)		const

Definition at line 2322 of file OTPseudonym.cpp.

 {
     int32_t nReturnValue = 0;
 
     const OTString strServerID(theServerID);
     std::string strID = strServerID.Get();
 
     dequeOfTransNums* pDeque = nullptr;
 
     // The Pseudonym has a deque of transaction numbers for each server.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then we found the right server.
     for (auto& it : THE_MAP) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             break;
         }
     }
 
     // We found the right server, so let's count the transaction numbers
     // that this nym has already stored for it.
     if (nullptr != pDeque) {
         nReturnValue = static_cast<int32_t>(pDeque->size());
     }
 
     return nReturnValue;
 }

bool opentxs::OTPseudonym::GetHighestNum	(	const OTString &	strServerID,
		int64_t &	lHighestNum
	)		const

Definition at line 3026 of file OTPseudonym.cpp.

 {
     bool bRetVal = false;
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a map of the highest transaction # it's received from
     // different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then send out the highest
     // number.
     //
     // Since the transaction number only ever gets bigger, this is a way of
     // preventing
     // the server from EVER tricking us by trying to give us a number that we've
     // already seen before.
     //
     for (auto& it : m_mapHighTransNo) {
         if (strID == it.first) {
             // Setup return value.
             lHighestNum = (it.second);
 
             // The call has succeeded
             bRetVal = true;
 
             break;
         }
     }
 
     return bRetVal;
 }

void opentxs::OTPseudonym::GetIdentifier ( OTIdentifier & theIdentifier ) const

Definition at line 6577 of file OTPseudonym.cpp.

 {
     theIdentifier = m_nymID;
 }

void opentxs::OTPseudonym::GetIdentifier ( OTString & theIdentifier ) const

Definition at line 6589 of file OTPseudonym.cpp.

 {
     m_nymID.GetString(theIdentifier);
 }

bool opentxs::OTPseudonym::GetInboxHash	(	const std::string &	acct_id,
		OTIdentifier &	theOutput
	)		const

Definition at line 1683 of file OTPseudonym.cpp.

 {
     return GetHash(m_mapInboxHash, acct_id, theOutput);
 }

int64_t opentxs::OTPseudonym::GetIssuedNum	(	const OTIdentifier &	theServerID,
		int32_t	nIndex
	)		const

Definition at line 2406 of file OTPseudonym.cpp.

 {
     return GetGenericNum(m_mapIssuedNum, theServerID, nIndex);
 }

int32_t opentxs::OTPseudonym::GetIssuedNumCount ( const OTIdentifier & theServerID ) const

Definition at line 2495 of file OTPseudonym.cpp.

 {
     return GetGenericNumCount(m_mapIssuedNum, theServerID);
 }

OTMessage * opentxs::OTPseudonym::GetMailByIndex ( int32_t nIndex ) const

Definition at line 1096 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeMail.empty() || (nIndex < 0) || (uIndex >= m_dequeMail.size()))
         return nullptr;
 
     return m_dequeMail.at(nIndex);
 }

int32_t opentxs::OTPseudonym::GetMailCount ( ) const

return the number of mail items available for this Nym.

Definition at line 1089 of file OTPseudonym.cpp.

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

mapOfTransNums& opentxs::OTPseudonym::GetMapAcknowledgedNum ( )

inline

Definition at line 732 of file OTPseudonym.hpp.

     {
         return m_mapAcknowledgedNum;
     } // This one actually stores request numbers.

mapOfTransNums& opentxs::OTPseudonym::GetMapIssuedNum ( )

inline

Definition at line 724 of file OTPseudonym.hpp.

     {
         return m_mapIssuedNum;
     }

mapOfTransNums& opentxs::OTPseudonym::GetMapTentativeNum ( )

inline

Definition at line 728 of file OTPseudonym.hpp.

     {
         return m_mapTentativeNum;
     }

mapOfTransNums& opentxs::OTPseudonym::GetMapTransNum ( )

inline

Definition at line 720 of file OTPseudonym.hpp.

     {
         return m_mapTransNum;
     }

OTCredential * opentxs::OTPseudonym::GetMasterCredential ( const OTString & strID )

Definition at line 4805 of file OTPseudonym.cpp.

 {
     auto iter = m_mapCredentials.find(strID.Get());
     OTCredential* pCredential = nullptr;
 
     if (iter != m_mapCredentials.end()) // found it
         pCredential = iter->second;
 
     return pCredential;
 }

const OTCredential * opentxs::OTPseudonym::GetMasterCredentialByIndex ( int32_t nIndex ) const

Definition at line 4827 of file OTPseudonym.cpp.

 {
     if ((nIndex < 0) ||
         (nIndex >= static_cast<int64_t>(m_mapCredentials.size()))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
         int32_t nLoopIndex = -1;
 
         for (const auto& it : m_mapCredentials) {
             const OTCredential* pCredential = it.second;
             OT_ASSERT(nullptr != pCredential);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pCredential;
         }
     }
     return nullptr;
 }

size_t opentxs::OTPseudonym::GetMasterCredentialCount ( ) const

Definition at line 3473 of file OTPseudonym.cpp.

 {
     return m_mapCredentials.size();
 }

bool opentxs::OTPseudonym::GetNextTransactionNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		int64_t &	lTransNum,
		bool	bSave = `true`
	)

Client side. Get the next available transaction number for the serverID The lTransNum parameter is for the return value. SAVES if successful.

Definition at line 2980 of file OTPseudonym.cpp.

 {
     bool bRetVal = false;
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of transaction numbers for each server.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then send out the transaction
     // number.
     //
     for (auto& it : m_mapTransNum) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             if (!(pDeque->empty())) {
                 lTransNum = pDeque->front();
 
                 pDeque->pop_front();
 
                 // The call has succeeded
                 bRetVal = true;
             }
             break;
         }
     }
 
     if (bRetVal && bSave) {
         if (!SaveSignedNymfile(SIGNER_NYM))
             otErr << "Error saving signed NymFile in "
                      "OTPseudonym::GetNextTransactionNum\n";
     }
 
     return bRetVal;
 }

bool opentxs::OTPseudonym::GetNymboxHash	(	const std::string &	server_id,
		OTIdentifier &	theOutput
	)		const

Definition at line 1659 of file OTPseudonym.cpp.

 {
     return GetHash(m_mapNymboxHash, server_id, theOutput);
 }

bool opentxs::OTPseudonym::GetNymboxHashServerSide	(	const OTIdentifier &	theServerID,
		OTIdentifier &	theOutput
	)

Definition at line 1640 of file OTPseudonym.cpp.

 {
     if (m_NymboxHash.IsEmpty()) {
         OTLedger theNymbox(m_nymID, m_nymID, theServerID);
 
         if (theNymbox.LoadNymbox() && theNymbox.CalculateNymboxHash(theOutput))
             return true;
     }
 
     return false;
 }

EXPORT const OTString& opentxs::OTPseudonym::GetNymIDSource ( ) const

inline

Definition at line 641 of file OTPseudonym.hpp.

     {
         return m_strSourceForNymID;
     } // Source for NymID for this credential. (Hash it to get ID.)

OTString& opentxs::OTPseudonym::GetNymName ( )

inline

Definition at line 470 of file OTPseudonym.hpp.

     {
         return m_strName;
     }

bool opentxs::OTPseudonym::GetOutboxHash	(	const std::string &	acct_id,
		OTIdentifier &	theOutput
	)		const

Definition at line 1695 of file OTPseudonym.cpp.

 {
     return GetHash(m_mapOutboxHash, acct_id, theOutput);
 }

OTMessage * opentxs::OTPseudonym::GetOutmailByIndex ( int32_t nIndex ) const

Definition at line 1151 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeOutmail.empty() || (nIndex < 0) ||
         (uIndex >= m_dequeOutmail.size()))
         return nullptr;
 
     return m_dequeOutmail.at(nIndex);
 }

int32_t opentxs::OTPseudonym::GetOutmailCount ( ) const

return the number of mail items available for this Nym.

Definition at line 1144 of file OTPseudonym.cpp.

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

OTMessage * opentxs::OTPseudonym::GetOutpaymentsByIndex ( int32_t nIndex ) const

Definition at line 1211 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeOutpayments.empty() || (nIndex < 0) ||
         (uIndex >= m_dequeOutpayments.size()))
         return nullptr;
 
     return m_dequeOutpayments.at(nIndex);
 }

int32_t opentxs::OTPseudonym::GetOutpaymentsCount ( ) const

return the number of payments items available for this Nym.

Definition at line 1204 of file OTPseudonym.cpp.

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

const OTAsymmetricKey & opentxs::OTPseudonym::GetPrivateAuthKey ( ) const

Definition at line 6286 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
 
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPrivateAuthKey(&m_listRevokedIDs); // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from where I can pluck a private "
                   "AUTHENTICATION key, apparently."
                   " Instead, using the private key on the Nym's keypair (a "
                   "system which is being deprecated in favor of credentials,"
                   " so it's not good that I'm having to do this here. Why are "
                   "there no credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPrivateKey();
     }
 }

void opentxs::OTPseudonym::GetPrivateCredentials	(	OTString &	strCredList,
		OTString::Map *	pmapCredFiles = `nullptr`
	)

Definition at line 4192 of file OTPseudonym.cpp.

 {
     OTString strNymID;
     GetIdentifier(strNymID);
 
     strCredList.Concatenate("<?xml version=\"%s\"?>\n",
                             "2.0"); // todo hardcoding.
 
     strCredList.Concatenate("<OTuser version=\"%s\"\n"
                             " nymID=\"%s\""
                             ">\n\n",
                             m_strVersion.Get(), strNymID.Get());
 
     SerializeNymIDSource(strCredList);
 
     SaveCredentialsToString(strCredList, nullptr, pmapCredFiles);
 
     strCredList.Concatenate("</OTuser>\n");
 }

const OTAsymmetricKey & opentxs::OTPseudonym::GetPrivateEncrKey ( ) const

Definition at line 6327 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
 
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPrivateEncrKey(&m_listRevokedIDs);
         ; // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from where I can pluck a private "
                   "ENCRYPTION key, apparently. "
                   "Instead, using the private key on the Nym's keypair (a "
                   "system which is being deprecated in favor of credentials, "
                   "so it's not good that I'm having to do this here. Why are "
                   "there no credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPrivateKey();
     }
 }

const OTAsymmetricKey & opentxs::OTPseudonym::GetPrivateSignKey ( ) const

Definition at line 6369 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
 
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPrivateSignKey(&m_listRevokedIDs); // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from where I can pluck a private "
                   "SIGNING key, apparently. Instead,"
                   " using the private key on the Nym's keypair (a system which "
                   "is being deprecated in favor of credentials, so it's not "
                   "good"
                   " that I'm having to do this here. Why are there no "
                   "credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPrivateKey();
     }
 }

const OTAsymmetricKey & opentxs::OTPseudonym::GetPublicAuthKey ( ) const

Definition at line 6411 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
 
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPublicAuthKey(&m_listRevokedIDs); // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from which I can pluck a public "
                   "AUTHENTICATION key, unfortunately. Instead,"
                   " using the public key on the Nym's keypair (a system which "
                   "is being deprecated in favor of credentials, so it's not "
                   "good"
                   " that I'm having to do this here. Why are there no "
                   "credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPublicKey();
     }
 }

void opentxs::OTPseudonym::GetPublicCredentials	(	OTString &	strCredList,
		OTString::Map *	pmapCredFiles = `nullptr`
	)		const

Definition at line 4160 of file OTPseudonym.cpp.

 {
     OTString strNymID;
     GetIdentifier(strNymID);
 
     strCredList.Concatenate("<?xml version=\"%s\"?>\n",
                             "2.0"); // todo hardcoding.
 
     strCredList.Concatenate("<OTuser version=\"%s\"\n"
                             " nymID=\"%s\""
                             ">\n\n",
                             m_strVersion.Get(), strNymID.Get());
 
     SerializeNymIDSource(strCredList);
 
     for (auto& it : m_mapCredentials) {
         OTCredential* pCredential = it.second;
         OT_ASSERT(nullptr != pCredential);
 
         pCredential->SerializeIDs(strCredList, m_listRevokedIDs,
                                   pmapCredFiles); // bShowRevoked=false by
                                                   // default, bValid=true by
                                                   // default. (True since we're
                                                   // looping m_mapCredentials
                                                   // only, and not
                                                   // m_mapRevoked.)
     }
 
     strCredList.Concatenate("</OTuser>\n");
 }

const OTAsymmetricKey & opentxs::OTPseudonym::GetPublicEncrKey ( ) const

Definition at line 6453 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPublicEncrKey(&m_listRevokedIDs); // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from which I can pluck a public "
                   "ENCRYPTION key, unfortunately. Instead,"
                   " using the public key on the Nym's keypair (a system which "
                   "is being deprecated in favor of credentials, so it's not "
                   "good"
                   " that I'm having to do this here. Why are there no "
                   "credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPublicKey();
     }
 }

int32_t opentxs::OTPseudonym::GetPublicKeysBySignature	(	listOfAsymmetricKeys &	listOutput,
		const OTSignature &	theSignature,
		char	cKeyType = `'0'`
	)		const

Definition at line 6548 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     // Unfortunately, theSignature can only narrow the search down (there may be
     // multiple results.)
     int32_t nCount = 0;
 
     for (const auto& it : m_mapCredentials) {
         const OTCredential* pCredential = it.second;
         OT_ASSERT(nullptr != pCredential);
 
         const int32_t nTempCount = pCredential->GetPublicKeysBySignature(
             listOutput, theSignature, cKeyType);
         nCount += nTempCount;
     }
 
     return nCount;
 }

const OTAsymmetricKey & opentxs::OTPseudonym::GetPublicSignKey ( ) const

Definition at line 6494 of file OTPseudonym.cpp.

 {
     if (!m_mapCredentials.empty()) {
         const OTCredential* pCredential = nullptr;
 
         for (const auto& it : m_mapCredentials) {
             // Todo: If we have some criteria, such as which master or
             // subcredential
             // is currently being employed by the user, we'll use that here to
             // skip
             // through this loop until we find the right one. Until then, I'm
             // just
             // going to return the first one that's valid (not null).
 
             pCredential = it.second;
             if (nullptr != pCredential) break;
         }
         if (nullptr == pCredential) OT_FAIL;
 
         return pCredential->GetPublicSignKey(&m_listRevokedIDs); // success
     }
     else {
         OTString strNymID;
         GetIdentifier(strNymID);
         otWarn << __FUNCTION__ << ": This nym (" << strNymID
                << ") has no credentials from which I can pluck a public "
                   "SIGNING key, unfortunately. Instead,"
                   " using the public key on the Nym's keypair (a system which "
                   "is being deprecated in favor of credentials, so it's not "
                   "good"
                   " that I'm having to do this here. Why are there no "
                   "credentials on this Nym?)\n";
     }
 
     //  else // Deprecated.
     {
         OT_ASSERT(nullptr != m_pkeypair);
 
         return m_pkeypair->GetPublicKey();
     }
 }

bool opentxs::OTPseudonym::GetRecentHash	(	const std::string &	server_id,
		OTIdentifier &	theOutput
	)		const

Definition at line 1671 of file OTPseudonym.cpp.

 {
     return GetHash(m_mapRecentHash, server_id, theOutput);
 }

OTCredential * opentxs::OTPseudonym::GetRevokedCredential ( const OTString & strID )

Definition at line 4816 of file OTPseudonym.cpp.

 {
     auto iter = m_mapRevoked.find(strID.Get());
     OTCredential* pCredential = nullptr;
 
     if (iter != m_mapRevoked.end()) // found it
         pCredential = iter->second;
 
     return pCredential;
 }

const OTCredential * opentxs::OTPseudonym::GetRevokedCredentialByIndex ( int32_t nIndex ) const

Definition at line 4849 of file OTPseudonym.cpp.

 {
     if ((nIndex < 0) || (nIndex >= static_cast<int64_t>(m_mapRevoked.size()))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
         int32_t nLoopIndex = -1;
 
         for (const auto& it : m_mapRevoked) {
             const OTCredential* pCredential = it.second;
             OT_ASSERT(nullptr != pCredential);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pCredential;
         }
     }
     return nullptr;
 }

size_t opentxs::OTPseudonym::GetRevokedCredentialCount ( ) const

Definition at line 3478 of file OTPseudonym.cpp.

 {
     return m_mapRevoked.size();
 }

const OTSubcredential * opentxs::OTPseudonym::GetRevokedSubcred	(	const OTString &	strRevokedID,
		const OTString &	strSubCredID
	)		const

Definition at line 4893 of file OTPseudonym.cpp.

 {
     auto iter = m_mapRevoked.find(strRevokedID.Get());
     const OTCredential* pMaster = nullptr;
 
     if (iter != m_mapRevoked.end()) // found it
         pMaster = iter->second;
 
     if (nullptr != pMaster) {
         const OTSubcredential* pSub = pMaster->GetSubcredential(strSubCredID);
 
         if (nullptr != pSub) return pSub;
     }
 
     return nullptr;
 }

std::set<std::string>& opentxs::OTPseudonym::GetSetAssetAccounts ( )

inline

Definition at line 466 of file OTPseudonym.hpp.

     {
         return m_setAccounts;
     } // stores acct IDs as std::string

std::set<int64_t>& opentxs::OTPseudonym::GetSetOpenCronItems ( )

inline

Definition at line 462 of file OTPseudonym.hpp.

     {
         return m_setOpenCronItems;
     }

const OTSubcredential * opentxs::OTPseudonym::GetSubcredential	(	const OTString &	strMasterID,
		const OTString &	strSubCredID
	)		const

Definition at line 4870 of file OTPseudonym.cpp.

 {
     auto iter = m_mapCredentials.find(strMasterID.Get());
     const OTCredential* pMaster = nullptr;
 
     if (iter != m_mapCredentials.end()) // found it
         pMaster = iter->second;
 
     if (nullptr != pMaster) {
         const OTSubcredential* pSub =
             pMaster->GetSubcredential(strSubCredID, &m_listRevokedIDs);
 
         if (nullptr != pSub) return pSub;
     }
 
     return nullptr;
 }

int64_t opentxs::OTPseudonym::GetTentativeNum	(	const OTIdentifier &	theServerID,
		int32_t	nIndex
	)		const

Definition at line 2399 of file OTPseudonym.cpp.

 {
     return GetGenericNum(m_mapTentativeNum, theServerID, nIndex);
 }

int32_t opentxs::OTPseudonym::GetTentativeNumCount ( const OTIdentifier & theServerID ) const

Definition at line 2536 of file OTPseudonym.cpp.

 {
     return GetGenericNumCount(m_mapTentativeNum, theServerID);
 }

int64_t opentxs::OTPseudonym::GetTransactionNum	(	const OTIdentifier &	theServerID,
		int32_t	nIndex
	)		const

Definition at line 2413 of file OTPseudonym.cpp.

 {
     return GetGenericNum(m_mapTransNum, theServerID, nIndex);
 }

int32_t opentxs::OTPseudonym::GetTransactionNumCount ( const OTIdentifier & theServerID ) const

Definition at line 2454 of file OTPseudonym.cpp.

 {
     return GetGenericNumCount(m_mapTransNum, theServerID);
 }

EXPORT const int64_t& opentxs::OTPseudonym::GetUsageCredits ( ) const

inline

Definition at line 439 of file OTPseudonym.hpp.

     {
         return m_lUsageCredits;
     }

void opentxs::OTPseudonym::HarvestIssuedNumbers	(	const OTIdentifier &	theServerID,
		OTPseudonym &	SIGNER_NYM,
		OTPseudonym &	theOtherNym,
		bool	bSave = `false`
	)

Definition at line 2900 of file OTPseudonym.cpp.

 {
     bool bChangedTheNym = false;
     int64_t lTransactionNumber = 0;
 
     for (auto& it : theOtherNym.GetMapIssuedNum()) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         OTString OTstrServerID =
             ((strServerID.size()) > 0 ? strServerID.c_str() : "");
         const OTIdentifier theTempID(OTstrServerID);
 
         if (!(pDeque->empty()) && (theServerID == theTempID)) {
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
 
                 // If number wasn't already on issued list, then add to BOTH
                 // lists.
                 // Otherwise do nothing (it's already on the issued list, and no
                 // longer
                 // valid on the available list--thus shouldn't be re-added there
                 // anyway.)
                 //
                 if (false ==
                     VerifyIssuedNum(OTstrServerID, lTransactionNumber)) {
                     AddTransactionNum(
                         SIGNER_NYM, OTstrServerID, lTransactionNumber,
                         false); // bSave = false (but saved below...)
                     bChangedTheNym = true;
                 }
             }
             break; // We found it! Might as well break out.
         }
     } // for
 
     if (bChangedTheNym && bSave) {
         SaveSignedNymfile(SIGNER_NYM);
     }
 }

void opentxs::OTPseudonym::HarvestTransactionNumbers	(	const OTIdentifier &	theServerID,
		OTPseudonym &	SIGNER_NYM,
		OTPseudonym &	theOtherNym,
		bool	bSave = `true`
	)

OtherNym is used as container for server to send us new transaction numbers Currently unused. (old) NEW USE: Okay then, new use: This will be the function that does what the below function does (OTPseudonym::HarvestIssuedNumbers), EXCEPT it only adds numbers that aren't on the TENTATIVE list. Also, it will set the new "highest" trans num for the appropriate server, based on the new numbers being harvested.

Definition at line 2765 of file OTPseudonym.cpp.

 {
     int64_t lTransactionNumber = 0;
 
     std::set<int64_t> setInput, setOutputGood, setOutputBad;
 
     for (auto& it : theOtherNym.GetMapIssuedNum()) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         OTString OTstrServerID = strServerID.c_str();
         const OTIdentifier theTempID(OTstrServerID);
 
         if (!(pDeque->empty()) &&
             (theServerID == theTempID)) // only for the matching serverID.
         {
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
 
                 // If number wasn't already on issued list, then add to BOTH
                 // lists.
                 // Otherwise do nothing (it's already on the issued list, and no
                 // longer
                 // valid on the available list--thus shouldn't be re-added there
                 // anyway.)
                 //
                 if ((true == VerifyTentativeNum(
                                  OTstrServerID,
                                  lTransactionNumber)) && // If I've actually
                                                          // requested this
                                                          // number and waiting
                                                          // on it...
                     (false ==
                      VerifyIssuedNum(OTstrServerID,
                                      lTransactionNumber)) // and if it's not
                                                           // already on my
                                                           // issued list...
                     )
                     setInput.insert(lTransactionNumber);
             }
             break; // We found it! Might as well break out.
         }
     } // for
 
     // Looks like we found some numbers to harvest
     // (tentative numbers we had already been waiting for,
     // yet hadn't processed onto our issued list yet...)
     //
     if (!setInput.empty()) {
         const OTString strServerID(theServerID), strNymID(m_nymID);
 
         int64_t lViolator = UpdateHighestNum(
             SIGNER_NYM, strServerID, setInput, setOutputGood,
             setOutputBad); // bSave=false (saved below already, if necessary)
 
         // NOTE: Due to the possibility that a server reply could be processed
         // twice (due to redundancy
         // for the purposes of preventing syncing issues) then we expect we
         // might get numbers in here
         // that are below our "last highest num" (due to processing the same
         // numbers twice.) Therefore
         // we don't need to assume an error in this case. UpdateHighestNum() is
         // already smart enough to
         // only update based on the good numbers, while ignoring the bad (i.e.
         // already-processed) ones.
         // Thus we really only have a problem if we receive a (-1), which would
         // mean an error occurred.
         // Also, the above call will log an FYI that it is skipping any numbers
         // below the line, so no need
         // to log more in the case of lViolater being >0 but less than the 'last
         // highest number.'
         //
         if ((-1) == lViolator)
             otErr << "OTPseudonym::HarvestTransactionNumbers"
                   << ": ERROR: UpdateHighestNum() returned (-1), "
                      "which is an error condition. "
                      "(Should never happen.)\nNym ID: " << strNymID << " \n";
         else {
             // We only remove-tentative-num/add-transaction-num for the numbers
             // that were above our 'last highest number'.
             // The contents of setOutputBad are thus ignored for these purposes.
             //
             for (auto& it : setOutputGood) {
                 const int64_t lNoticeNum = it;
 
                 // We already know it's on the TentativeNum list, since we
                 // checked that in the above for loop.
                 // We also already know that it's not on the issued list, since
                 // we checked that as well.
                 // That's why the below calls just ASSUME those things already.
                 //
                 RemoveTentativeNum(
                     strServerID, lNoticeNum); // doesn't save (but saved below)
                 AddTransactionNum(SIGNER_NYM, strServerID, lNoticeNum,
                                   false); // bSave = false (but saved below...)
             }
 
             // We save regardless of whether any removals or additions are made,
             // because data was
             // updated in UpdateHighestNum regardless.
             //
             if (bSave) SaveSignedNymfile(SIGNER_NYM);
         }
     }
 }

bool opentxs::OTPseudonym::HasPrivateKey ( )

Definition at line 6233 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->HasPrivateKey();
 }

bool opentxs::OTPseudonym::HasPublicKey ( )

Definition at line 6226 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->HasPublicKey();
 }

void opentxs::OTPseudonym::IncrementRequestNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID
	)

Definition at line 3354 of file OTPseudonym.cpp.

 {
     bool bSuccess = false;
 
     // The Pseudonym has a map of the request numbers for different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then send out the request
     // number and
     // increment it so it will be ready for the next request.
     //
     // Make sure to save the Pseudonym so the new request number is saved.
     std::string strID = strServerID.Get();
 
     for (auto& it : m_mapRequestNum) {
         if (strID == it.first) {
             // We found it!
             // Presumably we ONLY found it because this Nym has been properly
             // loaded first.
             // Good job! Otherwise, the list would have been empty even though
             // the request number
             // was sitting in the file.
 
             // Grab a copy of the old request number
             int64_t lOldRequestNumber = m_mapRequestNum[it.first];
 
             // Set the new request number to the old one plus one.
             m_mapRequestNum[it.first] = lOldRequestNumber + 1;
 
             // Now we can log BOTH, before and after... // debug here
             otLog4 << "Incremented Request Number from " << lOldRequestNumber
                    << " to " << m_mapRequestNum[it.first] << ". Saving...\n";
 
             // The call has succeeded
             bSuccess = true;
             break;
         }
     }
 
     // If I didn't find it in the list above (whether the list is empty or
     // not....)
     // that means it does not exist. So create it.
 
     if (!bSuccess) {
         otOut << "Creating Request Number entry as '100'. Saving...\n";
         m_mapRequestNum[strServerID.Get()] = 100;
         bSuccess = true;
     }
 
     if (bSuccess) {
         SaveSignedNymfile(SIGNER_NYM);
     }
 }

void opentxs::OTPseudonym::Initialize ( )

Definition at line 6604 of file OTPseudonym.cpp.

 {
     m_strVersion = "1.0";
 }

bool opentxs::OTPseudonym::IsMarkedForDeletion ( ) const

inline

Definition at line 451 of file OTPseudonym.hpp.

     {
         return m_bMarkForDeletion;
     }

bool opentxs::OTPseudonym::IsRegisteredAtServer ( const OTString & strServerID ) const

Definition at line 1790 of file OTPseudonym.cpp.

 {
     bool bRetVal = false; // default is return false: "No, I'm NOT registered at
                           // that Server."
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a map of the request numbers for different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then return TRUE.
     for (auto& it : m_mapRequestNum) {
         if (strID == it.first) {
             // The call has succeeded
             bRetVal = true;
 
             break;
         }
     }
 
     return bRetVal;
 }

bool opentxs::OTPseudonym::LoadCredentials	(	bool	bLoadPrivate = `false`,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 4295 of file OTPseudonym.cpp.

 {
     OTString strReason(nullptr == pPWData ? OT_PW_DISPLAY
                                           : pPWData->GetDisplayString());
 
     ClearCredentials();
 
     OTString strNymID;
     GetIdentifier(strNymID);
 
     OTString strFilename;
     strFilename.Format("%s.cred", strNymID.Get());
 
     const char* szFoldername = bLoadPrivate ? OTFolders::Credential().Get()
                                             : OTFolders::Pubcred().Get();
     const char* szFilename = strFilename.Get();
 
     if (OTDB::Exists(szFoldername, szFilename)) {
         OTString strFileContents(
             OTDB::QueryPlainString(szFoldername, szFilename));
 
         // The credential list file is like the nymfile except with ONLY
         // credential IDs inside.
         // Therefore, we LOAD it like we're loading a Nymfile from string.
         // There's no need for
         // the list itself to be signed, since we verify it fully before using
         // it to verify the
         // signature on the actual nymfile.
         // How is the list safe not to be signed? Because the Nym ID's source
         // string must hash
         // to form the NymID, and any credential IDs on the list must be found
         // on a lookup to
         // that source. An attacker cannot add a credential without putting it
         // inside the source,
         // which the user controls, and the attacker cannot change the source
         // without changing
         // the NymID. Therefore the credential list file itself doesn't need to
         // be signed, for
         // the same reason that the public key didn't need to be signed: because
         // you can prove
         // its validity by hashing (the source string that validates the
         // credentials in that list,
         // or by hashing/ the public key for that Nym, if doing things the old
         // way.)
         //
         if (strFileContents.Exists() && strFileContents.DecodeIfArmored()) {
             const bool bLoaded = LoadFromString(
                 strFileContents,
                 nullptr, // map of credentials--if nullptr, it loads
                          // them from local storage.
                 &strReason, pImportPassword); // optional to provide a
                                               // passphrase (otherwise one is
                                               // prompted for.)
 
             // Potentially set m_pkeypair here, though it's currently set in
             // LoadPublicKey and Loadx509CertAndPrivateKey.
             // (And thus set in static calls OTPseudonym::LoadPublicNym and
             // LoadPrivateNym.)
 
             return bLoaded;
         }
         else {
             otErr << __FUNCTION__
                   << ": Failed trying to load credential list from file: "
                   << szFoldername << OTLog::PathSeparator() << szFilename
                   << "\n";
         }
     }
 
     return false; // No log on failure, since often this may be used to SEE if
                   // credentials exist.
                   // (No need for error message every time they don't exist.)
 }

bool opentxs::OTPseudonym::LoadFromString	(	const OTString &	strNym,
		OTString::Map *	pMapCredentials = `nullptr`,
		OTString *	pstrReason = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 4938 of file OTPseudonym.cpp.

 {
     bool bSuccess = false;
 
     ClearAll(); // Since we are loading everything up... (credentials are NOT
                 // cleared here. See note in OTPseudonym::ClearAll.)
 
     OTStringXML strNymXML(strNym); // todo optimize
     irr::io::IrrXMLReader* xml = irr::io::createIrrXMLReader(strNymXML);
     OT_ASSERT(nullptr != xml);
     std::unique_ptr<irr::io::IrrXMLReader> theCleanup(xml);
 
     // parse the file until end reached
     while (xml && xml->read()) {
 
         //        switch(xml->getNodeType())
         //        {
         //            case(EXN_NONE):
         //                otErr << "ACK NUMS: EXN_NONE --  No xml node. This is
         // usually the node if you did not read anything yet.\n";
         //                break;
         //            case(EXN_ELEMENT):
         //                otErr << "ACK NUMS: EXN_ELEMENT -- An xml element such
         // as <foo>.\n";
         //                break;
         //            case(EXN_ELEMENT_END):
         //                otErr << "ACK NUMS: EXN_ELEMENT_END -- End of an xml
         // element such as </foo>.\n";
         //                break;
         //            case(EXN_TEXT):
         //                otErr << "ACK NUMS: EXN_TEXT -- Text within an xml
         // element: <foo> this is the text. <foo>.\n";
         //                break;
         //            case(EXN_COMMENT):
         //                otErr << "ACK NUMS: EXN_COMMENT -- An xml comment like
         // <!-- I am a comment --> or a DTD definition.\n";
         //                break;
         //            case(EXN_CDATA):
         //                otErr << "ACK NUMS: EXN_CDATA -- An xml cdata section
         // like <![CDATA[ this is some CDATA ]]>.\n";
         //                break;
         //            case(EXN_UNKNOWN):
         //                otErr << "ACK NUMS: EXN_UNKNOWN -- Unknown
         // element.\n";
         //                break;
         //            default:
         //                otErr << "ACK NUMS: default!! -- SHOULD NEVER
         // HAPPEN...\n";
         //                break;
         //        }
         //        otErr << "OTPseudonym::LoadFromString: NODE DATA: %s\n",
         // xml->getNodeData());
 
         // strings for storing the data that we want to read out of the file
         //
         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();
 
             //            switch(xml->getNodeType())
             //            {
             //                case(EXN_NONE):
             //                    otErr << "SKIPPING: EXN_NONE --  No xml node.
             // This is usually the node if you did not read anything yet.\n";
             //                    break;
             //                case(EXN_TEXT):
             //                    otErr << "SKIPPING: EXN_TEXT -- Text within an
             // xml element: <foo> this is the text. <foo>.\n";
             //                    break;
             //                case(EXN_COMMENT):
             //                    otErr << "SKIPPING: EXN_COMMENT -- An xml
             // comment like <!-- I am a comment --> or a DTD definition.\n";
             //                    break;
             //                case(EXN_ELEMENT_END):
             //                    otErr << "SKIPPING: EXN_ELEMENT_END -- End of
             // an xml element such as </foo>.\n";
             //                    break;
             //                case(EXN_CDATA):
             //                    otErr << "SKIPPING: EXN_CDATA -- An xml cdata
             // section like <![CDATA[ this is some CDATA ]]>.\n";
             //                    break;
             //                default:
             //                    otErr << "SKIPPING: default!! -- SHOULD NEVER
             // HAPPEN...\n";
             //                    break;
             //            }
 
             break;
         case irr::io::EXN_ELEMENT: {
             const OTString strNodeName = xml->getNodeName();
             //              otErr << "PROCESSING EXN_ELEMENT: NODE NAME: %s\n",
             // strNodeName.Get());
 
             if (strNodeName.Compare("OTuser")) {
                 m_strVersion = xml->getAttributeValue("version");
                 const OTString UserNymID = xml->getAttributeValue("nymID");
 
                 // Server-side only...
                 OTString strCredits = xml->getAttributeValue("usageCredits");
 
                 if (strCredits.GetLength() > 0)
                     m_lUsageCredits = atol(strCredits.Get());
                 else
                     m_lUsageCredits =
                         0; // This is the default anyway, but just being safe...
 
                 // TODO: no need to set the ID again here. We already know the
                 // ID
                 // at this point. Better to check and compare they are the same
                 // here.
                 // m_nymID.SetString(UserNymID);
 
                 if (UserNymID.GetLength())
                     otLog3 << "\nLoading user, version: " << m_strVersion
                            << " NymID:\n" << UserNymID << "\n";
                 bSuccess = true;
             }
             else if (strNodeName.Compare("nymIDSource")) {
                 //                  otLog3 << "Loading nymIDSource...\n");
                 OTASCIIArmor ascAltLocation =
                     xml->getAttributeValue("altLocation"); // optional.
                 if (ascAltLocation.Exists())
                     ascAltLocation.GetString(
                         m_strAltLocation,
                         false); // bLineBreaks=true by default.
 
                 if (!OTContract::LoadEncodedTextField(xml,
                                                       m_strSourceForNymID)) {
                     otErr << "Error in " << __FILE__ << " line " << __LINE__
                           << ": failed loading expected nymIDSource field.\n";
                     return false; // error condition
                 }
             }
             else if (strNodeName.Compare("revokedCredential")) {
                 const OTString strRevokedID = xml->getAttributeValue("ID");
                 otLog3 << "revokedCredential ID: " << strRevokedID << "\n";
                 auto iter =
                     std::find(m_listRevokedIDs.begin(), m_listRevokedIDs.end(),
                               strRevokedID.Get());
                 if (iter == m_listRevokedIDs.end()) // It's not already there,
                                                     // so it's safe to add it.
                     m_listRevokedIDs.push_back(
                         strRevokedID.Get()); // todo optimize.
             }
             else if (strNodeName.Compare("masterCredential")) {
                 const OTString strID = xml->getAttributeValue("ID");
                 const OTString strValid = xml->getAttributeValue("valid");
                 const bool bValid = strValid.Compare("true");
                 otLog3 << "Loading " << (bValid ? "valid" : "invalid")
                        << " masterCredential ID: " << strID << "\n";
                 OTString strNymID;
                 GetIdentifier(strNymID);
                 OTCredential* pCredential = nullptr;
 
                 if (nullptr == pMapCredentials) // pMapCredentials is an option
                                                 // that allows you to read
                     // credentials from the map instead
                     // of from local storage. (While
                     // loading the Nym...) In this
                     // case, the option isn't being
                     // employed...
                     pCredential = OTCredential::LoadMaster(strNymID, strID);
                 else // In this case, it potentially is on the map...
                 {
                     auto it_cred = pMapCredentials->find(strID.Get());
 
                     if (it_cred ==
                         pMapCredentials->end()) // Nope, didn't find it on the
                                                 // map. But if a Map was passed,
                                                 // then it SHOULD have contained
                                                 // all the listed credentials
                                                 // (including the one we're
                                                 // trying to load now.)
                         otErr << __FUNCTION__
                               << ": Expected master credential (" << strID
                               << ") on map of credentials, but couldn't find "
                                  "it. (Failure.)\n";
                     else // Found it on the map passed in (so no need to load
                          // from storage, we'll load from string instead.)
                     {
                         const OTString strMasterCredential(
                             it_cred->second.c_str());
                         if (strMasterCredential.Exists()) {
                             OTPasswordData thePWData(
                                 nullptr == pstrReason
                                     ? "OTPseudonym::LoadFromString"
                                     : pstrReason->Get());
                             pCredential = OTCredential::LoadMasterFromString(
                                 strMasterCredential, strNymID, strID,
                                 &thePWData, pImportPassword);
                         }
                     }
                 }
 
                 if (nullptr == pCredential) {
                     otErr << __FUNCTION__
                           << ": Failed trying to load Master Credential ID: "
                           << strID << "\n";
                     return false;
                 }
                 else // pCredential must be cleaned up or stored somewhere.
                 {
                     mapOfCredentials* pMap =
                         bValid ? &m_mapCredentials : &m_mapRevoked;
                     auto iter = pMap->find(strID.Get()); // todo optimize.
                     if (iter == pMap->end()) // It's not already there, so it's
                                              // safe to add it.
                         pMap->insert(std::pair<std::string, OTCredential*>(
                             strID.Get(), pCredential)); // <=====
                     else {
                         otErr << __FUNCTION__ << ": While loading credential ("
                               << strID << "), discovered it was already there "
                                           "on my list, or one with the exact "
                                           "same ID! Therefore, failed "
                                           "adding this newer one.\n";
                         delete pCredential;
                         pCredential = nullptr;
                         return false;
                     }
                 }
             }
             else if (strNodeName.Compare("keyCredential")) {
                 const OTString strID = xml->getAttributeValue("ID");
                 const OTString strValid = xml->getAttributeValue(
                     "valid"); // If this is false, the ID is already on
                               // revokedCredentials list. (FYI.)
                 const OTString strMasterCredID =
                     xml->getAttributeValue("masterID");
                 const bool bValid = strValid.Compare("true");
                 otLog3 << "Loading " << (bValid ? "valid" : "invalid")
                        << " keyCredential ID: " << strID
                        << "\n ...For master credential: " << strMasterCredID
                        << "\n";
                 OTCredential* pCredential =
                     GetMasterCredential(strMasterCredID); // no need to cleanup.
                 if (nullptr == pCredential)
                     pCredential = GetRevokedCredential(strMasterCredID);
                 if (nullptr == pCredential) {
                     otErr << __FUNCTION__
                           << ": While loading keyCredential, failed trying to "
                              "find expected Master Credential ID: "
                           << strMasterCredID << "\n";
                     return false;
                 }
                 else // We found the master credential that this keyCredential
                        // belongs to.
                 {
                     bool bLoaded = false;
 
                     if (nullptr ==
                         pMapCredentials) // pMapCredentials is an option
                                          // that allows you to read
                                          // credentials from the map
                                          // instead of from local
                                          // storage. (While loading the
                                          // Nym...) In this case, the
                                          // option isn't being
                                          // employed...
                         bLoaded = pCredential->LoadSubkey(strID);
                     else // In this case, it potentially is on the map...
                     {
                         auto it_cred = pMapCredentials->find(strID.Get());
 
                         if (it_cred ==
                             pMapCredentials->end()) // Nope, didn't find it on
                                                     // the map. But if a Map was
                                                     // passed, then it SHOULD
                                                     // have contained all the
                                                     // listed credentials
                                                     // (including the one we're
                                                     // trying to load now.)
                             otErr << __FUNCTION__
                                   << ": Expected keyCredential (" << strID
                                   << ") on map of credentials, but couldn't "
                                      "find it. (Failure.)\n";
                         else // Found it on the map passed in (so no need to
                              // load from storage, we'll load from string
                              // instead.)
                         {
                             const OTString strSubCredential(
                                 it_cred->second.c_str());
                             if (strSubCredential.Exists())
                                 bLoaded = pCredential->LoadSubkeyFromString(
                                     strSubCredential, strID, pImportPassword);
                         }
                     }
 
                     if (!bLoaded) {
                         OTString strNymID;
                         GetIdentifier(strNymID);
                         otErr << __FUNCTION__
                               << ": Failed loading keyCredential " << strID
                               << " for master credential " << strMasterCredID
                               << " for Nym " << strNymID << ".\n";
                         return false;
                     }
                 }
             }
             else if (strNodeName.Compare("subCredential")) {
                 const OTString strID = xml->getAttributeValue("ID");
                 const OTString strValid = xml->getAttributeValue(
                     "valid"); // If this is false, the ID is already on
                               // revokedCredentials list. (FYI.)
                 const OTString strMasterCredID =
                     xml->getAttributeValue("masterID");
                 const bool bValid = strValid.Compare("true");
                 otLog3 << "Loading " << (bValid ? "valid" : "invalid")
                        << " subCredential ID: " << strID
                        << "\n ...For master credential: " << strMasterCredID
                        << "\n";
                 OTCredential* pCredential =
                     GetMasterCredential(strMasterCredID); // no need to cleanup.
                 if (nullptr == pCredential)
                     pCredential = GetRevokedCredential(strMasterCredID);
                 if (nullptr == pCredential) {
                     otErr << __FUNCTION__
                           << ": While loading subCredential, failed trying to "
                              "find expected Master Credential ID: "
                           << strMasterCredID << "\n";
                     return false;
                 }
                 else // We found the master credential that this subCredential
                        // belongs to.
                 {
                     bool bLoaded = false;
 
                     if (nullptr ==
                         pMapCredentials) // pMapCredentials is an option
                                          // that allows you to read
                                          // credentials from the map
                                          // instead of from local
                                          // storage. (While loading the
                                          // Nym...) In this case, the
                                          // option isn't being
                                          // employed...
                         bLoaded = pCredential->LoadSubcredential(strID);
                     else // In this case, it potentially is on the map...
                     {
                         auto it_cred = pMapCredentials->find(strID.Get());
 
                         if (it_cred ==
                             pMapCredentials->end()) // Nope, didn't find it on
                                                     // the map. But if a Map was
                                                     // passed, then it SHOULD
                                                     // have contained all the
                                                     // listed credentials
                                                     // (including the one we're
                                                     // trying to load now.)
                             otErr << __FUNCTION__
                                   << ": Expected subCredential (" << strID
                                   << ") on map of credentials, but couldn't "
                                      "find it. (Failure.)\n";
                         else // Found it on the map passed in (so no need to
                              // load from storage, we'll load from string
                              // instead.)
                         {
                             const OTString strSubCredential(
                                 it_cred->second.c_str());
                             if (strSubCredential.Exists())
                                 bLoaded =
                                     pCredential->LoadSubcredentialFromString(
                                         strSubCredential, strID,
                                         pImportPassword);
                         }
                     }
 
                     if (!bLoaded) {
                         OTString strNymID;
                         GetIdentifier(strNymID);
                         otErr << __FUNCTION__
                               << ": Failed loading subCredential " << strID
                               << " for master credential " << strMasterCredID
                               << " for Nym " << strNymID << ".\n";
                         return false;
                     }
                 }
             }
             else if (strNodeName.Compare("requestNum")) {
                 const OTString ReqNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString ReqNumCurrent =
                     xml->getAttributeValue("currentRequestNum");
 
                 otLog3 << "\nCurrent Request Number is " << ReqNumCurrent
                        << " for ServerID: " << ReqNumServerID << "\n";
 
                 // Make sure now that I've loaded this request number, to add it
                 // to my
                 // internal map so that it is available for future lookups.
                 m_mapRequestNum[ReqNumServerID.Get()] =
                     atol(ReqNumCurrent.Get());
             }
             else if (strNodeName.Compare("nymboxHash")) {
                 const OTString strValue = xml->getAttributeValue("value");
 
                 otLog3 << "\nNymboxHash is: " << strValue << "\n";
 
                 if (strValue.Exists()) m_NymboxHash.SetString(strValue);
             }
             else if (strNodeName.Compare("nymboxHashItem")) {
                 const OTString strServerID = xml->getAttributeValue("serverID");
                 const OTString strNymboxHash =
                     xml->getAttributeValue("nymboxHash");
 
                 otLog3 << "\nNymboxHash is " << strNymboxHash
                        << " for ServerID: " << strServerID << "\n";
 
                 // Make sure now that I've loaded this nymboxHash, to add it to
                 // my
                 // internal map so that it is available for future lookups.
                 if (strServerID.Exists() && strNymboxHash.Exists()) {
                     const OTIdentifier theID(strNymboxHash);
                     m_mapNymboxHash[strServerID.Get()] = theID;
                 }
             }
             else if (strNodeName.Compare("recentHashItem")) {
                 const OTString strServerID = xml->getAttributeValue("serverID");
                 const OTString strRecentHash =
                     xml->getAttributeValue("recentHash");
 
                 otLog3 << "\nRecentHash is " << strRecentHash
                        << " for ServerID: " << strServerID << "\n";
 
                 // Make sure now that I've loaded this RecentHash, to add it to
                 // my
                 // internal map so that it is available for future lookups.
                 if (strServerID.Exists() && strRecentHash.Exists()) {
                     const OTIdentifier theID(strRecentHash);
                     m_mapRecentHash[strServerID.Get()] = theID;
                 }
             }
             else if (strNodeName.Compare("inboxHashItem")) {
                 const OTString strAccountID =
                     xml->getAttributeValue("accountID");
                 const OTString strHashValue =
                     xml->getAttributeValue("hashValue");
 
                 otLog3 << "\nInboxHash is " << strHashValue
                        << " for Account ID: " << strAccountID << "\n";
 
                 // Make sure now that I've loaded this InboxHash, to add it to
                 // my
                 // internal map so that it is available for future lookups.
                 //
                 if (strAccountID.Exists() && strHashValue.Exists()) {
                     const OTIdentifier theID(strHashValue);
                     m_mapInboxHash[strAccountID.Get()] = theID;
                 }
             }
             else if (strNodeName.Compare("outboxHashItem")) {
                 const OTString strAccountID =
                     xml->getAttributeValue("accountID");
                 const OTString strHashValue =
                     xml->getAttributeValue("hashValue");
 
                 otLog3 << "\nOutboxHash is " << strHashValue
                        << " for Account ID: " << strAccountID << "\n";
 
                 // Make sure now that I've loaded this OutboxHash, to add it to
                 // my
                 // internal map so that it is available for future lookups.
                 //
                 if (strAccountID.Exists() && strHashValue.Exists()) {
                     const OTIdentifier theID(strHashValue);
                     m_mapOutboxHash[strAccountID.Get()] = theID;
                 }
             }
             else if (strNodeName.Compare("highestTransNum")) {
                 const OTString HighNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString HighNumRecent =
                     xml->getAttributeValue("mostRecent");
 
                 otLog3 << "\nHighest Transaction Number ever received is "
                        << HighNumRecent << " for ServerID: " << HighNumServerID
                        << "\n";
 
                 // Make sure now that I've loaded this highest number, to add it
                 // to my
                 // internal map so that it is available for future lookups.
                 m_mapHighTransNo[HighNumServerID.Get()] =
                     atol(HighNumRecent.Get());
             }
             else if (strNodeName.Compare("transactionNums")) {
                 const OTString tempServerID =
                     xml->getAttributeValue("serverID");
                 OTString strTemp;
                 if (!tempServerID.Exists() ||
                     !OTContract::LoadEncodedTextField(xml, strTemp)) {
                     otErr << __FUNCTION__
                           << ": Error: transactionNums field without value.\n";
                     return false; // error condition
                 }
                 OTNumList theNumList;
 
                 if (strTemp.Exists()) theNumList.Add(strTemp);
 
                 int64_t lTemp = 0;
                 while (theNumList.Peek(lTemp)) {
                     theNumList.Pop();
 
                     otLog3 << "Transaction Number " << lTemp
                            << " ready-to-use for ServerID: " << tempServerID
                            << "\n";
                     AddTransactionNum(tempServerID, lTemp); // This version
                                                             // doesn't save to
                                                             // disk. (Why save
                                                             // to disk AS WE'RE
                                                             // LOADING?)
                 }
             }
             else if (strNodeName.Compare("issuedNums")) {
                 const OTString tempServerID =
                     xml->getAttributeValue("serverID");
                 OTString strTemp;
                 if (!tempServerID.Exists() ||
                     !OTContract::LoadEncodedTextField(xml, strTemp)) {
                     otErr << __FUNCTION__
                           << ": Error: issuedNums field without value.\n";
                     return false; // error condition
                 }
                 OTNumList theNumList;
 
                 if (strTemp.Exists()) theNumList.Add(strTemp);
 
                 int64_t lTemp = 0;
                 while (theNumList.Peek(lTemp)) {
                     theNumList.Pop();
 
                     otLog3 << "Currently liable for issued trans# " << lTemp
                            << " at ServerID: " << tempServerID << "\n";
                     AddIssuedNum(tempServerID, lTemp); // This version doesn't
                                                        // save to disk. (Why
                                                        // save to disk AS WE'RE
                                                        // LOADING?)
                 }
             }
             else if (strNodeName.Compare("tentativeNums")) {
                 const OTString tempServerID =
                     xml->getAttributeValue("serverID");
                 OTString strTemp;
                 if (!tempServerID.Exists() ||
                     !OTContract::LoadEncodedTextField(xml, strTemp)) {
                     otErr << "OTPseudonym::LoadFromString: Error: "
                              "tentativeNums field without value.\n";
                     return false; // error condition
                 }
                 OTNumList theNumList;
 
                 if (strTemp.Exists()) theNumList.Add(strTemp);
 
                 int64_t lTemp = 0;
                 while (theNumList.Peek(lTemp)) {
                     theNumList.Pop();
 
                     otLog3 << "Tentative: Currently awaiting success notice, "
                               "for accepting trans# " << lTemp
                            << " for ServerID: " << tempServerID << "\n";
                     AddTentativeNum(tempServerID, lTemp); // This version
                                                           // doesn't save to
                                                           // disk. (Why save to
                                                           // disk AS WE'RE
                                                           // LOADING?)
                 }
             }
             else if (strNodeName.Compare("ackNums")) {
                 const OTString tempServerID =
                     xml->getAttributeValue("serverID");
                 OTString strTemp;
                 if (!tempServerID.Exists()) {
                     otErr << __FUNCTION__
                           << ": Error: While loading ackNums "
                              "field: Missing serverID. Nym contents:\n\n"
                           << strNym << "\n\n";
                     return false; // error condition
                 }
 
                 //                  xml->read(); // there should be a text field
                 // next, with the data for the list of acknowledged numbers.
                 // Note: I think I was forced to add this when the numlist was
                 // empty, one time, so this may come back
                 // to haunt me, but I want to fix it right, not kludge it.
 
                 if (!OTContract::LoadEncodedTextField(xml, strTemp)) {
                     otErr << __FUNCTION__
                           << ": Error: ackNums field without value "
                              "(at least, unable to LoadEncodedTextField on "
                              "that value.)\n";
                     return false; // error condition
                 }
                 OTNumList theNumList;
 
                 if (strTemp.Exists()) theNumList.Add(strTemp);
 
                 int64_t lTemp = 0;
                 while (theNumList.Peek(lTemp)) {
                     theNumList.Pop();
 
                     otInfo << "Acknowledgment record exists for server reply, "
                               "for Request Number " << lTemp
                            << " for ServerID: " << tempServerID << "\n";
                     AddAcknowledgedNum(tempServerID, lTemp); // This version
                                                              // doesn't save to
                                                              // disk. (Why save
                                                              // to disk AS WE'RE
                                                              // LOADING?)
                 }
             }
 
             // THE BELOW FOUR ARE DEPRECATED, AND ARE REPLACED BY THE ABOVE
             // FOUR.
             else if (strNodeName.Compare("transactionNum")) {
                 const OTString TransNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString TransNumAvailable =
                     xml->getAttributeValue("transactionNum");
 
                 otLog3 << "Transaction Number " << TransNumAvailable
                        << " available for ServerID: " << TransNumServerID
                        << "\n";
 
                 AddTransactionNum(
                     TransNumServerID,
                     atol(TransNumAvailable.Get())); // This version doesn't save
                                                     // to disk. (Why save to
                                                     // disk AS WE'RE LOADING?)
             }
             else if (strNodeName.Compare("issuedNum")) {
                 const OTString TransNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString TransNumAvailable =
                     xml->getAttributeValue("transactionNum");
 
                 otLog3 << "Currently liable for Transaction Number "
                        << TransNumAvailable
                        << ", for ServerID: " << TransNumServerID << "\n";
 
                 AddIssuedNum(TransNumServerID,
                              atol(TransNumAvailable.Get())); // This version
                                                              // doesn't save to
                                                              // disk. (Why save
                                                              // to disk AS WE'RE
                                                              // LOADING?)
             }
             else if (strNodeName.Compare("tentativeNum")) {
                 const OTString TransNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString TransNumAvailable =
                     xml->getAttributeValue("transactionNum");
 
                 otLog3 << "Currently waiting on server success notice, "
                           "accepting Transaction Number " << TransNumAvailable
                        << ", for ServerID: " << TransNumServerID << "\n";
 
                 AddTentativeNum(TransNumServerID,
                                 atol(TransNumAvailable.Get())); // This version
                                                                 // doesn't save
                                                                 // to disk. (Why
                                                                 // save to disk
                                                                 // AS WE'RE
                                                                 // LOADING?)
             }
             else if (strNodeName.Compare("acknowledgedNum")) {
                 const OTString AckNumServerID =
                     xml->getAttributeValue("serverID");
                 const OTString AckNumValue =
                     xml->getAttributeValue("requestNum");
 
                 otLog3 << "Acknowledgment record exists for server reply, for "
                           "Request Number " << AckNumValue
                        << ", for ServerID: " << AckNumServerID << "\n";
 
                 AddAcknowledgedNum(AckNumServerID,
                                    atol(AckNumValue.Get())); // This version
                                                              // doesn't save to
                                                              // disk. (Why save
                                                              // to disk AS WE'RE
                                                              // LOADING?)
             }
             else if (strNodeName.Compare("MARKED_FOR_DELETION")) {
                 m_bMarkForDeletion = true;
                 otLog3 << "This nym has been MARKED_FOR_DELETION (at some "
                           "point prior.)\n";
             }
             else if (strNodeName.Compare("hasOpenCronItem")) {
                 OTString strID = xml->getAttributeValue("ID");
 
                 if (strID.Exists()) {
                     const int64_t lNewID = atol(strID.Get());
                     m_setOpenCronItems.insert(lNewID);
                     otLog3 << "This nym has an open cron item with ID: "
                            << strID << "\n";
                 }
                 else
                     otLog3 << "This nym MISSING ID when loading open cron item "
                               "record.\n";
             }
             else if (strNodeName.Compare("ownsAssetAcct")) {
                 OTString strID = xml->getAttributeValue("ID");
 
                 if (strID.Exists()) {
                     m_setAccounts.insert(strID.Get());
                     otLog3 << "This nym has an asset account with the ID: "
                            << strID << "\n";
                 }
                 else
                     otLog3 << "This nym MISSING asset account ID when loading "
                               "nym record.\n";
             }
             else if (strNodeName.Compare("mailMessage")) {
                 OTASCIIArmor armorMail;
                 OTString strMessage;
 
                 xml->read();
 
                 if (irr::io::EXN_TEXT == xml->getNodeType()) {
                     OTString strNodeData = xml->getNodeData();
 
                     // Sometimes the XML reads up the data with a prepended
                     // newline.
                     // This screws up my own objects which expect a consistent
                     // in/out
                     // So I'm checking here for that prepended newline, and
                     // removing it.
                     char cNewline;
                     if (strNodeData.Exists() && strNodeData.GetLength() > 2 &&
                         strNodeData.At(0, cNewline)) {
                         if ('\n' == cNewline)
                             armorMail.Set(strNodeData.Get() +
                                           1); // I know all this shit is ugly. I
                                               // refactored this in OTContract.
                         else // unfortunately OTNym is like a "basic type" and
                              // isn't derived from OTContract.
                             armorMail.Set(strNodeData.Get()); // TODO:
                                                               // OTContract now
                                                               // has STATIC
                                                               // methods for
                                                               // this. (Start
                                                               // using them
                                                               // here...)
 
                         if (armorMail.GetLength() > 2) {
                             armorMail.GetString(strMessage,
                                                 true); // linebreaks == true.
 
                             if (strMessage.GetLength() > 2) {
                                 OTMessage* pMessage = new OTMessage;
 
                                 OT_ASSERT(nullptr != pMessage);
 
                                 if (pMessage->LoadContractFromString(
                                         strMessage))
                                     m_dequeMail.push_back(
                                         pMessage); // takes ownership
                                 else
                                     delete pMessage;
                             }
                         } // armorMail
                     }     // strNodeData
                 }         // EXN_TEXT
             }
             else if (strNodeName.Compare("outmailMessage")) {
                 OTASCIIArmor armorMail;
                 OTString strMessage;
 
                 xml->read();
 
                 if (irr::io::EXN_TEXT == xml->getNodeType()) {
                     OTString strNodeData = xml->getNodeData();
 
                     // Sometimes the XML reads up the data with a prepended
                     // newline.
                     // This screws up my own objects which expect a consistent
                     // in/out
                     // So I'm checking here for that prepended newline, and
                     // removing it.
                     char cNewline;
                     if (strNodeData.Exists() && strNodeData.GetLength() > 2 &&
                         strNodeData.At(0, cNewline)) {
                         if ('\n' == cNewline)
                             armorMail.Set(strNodeData.Get() + 1);
                         else
                             armorMail.Set(strNodeData.Get());
 
                         if (armorMail.GetLength() > 2) {
                             armorMail.GetString(strMessage,
                                                 true); // linebreaks == true.
 
                             if (strMessage.GetLength() > 2) {
                                 OTMessage* pMessage = new OTMessage;
                                 OT_ASSERT(nullptr != pMessage);
 
                                 if (pMessage->LoadContractFromString(
                                         strMessage))
                                     m_dequeOutmail.push_back(
                                         pMessage); // takes ownership
                                 else
                                     delete pMessage;
                             }
                         } // armorMail
                     }     // strNodeData
                 }         // EXN_TEXT
             }             // outpayments message
             else if (strNodeName.Compare("outpaymentsMessage")) {
                 OTASCIIArmor armorMail;
                 OTString strMessage;
 
                 xml->read();
 
                 if (irr::io::EXN_TEXT == xml->getNodeType()) {
                     OTString strNodeData = xml->getNodeData();
 
                     // Sometimes the XML reads up the data with a prepended
                     // newline.
                     // This screws up my own objects which expect a consistent
                     // in/out
                     // So I'm checking here for that prepended newline, and
                     // removing it.
                     char cNewline;
                     if (strNodeData.Exists() && strNodeData.GetLength() > 2 &&
                         strNodeData.At(0, cNewline)) {
                         if ('\n' == cNewline)
                             armorMail.Set(strNodeData.Get() + 1);
                         else
                             armorMail.Set(strNodeData.Get());
 
                         if (armorMail.GetLength() > 2) {
                             armorMail.GetString(strMessage,
                                                 true); // linebreaks == true.
 
                             if (strMessage.GetLength() > 2) {
                                 OTMessage* pMessage = new OTMessage;
                                 OT_ASSERT(nullptr != pMessage);
 
                                 if (pMessage->LoadContractFromString(
                                         strMessage))
                                     m_dequeOutpayments.push_back(
                                         pMessage); // takes ownership
                                 else
                                     delete pMessage;
                             }
                         }
                     } // strNodeData
                 }     // EXN_TEXT
             }         // outpayments message
             else {
                 // unknown element type
                 otErr << "Unknown element type in " << __FUNCTION__ << ": "
                       << xml->getNodeName() << "\n";
                 bSuccess = false;
             }
             break;
         }
         default: {
             otLog5 << "Unknown XML type in " << __FUNCTION__ << ": "
                    << xml->getNodeName() << "\n";
             break;
         }
         } // switch
     }     // while
 
     return bSuccess;
 }

bool opentxs::OTPseudonym::LoadNymfile ( const char * szFilename = nullptr )

Definition at line 6062 of file OTPseudonym.cpp.

 {
     OTString strID;
     GetIdentifier(strID);
 
     const char* szFoldername = OTFolders::Nym().Get();
     const char* szTheFilename = strID.Get();
 
     // If no filename was passed in (user might have designated one) then we
     // create
     // the filename by appending the Nym's ID to the path.
     if (nullptr == szFilename) {
         m_strNymfile = szTheFilename;
     }
     else {
         m_strNymfile = szFilename;
     }
 
     if (!OTDB::Exists(szFoldername, m_strNymfile.Get())) {
         otErr << __FUNCTION__ << ": File does not exist: " << szFoldername
               << OTLog::PathSeparator() << m_strNymfile << "\n";
         return false;
     }
 
     std::string strFileContents(OTDB::QueryPlainString(
         szFoldername, m_strNymfile.Get())); // <=== LOADING FROM DATA STORE.
 
     if (strFileContents.length() < 2) {
         otErr << __FUNCTION__ << ": Error reading file: " << szFoldername
               << OTLog::PathSeparator() << m_strNymfile << "\n";
         return false;
     }
 
     OTString strRawFile = strFileContents.c_str();
 
     if (strRawFile.GetLength()) return LoadFromString(strRawFile);
 
     return false;
 }

OTPseudonym * opentxs::OTPseudonym::LoadPrivateNym	(	const OTIdentifier &	NYM_ID,
		bool	bChecking = `false`,
		const OTString *	pstrName = `nullptr`,
		const char *	szFuncName = `nullptr`,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

static

Definition at line 286 of file OTPseudonym.cpp.

 {
     const char* szFunc =
         (nullptr != szFuncName) ? szFuncName : "OTPseudonym::LoadPrivateNym";
 
     if (NYM_ID.IsEmpty()) return nullptr;
 
     const OTString strNymID(NYM_ID);
 
     // If name is empty, construct one way,
     // else construct a different way.
     //
     OTPseudonym* pNym = ((nullptr == pstrName) || !pstrName->Exists())
                             ? (new OTPseudonym(NYM_ID))
                             : (new OTPseudonym(*pstrName, strNymID, strNymID));
     OT_ASSERT_MSG(nullptr != pNym,
                   "OTPseudonym::LoadPrivateNym: Error allocating memory.\n");
 
     OTPasswordData thePWData(OT_PW_DISPLAY);
     if (nullptr == pPWData) pPWData = &thePWData;
 
     bool bLoadedKey = pNym->Loadx509CertAndPrivateKey(
         bChecking, pPWData,
         pImportPassword); // old style. (Deprecated.) Eventually remove this.
     //***  Right now Loadx509CertAndPrivateKey calls LoadCredentials at its top,
     // which is what we should be calling here. But that function handles
     // old-style Nyms too, so we keep it around until we lose those.  //
     //<====================
 
     // Error loading x509CertAndPrivateKey.
     if (!bLoadedKey)
         OTLog::vOutput(
             bChecking ? 1 : 0,
             "%s: %s: (%s: is %s).  Unable to load credentials, "
             "cert and private key for: %s (maybe this nym doesn't exist?)\n",
             __FUNCTION__, szFunc, "bChecking", bChecking ? "true" : "false",
             strNymID.Get());
     // success loading x509CertAndPrivateKey,
     // failure verifying pseudonym public key.
     else if (!pNym->VerifyPseudonym()) // <====================
         otErr << __FUNCTION__ << " " << szFunc
               << ": Failure verifying Nym public key: " << strNymID << "\n";
     // success verifying pseudonym public key.
     // failure loading signed nymfile.
     else if (!pNym->LoadSignedNymfile(*pNym)) // Unlike with public key,
                                               // with private key we DO
                                               // expect nymfile to be
                                               // here.
         otErr << __FUNCTION__ << " " << szFunc
               << ": Failure calling LoadSignedNymfile: " << strNymID << "\n";
     else // ultimate success.
         return pNym;
 
     delete pNym;
     pNym = nullptr;
 
     return nullptr;
 }

bool opentxs::OTPseudonym::LoadPublicKey ( )

Definition at line 3792 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     // Here we try to load credentials first (the new system) and if it's
     // successful, we
     // use that to set the public key from the credential, and then return.
     // Otherwise,
     // we run the old code.
     //
     if (LoadCredentials() && (GetMasterCredentialCount() > 0)) // New style!
     {
         //        auto it = m_mapCredentials.begin();
         //        OT_ASSERT(m_mapCredentials.end() != it);
         //        OTCredential * pCredential = it->second;
         //        OT_ASSERT(nullptr != pCredential);
 
         //        OTString strSigningKey;
         //
         //        if (const_cast<OTKeypair
         // &>(pCredential->GetSignKeypair(&m_listRevokedIDs)).GetPublicKey(strSigningKey,
         // false)) //bEscaped
         //            return m_pkeypair->SetPublicKey(strSigningKey, false); //
         // bEscaped
         //        else
         //            otErr << "%s: Failed in call to
         // pCredential->GetPublicSignKey().GetPublicKey()\n", __FUNCTION__);
 
         return true;
 
         // NOTE: LoadPublicKey (this function) calls LoadCredentials (above.) On
         // the server side, these are
         // public credentials which do not contain keys, per se. Instead, it
         // contains a single variable which in
         // turn contains the master-signed version of itself which then contains
         // the public keys.
         //
         // That means when the credentials are first loaded, there are no public
         // keys loaded! Each subcredential
         // is signed by itself, and contains a master-signed version of itself
         // that's signed by the master. It's
         // only AFTER loading, in verification
         // (OTSubcredential::VerifyInternally) when we verify the master
         // signature
         // on the master-signed version, and if it all checks out, THEN we copy
         // the public keys from the master-signed
         // version up into the actual subcredential. UNTIL WE DO THAT, the
         // actual subcredential HAS NO PUBLIC KEYS IN IT.
         //
         // That's why the above code was having problems -- we are trying to
         // "GetPublicKey" when there can be no
         // possibility that the public key will be there.
         // For now I'm going to NOT set m_pkeypair, since the public key isn't
         // available to set onto it yet.
         // We want to phase out m_pkeypair anyway, but I just hope this doesn't
         // cause problems where it was expected
         // in the future, where I still need to somehow make sure it's set.
         // (AFTER verification, apparently.)
         //
         // Notice however, that this only happens in cases where the credentials
         // were actually available, so maybe it
         // will just work, since the below block is where we handle cases where
         // the credentials WEREN'T available, so
         // we load the old key the old way. (Meaning we definitely know that
         // those "old cases" will continue to work.)
         // Any potential problems will have to be in cases where credentials ARE
         // available, but the code was nonetheless
         // still expecting things to work the old way -- and these are precisely
         // the sorts of cases I probably want to
         // uncover, so I can convert things over...
     }
 
     // OLD STYLE (below.) Deprecated!
 
     OTString strID;
 
     if (!Server_PubKeyExists(&strID)) // strID will contain *this
                                       // nymID after this call.
     {
         // Code will call this in order to see if there is a PublicKey to be
         // loaded.
         // Therefore I don't want to log a big error here since we expect that
         // sometimes
         // the key won't be there.
         // Therefore I log at level 4, the same level as I log the successful
         // outcome.
         //
         otLog4 << __FUNCTION__
                << ": Failed load: "
                   "Apparently this Nym doesn't exist. (Returning.)\n";
         return false;
     }
 
     const char* szFoldername = OTFolders::Pubkey().Get();
     const char* szFilename = strID.Get();
 
     const OTString strFoldername(szFoldername), strFilename(szFilename);
 
     // This loads up the ascii-armored Public Key.
     // On the client side, the entire x509 is stored in the cert folder.
     // (With other Nym's pubkeys stored in pubkey folder.)
     // On the server side, it's just the public key and stored here in pubkey
     // folder.
     //
     const bool bCanLoadKeyFile = OTDB::Exists(szFoldername, szFilename);
 
     if (bCanLoadKeyFile) {
         if (!m_pkeypair->LoadPublicKey(strFoldername, strFilename)) {
             otErr << __FUNCTION__ << ": Although the ascii-armored file ("
                   << szFoldername << OTLog::PathSeparator() << szFilename
                   << ") was read, LoadPublicKey returned false.\n";
             return false;
         }
         else {
             otLog4 << __FUNCTION__
                    << ": Successfully loaded public key from file: "
                    << szFoldername << OTLog::PathSeparator() << szFilename
                    << "\n";
         }
         return true;
     }
 
     otInfo << __FUNCTION__ << ": Failure.\n";
     return false;
 }

OTPseudonym * opentxs::OTPseudonym::LoadPublicNym	(	const OTIdentifier &	NYM_ID,
		const OTString *	pstrName = `nullptr`,
		const char *	szFuncName = `nullptr`
	)

static

Definition at line 159 of file OTPseudonym.cpp.

 {
     const char* szFunc =
         (nullptr != szFuncName) ? szFuncName : "OTPseudonym::LoadPublicNym";
 
     const OTString strNymID(NYM_ID);
 
     // If name is empty, construct one way,
     // else construct a different way.
     //
     OTPseudonym* pNym = ((nullptr == pstrName) || !pstrName->Exists())
                             ? (new OTPseudonym(NYM_ID))
                             : (new OTPseudonym(*pstrName, strNymID, strNymID));
     OT_ASSERT_MSG(nullptr != pNym,
                   "OTPseudonym::LoadPublicNym: Error allocating memory.\n");
 
     bool bLoadedKey =
         pNym->LoadPublicKey(); // Deprecated. Only used for old-style Nyms.
                                // Eventually, remove this. Currently
                                // LoadPublicKey calls LoadCredentials, which is
                                // what we should be calling, once the nym's own
                                // keypair is eliminated.
 
     // First load the public key
     if (!bLoadedKey)
         otWarn << __FUNCTION__ << ": " << szFunc
                << ": Unable to find nym: " << strNymID << "\n";
     else if (!pNym->VerifyPseudonym())
         otErr << __FUNCTION__ << ": " << szFunc
               << ": Security: Failure verifying Nym: " << strNymID << "\n";
     else if (!pNym->LoadSignedNymfile(*pNym)) {
         otLog4 << "OTPseudonym::LoadPublicNym " << szFunc
                << ": Usually normal: There's no Nymfile (" << strNymID
                << "), though there IS a public "
                   "key, which checks out. It's probably just someone else's "
                   "Nym. (So I'm still returning this Nym to "
                   "the caller so he can still use the public key.)\n";
         return pNym;
     }
     else // success
         return pNym;
 
     delete pNym;
     pNym = nullptr;
 
     return nullptr;
 }

bool opentxs::OTPseudonym::LoadSignedNymfile ( OTPseudonym & SIGNER_NYM )

Definition at line 5816 of file OTPseudonym.cpp.

 {
     // Get the Nym's ID in string form
     OTString nymID;
     GetIdentifier(nymID);
 
     // Create an OTSignedFile object, giving it the filename (the ID) and the
     // local directory ("nyms")
     OTSignedFile theNymfile(OTFolders::Nym(), nymID);
 
     if (!theNymfile.LoadFile()) {
         otWarn << __FUNCTION__ << ": Failed loading a signed nymfile: " << nymID
                << "\n\n";
     }
     // We verify:
     //
     // 1. That the file even exists and loads.
     // 2. That the local subdir and filename match the versions inside the file.
     // 3. That the signature matches for the signer nym who was passed in.
     //
     else if (!theNymfile.VerifyFile()) {
         otErr << __FUNCTION__ << ": Failed verifying nymfile: " << nymID
               << "\n\n";
     }
     else if (!theNymfile.VerifySignature(SIGNER_NYM)) {
         OTString strSignerNymID;
         SIGNER_NYM.GetIdentifier(strSignerNymID);
         otErr << __FUNCTION__
               << ": Failed verifying signature on nymfile: " << nymID
               << "\n Signer Nym ID: " << strSignerNymID << "\n";
     }
     // NOTE: Comment out the above two blocks if you want to load a Nym without
     // having
     // to verify his information. (For development reasons. Never do that
     // normally.)
     else {
         otInfo
             << "Loaded and verified signed nymfile. Reading from string...\n";
 
         if (theNymfile.GetFilePayload().GetLength() > 0)
             return LoadFromString(
                 theNymfile.GetFilePayload()); // <====== Success...
         else {
             const int64_t lLength =
                 static_cast<int64_t>(theNymfile.GetFilePayload().GetLength());
 
             otErr << __FUNCTION__ << ": Bad length (" << lLength
                   << ") while loading nymfile: " << nymID << "\n";
         }
     }
 
     return false;
 }

bool opentxs::OTPseudonym::Loadx509CertAndPrivateKey	(	bool	bChecking = `false`,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 6126 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     OTPasswordData thePWData(OT_PW_DISPLAY);
     if (nullptr == pPWData) pPWData = &thePWData;
     OTString strReason(pPWData->GetDisplayString());
 
     // Here we try to load credentials first (the new system) and if it's
     // successful, we
     // use that to set the private/public keypair from the credential, and then
     // return.
     // Otherwise, we run the old code.
     //
     if (LoadCredentials(true, pPWData, pImportPassword) &&
         (GetMasterCredentialCount() > 0)) // New style!
     {
         //      return true;
         auto it = m_mapCredentials.begin();
         OT_ASSERT(m_mapCredentials.end() != it);
         OTCredential* pCredential = it->second;
         OT_ASSERT(nullptr != pCredential);
 
         OTString strPubAndPrivCert;
 
         if (const_cast<OTKeypair&>(
                 pCredential->GetSignKeypair(&m_listRevokedIDs))
                 .SaveCertAndPrivateKeyToString(strPubAndPrivCert, &strReason,
                                                pImportPassword)) {
             const bool bReturnValue =
                 m_pkeypair->LoadCertAndPrivateKeyFromString(
                     strPubAndPrivCert, &strReason, pImportPassword);
 
             if (!bReturnValue)
                 otErr << __FUNCTION__
                       << ": Failed in call to m_pkeypair->SetPrivateKey.\n";
 
             return bReturnValue;
         }
     }
 
     // OLD STYLE (below) Deprecated.
 
     OTString strID(m_nymID);
 
     std::string strFoldername = OTFolders::Cert().Get();
     std::string strFilename = strID.Get();
 
     if (strFoldername.empty()) {
         otErr << __FUNCTION__ << ": Error: strFoldername is empty!";
         OT_FAIL;
     }
     if (strFilename.empty()) {
         otErr << __FUNCTION__ << ": Error: strFilename is empty!";
         OT_FAIL;
     }
 
     const bool bExists = OTDB::Exists(strFoldername, strFilename);
 
     if (!bExists) {
         OTLog::vOutput(bChecking ? 1 : 0,
                        "%s: (%s: is %s).  File does not exist: %s in: %s\n",
                        __FUNCTION__, "bChecking", bChecking ? "true" : "false",
                        strFoldername.c_str(), strFilename.c_str());
 
         return false;
     }
     else if (m_pkeypair->LoadBothKeysFromCertFile(
                    OTFolders::Cert(), // foldername
                    strID,             // filename
                    &strReason, pImportPassword))
         return true; // LoadBothKeysFromCertFile has plenty of logs, no need for
                      // more at this time here.
 
     otErr << __FUNCTION__ << ": Failure, filename: " << strFoldername
           << OTLog::PathSeparator() << strFilename << "\n";
     return false;
 }

bool opentxs::OTPseudonym::Loadx509CertAndPrivateKeyFromString	(	const OTString &	strInput,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 6102 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     if (!strInput.Exists()) {
         const OTString strID(m_nymID);
         otErr << __FUNCTION__ << ": strInput does not exist. (Returning "
                                  "false.) ID currently set to: " << strID
               << "\n";
         return false;
     }
 
     OTString strReason(nullptr == pPWData ? OT_PW_DISPLAY
                                           : pPWData->GetDisplayString());
 
     return m_pkeypair->LoadCertAndPrivateKeyFromString(strInput, &strReason,
                                                        pImportPassword);
 }

void opentxs::OTPseudonym::MarkAsUndeleted ( )

inline

Definition at line 455 of file OTPseudonym.hpp.

     {
         m_bMarkForDeletion = false;
     }

void opentxs::OTPseudonym::MarkForDeletion ( )

inline

Definition at line 447 of file OTPseudonym.hpp.

     {
         m_bMarkForDeletion = true;
     }

void opentxs::OTPseudonym::OnUpdateRequestNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		int64_t	lNewRequestNumber
	)

Definition at line 3413 of file OTPseudonym.cpp.

 {
     bool bSuccess = false;
 
     // The Pseudonym has a map of the request numbers for different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then send out the request
     // number and
     // increment it so it will be ready for the next request.
     //
     // Make sure to save the Pseudonym so the new request number is saved.
     std::string strID = strServerID.Get();
 
     for (auto& it : m_mapRequestNum) {
         if (strID == it.first) {
             // We found it!
             // Presumably we ONLY found it because this Nym has been properly
             // loaded first.
             // Good job! Otherwise, the list would have been empty even though
             // the request number
             // was sitting in the file.
 
             // The call has succeeded
             bSuccess = true;
 
             // Grab a copy of the old request number
             int64_t lOldRequestNumber = m_mapRequestNum[it.first];
 
             // Set the new request number to the old one plus one.
             m_mapRequestNum[it.first] = lNewRequestNumber;
 
             // Now we can log BOTH, before and after...
             otLog4 << "Updated Request Number from " << lOldRequestNumber
                    << " to " << m_mapRequestNum[it.first] << ". Saving...\n";
             break;
         }
     }
 
     // If I didn't find it in the list above (whether the list is empty or
     // not....)
     // that means it does not exist. So create it.
 
     if (!bSuccess) {
         otOut << "Creating Request Number entry as '" << lNewRequestNumber
               << "'. Saving...\n";
         m_mapRequestNum[strServerID.Get()] = lNewRequestNumber;
         bSuccess = true;
     }
 
     if (bSuccess) {
         SaveSignedNymfile(SIGNER_NYM);
     }
 }

bool opentxs::OTPseudonym::ReEncryptPrivateCredentials	(	bool	bImporting,
		const OTPasswordData *	pPWData = `nullptr`,
		const OTPassword *	pImportPassword = `nullptr`
	)

Definition at line 4092 of file OTPseudonym.cpp.

 {
     const OTPassword* pExportPassphrase = nullptr;
     std::unique_ptr<const OTPassword> thePasswordAngel;
 
     if (nullptr == pImportPassword) {
 
         // whether import/export, this display string is for the OUTSIDE OF
         // WALLET
         // portion of that process.
         //
         OTString strDisplay(
             nullptr != pPWData
                 ? pPWData->GetDisplayString()
                 : (bImporting ? "Enter passphrase for the Nym being imported."
                               : "Enter passphrase for exported Nym."));
         // Circumvents the cached key.
         pExportPassphrase = OTSymmetricKey::GetPassphraseFromUser(
             &strDisplay, !bImporting); // bAskTwice is true when exporting
                                        // (since the export passphrase is being
                                        // created at that time.)
         thePasswordAngel.reset(pExportPassphrase);
 
         if (nullptr == pExportPassphrase) {
             otErr << __FUNCTION__ << ": Failed in GetPassphraseFromUser.\n";
             return false;
         }
 
         //      otOut << "%s: DEBUGGING pExportPassphrase, size %d, contains: %s
         // \n",
         //                     __FUNCTION__,
         // pExportPassphrase->getPasswordSize(),
         // pExportPassphrase->getPassword());
     }
     else {
         pExportPassphrase = pImportPassword;
 
         //      otOut << "%s: DEBUGGING pImportPassword, size %d, contains: %s
         // \n",
         //                     __FUNCTION__, pImportPassword->getPasswordSize(),
         // pImportPassword->getPassword());
     }
 
     for (auto& it : m_mapCredentials) {
         OTCredential* pCredential = it.second;
         OT_ASSERT(nullptr != pCredential);
 
         if (false ==
             pCredential->ReEncryptPrivateCredentials(*pExportPassphrase,
                                                      bImporting))
             return false;
     }
 
     return true;
 }

void opentxs::OTPseudonym::ReleaseTransactionNumbers ( )

Definition at line 1856 of file OTPseudonym.cpp.

 {
     WIPE_MAP_AND_DEQUE(m_mapTransNum)
     WIPE_MAP_AND_DEQUE(m_mapIssuedNum)
     WIPE_MAP_AND_DEQUE(m_mapTentativeNum)
     WIPE_MAP_AND_DEQUE(m_mapAcknowledgedNum)
 }

bool opentxs::OTPseudonym::RemoveAcknowledgedNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lRequestNum,
		bool	bSave
	)

Definition at line 2740 of file OTPseudonym.cpp.

 {
     bool bSuccess = RemoveAcknowledgedNum(
         strServerID,
         lRequestNum); // Remove from list of acknowledged request numbers.
 
     if (bSuccess && bSave)
         bSave = SaveSignedNymfile(SIGNER_NYM);
     else
         bSave = true; // so the return at the bottom calculates correctly.
 
     return (bSuccess && bSave);
 }

bool opentxs::OTPseudonym::RemoveAcknowledgedNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lRequestNum
	)

Definition at line 2573 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapAcknowledgedNum, SIGNER_NYM, strServerID,
                             lRequestNum);
 }

bool opentxs::OTPseudonym::RemoveAcknowledgedNum	(	const OTString &	strServerID,
		const int64_t &	lRequestNum
	)

Definition at line 2581 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapAcknowledgedNum, strServerID, lRequestNum);
 }

void opentxs::OTPseudonym::RemoveAllNumbers	(	const OTString *	pstrServerID = `nullptr`,
		bool	bRemoveHighestNum = `true`
	)

Definition at line 1549 of file OTPseudonym.cpp.

 {
     std::string str_ServerID(pstrServerID ? pstrServerID->Get() : "");
 
     // These use str_ServerID (above)
     //
     CLEAR_MAP_AND_DEQUE(m_mapIssuedNum)
     CLEAR_MAP_AND_DEQUE(m_mapTransNum)
     CLEAR_MAP_AND_DEQUE(m_mapTentativeNum)
     CLEAR_MAP_AND_DEQUE(m_mapAcknowledgedNum)
 
     std::list<mapOfHighestNums::iterator> listOfHighestNums;
     std::list<mapOfIdentifiers::iterator> listOfNymboxHash;
     std::list<mapOfIdentifiers::iterator> listOfInboxHash;
     std::list<mapOfIdentifiers::iterator> listOfOutboxHash;
     std::list<mapOfIdentifiers::iterator> listOfRecentHash;
 
     if (bRemoveHighestNum) {
         for (auto it(m_mapHighTransNo.begin()); it != m_mapHighTransNo.end();
              ++it) {
             if ((nullptr != pstrServerID) &&
                 (str_ServerID != it->first)) // If passed in, and current it
                                              // doesn't match, then skip it
                                              // (continue).
                 continue;
 
             listOfHighestNums.push_back(it);
         }
     }
 
     for (auto it(m_mapNymboxHash.begin()); it != m_mapNymboxHash.end(); ++it) {
         if ((nullptr != pstrServerID) &&
             (str_ServerID != it->first)) // If passed in, and current it doesn't
                                          // match, then skip it (continue).
             continue;
 
         listOfNymboxHash.push_back(it);
     }
 
     // This is mapped to acct_id, not server_id.
     // (So we just wipe them all.)
     for (auto it(m_mapInboxHash.begin()); it != m_mapInboxHash.end(); ++it) {
         listOfInboxHash.push_back(it);
     }
 
     // This is mapped to acct_id, not server_id.
     // (So we just wipe them all.)
     for (auto it(m_mapOutboxHash.begin()); it != m_mapOutboxHash.end(); ++it) {
         listOfOutboxHash.push_back(it);
     }
 
     for (auto it(m_mapRecentHash.begin()); it != m_mapRecentHash.end(); ++it) {
         if ((nullptr != pstrServerID) &&
             (str_ServerID != it->first)) // If passed in, and current it doesn't
                                          // match, then skip it (continue).
             continue;
 
         listOfRecentHash.push_back(it);
     }
 
     while (!listOfHighestNums.empty()) {
         m_mapHighTransNo.erase(listOfHighestNums.back());
         listOfHighestNums.pop_back();
     }
     while (!listOfNymboxHash.empty()) {
         m_mapNymboxHash.erase(listOfNymboxHash.back());
         listOfNymboxHash.pop_back();
     }
     while (!listOfInboxHash.empty()) {
         m_mapInboxHash.erase(listOfInboxHash.back());
         listOfInboxHash.pop_back();
     }
     while (!listOfOutboxHash.empty()) {
         m_mapOutboxHash.erase(listOfOutboxHash.back());
         listOfOutboxHash.pop_back();
     }
     while (!listOfRecentHash.empty()) {
         m_mapRecentHash.erase(listOfRecentHash.back());
         listOfRecentHash.pop_back();
     }
 }

bool opentxs::OTPseudonym::RemoveGenericNum	(	mapOfTransNums &	THE_MAP,
		OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2208 of file OTPseudonym.cpp.

 {
     bool bRetVal = RemoveGenericNum(THE_MAP, strServerID, lTransNum);
 
     if (bRetVal) {
         SaveSignedNymfile(SIGNER_NYM);
     }
 
     return bRetVal;
 }

bool opentxs::OTPseudonym::RemoveGenericNum	(	mapOfTransNums &	THE_MAP,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2227 of file OTPseudonym.cpp.

 {
     bool bRetVal = false;
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of transaction numbers for each servers.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then find the transaction
     // number on
     // that list, and then remove it, and return true. Else return false.
     //
     for (auto& it : THE_MAP) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
 
             OT_ASSERT(nullptr != pDeque);
 
             if (!(pDeque->empty())) // there are some numbers for that server ID
             {
                 // Let's loop through them and see if the culprit is there
                 for (uint32_t i = 0; i < pDeque->size(); i++) {
                     // Found it!
                     if (lTransNum == pDeque->at(i)) {
                         pDeque->erase(pDeque->begin() + i);
                         bRetVal = true;
                         break;
                     }
                 }
             }
             break;
         }
     }
 
     return bRetVal;
 }

bool opentxs::OTPseudonym::RemoveIssuedNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum,
		bool	bSave
	)

Definition at line 2713 of file OTPseudonym.cpp.

 {
     bool bSuccess =
         RemoveIssuedNum(strServerID, lTransNum); // Remove from list of numbers
                                                  // that are still signed out.
 
     if (bSuccess && bSave)
         bSave = SaveSignedNymfile(SIGNER_NYM);
     else
         bSave = true; // so the return at the bottom calculates correctly.
 
     return (bSuccess && bSave);
 }

bool opentxs::OTPseudonym::RemoveIssuedNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2480 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapIssuedNum, SIGNER_NYM, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::RemoveIssuedNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2487 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapIssuedNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::RemoveMailByIndex ( int32_t nIndex )

Definition at line 1107 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeMail.empty() || (nIndex < 0) || (uIndex >= m_dequeMail.size()))
         return false;
 
     OTMessage* pMessage = m_dequeMail.at(nIndex);
 
     OT_ASSERT(nullptr != pMessage);
 
     m_dequeMail.erase(m_dequeMail.begin() + nIndex);
 
     delete pMessage;
 
     return true;
 }

bool opentxs::OTPseudonym::RemoveOutmailByIndex ( int32_t nIndex )

Definition at line 1163 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeOutmail.empty() || (nIndex < 0) ||
         (uIndex >= m_dequeOutmail.size()))
         return false;
 
     OTMessage* pMessage = m_dequeOutmail.at(nIndex);
 
     OT_ASSERT(nullptr != pMessage);
 
     m_dequeOutmail.erase(m_dequeOutmail.begin() + nIndex);
 
     delete pMessage;
 
     return true;
 }

bool opentxs::OTPseudonym::RemoveOutpaymentsByIndex	(	int32_t	nIndex,
		bool	bDeleteIt = `true`
	)

Definition at line 1224 of file OTPseudonym.cpp.

 {
     const uint32_t uIndex = nIndex;
 
     // Out of bounds.
     if (m_dequeOutpayments.empty() || (nIndex < 0) ||
         (uIndex >= m_dequeOutpayments.size())) {
         otErr << __FUNCTION__
               << ": Error: Index out of bounds: signed: " << nIndex
               << " unsigned: " << uIndex << " (size is "
               << m_dequeOutpayments.size() << ").\n";
         return false;
     }
 
     OTMessage* pMessage = m_dequeOutpayments.at(nIndex);
     OT_ASSERT(nullptr != pMessage);
 
     m_dequeOutpayments.erase(m_dequeOutpayments.begin() + uIndex);
 
     if (bDeleteIt) delete pMessage;
 
     return true;
 }

void opentxs::OTPseudonym::RemoveReqNumbers ( const OTString * pstrServerID = nullptr )

Definition at line 1769 of file OTPseudonym.cpp.

 {
     const std::string str_ServerID(pstrServerID ? pstrServerID->Get() : "");
 
     for (auto it(m_mapRequestNum.begin()); it != m_mapRequestNum.end(); ++it) {
         if ((nullptr != pstrServerID) &&
             (str_ServerID != it->first)) // If passed in, and current it doesn't
                                          // match, then skip it (continue).
             continue;
 
         m_mapRequestNum.erase(it);
     }
 }

bool opentxs::OTPseudonym::RemoveTentativeNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum,
		bool	bSave
	)

Definition at line 2687 of file OTPseudonym.cpp.

 {
     bool bSuccess = RemoveTentativeNum(
         strServerID, lTransNum); // Remove from list of numbers that haven't
                                  // been made available for use yet, though
                                  // they're "tentative"...
 
     if (bSuccess && bSave)
         bSave = SaveSignedNymfile(SIGNER_NYM);
     else
         bSave = true; // so the return at the bottom calculates correctly.
 
     return (bSuccess && bSave);
 }

bool opentxs::OTPseudonym::RemoveTentativeNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2520 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapTentativeNum, SIGNER_NYM, strServerID,
                             lTransNum);
 }

bool opentxs::OTPseudonym::RemoveTentativeNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2528 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapTentativeNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::RemoveTransactionNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2438 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapTransNum, SIGNER_NYM, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::RemoveTransactionNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)

Definition at line 2445 of file OTPseudonym.cpp.

 {
     return RemoveGenericNum(m_mapTransNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::ResyncWithServer	(	const OTLedger &	theNymbox,
		const OTPseudonym &	theMessageNym
	)

Definition at line 1990 of file OTPseudonym.cpp.

 {
     bool bSuccess = true;
 
     const OTIdentifier& theServerID = theNymbox.GetRealServerID();
     const OTString strServerID(theServerID);
     const OTString strNymID(m_nymID);
 
     const int32_t nIssuedNumCount =
         theMessageNym.GetIssuedNumCount(theServerID);
     const int32_t nTransNumCount =
         theMessageNym.GetTransactionNumCount(theServerID);
 
     // Remove all issued, transaction, and tentative numbers for a specific
     // server ID,
     // as well as all acknowledgedNums, and the highest transaction number for
     // that serverID,
     // from *this nym. Leave our record of the highest trans num received from
     // that server,
     // since we will want to just keep it when re-syncing. (Server doesn't store
     // that anyway.)
     //
     RemoveAllNumbers(&strServerID, false); // bRemoveHighestNum=true by
                                            // default. But in this case, I
                                            // keep it.
 
     // Any issued or trans numbers we add to *this from theMessageNym, are also
     // added here so
     // they can be used to update the "highest number" record (at the bottom of
     // this function.)
     //
     std::set<int64_t> setTransNumbers;
 
     // Now that *this has no issued or transaction numbers for theServerID, we
     // add
     // them back again from theMessageNym. (So they will match, and be 'N
     // SYNC!!!)
     //
     // Copy the issued and transaction numbers from theMessageNym onto *this.
     //
     for (int32_t n1 = 0; n1 < nIssuedNumCount; ++n1) {
         const int64_t lNum = theMessageNym.GetIssuedNum(theServerID, n1);
 
         if (!AddIssuedNum(strServerID, lNum)) // Add to list of
                                               // numbers that
                                               // haven't been
                                               // closed yet.
         {
             otErr << "OTPseudonym::ResyncWithServer: Failed trying to add "
                      "IssuedNum (" << lNum << ") onto *this nym: " << strNymID
                   << ", for server: " << strServerID << "\n";
             bSuccess = false;
         }
         else {
             setTransNumbers.insert(lNum);
 
             otWarn << "OTPseudonym::ResyncWithServer: Added IssuedNum (" << lNum
                    << ") onto *this nym: " << strNymID
                    << ", for server: " << strServerID << " \n";
         }
     }
 
     for (int32_t n2 = 0; n2 < nTransNumCount; ++n2) {
         const int64_t lNum = theMessageNym.GetTransactionNum(theServerID, n2);
 
         if (!AddTransactionNum(strServerID, lNum)) // Add to list of
                                                    // available-to-use
                                                    // numbers.
         {
             otErr << "OTPseudonym::ResyncWithServer: Failed trying to add "
                      "TransactionNum (" << lNum
                   << ") onto *this nym: " << strNymID
                   << ", for server: " << strServerID << "\n";
             bSuccess = false;
         }
         else {
             setTransNumbers.insert(lNum);
 
             otWarn << "OTPseudonym::ResyncWithServer: Added TransactionNum ("
                    << lNum << ") onto *this nym: " << strNymID
                    << ", for server: " << strServerID << " \n";
         }
     }
 
     // We already cleared all tentative numbers from *this (above in
     // RemoveAllNumbers). Next, loop through theNymbox and add Tentative numbers
     // to *this based on each successNotice in the Nymbox. This way, when the
     // notices
     // are processed, they will succeed because the Nym will believe he was
     // expecting them.
     //
     for (auto& it : theNymbox.GetTransactionMap()) {
         OTTransaction* pTransaction = it.second;
         OT_ASSERT(nullptr != pTransaction);
         //        OTString strTransaction(*pTransaction);
         //        otErr << "TRANSACTION CONTENTS:\n%s\n", strTransaction.Get());
 
         // (a new; ALREADY just added transaction number.)
         if ((OTTransaction::successNotice !=
              pTransaction->GetType())) // if !successNotice
             continue;
 
         const int64_t lNum =
             pTransaction->GetReferenceToNum(); // successNotice is inRefTo the
                                                // new transaction # that should
                                                // be on my tentative list.
 
         if (!AddTentativeNum(strServerID, lNum)) // Add to list of
         // tentatively-being-added
         // numbers.
         {
             otErr << "OTPseudonym::ResyncWithServer: Failed trying to add "
                      "TentativeNum (" << lNum
                   << ") onto *this nym: " << strNymID
                   << ", for server: " << strServerID << "\n";
             bSuccess = false;
         }
         else
             otWarn << "OTPseudonym::ResyncWithServer: Added TentativeNum ("
                    << lNum << ") onto *this nym: " << strNymID
                    << ", for server: " << strServerID << " \n";
         // There's no "else insert to setTransNumbers" here, like the other two
         // blocks above.
         // Why not? Because setTransNumbers is for updating the Highest Trans
         // Num record on this Nym,
         // and the Tentative Numbers aren't figured into that record until AFTER
         // they are accepted
         // from the Nymbox. So I leave them out, since this function is
         // basically setting us up to
         // successfully process the Nymbox, which will then naturally update the
         // highest num record
         // based on the tentatives, as it's removing them from the tentative
         // list and adding them to
         // the "available" transaction list (and issued.)
     }
 
     const std::string strID = strServerID.Get();
 
     for (auto& it_high_num : m_mapHighTransNo) {
         // We found it!
         if (strID == it_high_num.first) {
             // See if any numbers on the set are higher, and if so, update the
             // record to match.
             //
             for (auto& it : setTransNumbers) {
                 const int64_t lTransNum = it;
 
                 // Grab a copy of the old highest trans number
                 const int64_t lOldHighestNumber = it_high_num.second;
 
                 if (lTransNum > lOldHighestNumber) // Did we find a bigger one?
                 {
                     // Then update the Nym's record!
                     m_mapHighTransNo[it_high_num.first] = lTransNum;
                     otWarn
                         << "OTPseudonym::ResyncWithServer: Updated HighestNum ("
                         << lTransNum << ") record on *this nym: " << strNymID
                         << ", for server: " << strServerID << " \n";
                 }
             }
 
             // We only needed to do this for the one server, so we can break
             // now.
             break;
         }
     }
 
     return (SaveSignedNymfile(*this) && bSuccess);
 }

bool opentxs::OTPseudonym::SaveCredentialList ( )

Definition at line 4255 of file OTPseudonym.cpp.

 {
     OTString strNymID, strOutput;
     GetIdentifier(strNymID);
 
     SaveCredentialListToString(strOutput);
 
     if (strOutput.Exists()) {
         OTASCIIArmor ascOutput(strOutput);
         strOutput.Release();
         if (ascOutput.WriteArmoredString(
                 strOutput, "CREDENTIAL LIST") && // bEscaped=false by default.
             strOutput.Exists()) {
 
             // Save it to local storage.
             OTString strFilename;
             strFilename.Format("%s.cred", strNymID.Get());
 
             std::string str_Folder = HasPrivateKey()
                                          ? OTFolders::Credential().Get()
                                          : OTFolders::Pubcred().Get();
 
             if (!OTDB::StorePlainString(strOutput.Get(), str_Folder,
                                         strFilename.Get())) {
                 otErr << __FUNCTION__ << ": Failure trying to store "
                       << (HasPrivateKey() ? "private" : "public")
                       << " credential list for Nym: " << strNymID << "\n";
                 return false;
             }
 
             return true;
         }
     }
     return false;
 }

void opentxs::OTPseudonym::SaveCredentialListToString ( OTString & strOutput )

Definition at line 4235 of file OTPseudonym.cpp.

 {
     OTString strNymID;
     GetIdentifier(strNymID);
 
     strOutput.Concatenate("<?xml version=\"%s\"?>\n",
                           "2.0"); // todo hardcoding.
 
     strOutput.Concatenate("<OTuser version=\"%s\"\n"
                           " nymID=\"%s\""
                           ">\n\n",
                           m_strVersion.Get(), strNymID.Get());
 
     SerializeNymIDSource(strOutput);
 
     SaveCredentialsToString(strOutput);
 
     strOutput.Concatenate("</OTuser>\n");
 }

void opentxs::OTPseudonym::SaveCredentialsToString	(	OTString &	strOutput,
		OTString::Map *	pmapPubInfo = `nullptr`,
		OTString::Map *	pmapPriInfo = `nullptr`
	)

Definition at line 4373 of file OTPseudonym.cpp.

 {
 
     // IDs for revoked subcredentials are saved here.
     for (auto& it : m_listRevokedIDs) {
         std::string str_revoked_id = it;
         strOutput.Concatenate("<revokedCredential\n"
                               " ID=\"%s\""
                               "/>\n\n",
                               str_revoked_id.c_str());
     }
 
     // Serialize master and sub-credentials here.
     for (auto& it : m_mapCredentials) {
         OTCredential* pCredential = it.second;
         OT_ASSERT(nullptr != pCredential);
 
         pCredential->SerializeIDs(
             strOutput, m_listRevokedIDs, pmapPubInfo, pmapPriInfo,
             true); // bShowRevoked=false by default (true here), bValid=true
     }
 
     // Serialize Revoked master credentials here, including their subkeys.
     for (auto& it : m_mapRevoked) {
         OTCredential* pCredential = it.second;
         OT_ASSERT(nullptr != pCredential);
 
         pCredential->SerializeIDs(
             strOutput, m_listRevokedIDs, pmapPubInfo, pmapPriInfo, true,
             false); // bShowRevoked=false by default. (Here it's true.)
                     // bValid=true by default. Here is for revoked, so false.
     }
 }

bool opentxs::OTPseudonym::SavePseudonym ( )

Definition at line 4047 of file OTPseudonym.cpp.

 {
     if (!m_strNymfile.GetLength()) {
         OTString nymID;
         GetIdentifier(nymID);
         m_strNymfile.Format("%s", nymID.Get());
     }
 
     otInfo << "Saving nym to: " << OTFolders::Nym() << OTLog::PathSeparator()
            << m_strNymfile << "\n";
 
     return SavePseudonym(OTFolders::Nym().Get(), m_strNymfile.Get());
 }

bool opentxs::OTPseudonym::SavePseudonym	(	const char *	szFoldername,
		const char *	szFilename
	)

Definition at line 4061 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != szFoldername);
     OT_ASSERT(nullptr != szFilename);
 
     OTString strNym;
     SavePseudonym(strNym);
 
     bool bSaved =
         OTDB::StorePlainString(strNym.Get(), szFoldername, szFilename);
     if (!bSaved)
         otErr << __FUNCTION__ << ": Error saving file: " << szFoldername
               << OTLog::PathSeparator() << szFilename << "\n";
 
     return bSaved;
 }

bool opentxs::OTPseudonym::SavePseudonym ( OTString & strNym )

Definition at line 4410 of file OTPseudonym.cpp.

 {
     OTString nymID;
     GetIdentifier(nymID);
 
     strNym.Concatenate("<?xml version=\"%s\"?>\n", "2.0");
 
     if (m_lUsageCredits == 0)
         strNym.Concatenate("<OTuser version=\"%s\"\n"
                            " nymID=\"%s\""
                            ">\n\n",
                            m_strVersion.Get(), nymID.Get());
     else
         strNym.Concatenate("<OTuser version=\"%s\"\n"
                            " nymID=\"%s\"\n"
                            " usageCredits=\"%lld\""
                            ">\n\n",
                            m_strVersion.Get(), nymID.Get(), m_lUsageCredits);
 
     SerializeNymIDSource(strNym);
 
     // For now I'm saving the credential list to a separate file. (And then of
     // course,
     // each credential also gets its own file.) We load the credential list
     // file,
     // and any associated credentials, before loading the Nymfile proper.
     // Then we use the keys from those credentials possibly to verify the
     // signature on
     // the Nymfile (or not, in the case of the server which uses its own key.)
 
     //  SaveCredentialsToString(strNym);
 
     for (auto& it : m_mapRequestNum) {
         std::string strServerID = it.first;
         int64_t lRequestNum = it.second;
 
         strNym.Concatenate("<requestNum\n"
                            " serverID=\"%s\"\n"
                            " currentRequestNum=\"%lld\""
                            "/>\n\n",
                            strServerID.c_str(), lRequestNum);
     }
 
     for (auto& it : m_mapHighTransNo) {
         std::string strServerID = it.first;
         int64_t lHighestNum = it.second;
 
         strNym.Concatenate("<highestTransNum\n"
                            " serverID=\"%s\"\n"
                            " mostRecent=\"%lld\""
                            "/>\n\n",
                            strServerID.c_str(), lHighestNum);
     }
 
     // When you delete a Nym, it just marks it.
     // Actual deletion occurs during maintenance sweep (targeting marked
     // nyms...)
     //
     if (m_bMarkForDeletion)
         strNym.Concatenate(
             "<MARKED_FOR_DELETION>\n"
             "%s</MARKED_FOR_DELETION>\n\n",
             "THIS NYM HAS BEEN MARKED FOR DELETION AT ITS OWN REQUEST");
 
     int64_t lTransactionNumber = 0;
 
     for (auto& it : m_mapTransNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         //        if (!(pDeque->empty()) && (strServerID.size() > 0) )
         //        {
         //            for (uint32_t i = 0; i < pDeque->size(); i++)
         //            {
         //                lTransactionNumber = pDeque->at(i);
         //
         //                strNym.Concatenate("<transactionNum\n"
         //                                   " serverID=\"%s\"\n"
         //                                   " transactionNum=\"%lld\""
         //                                   "/>\n\n",
         //                                   strServerID.c_str(),
         //                                   lTransactionNumber
         //                                   );
         //            }
         //        }
 
         if (!(pDeque->empty()) && (strServerID.size() > 0)) {
             OTNumList theList;
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
                 theList.Add(lTransactionNumber);
             }
             OTString strTemp;
             if ((theList.Count() > 0) && theList.Output(strTemp) &&
                 strTemp.Exists()) {
                 const OTASCIIArmor ascTemp(strTemp);
 
                 if (ascTemp.Exists())
                     strNym.Concatenate("<transactionNums "
                                        "serverID=\"%s\">\n%s</"
                                        "transactionNums>\n\n",
                                        strServerID.c_str(), ascTemp.Get());
             }
         }
     } // for
 
     lTransactionNumber = 0;
 
     for (auto& it : m_mapIssuedNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         //        if (!(pDeque->empty()) && (strServerID.size() > 0) )
         //        {
         //            for (uint32_t i = 0; i < pDeque->size(); i++)
         //            {
         //                lTransactionNumber = pDeque->at(i);
         //
         //                strNym.Concatenate("<issuedNum\n"
         //                                   " serverID=\"%s\"\n"
         //                                   " transactionNum=\"%lld\""
         //                                   "/>\n\n",
         //                                   strServerID.c_str(),
         //                                   lTransactionNumber
         //                                   );
         //            }
         //        }
 
         if (!(pDeque->empty()) && (strServerID.size() > 0)) {
             OTNumList theList;
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
                 theList.Add(lTransactionNumber);
             }
             OTString strTemp;
             if ((theList.Count() > 0) && theList.Output(strTemp) &&
                 strTemp.Exists()) {
                 const OTASCIIArmor ascTemp(strTemp);
 
                 if (ascTemp.Exists())
                     strNym.Concatenate(
                         "<issuedNums serverID=\"%s\">\n%s</issuedNums>\n\n",
                         strServerID.c_str(), ascTemp.Get());
             }
         }
     } // for
 
     lTransactionNumber = 0;
 
     for (auto& it : m_mapTentativeNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         //        if (!(pDeque->empty()) && (strServerID.size() > 0) )
         //        {
         //            for (uint32_t i = 0; i < pDeque->size(); i++)
         //            {
         //                lTransactionNumber = pDeque->at(i);
         //
         //                strNym.Concatenate("<tentativeNum\n"
         //                                   " serverID=\"%s\"\n"
         //                                   " transactionNum=\"%lld\""
         //                                   "/>\n\n",
         //                                   strServerID.c_str(),
         //                                   lTransactionNumber
         //                                   );
         //            }
         //        }
 
         if (!(pDeque->empty()) && (strServerID.size() > 0)) {
             OTNumList theList;
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
                 theList.Add(lTransactionNumber);
             }
             OTString strTemp;
             if ((theList.Count() > 0) && theList.Output(strTemp) &&
                 strTemp.Exists()) {
                 const OTASCIIArmor ascTemp(strTemp);
 
                 if (ascTemp.Exists())
                     strNym.Concatenate("<tentativeNums "
                                        "serverID=\"%s\">\n%s</"
                                        "tentativeNums>\n\n",
                                        strServerID.c_str(), ascTemp.Get());
             }
         }
 
     } // for
 
     // although mapOfTransNums is used, in this case,
     // request numbers are what is actually being stored.
     // The data structure just happened to be appropriate
     // in this case, with generic manipulation functions
     // already written, so I used that pre-existing system.
     //
     for (auto& it : m_mapAcknowledgedNum) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OT_ASSERT(nullptr != pDeque);
 
         //        if (!(pDeque->empty()) && (strServerID.size() > 0) )
         //        {
         //            for (uint32_t i = 0; i < pDeque->size(); i++)
         //            {
         //                const int64_t lRequestNumber = pDeque->at(i);
         //
         //                strNym.Concatenate("<acknowledgedNum\n"
         //                                   " serverID=\"%s\"\n"
         //                                   " requestNum=\"%lld\""
         //                                   "/>\n\n",
         //                                   strServerID.c_str(),
         //                                   lRequestNumber
         //                                   );
         //            }
         //        }
 
         if (!(pDeque->empty()) && (strServerID.size() > 0)) {
             OTNumList theList;
 
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 const int64_t lRequestNumber = pDeque->at(i);
                 theList.Add(lRequestNumber);
             }
             OTString strTemp;
             if ((theList.Count() > 0) && theList.Output(strTemp) &&
                 strTemp.Exists()) {
                 const OTASCIIArmor ascTemp(strTemp);
 
                 if (ascTemp.Exists())
                     strNym.Concatenate(
                         "<ackNums serverID=\"%s\">\n%s</ackNums>\n\n",
                         strServerID.c_str(), ascTemp.Get());
             }
         }
 
     } // for
 
     if (!(m_dequeMail.empty())) {
         for (uint32_t i = 0; i < m_dequeMail.size(); i++) {
             OTMessage* pMessage = m_dequeMail.at(i);
             OT_ASSERT(nullptr != pMessage);
 
             OTString strMail(*pMessage);
 
             OTASCIIArmor ascMail;
 
             if (strMail.Exists()) ascMail.SetString(strMail);
 
             if (ascMail.Exists())
                 strNym.Concatenate("<mailMessage>\n"
                                    "%s</mailMessage>\n\n",
                                    ascMail.Get());
         }
     }
 
     if (!(m_dequeOutmail.empty())) {
         for (uint32_t i = 0; i < m_dequeOutmail.size(); i++) {
             OTMessage* pMessage = m_dequeOutmail.at(i);
             OT_ASSERT(nullptr != pMessage);
 
             OTString strOutmail(*pMessage);
 
             OTASCIIArmor ascOutmail;
 
             if (strOutmail.Exists()) ascOutmail.SetString(strOutmail);
 
             if (ascOutmail.Exists())
                 strNym.Concatenate("<outmailMessage>\n"
                                    "%s</outmailMessage>\n\n",
                                    ascOutmail.Get());
         }
     }
 
     if (!(m_dequeOutpayments.empty())) {
         for (uint32_t i = 0; i < m_dequeOutpayments.size(); i++) {
             OTMessage* pMessage = m_dequeOutpayments.at(i);
             OT_ASSERT(nullptr != pMessage);
 
             OTString strOutpayments(*pMessage);
 
             OTASCIIArmor ascOutpayments;
 
             if (strOutpayments.Exists())
                 ascOutpayments.SetString(strOutpayments);
 
             if (ascOutpayments.Exists())
                 strNym.Concatenate("<outpaymentsMessage>\n"
                                    "%s</outpaymentsMessage>\n\n",
                                    ascOutpayments.Get());
         }
     }
 
     // These are used on the server side.
     // (That's why you don't see the server ID saved here.)
     //
     if (!(m_setOpenCronItems.empty())) {
         for (auto& it : m_setOpenCronItems) {
             strNym.Concatenate("<hasOpenCronItem ID=\"%lld\" />\n\n", it);
         }
     }
 
     // These are used on the server side.
     // (That's why you don't see the server ID saved here.)
     //
     if (!(m_setAccounts.empty())) {
         for (auto& it : m_setAccounts) {
             strNym.Concatenate("<ownsAssetAcct ID=\"%s\" />\n\n", it.c_str());
         }
     }
 
     // client-side
     for (auto& it : m_mapNymboxHash) {
         std::string strServerID = it.first;
         OTIdentifier& theID = it.second;
 
         if ((strServerID.size() > 0) && !theID.IsEmpty()) {
             const OTString strNymboxHash(theID);
             strNym.Concatenate("<nymboxHashItem\n"
                                " serverID=\"%s\"\n"
                                " nymboxHash=\"%s\""
                                "/>\n\n",
                                strServerID.c_str(), strNymboxHash.Get());
         }
     } // for
 
     // client-side
     for (auto& it : m_mapRecentHash) {
         std::string strServerID = it.first;
         OTIdentifier& theID = it.second;
 
         if ((strServerID.size() > 0) && !theID.IsEmpty()) {
             const OTString strRecentHash(theID);
             strNym.Concatenate("<recentHashItem\n"
                                " serverID=\"%s\"\n"
                                " recentHash=\"%s\""
                                "/>\n\n",
                                strServerID.c_str(), strRecentHash.Get());
         }
     } // for
 
     // server-side
     if (!m_NymboxHash.IsEmpty()) {
         const OTString strNymboxHash(m_NymboxHash);
         strNym.Concatenate("<nymboxHash\n"
                            " value=\"%s\""
                            "/>\n\n",
                            strNymboxHash.Get());
     }
 
     // client-side
     for (auto& it : m_mapInboxHash) {
         std::string strAcctID = it.first;
         OTIdentifier& theID = it.second;
 
         if ((strAcctID.size() > 0) && !theID.IsEmpty()) {
             const OTString strHash(theID);
             strNym.Concatenate("<inboxHashItem\n"
                                " accountID=\"%s\"\n"
                                " hashValue=\"%s\""
                                "/>\n\n",
                                strAcctID.c_str(), strHash.Get());
         }
     } // for
 
     // client-side
     for (auto& it : m_mapOutboxHash) {
         std::string strAcctID = it.first;
         OTIdentifier& theID = it.second;
 
         if ((strAcctID.size() > 0) && !theID.IsEmpty()) {
             const OTString strHash(theID);
             strNym.Concatenate("<outboxHashItem\n"
                                " accountID=\"%s\"\n"
                                " hashValue=\"%s\""
                                "/>\n\n",
                                strAcctID.c_str(), strHash.Get());
         }
     } // for
 
     strNym.Concatenate("</OTuser>\n");
 
     return true;
 }

bool opentxs::OTPseudonym::SavePseudonym ( std::ofstream & ofs )

Definition at line 4079 of file OTPseudonym.cpp.

 {
     OTString strNym;
     SavePseudonym(strNym);
 
     ofs << strNym;
 
     return true;
 }

bool opentxs::OTPseudonym::SavePseudonymWallet ( OTString & strOutput ) const

Definition at line 3671 of file OTPseudonym.cpp.

 {
     OTString nymID;
     GetIdentifier(nymID);
 
     OTASCIIArmor ascName;
 
     if (m_strName.Exists()) // name is in the clear in memory, and base64 in
                             // storage.
     {
         ascName.SetString(m_strName, false); // linebreaks == false
     }
 
     strOutput.Concatenate("<pseudonym name=\"%s\"\n"
                           " nymID=\"%s\" />\n\n",
                           ascName.Get(), nymID.Get());
 
     return true;
 }

bool opentxs::OTPseudonym::SavePseudonymWallet ( std::ofstream & ofs ) const

Definition at line 3691 of file OTPseudonym.cpp.

 {
     OTString strOutput;
 
     if (SavePseudonymWallet(strOutput))
         ofs << strOutput;
     else
         return false;
 
     return true;
 }

bool opentxs::OTPseudonym::SavePublicKey ( const OTString & strPath ) const

Definition at line 3705 of file OTPseudonym.cpp.

 {
     const char* szFoldername = OTFolders::Pubkey().Get();
     const char* szFilename = strPath.Get();
 
     OT_ASSERT(nullptr != szFoldername);
     OT_ASSERT(nullptr != szFilename);
 
     OT_ASSERT(nullptr != m_pkeypair);
 
     // By passing in an OTString instead of OTASCIIArmor, it knows to add the
     // bookends
     // ----- BEGIN PUBLIC KEY  etc.  These bookends are necessary for
     // OTASCIIArmor to later
     // read the thing back up into memory again.
     OTString strKey;
 
     if (m_pkeypair->GetPublicKey(strKey, false)) // false means "do not ESCAPE
                                                  // the bookends"
     // Ie we'll get ----------- instead of - ---------
     {
         bool bStored =
             OTDB::StorePlainString(strKey.Get(), szFoldername, szFilename);
 
         if (!bStored) {
             otErr << "Failure in OTPseudonym::SavePublicKey while saving to "
                      "storage: " << szFoldername << OTLog::PathSeparator()
                   << szFilename << "\n";
             return false;
         }
     }
     else {
         otErr << "Error in OTPseudonym::SavePublicKey: unable to GetPublicKey "
                  "from Nym\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTPseudonym::SavePublicKey ( std::ofstream & ofs ) const

Definition at line 3745 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     // By passing in an OTString instead of OTASCIIArmor, it knows to add the
     // bookends
     // ----- BEGIN PUBLIC KEY  etc.  These bookends are necessary for
     // OTASCIIArmor to later
     // read the thing back up into memory again.
     OTString strKey;
 
     if (m_pkeypair->GetPublicKey(strKey, false)) // false means "do not ESCAPE
                                                  // the bookends"
     // Ie we'll get ----------- instead of - ---------
     {
         strKey.WriteToFile(ofs);
     }
     else {
         otErr << "Error in OTPseudonym::SavePublicKey: unable to GetPublicKey "
                  "from Nym\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTPseudonym::SaveSignedNymfile ( OTPseudonym & SIGNER_NYM )

Definition at line 5870 of file OTPseudonym.cpp.

 {
     // Get the Nym's ID in string form
     OTString strNymID;
     GetIdentifier(strNymID);
 
     // Create an OTSignedFile object, giving it the filename (the ID) and the
     // local directory ("nyms")
     OTSignedFile theNymfile(OTFolders::Nym().Get(), strNymID);
     theNymfile.GetFilename(m_strNymfile);
 
     otInfo << "Saving nym to: " << m_strNymfile << "\n";
 
     // First we save this nym to a string...
     // Specifically, the file payload string on the OTSignedFile object.
     SavePseudonym(theNymfile.GetFilePayload());
 
     // Now the OTSignedFile contains the path, the filename, AND the
     // contents of the Nym itself, saved to a string inside the OTSignedFile
     // object.
 
     if (theNymfile.SignContract(SIGNER_NYM) && theNymfile.SaveContract()) {
         const bool bSaved = theNymfile.SaveFile();
 
         if (!bSaved) {
             OTString strSignerNymID;
             SIGNER_NYM.GetIdentifier(strSignerNymID);
             otErr << __FUNCTION__
                   << ": Failed while calling theNymfile.SaveFile() for Nym "
                   << strNymID << " using Signer Nym " << strSignerNymID << "\n";
         }
 
         return bSaved;
     }
     else {
         OTString strSignerNymID;
         SIGNER_NYM.GetIdentifier(strSignerNymID);
         otErr << __FUNCTION__
               << ": Failed trying to sign and save Nymfile for Nym " << strNymID
               << " using Signer Nym " << strSignerNymID << "\n";
     }
 
     return false;
 }

bool opentxs::OTPseudonym::Savex509CertAndPrivateKey	(	bool	bCreateFile = `true`,
		const OTString *	pstrReason = `nullptr`
	)

Definition at line 1356 of file OTPseudonym.cpp.

 {
 
     OTString strOutput;
     const bool bSuccess =
         m_pkeypair->SaveAndReloadBothKeysFromTempFile(&strOutput, pstrReason);
 
     //
     // At this point, the Nym's private key is set, and its public key is also
     // set.
     // So the object in memory is good to go.
     // Now we just need to create some files, especially where the keys are
     // stored,
     // since the Nym normally never writes to those files (just reads.)
     //
     if (bSuccess) {
 
         // NYM ID based on SOURCE
         //
         if (m_strSourceForNymID.Exists())
             m_nymID.CalculateDigest(m_strSourceForNymID);
 
         // (or) NYM ID based on PUBLIC SIGNING KEY
         //
         else if (!SetIdentifierByPubkey()) {
             otErr << __FUNCTION__ << ": Error calculating Nym ID (as a digest "
                                      "of Nym's public (signing) key.)\n";
             return false;
         }
 
         // If we set the ID based on the public key (above block),
         // then we should set the source to contain that public key.
         else {
             OTString strTempSource;
             m_pkeypair->GetPublicKey(strTempSource); // bEscaped=true by default
 
             SetNymIDSource(strTempSource);
         }
 
         const OTString strFilenameByID(m_nymID); // FILENAME based on NYM ID
 
         if (bCreateFile &&
             (false ==
              OTDB::StorePlainString(strOutput.Get(), OTFolders::Cert().Get(),
                                     strFilenameByID.Get()))) // Store as actual
                                                              // Nym ID this time
                                                              // instead of
                                                              // temp.nym
         {
             otErr << __FUNCTION__
                   << ": Failure storing cert for new nym: " << strFilenameByID
                   << "\n";
             return false;
         }
     }
 
     return bSuccess;
 }

bool opentxs::OTPseudonym::Savex509CertAndPrivateKeyToString	(	OTString &	strOutput,
		const OTString *	pstrReason = `nullptr`
	)

Definition at line 1350 of file OTPseudonym.cpp.

 {
     return m_pkeypair->SaveCertAndPrivateKeyToString(strOutput, pstrReason);
 }

void opentxs::OTPseudonym::SerializeNymIDSource ( OTString & strOutput ) const

Definition at line 4213 of file OTPseudonym.cpp.

 {
 
     // We encode these before storing.
     if (m_strSourceForNymID.Exists()) {
         const OTASCIIArmor ascSourceForNymID(m_strSourceForNymID);
 
         if (m_strAltLocation.Exists()) {
             OTASCIIArmor ascAltLocation;
             ascAltLocation.SetString(m_strAltLocation,
                                      false); // bLineBreaks=true by default.
 
             strOutput.Concatenate(
                 "<nymIDSource altLocation=\"%s\">\n%s</nymIDSource>\n\n",
                 ascAltLocation.Get(), ascSourceForNymID.Get());
         }
         else
             strOutput.Concatenate("<nymIDSource>\n%s</nymIDSource>\n\n",
                                   ascSourceForNymID.Get());
     }
 }

bool opentxs::OTPseudonym::Server_PubKeyExists ( OTString * pstrID = nullptr )

Definition at line 3772 of file OTPseudonym.cpp.

 {
 
     OTString strID;
     if (nullptr == pstrID) {
         pstrID = &strID;
     }
     GetIdentifier(*pstrID);
 
     // Below this point, pstrID is a GOOD pointer, no matter what. (And no need
     // to delete it.)
 
     return OTDB::Exists(OTFolders::Pubkey().Get(), pstrID->Get());
 }

EXPORT void opentxs::OTPseudonym::SetAltLocation ( const OTString & strLocation )

inline

Definition at line 655 of file OTPseudonym.hpp.

     {
         m_strAltLocation = strLocation;
     }

bool opentxs::OTPseudonym::SetCertificate	(	const OTString &	strCert,
		bool	bEscaped = `true`
	)

Definition at line 6242 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->LoadPublicKeyFromCertString(strCert, bEscaped);
 }

void opentxs::OTPseudonym::SetIdentifier ( const OTIdentifier & theIdentifier )

Definition at line 6571 of file OTPseudonym.cpp.

 {
     m_nymID = theIdentifier;
 }

void opentxs::OTPseudonym::SetIdentifier ( const OTString & theIdentifier )

Definition at line 6583 of file OTPseudonym.cpp.

 {
     m_nymID.SetString(theIdentifier);
 }

bool opentxs::OTPseudonym::SetIdentifierByPubkey ( )

Definition at line 1516 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     const bool bCalculated = m_pkeypair->CalculateID(
         m_nymID); // OTAsymmetricKey::CalculateID only works with public keys.
 
     if (!bCalculated) {
         otErr << __FUNCTION__ << ": Error calculating Nym ID in "
                                  "OTAsymmetricKey::CalculateID().\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTPseudonym::SetInboxHash	(	const std::string &	acct_id,
		const OTIdentifier &	theInput
	)

Definition at line 1689 of file OTPseudonym.cpp.

 {
     return SetHash(m_mapInboxHash, acct_id, theInput);
 }

bool opentxs::OTPseudonym::SetNymboxHash	(	const std::string &	server_id,
		const OTIdentifier &	theInput
	)

Definition at line 1665 of file OTPseudonym.cpp.

 {
     return SetHash(m_mapNymboxHash, server_id, theInput);
 }

void opentxs::OTPseudonym::SetNymboxHashServerSide ( const OTIdentifier & theInput )

Definition at line 1653 of file OTPseudonym.cpp.

 {
     m_NymboxHash = theInput;
 }

EXPORT void opentxs::OTPseudonym::SetNymIDSource ( const OTString & strSource )

inline

Definition at line 651 of file OTPseudonym.hpp.

     {
         m_strSourceForNymID = strSource;
     }

void opentxs::OTPseudonym::SetNymName ( const OTString & strName )

inline

Definition at line 474 of file OTPseudonym.hpp.

     {
         m_strName = strName;
     }

bool opentxs::OTPseudonym::SetOutboxHash	(	const std::string &	acct_id,
		const OTIdentifier &	theInput
	)

Definition at line 1701 of file OTPseudonym.cpp.

 {
     return SetHash(m_mapOutboxHash, acct_id, theInput);
 }

bool opentxs::OTPseudonym::SetPrivateKey	(	const OTString &	strKey,
		bool	bEscaped = `true`
	)

Definition at line 6270 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->SetPrivateKey(strKey, bEscaped);
 }

bool opentxs::OTPseudonym::SetPrivateKey ( const OTASCIIArmor & strKey )

Definition at line 6279 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->SetPrivateKey(strKey);
 }

bool opentxs::OTPseudonym::SetPublicKey	(	const OTString &	strKey,
		bool	bEscaped = `true`
	)

Definition at line 6251 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->SetPublicKey(strKey, bEscaped);
 }

bool opentxs::OTPseudonym::SetPublicKey ( const OTASCIIArmor & strKey )

Definition at line 6259 of file OTPseudonym.cpp.

 {
     OT_ASSERT(nullptr != m_pkeypair);
 
     return m_pkeypair->SetPublicKey(strKey);
 }

bool opentxs::OTPseudonym::SetRecentHash	(	const std::string &	server_id,
		const OTIdentifier &	theInput
	)

Definition at line 1677 of file OTPseudonym.cpp.

 {
     return SetHash(m_mapRecentHash, server_id, theInput);
 }

EXPORT void opentxs::OTPseudonym::SetUsageCredits ( const int64_t & lUsage )

inline

Definition at line 443 of file OTPseudonym.hpp.

     {
         m_lUsageCredits = lUsage;
     }

bool opentxs::OTPseudonym::UnRegisterAtServer ( const OTString & strServerID )

Definition at line 1819 of file OTPseudonym.cpp.

 {
     bool bRetVal = false; // default is return false: "No, I'm NOT registered at
                           // that Server."
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a map of the request numbers for different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then delete that one.
     //
     for (auto it(m_mapRequestNum.begin()); it != m_mapRequestNum.end(); ++it) {
         if (strID == it->first) {
             // The call has succeeded
             bRetVal = true;
             m_mapRequestNum.erase(it);
             break;
         }
     }
 
     return bRetVal;
 }

int64_t opentxs::OTPseudonym::UpdateHighestNum	(	OTPseudonym &	SIGNER_NYM,
		const OTString &	strServerID,
		std::set< int64_t > &	setNumbers,
		std::set< int64_t > &	setOutputGood,
		std::set< int64_t > &	setOutputBad,
		bool	bSave = `false`
	)

Definition at line 3076 of file OTPseudonym.cpp.

 {
     bool bFoundServerID = false;
     int64_t lReturnVal = 0; // 0 is success.
 
     // First find the highest and lowest numbers out of the new set.
     //
     int64_t lHighestInSet = 0;
     int64_t lLowestInSet = 0;
 
     for (auto& it : setNumbers) {
         const int64_t lSetNum = it;
 
         if (lSetNum > lHighestInSet)
             lHighestInSet = lSetNum; // Set lHighestInSet to contain the highest
                                      // number out of setNumbers (input)
 
         if (0 == lLowestInSet)
             lLowestInSet = lSetNum; // If lLowestInSet is still 0, then set it
                                     // to the current number (happens first
                                     // iteration.)
         else if (lSetNum < lLowestInSet)
             lLowestInSet = lSetNum; // If current number is less than
                                     // lLowestInSet, then set lLowestInSet to
                                     // current Number.
     }
 
     // By this point, lLowestInSet contains the lowest number in setNumbers,
     // and lHighestInSet contains the highest number in setNumbers.
 
     //
     // The Pseudonym has a map of the "highest transaction numbers" for
     // different servers.
     // For Server Bob, with this Pseudonym, I might be on number 34.
     // For but Server Alice, I might be on number 59.
     //
     // So let's loop through all the numbers I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then update it there (then
     // break.)
     //
     // Make sure to save the Pseudonym afterwards, so the new numbers are saved.
 
     std::string strID = strServerID.Get();
 
     for (auto& it : m_mapHighTransNo) {
         // We found the serverID key on the map?
         // We now know the highest trans number for that server?
         //
         if (strID == it.first) // Iterates inside this block zero times or one
                                // time. (One if it finds it, zero if not.)
         {
             // We found it!
             // Presumably we ONLY found it because this Nym has been properly
             // loaded first.
             // Good job! Otherwise, the list would have been empty even though
             // the highest number
             // was sitting in the file.
 
             // Grab a copy of the old highest trans number for this server.
             //
             const int64_t lOldHighestNumber =
                 it.second; // <=========== The previous "highest number".
 
             // Loop through the numbers passed in, and for each, see if it's
             // less than
             // the previous "highest number for this server."
             //
             // If it's less, then we can't add it (must have added it
             // already...)
             // So we add it to the bad list.
             // But if it's more,
 
             for (auto& it_numbers : setNumbers) {
                 const int64_t lSetNum = it_numbers;
 
                 // If the current number (this iteration) is less than or equal
                 // to the
                 // "old highest number", then it's not going to be added twice.
                 // (It goes on the "bad list.")
                 //
                 if (lSetNum <= lOldHighestNumber) {
                     otWarn << "OTPseudonym::UpdateHighestNum: New transaction "
                               "number is less-than-or-equal-to "
                               "last known 'highest trans number' record. (Must "
                               "be seeing the same server reply for "
                               "a second time, due to a receipt in my Nymbox.) "
                               "FYI, last known 'highest' number received: "
                            << lOldHighestNumber
                            << " (Current 'violator': " << lSetNum
                            << ") Skipping...\n";
                     setOutputBad.insert(lSetNum);
                 }
 
                 // The current number this iteration, as it should be, is HIGHER
                 // than any transaction
                 // number I've ever received before. (Although sometimes old
                 // messages will 'echo'.)
                 // I want to replace the "highest" record with this one
                 else {
                     setOutputGood.insert(lSetNum);
                 }
             }
 
             // Here we're making sure that all the numbers in the set are larger
             // than any others
             // that we've had before for the same server (They should only ever
             // get larger.)
             //
             //            if (lLowestInSet <= lOldHighestNumber) // ERROR!!! The
             // new numbers should ALWAYS be larger than the previous ones!
             if ((lLowestInSet > 0) &&
                 (lLowestInSet <= lOldHighestNumber)) // WARNING! The new numbers
                                                      // should ALWAYS be larger
                                                      // than the previous ones!
                 // UPDATE: Unless we happen to be processing the same receipt
                 // for a second time, due to redundancy in the system (for
                 // preventing syncing errors.)
                 lReturnVal = lLowestInSet; // We return the violator (otherwise
                                            // 0 if success).
 
             // The loop has succeeded in finding the server ID and its
             // associated "highest number" value.
             //
             bFoundServerID = true;
             break;
             // This main for only ever has one active iteration: the one with
             // the right server ID. Once we find it, we break (no matter what.)
         } // server ID matches.
     }
 
     // If we found the server ID, that means the highest number was previously
     // recorded.
     // We don't want to replace it unless we were successful in this function.
     // And if we
     // were, then we want to replace it with the new "highest number in the
     // set."
     //
     // IF we found the server ID for a previously recorded highestNum, and
     // IF this function was a success in terms of the new numbers all exceeding
     // that old record,
     // THEN ERASE that old record and replace it with the new highest number.
     //
     // Hmm: Should I require ALL new numbers to be valid? Or should I take the
     // valid ones,
     // and ignore the invalid ones?
     //
     // Update: Just found this comment from the calling function:
     // NOTE: Due to the possibility that a server reply could be processed twice
     // (due to redundancy
     // for the purposes of preventing syncing issues) then we expect we might
     // get numbers in here
     // that are below our "last highest num" (due to processing the same numbers
     // twice.) Therefore
     // we don't need to assume an error in this case. UpdateHighestNum() is
     // already smart enough to
     // only update based on the good numbers, while ignoring the bad (i.e.
     // already-processed) ones.
     // Thus we really only have a problem if we receive a (-1), which would mean
     // an error occurred.
     // Also, the above call will log an FYI that it is skipping any numbers
     // below the line, so no need
     // to log more in the case of lViolater being >0 but less than the 'last
     // highest number.'
     //
     // ===> THEREFORE, we don't need an lReturnVal of 0 in order to update the
     // highest record.
     // Instead, we just need bFoundServerID to be true, and we need
     // setOutputGood to not be empty
     // (we already know the numbers in setOutputGood are higher than the last
     // highest recorded trans
     // num... that's why they are in setOutputGood instead of setOutputBad.)
     //
     if (!setOutputGood.empty()) // There's numbers worth savin'!
     {
         if (bFoundServerID) {
             otOut << "OTPseudonym::UpdateHighestNum: Raising Highest Trans "
                      "Number from " << m_mapHighTransNo[strID] << " to "
                   << lHighestInSet << ".\n";
 
             // We KNOW it's there, so we can straight-away just
             // erase it and insert it afresh..
             //
             m_mapHighTransNo.erase(strID);
             m_mapHighTransNo.insert(
                 std::pair<std::string, int64_t>(strID, lHighestInSet));
         }
 
         // If I didn't find the server in the list above (whether the list is
         // empty or not....)
         // that means the record does not yet exist. (So let's create it)--we
         // wouldn't even be
         // here unless we found valid transaction numbers and added them to
         // setOutputGood.
         // (So let's record lHighestInSet mapped to strID, just as above.)
         else {
             otOut << "OTPseudonym::UpdateHighestNum: Creating "
                      "Highest Transaction Number entry for this server as '"
                   << lHighestInSet << "'.\n";
             m_mapHighTransNo.insert(
                 std::pair<std::string, int64_t>(strID, lHighestInSet));
         }
 
         // By this point either the record was created, or we were successful
         // above in finding it
         // and updating it. Either way, it's there now and potentially needs to
         // be saved.
         //
         if (bSave) SaveSignedNymfile(SIGNER_NYM);
     }
     else // setOutputGood was completely empty in this case...
     {      // (So there's nothing worth saving.) A repeat message.
            //
            // Should I return a -1 here or something? Let's say it's
            // a redundant message...I've already harvested these numbers. So
            // they are ignored this time, my record of 'highest' is unimpacted,
         // and if I just return lReturnVal below, it will contain 0 for success
         // or a transaction number (the min/low violator) but even that is
         // considered
         // a "success" in the sense that some of the numbers would still
         // normally be
         // expected to have passed through.
         // The caller will check for -1 in case of some drastic error, but so
         // far I don't
         // see a place here for that return value.
         //
     }
 
     return lReturnVal; // Defaults to 0 (success) but above, might have been set
                        // to "lLowestInSet" (if one was below the mark.)
 }

bool opentxs::OTPseudonym::VerifyAcknowledgedNum	(	const OTString &	strServerID,
		const int64_t &	lRequestNum
	)		const

Definition at line 2562 of file OTPseudonym.cpp.

 {
     return VerifyGenericNum(m_mapAcknowledgedNum, strServerID, lRequestNum);
 }

bool opentxs::OTPseudonym::VerifyGenericNum	(	const mapOfTransNums &	THE_MAP,
		const OTString &	strServerID,
		const int64_t &	lTransNum
	)		const

Definition at line 2168 of file OTPseudonym.cpp.

 {
     std::string strID = strServerID.Get();
 
     // The Pseudonym has a deque of transaction numbers for each servers.
     // These deques are mapped by Server ID.
     //
     // So let's loop through all the deques I have, and if the server ID on the
     // map
     // matches the Server ID that was passed in, then find the transaction
     // number on
     // that list, and then return true. Else return false.
     //
     for (auto& it : THE_MAP) {
         // if the ServerID passed in matches the serverID for the current deque
         if (strID == it.first) {
             dequeOfTransNums* pDeque = (it.second);
             OT_ASSERT(nullptr != pDeque);
 
             if (!(pDeque->empty())) // there are some numbers for that server ID
             {
                 // Let's loop through them and see if the culprit is there
                 for (uint32_t i = 0; i < pDeque->size(); i++) {
                     // Found it!
                     if (lTransNum == pDeque->at(i)) {
                         return true;
                     }
                 }
             }
             break;
         }
     }
 
     return false;
 }

bool opentxs::OTPseudonym::VerifyIssuedNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)		const

Definition at line 2472 of file OTPseudonym.cpp.

 {
     return VerifyGenericNum(m_mapIssuedNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::VerifyIssuedNumbersOnNym ( OTPseudonym & THE_NYM )

See if two nyms have identical lists of issued transaction numbers (#s currently signed for.)

Definition at line 5917 of file OTPseudonym.cpp.

 {
     int64_t lTransactionNumber = 0; // Used in the loop below.
 
     int32_t nNumberOfTransactionNumbers1 = 0; // *this
     int32_t nNumberOfTransactionNumbers2 = 0; // THE_NYM.
 
     std::string strServerID;
 
     // First, loop through the Nym on my side (*this), and count how many
     // numbers total he has...
     //
     for (auto& it : GetMapIssuedNum()) {
         dequeOfTransNums* pDeque = (it.second);
         OT_ASSERT(nullptr != pDeque);
 
         if (!(pDeque->empty())) {
             nNumberOfTransactionNumbers1 +=
                 static_cast<int32_t>(pDeque->size());
         }
     } // for
 
     // Next, loop through THE_NYM, and count his numbers as well...
     // But ALSO verify that each one exists on *this, so that each individual
     // number is checked.
     //
     for (auto& it : THE_NYM.GetMapIssuedNum()) {
         strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
         OT_ASSERT(nullptr != pDeque);
 
         OTString OTstrServerID = strServerID.c_str();
 
         if (!(pDeque->empty())) {
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
 
                 //                if ()
                 {
                     nNumberOfTransactionNumbers2++;
 
                     if (false ==
                         VerifyIssuedNum(OTstrServerID, lTransactionNumber)) {
                         otOut << "OTPseudonym::" << __FUNCTION__
                               << ": Issued transaction # " << lTransactionNumber
                               << " from THE_NYM not found on *this.\n";
 
                         return false;
                     }
                 }
             }
         }
     } // for
 
     // Finally, verify that the counts match...
     if (nNumberOfTransactionNumbers1 != nNumberOfTransactionNumbers2) {
         otOut << "OTPseudonym::" << __FUNCTION__
               << ": Issued transaction # Count mismatch: "
               << nNumberOfTransactionNumbers1 << " and "
               << nNumberOfTransactionNumbers2 << "\n";
 
         return false;
     }
 
     return true;
 }

bool opentxs::OTPseudonym::VerifyPseudonym ( ) const

Definition at line 3525 of file OTPseudonym.cpp.

 {
     // If there are credentials, then we verify the Nym via his credentials.
     // Otherwise we do it the old way (using the Nym's "keypair")--which is
     // being deprecated.
     //
     if (!m_mapCredentials.empty()) {
         // Verify Nym by his own credentials.
         for (const auto& it : m_mapCredentials) {
             const OTCredential* pCredential = it.second;
             OT_ASSERT(nullptr != pCredential);
 
             const OTIdentifier theCredentialNymID(pCredential->GetNymID());
             if (!CompareID(theCredentialNymID)) {
                 OTString strNymID;
                 GetIdentifier(strNymID);
                 otOut << __FUNCTION__ << ": Credential NymID ("
                       << pCredential->GetNymID()
                       << ") doesn't match actual NymID: " << strNymID << "\n";
                 return false;
             }
 
             if (!pCredential->VerifyInternally()) {
                 otOut << __FUNCTION__ << ": Credential ("
                       << pCredential->GetMasterCredID()
                       << ") failed its own internal verification.\n";
                 return false;
             }
 
             // Warning: time-intensive. Todo optimize: load a contract here
             // which verifies authorization,
             // based on a signature from a separate process which did an
             // identity lookup externally.
             // Once that authorization times out, then the identity verification
             // server can just sign
             // another one.
             //
             if (!pCredential->VerifyAgainstSource()) // todo optimize,
                                                      // warning:
                                                      // time-intensive.
             {
                 otOut
                     << __FUNCTION__
                     << ": Credential failed against its source. Credential ID: "
                     << pCredential->GetMasterCredID()
                     << "\n"
                        "NymID: " << pCredential->GetNymID()
                     << "\nSource: " << pCredential->GetSourceForNymID() << "\n";
                 return false;
             }
         }
 
         // NOTE: m_pkeypair needs to be phased out entirely. TODO!!
         // In the meantime, ::LoadPublicKey isn't setting m_pkeypair
         // because the key isn't actually available until AFTER the
         // pCredential->VerifyInternally() has occurred. Well, right
         // here, it just occurred (above) and so we can actually set
         // m_pkeypair at this point, where we couldn't do it before in
         // LoadPublicKey.
         //
         // The real solution is to just phase out m_pkeypair entirely. TODO!
         // But in the meantime, as long as there are vestiges of the code
         // that still use it, we need to make sure it's set, and we can
         // only do that here, after VerifyInternally() has finished.
         //
         // (So that's what I'm doing.)
         //
         if (!m_pkeypair->HasPublicKey()) {
             auto it = m_mapCredentials.begin();
             OT_ASSERT(m_mapCredentials.end() != it);
             OTCredential* pCredential = it->second;
             OT_ASSERT(nullptr != pCredential);
 
             OTString strSigningKey;
 
             if (const_cast<OTKeypair&>(
                     pCredential->GetSignKeypair(&m_listRevokedIDs))
                     .GetPublicKey(strSigningKey, false)) // bEscaped
                 return m_pkeypair->SetPublicKey(strSigningKey,
                                                 false); // bEscaped
             else
                 otErr << __FUNCTION__ << ": Failed in call to "
                                          "pCredential->GetPublicSignKey()."
                                          "GetPublicKey()\n";
         }
 
         return true;
 
     }    // If there are credentials
     else // Deprecated. OTPseudonym::m_pkeypair was used for encryption,
          // signing, and authentication.
     { // (Replaced by the above block, which has a map of credentials for each
         // Nym, with each
         // credential having a master key and a set of subcredentials including
         // subkeys.
         //
         OT_ASSERT(nullptr != m_pkeypair);
 
         OTString strPublicKey;
         bool bGotPublicKey = m_pkeypair->GetPublicKey(strPublicKey);
 
         if (!bGotPublicKey) {
             otErr << "Error getting public key in "
                      "OTPseudonym::VerifyPseudonym.\n";
             return false;
         }
 
         OTIdentifier newID;
         bool bSuccessCalculateDigest = newID.CalculateDigest(strPublicKey);
 
         if (!bSuccessCalculateDigest) {
             otErr << "Error calculating pubkey digest.\n";
             return false;
         }
 
         // newID now contains the Hash aka Message Digest aka Fingerprint aka
         // "IDENTIFIER"
         // of the public key (in its text form, with escaped bookends.)
         //
         // Now let's compare that identifier to the one already loaded by the
         // wallet
         // and make sure they MATCH.
 
         if (m_nymID != newID) {
             OTString str1(m_nymID), str2(newID);
             otErr << "\nHashes do NOT match in OTPseudonym::VerifyPseudonym!\n"
                   << str1 << "\n" << str2 << "\n";
 
             return false;
         }
         else {
             //        OTString str2(newID);
             //        otWarn << "\nNymID from wallet *SUCCESSFUL* match to hash
             // of Nym\'s public key:\n%s\n"
             //                "---------------------------------------------------------------\n",
             // str2.Get());
             return true;
         }
     }
 }

bool opentxs::OTPseudonym::VerifyTentativeNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)		const

Definition at line 2512 of file OTPseudonym.cpp.

 {
     return VerifyGenericNum(m_mapTentativeNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::VerifyTransactionNum	(	const OTString &	strServerID,
		const int64_t &	lTransNum
	)		const

Definition at line 2430 of file OTPseudonym.cpp.

 {
     return VerifyGenericNum(m_mapTransNum, strServerID, lTransNum);
 }

bool opentxs::OTPseudonym::VerifyTransactionStatementNumbersOnNym ( OTPseudonym & THE_NYM )

Definition at line 6003 of file OTPseudonym.cpp.

 {
     int64_t lTransactionNumber = 0; // Used in the loop below.
 
     std::string strServerID;
 
     // First, loop through the Nym on my side (*this), and verify that all those
     // #s appear on the last receipt (THE_NYM)
     //
     for (auto& it : GetMapIssuedNum()) {
         strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
 
         OTString OTstrServerID = strServerID.c_str();
 
         OT_ASSERT(nullptr != pDeque);
 
         if (!(pDeque->empty())) {
             for (uint32_t i = 0; i < pDeque->size(); i++) {
                 lTransactionNumber = pDeque->at(i);
 
                 if (false ==
                     THE_NYM.VerifyIssuedNum(OTstrServerID,
                                             lTransactionNumber)) {
                     otOut << "OTPseudonym::" << __FUNCTION__
                           << ": Issued transaction # " << lTransactionNumber
                           << " from *this not found on THE_NYM.\n";
                     return false;
                 }
             }
         }
     } // for
 
     // Getting here means that, though issued numbers may have been removed from
     // my responsibility
     // in a subsequent balance agreement (since the transaction agreement was
     // signed), I know
     // for a fact that no numbers have been ADDED to my list of responsibility.
     // That's the most we can verify here, since we don't know the account
     // number that was
     // used for the last balance agreement.
 
     return true;
 }

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

/usr/local/src/opentxs/include/opentxs/core/OTPseudonym.hpp
/usr/local/src/opentxs/src/core/OTPseudonym.cpp

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation