#include <Purse.hpp>

Inheritance diagram for opentxs::Purse:

Collaboration diagram for opentxs::Purse:

Public Member Functions
virtual int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

EXPORT bool	GenerateInternalKey ()

EXPORT OTSymmetricKey *	GetInternalKey ()

EXPORT std::shared_ptr < OTCachedKey >	GetInternalMaster ()

EXPORT bool	GetPassphrase (OTPassword &theOutput, const char *szDisplay=nullptr)

EXPORT bool	IsNymIDIncluded () const

EXPORT bool	IsPasswordProtected () const

EXPORT bool	GetNymID (OTIdentifier &theOutput) const

EXPORT bool	Push (OTNym_or_SymmetricKey theOwner, const Token &theToken)

EXPORT Token *	Pop (OTNym_or_SymmetricKey theOwner)

EXPORT Token *	Peek (OTNym_or_SymmetricKey theOwner) const

EXPORT int32_t	Count () const

EXPORT bool	IsEmpty () const

int64_t	GetTotalValue () const

EXPORT time64_t	GetLatestValidFrom () const

EXPORT time64_t	GetEarliestValidTo () const

EXPORT bool	VerifyCurrentDate ()

EXPORT bool	IsExpired ()

EXPORT bool	Merge (const OTPseudonym &theSigner, OTNym_or_SymmetricKey theOldNym, OTNym_or_SymmetricKey theNewNym, Purse &theNewPurse)

EXPORT	Purse (const Purse &thePurse)

EXPORT	Purse (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

EXPORT	Purse (const OTIdentifier &SERVER_ID)

EXPORT	Purse (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &USER_ID)

virtual EXPORT	~Purse ()

EXPORT bool	LoadPurse (const char szServerID=nullptr, const char szUserID=nullptr, const char *szAssetTypeID=nullptr)

EXPORT bool	SavePurse (const char szServerID=nullptr, const char szUserID=nullptr, const char *szAssetTypeID=nullptr)

virtual bool	LoadContract ()

const OTIdentifier &	GetServerID () const

const OTIdentifier &	GetAssetID () const

EXPORT void	InitPurse ()

virtual void	Release ()

EXPORT void	Release_Purse ()

EXPORT void	ReleaseTokens ()

virtual bool	SaveContractWallet (std::ofstream &ofs) const

Public Member Functions inherited from opentxs::OTContract
const char *	GetHashType () const

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

EXPORT	OTContract (const OTString &name, const OTString &foldername, const OTString &filename, const OTString &strID)

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

virtual EXPORT bool	CreateContract (const OTString &strContract, const OTPseudonym &theSigner)

EXPORT bool	InsertNym (const OTString &strKeyName, const OTString &strKeyValue)

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT bool	VerifyContract ()

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

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

EXPORT bool	LoadContractFromString (const OTString &theStr)

bool	LoadContractRawFile ()

EXPORT bool	ParseRawFile ()

EXPORT bool	SaveToContractFolder ()

EXPORT bool	SaveContractRaw (OTString &strOutput) const

EXPORT bool	RewriteContract (OTString &strOutput) const

EXPORT bool	SaveContract ()

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

virtual EXPORT void	CreateContents ()

EXPORT void	CreateInnerContents ()

virtual EXPORT bool	SaveContents (std::ofstream &ofs) const

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

virtual EXPORT bool	DisplayStatistics (OTString &strContents) const

virtual EXPORT bool	SaveContents (OTString &strContents) const

virtual EXPORT bool	SignContract (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTAsymmetricKey &theKey, OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const char szFoldername, const char szFilename, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

virtual EXPORT bool	VerifyContractID () const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

virtual EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

virtual EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifyWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTAsymmetricKey &theKey, const OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const char szFoldername, const char szFilename, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT const OTAsymmetricKey *	GetContractPublicKey () const

EXPORT const OTPseudonym *	GetContractPublicNym () const

Static Public Member Functions
static EXPORT Purse *	PurseFactory (OTString strInput)

static EXPORT Purse *	PurseFactory (OTString strInput, const OTIdentifier &SERVER_ID)

static EXPORT Purse *	PurseFactory (OTString strInput, const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

static EXPORT Purse *	LowLevelInstantiate (const OTString &strFirstLine)

static EXPORT Purse *	LowLevelInstantiate (const OTString &strFirstLine, const OTIdentifier &SERVER_ID)

static EXPORT Purse *	LowLevelInstantiate (const OTString &strFirstLine, const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

Static Public Member Functions inherited from opentxs::OTContract
static EXPORT bool	DearmorAndTrim (const OTString &strInput, OTString &strOutput, OTString &strFirstLine)

static bool	AddBookendsAroundContent (OTString &strOutput, const OTString &strContents, const OTString &strContractType, const OTString &strHashType, const listOfSignatures &listSignatures)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTASCIIArmor &ascOutput)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTString &strOutput)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTASCIIArmor &ascOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTString &strOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	SkipToElement (irr::io::IrrXMLReader *&xml)

static bool	SkipToTextField (irr::io::IrrXMLReader *&xml)

static bool	SkipAfterLoadingField (irr::io::IrrXMLReader *&xml)

static EXPORT bool	SignFlatText (OTString &strFlatText, const OTString &strContractType, const OTPseudonym &theSigner, OTString &strOutput)

Protected Member Functions
virtual void	UpdateContents ()

void	RecalculateExpirationDates (OTNym_or_SymmetricKey &theOwner)

	Purse ()

Protected Member Functions inherited from opentxs::OTContract
bool	LoadContractXML ()

Protected Attributes
dequeOfTokens	m_dequeTokens

OTIdentifier	m_UserID

OTIdentifier	m_ServerID

OTIdentifier	m_AssetID

int64_t	m_lTotalValue

bool	m_bPasswordProtected

bool	m_bIsNymIDIncluded

OTSymmetricKey *	m_pSymmetricKey

std::shared_ptr< OTCachedKey >	m_pCachedKey

time64_t	m_tLatestValidFrom

time64_t	m_tEarliestValidTo

Protected Attributes inherited from opentxs::OTContract
OTString	m_strName

OTString	m_strFoldername

OTString	m_strFilename

OTIdentifier	m_ID

OTStringXML	m_xmlUnsigned

OTString	m_strRawFile

OTString	m_strSigHashType

OTString	m_strContractType

mapOfNyms	m_mapNyms

listOfSignatures	m_listSignatures

OTString	m_strVersion

OTString	m_strEntityShortName

OTString	m_strEntityLongName

OTString	m_strEntityEmail

OTString::Map	m_mapConditions

Detailed Description

Definition at line 172 of file Purse.hpp.

Constructor & Destructor Documentation

opentxs::Purse::Purse ( )

protected

Definition at line 696 of file Purse.cpp.

     : ot_super()
     ,
     //    m_ServerID(),
     //    m_AssetID(),
     m_lTotalValue(0)
     , m_bPasswordProtected(false)
     , m_bIsNymIDIncluded(false)
     , m_pSymmetricKey(nullptr)
     , m_tLatestValidFrom(OT_TIME_ZERO)
     , m_tEarliestValidTo(OT_TIME_ZERO)
 {
     InitPurse();
 }

opentxs::Purse::Purse ( const Purse & thePurse )

Definition at line 711 of file Purse.cpp.

     : ot_super()
     , m_UserID()
     , m_ServerID(thePurse.GetServerID())
     , m_AssetID(thePurse.GetAssetID())
     , m_lTotalValue(0)
     , m_bPasswordProtected(false)
     , m_bIsNymIDIncluded(false)
     , m_pSymmetricKey(nullptr)
     , m_tLatestValidFrom(OT_TIME_ZERO)
     , m_tEarliestValidTo(OT_TIME_ZERO)
 {
     InitPurse();
 }

opentxs::Purse::Purse	(	const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID
	)

Definition at line 742 of file Purse.cpp.

     : ot_super()
     , m_ServerID(SERVER_ID)
     , m_AssetID(ASSET_ID)
     , m_lTotalValue(0)
     , m_bPasswordProtected(false)
     , m_bIsNymIDIncluded(false)
     , m_pSymmetricKey(nullptr)
     , m_tLatestValidFrom(OT_TIME_ZERO)
     , m_tEarliestValidTo(OT_TIME_ZERO)
 {
     InitPurse();
 }

opentxs::Purse::Purse ( const OTIdentifier & SERVER_ID )

Definition at line 729 of file Purse.cpp.

     : ot_super()
     , m_ServerID(SERVER_ID)
     , m_lTotalValue(0)
     , m_bPasswordProtected(false)
     , m_bIsNymIDIncluded(false)
     , m_pSymmetricKey(nullptr)
     , m_tLatestValidFrom(OT_TIME_ZERO)
     , m_tEarliestValidTo(OT_TIME_ZERO)
 {
     InitPurse();
 }

opentxs::Purse::Purse	(	const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID,
		const OTIdentifier &	USER_ID
	)

Definition at line 756 of file Purse.cpp.

     : ot_super()
     , m_UserID(USER_ID)
     , m_ServerID(SERVER_ID)
     , m_AssetID(ASSET_ID)
     , m_lTotalValue(0)
     , m_bPasswordProtected(false)
     , m_bIsNymIDIncluded(false)
     , m_pSymmetricKey(nullptr)
     , m_tLatestValidFrom(OT_TIME_ZERO)
     , m_tEarliestValidTo(OT_TIME_ZERO)
 {
     InitPurse();
 }

opentxs::Purse::~Purse ( )

virtual

Definition at line 782 of file Purse.cpp.

 {
     Release_Purse();
 }

Member Function Documentation

int32_t opentxs::Purse::Count ( ) const

Definition at line 1641 of file Purse.cpp.

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

bool opentxs::Purse::GenerateInternalKey ( )

Definition at line 257 of file Purse.cpp.

 {
     if (IsPasswordProtected() ||
         (nullptr != m_pSymmetricKey) || // GetInternalKey())
         (m_pCachedKey)) {
         otOut << __FUNCTION__
               << ": Failed: internal Key  or master key already exists. "
                  "Or IsPasswordProtected was true.\n";
         return false;
     }
 
     if (!IsEmpty()) {
         otOut << __FUNCTION__
               << ": Failed: The purse must be EMPTY before you create a "
                  "new symmetric key, internal to that purse. (For the purposes "
                  "of "
                  "adding a passphrase to the purse, normally.) Otherwise I "
                  "would have "
                  "to loop through all the tokens and re-assign ownership of "
                  "each one. "
                  "Instead, I'm just going to return false. That's easier.\n";
         return false;
     }
 
     //  OTSymmetricKey *   m_pSymmetricKey;    // If this purse contains its own
     // symmetric key (instead of using an owner Nym)...
     //  OTCachedKey    *   m_pCachedKey;       // ...then it will have a master
     // key as well, for unlocking that symmetric key, and managing timeouts.
 
     // m_pSymmetricKey and m_pCachedKey are both explicitly checked for nullptr
     // (above.)
     // Therefore we have to instantiate them both now.
     //
     // We'll do the Master key first, since we need the passphrase from that, in
     // order to
     // create the symmetric key.
     //
     OTPassword thePassphrase;
     const OTString strDisplay(
         "Enter the new passphrase for this new password-protected "
         "purse."); // todo internationalization / hardcoding.
 
     // thePassphrase and m_pCachedKey are BOTH output from the below function.
     //
     m_pCachedKey = OTCachedKey::CreateMasterPassword(
         thePassphrase,
         strDisplay.Get()); // int32_t nTimeoutSeconds=OT_MASTER_KEY_TIMEOUT)
 
     if ((!m_pCachedKey) || !m_pCachedKey->IsGenerated()) // This one is
                                                          // unnecessary because
                                                          // CreateMasterPassword
                                                          // already checks it.
                                                          // todo optimize.
     {
         otOut << __FUNCTION__
               << ": Failed: While calling OTCachedKey::CreateMasterPassword.\n";
         return false;
     }
 
     m_pSymmetricKey =
         new OTSymmetricKey(thePassphrase); // Creates the symmetric key here
                                            // based on the passphrase from
                                            // purse's master key.
     OT_ASSERT(nullptr != m_pSymmetricKey);
 
     if (!m_pSymmetricKey->IsGenerated()) {
         otOut << __FUNCTION__ << ": Failed: generating m_pSymmetricKey.\n";
         delete m_pSymmetricKey;
         m_pSymmetricKey = nullptr;
         m_pCachedKey.reset();
         return false;
     }
 
     m_UserID.Release();
     m_bIsNymIDIncluded = false;
 
     otWarn << __FUNCTION__
            << ": Successfully created a purse's internal key.\n";
 
     m_bPasswordProtected = true;
 
     std::shared_ptr<OTCachedKey> pCachedMaster(Purse::GetInternalMaster());
     if (!pCachedMaster)
         otErr << __FUNCTION__
               << ": Failed trying to cache the master key for this purse.\n";
 
     return true;
 }

const OTIdentifier& opentxs::Purse::GetAssetID ( ) const

inline

Definition at line 335 of file Purse.hpp.

     {
         return m_AssetID;
     }

time64_t opentxs::Purse::GetEarliestValidTo ( ) const

Definition at line 1375 of file Purse.cpp.

 {
     return m_tEarliestValidTo;
 }

EXPORT OTSymmetricKey* opentxs::Purse::GetInternalKey ( )

inline

Definition at line 252 of file Purse.hpp.

     {
         return m_pSymmetricKey;
     } // symmetric key for this purse.

std::shared_ptr< OTCachedKey > opentxs::Purse::GetInternalMaster ( )

Definition at line 207 of file Purse.cpp.

 {
 
     if (!IsPasswordProtected() ||
         (!m_pCachedKey)) // this second half of the logic should never happen.
     {
         otOut << __FUNCTION__
               << ": Failed: no internal master key exists, in this purse.\n";
         return std::shared_ptr<OTCachedKey>();
     }
 
     if (!m_pCachedKey->IsGenerated()) // should never happen, since the purse IS
                                       // password-protected... then where's the
                                       // master key?
     {
         otOut << __FUNCTION__
               << ": Error: internal master key has not yet been generated.\n";
         return std::shared_ptr<OTCachedKey>();
     }
 
     // By this point we know the purse is password protected, the internal
     // master key
     // exists (not nullptr) and it's been properly generated, so we won't be
     // inadvertantly sticking
     // a copy of it on the CachedKey map indexed to some nonexistent ID for an
     // ungenerated key.
     // The caller will be forced to make sure the master key is real and
     // generated, before passing
     // it in here where it could get copied.
     //
     // Why is that important? BECAUSE THE COPY is all the caller will ever
     // actually use! So if it's
     // not ENTIRELY loaded up properly BEFORE it's copied, the caller will never
     // see the properly
     // loaded version of that master key.
     //
     return OTCachedKey::It(*m_pCachedKey); // here we return a cached copy of
                                            // the master key (so it's available
                                            // between instances of this purse.)
 }

time64_t opentxs::Purse::GetLatestValidFrom ( ) const

Definition at line 1370 of file Purse.cpp.

 {
     return m_tLatestValidFrom;
 }

bool opentxs::Purse::GetNymID ( OTIdentifier & theOutput ) const

Definition at line 154 of file Purse.cpp.

 {
     bool bSuccess = false;
     theOutput.Release();
 
     if (IsPasswordProtected()) {
         bSuccess = false; // optimizer will remove automatically anyway, I
                           // assume. Might as well have it here for clarity.
     }
     else if (IsNymIDIncluded() && !m_UserID.IsEmpty()) {
         bSuccess = true;
         theOutput = m_UserID;
     }
     else if (!m_UserID.IsEmpty()) {
         bSuccess = true;
         theOutput = m_UserID;
     }
 
     return bSuccess;
 }

bool opentxs::Purse::GetPassphrase	(	OTPassword &	theOutput,
		const char *	szDisplay = `nullptr`
	)

Definition at line 179 of file Purse.cpp.

 {
     const char* szFunc = "Purse::GetPassphrase";
 
     if (!IsPasswordProtected()) {
         otOut << szFunc
               << ": Failed: this purse isn't even password-protected.\n";
         return false;
     }
 
     std::shared_ptr<OTCachedKey> pCachedKey(GetInternalMaster());
     if (!pCachedKey) OT_FAIL;
 
     const OTString strReason((nullptr == szDisplay) ? szFunc : szDisplay);
 
     const bool bGotMasterPassword = pCachedKey->GetMasterPassword(
         pCachedKey, theOutput, strReason.Get()); // bVerifyTwice=false
     return bGotMasterPassword;
 }

const OTIdentifier& opentxs::Purse::GetServerID ( ) const

inline

Definition at line 331 of file Purse.hpp.

     {
         return m_ServerID;
     }

int64_t opentxs::Purse::GetTotalValue ( ) const

inline

Definition at line 292 of file Purse.hpp.

     {
         return m_lTotalValue;
     }

void opentxs::Purse::InitPurse ( )

Definition at line 772 of file Purse.cpp.

 {
     m_strContractType.Set("PURSE");
 
     m_lTotalValue = 0;
 
     m_bPasswordProtected = false;
     m_bIsNymIDIncluded = false;
 }

bool opentxs::Purse::IsEmpty ( ) const

Definition at line 1646 of file Purse.cpp.

 {
     return m_dequeTokens.empty();
 }

bool opentxs::Purse::IsExpired ( )

Definition at line 1387 of file Purse.cpp.

 {
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     // If the current time is AFTER the valid-TO date,
     // AND the valid_to is a nonzero number (0 means "doesn't expire")
     // THEN return true (it's expired.)
     //
     if ((CURRENT_TIME >= m_tEarliestValidTo) &&
         (m_tEarliestValidTo > OT_TIME_ZERO))
         return true;
     else
         return false;
 }

EXPORT bool opentxs::Purse::IsNymIDIncluded ( ) const

inline

Definition at line 268 of file Purse.hpp.

     {
         return m_bIsNymIDIncluded;
     } // NymID may be left blank, with user left guessing.

EXPORT bool opentxs::Purse::IsPasswordProtected ( ) const

inline

Definition at line 272 of file Purse.hpp.

     {
         return m_bPasswordProtected;
     }

bool opentxs::Purse::LoadContract ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 827 of file Purse.cpp.

 {
     return LoadPurse();
 }

bool opentxs::Purse::LoadPurse	(	const char *	szServerID = `nullptr`,
		const char *	szUserID = `nullptr`,
		const char *	szAssetTypeID = `nullptr`
	)

Definition at line 832 of file Purse.cpp.

 {
     OT_ASSERT(!IsPasswordProtected());
 
     if (!m_strFoldername.Exists())
         m_strFoldername.Set(OTFolders::Purse().Get());
 
     OTString strServerID(m_ServerID), strUserID(m_UserID),
         strAssetTypeID(m_AssetID);
 
     if (nullptr != szServerID) strServerID = szServerID;
     if (nullptr != szUserID) strUserID = szUserID;
     if (nullptr != szAssetTypeID) strAssetTypeID = szAssetTypeID;
 
     if (!m_strFilename.Exists()) {
         m_strFilename.Format("%s%s%s%s%s", strServerID.Get(),
                              OTLog::PathSeparator(), strUserID.Get(),
                              OTLog::PathSeparator(), strAssetTypeID.Get());
     }
 
     const char* szFolder1name = OTFolders::Purse().Get(); // purse
     const char* szFolder2name = strServerID.Get();        // purse/SERVER_ID
     const char* szFolder3name = strUserID.Get(); // purse/SERVER_ID/USER_ID
     const char* szFilename =
         strAssetTypeID.Get(); // purse/SERVER_ID/USER_ID/ASSET_TYPE_ID
 
     if (false ==
         OTDB::Exists(szFolder1name, szFolder2name, szFolder3name, szFilename)) {
         otInfo << "Purse::LoadPurse: File does not exist: " << szFolder1name
                << OTLog::PathSeparator() << szFolder2name
                << OTLog::PathSeparator() << szFolder3name
                << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     std::string strFileContents(
         OTDB::QueryPlainString(szFolder1name, szFolder2name, szFolder3name,
                                szFilename)); // <=== LOADING FROM DATA STORE.
 
     if (strFileContents.length() < 2) {
         otErr << "Purse::LoadPurse: Error reading file: " << szFolder1name
               << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFolder3name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     // NOTE: No need here to deal with OT ARMORED file format, since
     // LoadContractFromString
     // already handles it internally.
 
     OTString strRawFile(strFileContents.c_str());
 
     return LoadContractFromString(strRawFile);
 }

Purse * opentxs::Purse::LowLevelInstantiate ( const OTString & strFirstLine )

static

Definition at line 566 of file Purse.cpp.

 {
     Purse* pPurse = nullptr;
     if (strFirstLine.Contains("-----BEGIN SIGNED PURSE-----")) // this string is
                                                                // 28 chars long.
                                                                // todo
                                                                // hardcoding.
     {
         pPurse = new Purse();
         OT_ASSERT(nullptr != pPurse);
     }
     return pPurse;
 }

Purse * opentxs::Purse::LowLevelInstantiate	(	const OTString &	strFirstLine,
		const OTIdentifier &	SERVER_ID
	)

static

Definition at line 551 of file Purse.cpp.

 {
     Purse* pPurse = nullptr;
     if (strFirstLine.Contains("-----BEGIN SIGNED PURSE-----")) // this string is
                                                                // 28 chars long.
                                                                // todo
                                                                // hardcoding.
     {
         pPurse = new Purse(SERVER_ID);
         OT_ASSERT(nullptr != pPurse);
     }
     return pPurse;
 }

Purse * opentxs::Purse::LowLevelInstantiate	(	const OTString &	strFirstLine,
		const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID
	)

static

Definition at line 535 of file Purse.cpp.

 {
     Purse* pPurse = nullptr;
     if (strFirstLine.Contains("-----BEGIN SIGNED PURSE-----")) // this string is
                                                                // 28 chars long.
                                                                // todo
                                                                // hardcoding.
     {
         pPurse = new Purse(SERVER_ID, ASSET_ID);
         OT_ASSERT(nullptr != pPurse);
     }
     return pPurse;
 }

bool opentxs::Purse::Merge	(	const OTPseudonym &	theSigner,
		OTNym_or_SymmetricKey	theOldNym,
		OTNym_or_SymmetricKey	theNewNym,
		Purse &	theNewPurse
	)

Definition at line 349 of file Purse.cpp.

 {
     const char* szFunc = "Purse::Merge";
 
     mapOfTokenPointers theMap;
 
     while (Count() > 0) {
         Token* pToken = Pop(theOldNym); // must be private, if a Nym.
         OT_ASSERT_MSG(nullptr != pToken,
                       "Purse::Merge: Assert: nullptr != Pop(theOldNym) \n");
 
         const OTASCIIArmor& ascTokenID = pToken->GetSpendable();
 
         std::list<mapOfTokenPointers::iterator> listOfTokenMapIterators;
 
         // I just popped a Token off of *this. Let's see if it's in my temporary
         // map...
         // If it's already there, then just delete it (duplicate).
         //
         for (auto it(theMap.begin()); it != theMap.end(); ++it) {
             Token* pTempToken = it->second;
             OT_ASSERT(nullptr != pTempToken);
 
             const OTASCIIArmor& ascTempTokenID = pTempToken->GetSpendable();
 
             // It's already there. Delete the one that's already there.
             // (That way we can add it after, whether it was there originally or
             // not.)
             if (ascTempTokenID == ascTokenID) {
                 listOfTokenMapIterators.push_back(it);
                 //                theMap.erase(it);
                 //                delete pTempToken;
                 //              pTempToken = nullptr;
                 // break; // In case there are multiple duplicates, not just
                 // one.
             }
         }
         while (!listOfTokenMapIterators.empty()) {
             Token* pTempToken = (listOfTokenMapIterators.back())->second;
             theMap.erase(listOfTokenMapIterators.back());
             delete pTempToken;
             pTempToken = nullptr;
             listOfTokenMapIterators.pop_back();
         }
 
         // Now we know there aren't any duplicates on the temporary map, let's
         // add the token to it.
         std::string theKey = ascTokenID.Get();
         theMap.insert(std::pair<std::string, Token*>(theKey, pToken));
     }
     // At this point, all of the tokens on *this have been popped, and added
     // to the temporary map as token pointers, with any duplicates removed.
 
     // Basically now I just want to do the exact same thing with the other
     // purse...
     //
     while (theNewPurse.Count() > 0) {
         Token* pToken = theNewPurse.Pop(theNewNym);
         OT_ASSERT_MSG(
             nullptr != pToken,
             "Purse::Merge: Assert: nullptr != theNewPurse.Pop(theNewNym) \n");
 
         const OTASCIIArmor& ascTokenID = pToken->GetSpendable();
 
         std::list<mapOfTokenPointers::iterator> listOfTokenMapIterators;
 
         // I just popped a Token off of theNewPurse. Let's see if it's in my
         // temporary map...
         // If it's already there, then just delete it (it's a duplicate.)
         for (auto it(theMap.begin()); it != theMap.end(); ++it) {
             Token* pTempToken = it->second;
             OT_ASSERT(nullptr != pTempToken);
 
             const OTASCIIArmor& ascTempTokenID = pTempToken->GetSpendable();
 
             // It's already there. Delete the one that's already there.
             // (That way we can add it after, whether it was there originally or
             // not.)
             if (ascTempTokenID == ascTokenID) {
                 listOfTokenMapIterators.push_back(it);
                 //                theMap.erase(it);
                 //                delete pTempToken;
                 //              pTempToken = nullptr;
                 // break; // In case there are multiple duplicates, not just
                 // one.
             }
         }
         while (!listOfTokenMapIterators.empty()) {
             Token* pTempToken = (listOfTokenMapIterators.back())->second;
             theMap.erase(listOfTokenMapIterators.back());
             delete pTempToken;
             pTempToken = nullptr;
             listOfTokenMapIterators.pop_back();
         }
         // Now we KNOW there aren't any duplicates on the temporary map, so
         // let's
         // add the token to it...
         //
         std::string theKey = ascTokenID.Get();
         theMap.insert(std::pair<std::string, Token*>(theKey, pToken));
 
         //
         // SINCE THE new purse is being MERGED into the old purse, we don't have
         // to re-assign ownership
         // of any of the old tokens. But we DO need to re-assign ownership of
         // the NEW tokens that are being
         // merged in. We reassign them from New ==> TO OLD. (And we only bother
         // if they aren't the same Nym.)
         //
         //      if (!theNewNym.CompareID(theOldNym)) // Not the same
         // Nym!!
         //
         // UPDATE: the above line was moved INSIDE OTToken::ReassignOwnership,
         // FYI.
         //
         if (false ==
             pToken->ReassignOwnership(theNewNym,  // must be private, if a Nym.
                                       theOldNym)) // can be public, if a Nym.
         {
             otErr << szFunc << ": Error: Failed while attempting to re-assign "
                                "ownership of token during purse merge.\n";
         }
         else {
             otWarn << szFunc << ": FYI: Success re-assigning ownership of "
                                 "token during purse merge.\n";
 
             pToken->ReleaseSignatures();
             pToken->SignContract(theSigner);
             pToken->SaveContract();
         }
     }
 
     // At this point, all of the tokens on *this (old purse) AND theNewPurse
     // have been popped, and added
     // to the temporary map as token pointers, with any duplicates removed.
     // Also, the tokens on the New Purse have been reassigned (from theNewNym as
     // owner, to theOldNym as
     // owner) and each has been signed and saved properly, using the old Nym.
 
     // Next, we loop through theMap, and Push ALL of those tokens back onto
     // *this. (The old purse.)
 
     bool bSuccess = true;
 
     for (auto& it : theMap) {
         Token* pToken = it.second;
         OT_ASSERT(nullptr != pToken);
 
         bool bPush = Push(theOldNym, // can be public, if a Nym.
                           *pToken);  // The purse makes it's own copy of
                                      // the token, into string form.
 
         if (!bPush) {
             otErr << szFunc << ": Error: Failure pushing token into purse.\n";
             bSuccess = false;
         }
         // Notice we don't break here if 1 token fails -- we loop through them
         // all.
         // Maybe shouldn't? Seems right somehow.
     }
 
     // Next I clean up all the tokens out of the temporary map, since they will
     // leak otherwise.
     //
     while (!theMap.empty()) {
         Token* pToken = theMap.begin()->second;
         OT_ASSERT(nullptr != pToken);
 
         delete pToken;
         pToken = nullptr;
 
         theMap.erase(theMap.begin());
     }
 
     // Note: Caller needs to re-sign and re-save this purse, since we aren't
     // doing it
     // internally here.
 
     return bSuccess;
 }

Token * opentxs::Purse::Peek ( OTNym_or_SymmetricKey theOwner ) const

Definition at line 1419 of file Purse.cpp.

 {
     if (m_dequeTokens.empty()) return nullptr;
 
     // Grab a pointer to the first armored token on the deque.
     //
     const OTASCIIArmor* pArmor = m_dequeTokens.front();
     // ---------------
     // Copy the token contents into an Envelope.
     OTEnvelope theEnvelope(*pArmor);
 
     // Open the envelope into a string.
     //
     OTString strToken;
     const OTString strDisplay(__FUNCTION__); // this is the passphrase string
                                              // that will display if theOwner
                                              // doesn't have one already.
 
     const bool bSuccess =
         theOwner.Open_or_Decrypt(theEnvelope, strToken, &strDisplay);
 
     if (bSuccess) {
         // Create a new token with the same server and asset IDs as this purse.
         Token* pToken = Token::TokenFactory(strToken, *this);
         OT_ASSERT(nullptr != pToken);
 
         if (pToken->GetAssetID() != m_AssetID ||
             pToken->GetServerID() != m_ServerID) {
             delete pToken;
             pToken = nullptr;
 
             otErr << __FUNCTION__
                   << ": ERROR: Cash token with wrong server or asset type.\n";
         }
         else {
             // CALLER is responsible to delete this token.
             return pToken;
         }
     }
     else
         otErr << __FUNCTION__ << ": Failure: theOwner.Open_or_Decrypt.\n";
 
     return nullptr;
 }

Token * opentxs::Purse::Pop ( OTNym_or_SymmetricKey theOwner )

Definition at line 1473 of file Purse.cpp.

 {
     if (m_dequeTokens.empty()) return nullptr;
 
     Token* pToken = Peek(theOwner);
 
     if (nullptr == pToken) {
         otErr << __FUNCTION__ << ": Failure: Peek(theOwner) "
                                  "(And m_dequeTokens isn't empty, either.)\n";
         return nullptr;
     }
 
     // Grab a pointer to the ascii-armored token, and remove it from the deque.
     // (And delete it.)
     //
     OTASCIIArmor* pArmor = m_dequeTokens.front();
     m_dequeTokens.pop_front();
     delete pArmor;
     pArmor = nullptr;
 
     // We keep track of the purse's total value.
     m_lTotalValue -= pToken->GetDenomination();
 
     // We keep track of the purse's expiration dates, based on the tokens
     // within.
     //
     //    OT_ASSERT(pToken->GetValidFrom() <= m_tLatestValidFrom); // If the
     // token's was larger, then the purse's should match it already.
     //    OT_ASSERT(pToken->GetValidTo()   >= m_tEarliestValidTo); // If the
     // token's was smaller, then the purse's should match it already.
 
     // NOTE: the above asserts were commented out because the below call to
     // RecalculateExpirationDates
     // was commented out (because without recalculating those dates when tokens
     // are removed, these asserts
     // would get triggered.)
 
     if ((pToken->GetValidFrom() == m_tLatestValidFrom) ||
         (pToken->GetValidTo() == m_tEarliestValidTo)) {
         //      RecalculateExpirationDates(theOwner);
     }
 
     // CALLER is responsible to delete this token.
     return pToken;
 }

int32_t opentxs::Purse::ProcessXMLNode ( irr::io::IrrXMLReader *& xml )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 1063 of file Purse.cpp.

 {
     const char* szFunc = "Purse::ProcessXMLNode";
 
     const OTString strNodeName(xml->getNodeName());
 
     if (strNodeName.Compare("purse")) {
         m_strVersion = xml->getAttributeValue("version");
 
         const OTString strTotalValue = xml->getAttributeValue("totalValue");
 
         if (strTotalValue.Exists() && (atol(strTotalValue.Get()) > 0))
             m_lTotalValue = atol(strTotalValue.Get());
         else
             m_lTotalValue = 0;
 
         const OTString str_valid_from = xml->getAttributeValue("validFrom");
         const OTString str_valid_to = xml->getAttributeValue("validTo");
 
         if (str_valid_from.Exists()) {
             int64_t lValidFrom = str_valid_from.ToLong();
 
             m_tLatestValidFrom = OTTimeGetTimeFromSeconds(lValidFrom);
         }
         if (str_valid_to.Exists()) {
             int64_t lValidTo = str_valid_to.ToLong();
 
             m_tEarliestValidTo = OTTimeGetTimeFromSeconds(lValidTo);
         }
 
         const OTString strPasswdProtected =
             xml->getAttributeValue("isPasswordProtected");
         m_bPasswordProtected = strPasswdProtected.Compare("true");
 
         const OTString strNymIDIncluded =
             xml->getAttributeValue("isNymIDIncluded");
         m_bIsNymIDIncluded = strNymIDIncluded.Compare("true");
 
         // TODO security: Might want to verify the server ID here, if it's
         // already set.
         // Just to make sure it's the one we were expecting.
         const OTString strServerID = xml->getAttributeValue("serverID");
         if (strServerID.Exists())
             m_ServerID.SetString(strServerID);
         else {
             m_ServerID.Release();
             otErr << szFunc
                   << ": Failed loading serverID, when one was expected.\n";
             return (-1);
         }
 
         // TODO security: Might want to verify the asset ID here, if it's
         // already set.
         // Just to make sure it's the one we were expecting.
         const OTString strAssetTypeID = xml->getAttributeValue("assetTypeID");
         if (strAssetTypeID.Exists())
             m_AssetID.SetString(strAssetTypeID);
         else {
             m_AssetID.Release();
             otErr << szFunc
                   << ": Failed loading assetTypeID, when one was expected.\n";
             return (-1);
         }
 
         const OTString strUserID =
             xml->getAttributeValue("userID"); // (May not exist.)
         if (m_bIsNymIDIncluded) // Nym ID **is** included.  (It's optional. Even
                                 // if you use one, you don't have to list it.)
         {
             if (strUserID.Exists())
                 m_UserID.SetString(strUserID);
             else {
                 otErr << szFunc
                       << ": Failed loading userID, when one was expected. "
                          "(isNymIDIncluded was true.)\n";
                 m_UserID.Release();
                 return (-1);
             }
         }
         else // UserID SUPPOSED to be blank here. (Thus the Release.) Maybe
                // later,
             // we might consider trying to read it, in order to validate this.
             //
             m_UserID.Release(); // For now, just assume it's not there to be
                                 // read, and Release my own value to match it.
 
         otLog4 << szFunc << ": Loaded purse... ("
                << (m_bPasswordProtected ? "Password-protected"
                                         : "NOT password-protected")
                << ")\n ServerID: " << strServerID
                << "\n UserID: " << (m_bIsNymIDIncluded ? strUserID.Get() : "")
                << "\n Asset ID: " << strAssetTypeID << "\n----------\n";
 
         return 1;
     }
 
     // Sometimes you want the purse to have a passphrase on it, without being
     // attached to
     // one of your actual Nyms in your wallet. To accommodate this, OT creates a
     // symmetric key
     // and stashes it INSIDE the purse. This symmetric key can have whatever
     // passphrase you want.
     // There is also a master key attached, which allows for passphrase timeouts
     // on the symmetric key.
     // Therefore internalKey and cachedKey will both be attached to the purse
     // (or neither will be.)
     //
     else if (strNodeName.Compare("internalKey")) {
         if (!m_bPasswordProtected) // If we're NOT using the internal key, then
                                    // why am I in the middle of loading one
                                    // here?
         {
             otErr << szFunc << ": Error: Unexpected 'internalKey' data, "
                                "since m_bPasswordProtected is set to false!\n";
             return (-1); // error condition
         }
 
         if (!m_UserID.IsEmpty()) // If the UserID isn't empty, then why am I in
                                  // the middle of loading an internal Key?
         {
             otErr << szFunc << ": Error: Unexpected 'internalKey' data, since "
                                "m_UserID is not blank! "
                                "(The UserID should have loaded before THIS "
                                "node ever popped up...)\n";
             return (-1); // error condition
         }
 
         OTASCIIArmor ascValue;
 
         if (!OTContract::LoadEncodedTextField(xml, ascValue) ||
             !ascValue.Exists()) {
             otErr << szFunc << ": Error: Expected "
                   << "internalKey"
                   << " element to have text field.\n";
             return (-1); // error condition
         }
 
         // Let's see if the internal key is already loaded somehow... (Shouldn't
         // be...)
         //
         if (nullptr != m_pSymmetricKey) {
             otErr << szFunc
                   << ": WARNING: While loading internal Key for a purse, "
                      "noticed the pointer was ALREADY set! (I'm deleting old "
                      "one to make room, "
                      "and then allowing this one to load instead...)\n";
             //          return (-1); // error condition
 
             delete m_pSymmetricKey;
             m_pSymmetricKey = nullptr;
         }
 
         // By this point, I've loaded up the string containing the encrypted
         // symmetric key.
         // I also know that m_bPasswordProtected is set to true, and I know that
         // m_pSymmetricKey is nullptr.
         //
         // (It's only now that I bother instantiating.)
         //
         OTSymmetricKey* pSymmetricKey = new OTSymmetricKey();
         OT_ASSERT_MSG(nullptr != pSymmetricKey, "Purse::ProcessXMLNode: "
                                                 "Assert: nullptr != new "
                                                 "OTSymmetricKey \n");
 
         // NOTE: In the event of any error, need to delete pSymmetricKey before
         // returning.
         // (Or it will leak.)
         //
         if (!pSymmetricKey->SerializeFrom(ascValue)) {
             otErr
                 << szFunc
                 << ": Error: While loading internal Key for a purse, failed "
                    "serializing from stored string! (Failed loading purse.)\n";
             delete pSymmetricKey;
             pSymmetricKey = nullptr;
             return (-1);
         }
 
         // By this point, the symmetric key has loaded successfully from
         // storage.
 
         otWarn << szFunc << ": Successfully loaded a purse's internal key.\n";
 
         // No more worry about pSymmetricKey cleanup, now that this pointer is
         // set.
 
         m_pSymmetricKey = pSymmetricKey;
 
         return 1;
     }
     else if (strNodeName.Compare("cachedKey")) {
         if (!m_bPasswordProtected) // If we're NOT using the internal and master
                                    // keys, then why am I in the middle of
                                    // loading one here?
         {
             otErr << szFunc << ": Error: Unexpected 'cachedKey' data, "
                                "since m_bPasswordProtected is set to false!\n";
             return (-1); // error condition
         }
 
         if (!m_UserID.IsEmpty()) // If the UserID isn't empty, then why am I in
                                  // the middle of loading an internal Key?
         {
             otErr << szFunc << ": Error: Unexpected 'cachedKey' data, since "
                                "m_UserID is not blank!\n";
             return (-1); // error condition
         }
 
         OTASCIIArmor ascValue;
 
         if (!OTContract::LoadEncodedTextField(xml, ascValue) ||
             !ascValue.Exists()) {
             otErr << szFunc << ": Error: Expected "
                   << "cachedKey"
                   << " element to have text field.\n";
             return (-1); // error condition
         }
 
         // Let's see if the master key is already loaded somehow... (Shouldn't
         // be...)
         //
         if (m_pCachedKey) {
             otErr << szFunc
                   << ": WARNING: While loading master Key for a purse, "
                      "noticed the pointer was ALREADY set! (I'm deleting old "
                      "one to make room, "
                      "and then allowing this one to load instead...)\n";
             //          return (-1); // error condition
 
             m_pCachedKey.reset();
         }
 
         // By this point, I've loaded up the string containing the encrypted
         // symmetric key.
         // I also know that m_bPasswordProtected is set to true, and I know that
         // m_pSymmetricKey is nullptr.
         //
         // (It's only now that I bother instantiating.)
         //
         std::shared_ptr<OTCachedKey> pCachedKey(new OTCachedKey(ascValue));
         //        OT_ASSERT_MSG(nullptr != pCachedKey, "Purse::ProcessXMLNode:
         // Assert: nullptr != new OTCachedKey \n");
 
         // NOTE: In the event of any error, need to delete pCachedKey before
         // returning.
         // (Or it will leak.)
         //
         if (!pCachedKey->SerializeFrom(ascValue)) {
             otErr
                 << szFunc
                 << ": Error: While loading master Key for a purse, failed "
                    "serializing from stored string! (Failed loading purse.)\n";
             //            delete pCachedKey; pCachedKey = nullptr;
             return (-1);
         }
 
         // By this point, the symmetric key has loaded successfully from
         // storage.
 
         otWarn << szFunc << ": Successfully loaded a purse's master key.\n";
 
         // No more worry about pSymmetricKey cleanup, now that this pointer is
         // set.
 
         m_pCachedKey = pCachedKey;
 
         // NOTE: Hereafter, do NOT use m_pCachedKey directly.
         // Instead, use OTCachedKey::It(*m_pCachedKey) (So you deal with the
         // cached
         // version, and avoid forcing the user to re-type his passphrase more
         // than
         // necessary according to timeouts designed in OTCachedKey class.)
         //
         // In fact, don't even use that. Instead, I'll add an
         // Purse::GetPassphrase
         // method, which handles that for you.
 
         return 1;
     }
     else if (strNodeName.Compare("token")) {
         OTASCIIArmor* pArmor = new OTASCIIArmor;
         OT_ASSERT(nullptr != pArmor);
 
         if (!OTContract::LoadEncodedTextField(xml, *pArmor) ||
             !pArmor->Exists()) {
             otErr << szFunc << ": Error: token field without value.\n";
 
             delete pArmor;
             pArmor = nullptr;
 
             return (-1); // error condition
         }
         else {
             m_dequeTokens.push_front(pArmor);
         }
 
         return 1;
     }
 
     return 0;
 }

Purse * opentxs::Purse::PurseFactory ( OTString strInput )

static

Definition at line 671 of file Purse.cpp.

 {
     //  const char * szFunc = "Purse::PurseFactory";
 
     OTString strContract, strFirstLine; // output for the below function.
     const bool bProcessed =
         OTContract::DearmorAndTrim(strInput, strContract, strFirstLine);
 
     if (bProcessed) {
         Purse* pPurse = Purse::LowLevelInstantiate(strFirstLine);
 
         // The string didn't match any of the options in the factory.
         if (nullptr == pPurse) return nullptr;
 
         // Does the contract successfully load from the string passed in?
         if (pPurse->LoadContractFromString(strContract))
             return pPurse;
         else
             delete pPurse;
     }
 
     return nullptr;
 }

Purse * opentxs::Purse::PurseFactory	(	OTString	strInput,
		const OTIdentifier &	SERVER_ID
	)

static

Definition at line 635 of file Purse.cpp.

 {
     OTString strContract, strFirstLine; // output for the below function.
     const bool bProcessed =
         OTContract::DearmorAndTrim(strInput, strContract, strFirstLine);
 
     if (bProcessed) {
         Purse* pPurse = Purse::LowLevelInstantiate(strFirstLine, SERVER_ID);
 
         // The string didn't match any of the options in the factory.
         if (nullptr == pPurse) return nullptr;
 
         // Does the contract successfully load from the string passed in?
         if (pPurse->LoadContractFromString(strContract)) {
             if (SERVER_ID != pPurse->GetServerID()) {
                 const OTString strServerID(SERVER_ID),
                     strPurseServerID(pPurse->GetServerID());
                 otErr << "Purse::PurseFactory"
                       << ": Failure: ServerID on purse (" << strPurseServerID
                       << ") doesn't match expected server ID (" << strServerID
                       << ").\n";
                 delete pPurse;
                 pPurse = nullptr;
             }
             else
                 return pPurse;
         }
         else {
             delete pPurse;
             pPurse = nullptr;
         }
     }
 
     return nullptr;
 }

Purse * opentxs::Purse::PurseFactory	(	OTString	strInput,
		const OTIdentifier &	SERVER_ID,
		const OTIdentifier &	ASSET_ID
	)

static

Definition at line 584 of file Purse.cpp.

 {
     OTString strContract, strFirstLine; // output for the below function.
     const bool bProcessed =
         OTContract::DearmorAndTrim(strInput, strContract, strFirstLine);
 
     if (bProcessed) {
         Purse* pPurse =
             Purse::LowLevelInstantiate(strFirstLine, SERVER_ID, ASSET_ID);
 
         // The string didn't match any of the options in the factory.
         if (nullptr == pPurse) return nullptr;
 
         // Does the contract successfully load from the string passed in?
         if (pPurse->LoadContractFromString(strContract)) {
             const char* szFunc = "Purse::PurseFactory";
             if (SERVER_ID != pPurse->GetServerID()) {
                 const OTString strServerID(SERVER_ID),
                     strPurseServerID(pPurse->GetServerID());
                 otErr << szFunc << ": Failure: ServerID on purse ("
                       << strPurseServerID << ") doesn't match expected "
                                              "server ID (" << strServerID
                       << ").\n";
                 delete pPurse;
                 pPurse = nullptr;
             }
             else if (ASSET_ID != pPurse->GetAssetID()) {
                 const OTString strAssetID(ASSET_ID),
                     strPurseAssetID(pPurse->GetAssetID());
                 otErr << szFunc << ": Failure: AssetID on purse ("
                       << strPurseAssetID << ") doesn't match expected "
                                             "asset ID (" << strAssetID
                       << ").\n";
                 delete pPurse;
                 pPurse = nullptr;
             }
             else
                 return pPurse;
         }
         else {
             delete pPurse;
             pPurse = nullptr;
         }
     }
 
     return nullptr;
 }

bool opentxs::Purse::Push	(	OTNym_or_SymmetricKey	theOwner,
		const Token &	theToken
	)

Definition at line 1575 of file Purse.cpp.

 {
     if (theToken.GetAssetID() == m_AssetID) {
         const OTString strDisplay(__FUNCTION__); // this is the passphrase
                                                  // string that will display if
                                                  // theOwner doesn't have one
                                                  // already.
 
         OTString strToken(theToken);
         OTEnvelope theEnvelope;
         const bool bSuccess =
             theOwner.Seal_or_Encrypt(theEnvelope, strToken, &strDisplay);
 
         if (bSuccess) {
             OTASCIIArmor* pArmor = new OTASCIIArmor(theEnvelope);
 
             m_dequeTokens.push_front(pArmor);
 
             // We keep track of the purse's total value.
             m_lTotalValue += theToken.GetDenomination();
 
             // We keep track of the expiration dates for the purse, based on the
             // tokens within.
             //
             if (m_tLatestValidFrom < theToken.GetValidFrom()) {
                 m_tLatestValidFrom = theToken.GetValidFrom();
             }
 
             if ((OT_TIME_ZERO == m_tEarliestValidTo) ||
                 (m_tEarliestValidTo > theToken.GetValidTo())) {
                 m_tEarliestValidTo = theToken.GetValidTo();
             }
 
             if (m_tLatestValidFrom > m_tEarliestValidTo)
                 otErr << __FUNCTION__
                       << ": WARNING: This purse has a 'valid from' date LATER "
                          "than the 'valid to' date. "
                          "(due to different tokens with different date "
                          "ranges...)\n";
 
             return true;
         }
         else {
             OTString strPurseAssetType(m_AssetID),
                 strTokenAssetType(theToken.GetAssetID());
             otErr << __FUNCTION__ << ": Failed while calling: "
                                      "theOwner.Seal_or_Encrypt(theEnvelope, "
                                      "strToken)\nPurse Asset Type:\n"
                   << strPurseAssetType << "\n"
                                           "Token Asset Type:\n"
                   << strTokenAssetType << "\n";
         }
     }
     else {
         OTString strPurseAssetType(m_AssetID),
             strTokenAssetType(theToken.GetAssetID());
         otErr << __FUNCTION__ << ": ERROR: Tried to push token with wrong "
                                  "asset type.\nPurse Asset Type:\n"
               << strPurseAssetType << "\n"
                                       "Token Asset Type:\n" << strTokenAssetType
               << "\n";
     }
 
     return false;
 }

void opentxs::Purse::RecalculateExpirationDates ( OTNym_or_SymmetricKey & theOwner )

protected

Definition at line 1519 of file Purse.cpp.

 {
     m_tLatestValidFrom = OT_TIME_ZERO;
     m_tEarliestValidTo = OT_TIME_ZERO;
 
     for (auto& it : m_dequeTokens) {
         OTASCIIArmor* pArmor = it;
         OT_ASSERT(nullptr != pArmor);
 
         OTEnvelope theEnvelope(*pArmor);
 
         // Open the envelope into a string.
         //
         OTString strToken;
         const OTString strDisplay(__FUNCTION__); // this is the passphrase
                                                  // string that will display if
                                                  // theOwner doesn't have one
                                                  // already.
 
         const bool bSuccess =
             theOwner.Open_or_Decrypt(theEnvelope, strToken, &strDisplay);
 
         if (bSuccess) {
             // Create a new token with the same server and asset IDs as this
             // purse.
             Token* pToken = Token::TokenFactory(strToken, *this);
             OT_ASSERT(nullptr != pToken);
 
             if (m_tLatestValidFrom < pToken->GetValidFrom()) {
                 m_tLatestValidFrom = pToken->GetValidFrom();
             }
 
             if ((OT_TIME_ZERO == m_tEarliestValidTo) ||
                 (m_tEarliestValidTo > pToken->GetValidTo())) {
                 m_tEarliestValidTo = pToken->GetValidTo();
             }
 
             if (m_tLatestValidFrom > m_tEarliestValidTo)
                 otErr << __FUNCTION__
                       << ": WARNING: This purse has a 'valid from' date LATER "
                          "than the 'valid to' date. "
                          "(due to different tokens with different date "
                          "ranges...)\n";
 
         }
         else
             otErr << __FUNCTION__
                   << ": Failure while trying to decrypt a token.\n";
     }
 }

void opentxs::Purse::Release ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 812 of file Purse.cpp.

 {
     Release_Purse();
 
     ot_super::Release();
 
     InitPurse();
 }

void opentxs::Purse::Release_Purse ( )

Definition at line 787 of file Purse.cpp.

 {
     // This sets m_lTotalValue to 0 already.
     ReleaseTokens();
     //    m_lTotalValue = 0;
 
     m_bPasswordProtected = false;
     m_bIsNymIDIncluded = false;
 
     // the Temp Nym is when a purse contains its own Nym, created just
     // for that purse, so that it can be password protected instead of using
     // one of the real Nyms in your wallet.
     //
     if (nullptr != m_pSymmetricKey) {
         delete m_pSymmetricKey;
         m_pSymmetricKey = nullptr;
     }
 
     //    if (m_pCachedKey)
     //    {
     //        delete m_pCachedKey;
     //        m_pCachedKey = nullptr;
     //    }
 }

void opentxs::Purse::ReleaseTokens ( )

Definition at line 1651 of file Purse.cpp.

 {
     while (!m_dequeTokens.empty()) {
         OTASCIIArmor* pArmor = m_dequeTokens.front();
         m_dequeTokens.pop_front();
         delete pArmor;
     }
 
     m_lTotalValue = 0;
 }

bool opentxs::Purse::SaveContractWallet ( std::ofstream & ofs ) const

virtual

Implements opentxs::OTContract.

Definition at line 1365 of file Purse.cpp.

 {
     return true;
 }

bool opentxs::Purse::SavePurse	(	const char *	szServerID = `nullptr`,
		const char *	szUserID = `nullptr`,
		const char *	szAssetTypeID = `nullptr`
	)

Definition at line 889 of file Purse.cpp.

 {
     OT_ASSERT(!IsPasswordProtected());
 
     if (!m_strFoldername.Exists())
         m_strFoldername.Set(OTFolders::Purse().Get());
 
     OTString strServerID(m_ServerID), strUserID(m_UserID),
         strAssetTypeID(m_AssetID);
 
     if (nullptr != szServerID) strServerID = szServerID;
     if (nullptr != szUserID) strUserID = szUserID;
     if (nullptr != szAssetTypeID) strAssetTypeID = szAssetTypeID;
 
     if (!m_strFilename.Exists()) {
         m_strFilename.Format("%s%s%s%s%s", strServerID.Get(),
                              OTLog::PathSeparator(), strUserID.Get(),
                              OTLog::PathSeparator(), strAssetTypeID.Get());
     }
 
     const char* szFolder1name = OTFolders::Purse().Get(); // purse
     const char* szFolder2name = strServerID.Get();        // purse/SERVER_ID
     const char* szFolder3name = strUserID.Get(); // purse/SERVER_ID/USER_ID
     const char* szFilename =
         strAssetTypeID.Get(); // purse/SERVER_ID/USER_ID/ASSET_TYPE_ID
 
     OTString strRawFile;
 
     if (!SaveContractRaw(strRawFile)) {
         otErr << "Purse::SavePurse: Error saving Pursefile (to string):\n"
               << szFolder1name << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFolder3name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     OTString strFinal;
     OTASCIIArmor ascTemp(strRawFile);
 
     if (false ==
         ascTemp.WriteArmoredString(strFinal, m_strContractType.Get())) {
         otErr << "Purse::SavePurse: Error saving Pursefile (failed writing "
                  "armored string):\n" << szFolder1name << OTLog::PathSeparator()
               << szFolder2name << OTLog::PathSeparator() << szFolder3name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     bool bSaved = OTDB::StorePlainString(
         strFinal.Get(), szFolder1name, szFolder2name, szFolder3name,
         szFilename); // <=== SAVING TO DATA STORE.
     if (!bSaved) {
         otErr << "Purse::SavePurse: Error writing to file: " << szFolder1name
               << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFolder3name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     return true;
 }

void opentxs::Purse::UpdateContents ( )

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 952 of file Purse.cpp.

 {
     const OTString SERVER_ID(m_ServerID), USER_ID(m_UserID),
         ASSET_TYPE_ID(m_AssetID);
 
     int64_t lValidFrom = OTTimeGetSecondsFromTime(m_tLatestValidFrom);
     int64_t lValidTo = OTTimeGetSecondsFromTime(m_tEarliestValidTo);
 
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n\n", "1.0");
     m_xmlUnsigned.Concatenate(
         "<purse version=\"%s\"\n"
         " totalValue=\"%" PRId64 "\"\n" // Total value of all the tokens within.
         " validFrom=\"%" PRId64
         "\"\n" // Latest "valid from" date of all tokens contained.
         " validTo=\"%" PRId64
         "\"\n" // Earliest "valid to" date of all tokens contained.
         " isPasswordProtected=\"%s\"\n"
         " isNymIDIncluded=\"%s\"\n"
         " userID=\"%s\"\n"       // UserID   is optional.
         " assetTypeID=\"%s\"\n"  // assetTypeID required.
         " serverID=\"%s\">\n\n", // serverID is required.
         m_strVersion.Get(),
         m_lTotalValue, lValidFrom, lValidTo,
         m_bPasswordProtected ? "true" : "false",
         m_bIsNymIDIncluded ? "true" : "false",
 
         // USER_ID / NYM_ID of purse owner.
         // IF a real NymID (from the user's wallet) is listed in the purse
         // (which is
         // optional--user's choice) we attach that NymID here...
         //
         (m_bIsNymIDIncluded &&
          !m_UserID.IsEmpty()) // (Provided that the ID even exists, of course.)
             ?                 // =====>
             USER_ID.Get()
             : "", // Then print the ID (otherwise print an empty string.)
         (!m_AssetID.IsEmpty()) ? ASSET_TYPE_ID.Get()
                                : "", // (Should never actually be empty.) todo:
                                      // Change this to just the Get()
         (!m_ServerID.IsEmpty()) ? SERVER_ID.Get()
                                 : "" // (Should never actually be empty.) todo:
                                      // Change this to just the Get()
         );
 
     // Save the Internal Symmetric Key here (if there IS one.)
     // (Some Purses own their own internal Symmetric Key, in order to "password
     // protect" the purse.)
     //
     if (m_bPasswordProtected) {
         if (!m_pCachedKey)
             otErr
                 << __FUNCTION__
                 << ": Error: m_pCachedKey is unexpectedly nullptr, even though "
                    "m_bPasswordProtected is true!\n";
         else if (nullptr == m_pSymmetricKey)
             otErr << __FUNCTION__ << ": Error: m_pSymmetricKey is unexpectedly "
                                      "nullptr, even though "
                                      "m_bPasswordProtected is true!\n";
         else // m_pCachedKey and m_pSymmetricKey are good pointers. (Or at
              // least, not-null.)
         {
             if (!m_pCachedKey->IsGenerated())
                 otErr << __FUNCTION__ << ": Error: m_pCachedKey wasn't a "
                                          "generated key! Even though "
                                          "m_bPasswordProtected is true.\n";
             else if (!m_pSymmetricKey->IsGenerated())
                 otErr << __FUNCTION__ << ": Error: m_pSymmetricKey wasn't a "
                                          "generated key! Even though "
                                          "m_bPasswordProtected is true.\n";
             else {
                 OTASCIIArmor ascCachedKey, ascSymmetricKey;
 
                 if (!m_pCachedKey->SerializeTo(ascCachedKey) ||
                     !ascCachedKey.Exists() ||
                     !m_pSymmetricKey->SerializeTo(ascSymmetricKey) ||
                     !ascSymmetricKey.Exists())
                     otErr << __FUNCTION__
                           << ": Error: m_pCachedKey or m_pSymmetricKey failed "
                              "trying to serialize to OTASCIIArmor.\n";
                 else {
                     // ascInternalKey is good by this point.
                     // Therefore, let's serialize it...
 
                     // By this point, ascInternalKey contains the Key itself.
                     //
                     m_xmlUnsigned.Concatenate(
                         "<cachedKey>\n%s</cachedKey>\n\n",
                         ascCachedKey.Get()); // The "password" for the internal
                                              // symmetric key.
 
                     m_xmlUnsigned.Concatenate(
                         "<internalKey>\n%s</internalKey>\n\n",
                         ascSymmetricKey.Get()); // The internal symmetric key,
                                                 // owned by the purse.
                                                 // ascii-armored.
                 }
             }
         }
     }
 
     for (int32_t i = 0; i < Count(); i++) {
         m_xmlUnsigned.Concatenate("<token>\n%s</token>\n\n",
                                   m_dequeTokens[i]->Get());
     }
 
     m_xmlUnsigned.Concatenate("</purse>\n");
 }

bool opentxs::Purse::VerifyCurrentDate ( )

Definition at line 1404 of file Purse.cpp.

 {
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     if ((CURRENT_TIME >= m_tLatestValidFrom) &&
         ((CURRENT_TIME <= m_tEarliestValidTo) ||
          (OT_TIME_ZERO == m_tEarliestValidTo)))
         return true;
     else
         return false;
 }

Member Data Documentation

OTIdentifier opentxs::Purse::m_AssetID

protected

Definition at line 189 of file Purse.hpp.

bool opentxs::Purse::m_bIsNymIDIncluded

protected

Definition at line 208 of file Purse.hpp.

bool opentxs::Purse::m_bPasswordProtected

protected

Definition at line 192 of file Purse.hpp.

dequeOfTokens opentxs::Purse::m_dequeTokens

protected

Definition at line 181 of file Purse.hpp.

int64_t opentxs::Purse::m_lTotalValue

protected

Definition at line 190 of file Purse.hpp.

std::shared_ptr<OTCachedKey> opentxs::Purse::m_pCachedKey

protected

Definition at line 218 of file Purse.hpp.

OTSymmetricKey* opentxs::Purse::m_pSymmetricKey

protected

Definition at line 213 of file Purse.hpp.

OTIdentifier opentxs::Purse::m_ServerID

protected

Definition at line 188 of file Purse.hpp.

time64_t opentxs::Purse::m_tEarliestValidTo

protected

Definition at line 221 of file Purse.hpp.

time64_t opentxs::Purse::m_tLatestValidFrom

protected

Definition at line 219 of file Purse.hpp.

OTIdentifier opentxs::Purse::m_UserID

protected

Definition at line 187 of file Purse.hpp.

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

/usr/local/src/opentxs/include/opentxs/cash/Purse.hpp
/usr/local/src/opentxs/src/cash/Purse.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation