#include <Mint.hpp>

Inheritance diagram for opentxs::Mint:

Collaboration diagram for opentxs::Mint:

Public Member Functions
int32_t	GetSeries () const

time64_t	GetValidFrom () const

time64_t	GetValidTo () const

time64_t	GetExpiration () const

EXPORT bool	Expired () const

OTAccount *	GetCashReserveAccount () const

virtual EXPORT	~Mint ()

virtual void	Release ()

void	Release_Mint ()

void	ReleaseDenominations ()

EXPORT bool	LoadMint (const char *szAppend=nullptr)

EXPORT bool	SaveMint (const char *szAppend=nullptr)

virtual bool	LoadContract ()

void	SetSavePrivateKeys (bool bDoIt=true)

bool	GetPrivate (OTASCIIArmor &theArmor, int64_t lDenomination)

bool	GetPublic (OTASCIIArmor &theArmor, int64_t lDenomination)

int64_t	GetDenomination (int32_t nIndex)

EXPORT int64_t	GetLargestDenomination (int64_t lAmount)

virtual bool	AddDenomination (OTPseudonym &theNotary, int64_t lDenomination, int32_t nPrimeLength=1024)=0

int32_t	GetDenominationCount () const

virtual bool	VerifyContractID () const

EXPORT bool	VerifyMint (const OTPseudonym &theOperator)

virtual void	UpdateContents ()

void	SetAssetID (const OTIdentifier &newID)

EXPORT void	GenerateNewMint (int32_t nSeries, time64_t VALID_FROM, time64_t VALID_TO, time64_t MINT_EXPIRATION, const OTIdentifier &theAssetID, const OTIdentifier &theServerID, OTPseudonym &theNotary, int64_t nDenom1=0, int64_t nDenom2=0, int64_t nDenom3=0, int64_t nDenom4=0, int64_t nDenom5=0, int64_t nDenom6=0, int64_t nDenom7=0, int64_t nDenom8=0, int64_t nDenom9=0, int64_t nDenom10=0)

virtual EXPORT bool	SignToken (OTPseudonym &theNotary, Token &theToken, OTString &theOutput, int32_t nTokenIndex)=0

virtual EXPORT bool	VerifyToken (OTPseudonym &theNotary, OTString &theCleartextToken, int64_t lDenomination)=0

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 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 Mint *	MintFactory ()

static EXPORT Mint *	MintFactory (const OTString &strServerID, const OTString &strAssetTypeID)

static EXPORT Mint *	MintFactory (const OTString &strServerID, const OTString &strServerNymID, const OTString &strAssetTypeID)

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 int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

void	InitMint ()

	Mint ()

EXPORT	Mint (const OTString &strServerID, const OTString &strAssetTypeID)

EXPORT	Mint (const OTString &strServerID, const OTString &strServerNymID, const OTString &strAssetTypeID)

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

Protected Attributes
mapOfArmor	m_mapPrivate

mapOfArmor	m_mapPublic

OTIdentifier	m_ServerID

OTIdentifier	m_ServerNymID

OTAsymmetricKey *	m_pKeyPublic

OTIdentifier	m_AssetID

int32_t	m_nDenominationCount

bool	m_bSavePrivateKeys

int32_t	m_nSeries

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

time64_t	m_EXPIRATION

OTIdentifier	m_CashAccountID

OTAccount *	m_pReserveAcct

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 150 of file Mint.hpp.

Constructor & Destructor Documentation

opentxs::Mint::Mint ( )

protected

Definition at line 358 of file Mint.cpp.

     : ot_super()
     , m_pKeyPublic(OTAsymmetricKey::KeyFactory())
     , m_nDenominationCount(0)
     , m_bSavePrivateKeys(false)
     , m_nSeries(0)
     , m_VALID_FROM(OT_TIME_ZERO)
     , m_VALID_TO(OT_TIME_ZERO)
     , m_EXPIRATION(OT_TIME_ZERO)
     , m_pReserveAcct(nullptr)
 {
     InitMint();
 }

opentxs::Mint::Mint	(	const OTString &	strServerID,
		const OTString &	strAssetTypeID
	)

protected

Definition at line 338 of file Mint.cpp.

     : ot_super(strAssetTypeID)
     , m_ServerID(strServerID)
     , m_pKeyPublic(OTAsymmetricKey::KeyFactory())
     , m_AssetID(strAssetTypeID)
     , m_nDenominationCount(0)
     , m_bSavePrivateKeys(false)
     , m_nSeries(0)
     , m_VALID_FROM(OT_TIME_ZERO)
     , m_VALID_TO(OT_TIME_ZERO)
     , m_EXPIRATION(OT_TIME_ZERO)
     , m_pReserveAcct(nullptr)
 {
     m_strFoldername.Set(OTFolders::Mint().Get());
     m_strFilename.Format("%s%s%s", strServerID.Get(), OTLog::PathSeparator(),
                          strAssetTypeID.Get());
 
     InitMint();
 }

opentxs::Mint::Mint	(	const OTString &	strServerID,
		const OTString &	strServerNymID,
		const OTString &	strAssetTypeID
	)

protected

Definition at line 316 of file Mint.cpp.

     : ot_super(strAssetTypeID)
     , m_ServerID(strServerID)
     , m_ServerNymID(strServerNymID)
     , m_pKeyPublic(OTAsymmetricKey::KeyFactory())
     , m_AssetID(strAssetTypeID)
     , m_nDenominationCount(0)
     , m_bSavePrivateKeys(false)
     , m_nSeries(0)
     , m_VALID_FROM(OT_TIME_ZERO)
     , m_VALID_TO(OT_TIME_ZERO)
     , m_EXPIRATION(OT_TIME_ZERO)
     , m_pReserveAcct(nullptr)
 {
     m_strFoldername.Set(OTFolders::Mint().Get());
     m_strFilename.Format("%s%s%s", strServerID.Get(), OTLog::PathSeparator(),
                          strAssetTypeID.Get());
 
     InitMint();
 }

opentxs::Mint::~Mint ( )

virtual

Definition at line 282 of file Mint.cpp.

 {
     Release_Mint();
 
     if (nullptr != m_pKeyPublic) {
         delete m_pKeyPublic;
         m_pKeyPublic = nullptr;
     }
     else
         otErr << __FUNCTION__ << ": the logic: if (nullptr != m_pKeyPublic) "
                                  "failed, though it NEVER should. "
                                  "(That pointer should never be nullptr.)\n";
 }

Member Function Documentation

virtual bool opentxs::Mint::AddDenomination	(	OTPseudonym &	theNotary,
		int64_t	lDenomination,
		int32_t	nPrimeLength = `1024`
	)

pure virtual

Implemented in opentxs::MintLucre.

bool opentxs::Mint::Expired ( ) const

Definition at line 227 of file Mint.cpp.

 {
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
 
     if ((CURRENT_TIME >= m_VALID_FROM) && (CURRENT_TIME <= m_EXPIRATION))
         return false;
     else
         return true;
 }

void opentxs::Mint::GenerateNewMint	(	int32_t	nSeries,
		time64_t	VALID_FROM,
		time64_t	VALID_TO,
		time64_t	MINT_EXPIRATION,
		const OTIdentifier &	theAssetID,
		const OTIdentifier &	theServerID,
		OTPseudonym &	theNotary,
		int64_t	nDenom1 = `0`,
		int64_t	nDenom2 = `0`,
		int64_t	nDenom3 = `0`,
		int64_t	nDenom4 = `0`,
		int64_t	nDenom5 = `0`,
		int64_t	nDenom6 = `0`,
		int64_t	nDenom7 = `0`,
		int64_t	nDenom8 = `0`,
		int64_t	nDenom9 = `0`,
		int64_t	nDenom10 = `0`
	)

Definition at line 879 of file Mint.cpp.

 {
     Release();
 
     m_AssetID = theAssetID;
     m_ServerID = theServerID;
 
     OTIdentifier SERVER_NYM_ID(theNotary);
     m_ServerNymID = SERVER_NYM_ID;
 
     m_nSeries = nSeries;
     m_VALID_FROM = VALID_FROM;
     m_VALID_TO = VALID_TO;
     m_EXPIRATION = MINT_EXPIRATION;
 
     // Normally asset accounts are created based on an incoming message,
     // so I'm just simulating that in order to make sure it gets its
     // necessary input values, such as asset type, server ID, etc.
     OTMessage theMessage;
     SERVER_NYM_ID.GetString(theMessage.m_strNymID);
     theAssetID.GetString(theMessage.m_strAssetID);
     theServerID.GetString(theMessage.m_strServerID);
 
     /* OTAccount::
      GenerateNewAccount(const OTIdentifier & theUserID, const OTIdentifier &
      theServerID,
                         const OTPseudonym & theServerNym, const OTMessage &
      theMessage,
                         const AccountType eAcctType=simple);
      */
     m_pReserveAcct = OTAccount::GenerateNewAccount(
         SERVER_NYM_ID, theServerID, theNotary, theMessage, OTAccount::mint);
 
     if (m_pReserveAcct) {
         m_pReserveAcct->GetIdentifier(m_CashAccountID);
         otOut << "Successfully created cash reserve account for new mint.\n";
     }
     else {
         otErr << "Error creating cash reserve account for new mint.\n";
     }
 
     if (nDenom1) {
         AddDenomination(theNotary,
                         nDenom1); // int32_t nPrimeLength default = 1024
     }
     if (nDenom2) {
         AddDenomination(theNotary,
                         nDenom2); // int32_t nPrimeLength default = 1024
     }
     if (nDenom3) {
         AddDenomination(theNotary,
                         nDenom3); // int32_t nPrimeLength default = 1024
     }
     if (nDenom4) {
         AddDenomination(theNotary,
                         nDenom4); // int32_t nPrimeLength default = 1024
     }
     if (nDenom5) {
         AddDenomination(theNotary,
                         nDenom5); // int32_t nPrimeLength default = 1024
     }
     if (nDenom6) {
         AddDenomination(theNotary,
                         nDenom6); // int32_t nPrimeLength default = 1024
     }
     if (nDenom7) {
         AddDenomination(theNotary,
                         nDenom7); // int32_t nPrimeLength default = 1024
     }
     if (nDenom8) {
         AddDenomination(theNotary,
                         nDenom8); // int32_t nPrimeLength default = 1024
     }
     if (nDenom9) {
         AddDenomination(theNotary,
                         nDenom9); // int32_t nPrimeLength default = 1024
     }
     if (nDenom10) {
         AddDenomination(theNotary,
                         nDenom10); // int32_t nPrimeLength default = 1024
     }
 }

OTAccount* opentxs::Mint::GetCashReserveAccount ( ) const

inline

Definition at line 234 of file Mint.hpp.

     {
         return m_pReserveAcct;
     }

int64_t opentxs::Mint::GetDenomination ( int32_t nIndex )

Definition at line 610 of file Mint.cpp.

 {
     // index out of bounds.
     if (nIndex > (m_nDenominationCount - 1)) {
         return 0;
     }
 
     int32_t nIterateIndex = 0;
 
     for (auto it = m_mapPublic.begin(); it != m_mapPublic.end();
          ++it, nIterateIndex++) {
         OTASCIIArmor* pArmor = it->second;
         OT_ASSERT_MSG(nullptr != pArmor,
                       "nullptr mint pointer in Mint::GetDenomination.\n");
 
         if (nIndex == nIterateIndex) return it->first;
     }
 
     return 0;
 }

int32_t opentxs::Mint::GetDenominationCount ( ) const

inline

Definition at line 282 of file Mint.hpp.

     {
         return m_nDenominationCount;
     }

time64_t opentxs::Mint::GetExpiration ( ) const

inline

Definition at line 226 of file Mint.hpp.

     {
         return m_EXPIRATION;
     }                            // The date the mint expires (should be halfway

int64_t opentxs::Mint::GetLargestDenomination ( int64_t lAmount )

Definition at line 596 of file Mint.cpp.

 {
     for (int32_t nIndex = GetDenominationCount() - 1; nIndex >= 0; nIndex--) {
         int64_t lDenom = GetDenomination(nIndex);
 
         if (lDenom <= lAmount) return lDenom;
     }
 
     return 0;
 }

bool opentxs::Mint::GetPrivate	(	OTASCIIArmor &	theArmor,
		int64_t	lDenomination
	)

Definition at line 557 of file Mint.cpp.

 {
     for (auto& it : m_mapPrivate) {
         OTASCIIArmor* pArmor = it.second;
         OT_ASSERT_MSG(nullptr != pArmor,
                       "nullptr mint pointer in Mint::GetPrivate.\n");
         // if this denomination (say, 50) matches the one passed in
         if (it.first == lDenomination) {
             theArmor.Set(*pArmor);
             return true;
         }
     }
     return false;
 }

bool opentxs::Mint::GetPublic	(	OTASCIIArmor &	theArmor,
		int64_t	lDenomination
	)

Definition at line 574 of file Mint.cpp.

 {
     for (auto& it : m_mapPublic) {
         OTASCIIArmor* pArmor = it.second;
         OT_ASSERT_MSG(nullptr != pArmor,
                       "nullptr mint pointer in Mint::GetPublic.\n");
         // if this denomination (say, 50) matches the one passed in
         if (it.first == lDenomination) {
             theArmor.Set(*pArmor);
             return true;
         }
     }
 
     return false;
 }

int32_t opentxs::Mint::GetSeries ( ) const

inline

Definition at line 214 of file Mint.hpp.

     {
         return m_nSeries;
     } // The series ID

time64_t opentxs::Mint::GetValidFrom ( ) const

inline

Definition at line 218 of file Mint.hpp.

     {
         return m_VALID_FROM;
     } // The token "valid from" date for this series

time64_t opentxs::Mint::GetValidTo ( ) const

inline

Definition at line 222 of file Mint.hpp.

     {
         return m_VALID_TO;
     } // The token "valid until" date for this series

void opentxs::Mint::InitMint ( )

protected

Definition at line 296 of file Mint.cpp.

 {
     m_strContractType.Set("MINT");
 
     m_nDenominationCount = 0;
 
     m_bSavePrivateKeys =
         false; // Determines whether it serializes private keys (no if false)
 
     // Mints expire and new ones are rotated in.
     // All tokens have the same series, and validity dates,
     // of the mint that created them.
     m_nSeries = 0;
     m_VALID_FROM = OT_TIME_ZERO;
     m_VALID_TO = OT_TIME_ZERO;
     m_EXPIRATION = OT_TIME_ZERO;
 
     m_pReserveAcct = nullptr;
 }

bool opentxs::Mint::LoadContract ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 372 of file Mint.cpp.

 {
     otOut << "Mint::LoadContract OVERRIDE.\n";
     return LoadMint();
 }

bool opentxs::Mint::LoadMint ( const char * szAppend = nullptr )

Definition at line 378 of file Mint.cpp.

 {
     if (!m_strFoldername.Exists()) m_strFoldername.Set(OTFolders::Mint().Get());
 
     const OTString strServerID(m_ServerID), strAssetTypeID(m_AssetID);
 
     if (!m_strFilename.Exists()) {
         if (nullptr != szAppend)
             m_strFilename.Format("%s%s%s%s", strServerID.Get(),
                                  OTLog::PathSeparator(), // server appends ".1"
                                                          // or ".PUBLIC" here.
                                  strAssetTypeID.Get(), szAppend);
         else
             m_strFilename.Format(
                 "%s%s%s", strServerID.Get(), OTLog::PathSeparator(),
                 strAssetTypeID.Get()); // client uses only asset ID, no append.
     }
 
     OTString strFilename;
     if (nullptr != szAppend)
         strFilename.Format("%s%s", strAssetTypeID.Get(),
                            szAppend); // server side
     else
         strFilename = strAssetTypeID.Get(); // client side
 
     const char* szFolder1name = OTFolders::Mint().Get(); // "mints"
     const char* szFolder2name = strServerID.Get();       // "mints/SERVER_ID"
     const char* szFilename =
         strFilename.Get(); // "mints/SERVER_ID/ASSET_TYPE_ID<szAppend>"
 
     if (!OTDB::Exists(szFolder1name, szFolder2name, szFilename)) {
         otOut << "Mint::LoadMint: File does not exist: " << szFolder1name
               << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     std::string strFileContents(
         OTDB::QueryPlainString(szFolder1name, szFolder2name,
                                szFilename)); // <=== LOADING FROM DATA STORE.
 
     if (strFileContents.length() < 2) {
         otErr << "Mint::LoadMint: Error reading file: " << szFolder1name
               << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     // NOTE: No need to worry about the OT ARMORED file format, since
     // LoadContractFromString already handles that internally.
 
     OTString strRawFile(strFileContents.c_str());
 
     bool bSuccess = LoadContractFromString(
         strRawFile); // Note: This handles OT ARMORED file format.
 
     return bSuccess;
 }

Mint * opentxs::Mint::MintFactory ( )

static

Definition at line 154 of file Mint.cpp.

 {
     Mint* pMint = nullptr;
 
 #if defined(OT_CASH_USING_LUCRE)
     pMint = new MintLucre;
 #elif defined(OT_CASH_USING_MAGIC_MONEY)
     //  pMint = new Mint_MagicMoney;
     otErr << __FUCNTION__ << ": Open-Transactions doesn't support Magic Money "
                              "by Pr0duct Cypher (yet), "
           << "so it's impossible to instantiate a mint.\n";
 #else
     otErr
         << __FUNCTION__
         << ": Open-Transactions isn't built with any digital cash algorithms, "
         << "so it's impossible to instantiate a mint.\n";
 #endif
     return pMint;
 }

Mint * opentxs::Mint::MintFactory	(	const OTString &	strServerID,
		const OTString &	strAssetTypeID
	)

static

Definition at line 175 of file Mint.cpp.

 {
     Mint* pMint = nullptr;
 
 #if defined(OT_CASH_USING_LUCRE)
     pMint = new MintLucre(strServerID, strAssetTypeID);
 #elif defined(OT_CASH_USING_MAGIC_MONEY)
     //  pMint = new OTMint_MagicMoney;
     otErr << __FUNCTION__ << ": Open-Transactions doesn't support Magic Money "
                              "by Pr0duct Cypher (yet), "
           << "so it's impossible to instantiate a mint.\n";
 #else
     otErr
         << __FUNCTION__
         << ": Open-Transactions isn't built with any digital cash algorithms, "
         << "so it's impossible to instantiate a mint.\n";
 #endif
     return pMint;
 }

Mint * opentxs::Mint::MintFactory	(	const OTString &	strServerID,
		const OTString &	strServerNymID,
		const OTString &	strAssetTypeID
	)

static

Definition at line 197 of file Mint.cpp.

 {
     Mint* pMint = nullptr;
 
 #if defined(OT_CASH_USING_LUCRE)
     pMint = new MintLucre(strServerID, strServerNymID, strAssetTypeID);
 #elif defined(OT_CASH_USING_MAGIC_MONEY)
     //  pMint = new OTMint_MagicMoney;
     otErr << __FUNCTION__ << ": Open-Transactions doesn't support Magic Money "
                              "by Pr0duct Cypher (yet), "
           << "so it's impossible to instantiate a mint.\n";
 #else
     otErr
         << __FUNCTION__
         << ": Open-Transactions isn't built with any digital cash algorithms, "
         << "so it's impossible to instantiate a mint.\n";
 #endif
     return pMint;
 }

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

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 704 of file Mint.cpp.

 {
     OT_ASSERT(nullptr != m_pKeyPublic);
 
     int32_t nReturnVal = 0;
 
     const OTString strNodeName(xml->getNodeName());
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note you can choose not to call the parent if
     // you don't want to use any of those xml tags.
     // As I do below, in the case of OTAccount.
     // if (nReturnVal = ot_super::ProcessXMLNode(xml))
     //    return nReturnVal;
 
     if (strNodeName.Compare("mint")) {
         OTString strServerID, strServerNymID, strAssetID, strCashAcctID;
 
         m_strVersion = xml->getAttributeValue("version");
         strServerID = xml->getAttributeValue("serverID");
         strServerNymID = xml->getAttributeValue("serverNymID");
         strAssetID = xml->getAttributeValue("assetTypeID");
         strCashAcctID = xml->getAttributeValue("cashAcctID");
 
         m_nSeries = atoi(xml->getAttributeValue("series"));
         m_EXPIRATION =
             OTTimeGetTimeFromSeconds(xml->getAttributeValue("expiration"));
 
         const OTString str_valid_from = xml->getAttributeValue("validFrom");
         const OTString str_valid_to = xml->getAttributeValue("validTo");
 
         m_VALID_FROM = OTTimeGetTimeFromSeconds(str_valid_from.ToLong());
         m_VALID_TO = OTTimeGetTimeFromSeconds(str_valid_to.ToLong());
 
         m_ServerID.SetString(strServerID);
         m_ServerNymID.SetString(strServerNymID);
         m_AssetID.SetString(strAssetID);
         m_CashAccountID.SetString(strCashAcctID);
 
         if (m_pReserveAcct) {
             delete m_pReserveAcct;
             m_pReserveAcct = nullptr;
         }
 
         // Every Mint has its own cash account. Here we load ours so it's ready
         // for transactions.
         if (strCashAcctID.Exists())
             m_pReserveAcct =
                 OTAccount::LoadExistingAccount(m_CashAccountID, m_ServerID);
 
         int64_t nValidFrom = OTTimeGetSecondsFromTime(m_VALID_FROM);
         int64_t nValidTo = OTTimeGetSecondsFromTime(m_VALID_TO);
         int64_t nExpiration = OTTimeGetSecondsFromTime(m_EXPIRATION);
 
         otWarn <<
             //    "\n===> Loading XML for mint into memory structures..."
             "\n\nMint version: " << m_strVersion
                << "\n Server ID: " << strServerID
                << "\n Asset Type ID: " << strAssetID
                << "\n Cash Acct ID: " << strCashAcctID << "\n"
                                                           ""
                << ((m_pReserveAcct != nullptr) ? "SUCCESS" : "FAILURE")
                << " loading Cash Account into memory for pointer: "
                   "Mint::m_pReserveAcct\n"
                   " Series: " << m_nSeries << "\n Expiration: " << nExpiration
                << "\n Valid From: " << nValidFrom << "\n Valid To: " << nValidTo
                << "\n";
 
         nReturnVal = 1;
     }
     else if (strNodeName.Compare("mintPublicKey")) {
         OTASCIIArmor armorPublicKey;
 
         if (!OTContract::LoadEncodedTextField(xml, armorPublicKey) ||
             !armorPublicKey.Exists()) {
             otErr << "Error in Mint::ProcessXMLNode: mintPublicKey field "
                      "without value.\n";
             return (-1); // error condition
         }
         else {
             m_pKeyPublic->SetPublicKey(
                 armorPublicKey); // todo check this for failure.
         }
 
         return 1;
     }
     else if (strNodeName.Compare("mintPrivateInfo")) {
         int64_t lDenomination = atol(xml->getAttributeValue("denomination"));
 
         OTASCIIArmor* pArmor = new OTASCIIArmor;
 
         OT_ASSERT(nullptr != pArmor);
 
         if (!OTContract::LoadEncodedTextField(xml, *pArmor) ||
             !pArmor->Exists()) {
             otErr << "Error in Mint::ProcessXMLNode: mintPrivateInfo field "
                      "without value.\n";
 
             delete pArmor;
             pArmor = nullptr;
 
             return (-1); // error condition
         }
         else {
             m_mapPrivate[lDenomination] = pArmor;
         }
 
         return 1;
     }
     else if (strNodeName.Compare("mintPublicInfo")) {
         int64_t lDenomination = atol(xml->getAttributeValue("denomination"));
 
         OTASCIIArmor* pArmor = new OTASCIIArmor;
 
         OT_ASSERT(nullptr != pArmor);
 
         if (!OTContract::LoadEncodedTextField(xml, *pArmor) ||
             !pArmor->Exists()) {
             otErr << "Error in Mint::ProcessXMLNode: mintPublicInfo field "
                      "without value.\n";
 
             delete pArmor;
             pArmor = nullptr;
 
             return (-1); // error condition
         }
         else {
             m_mapPublic[lDenomination] = pArmor;
             m_nDenominationCount++; // Whether client or server, both sides have
                                     // public. Each public denomination should
                                     // increment this count.
         }
 
         return 1;
     }
 
     return nReturnVal;
 }

void opentxs::Mint::Release ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 272 of file Mint.cpp.

 {
     Release_Mint();
 
     ot_super::Release(); // I overrode the parent, so now I give him a chance to
                          // clean up.
 
     InitMint();
 }

void opentxs::Mint::Release_Mint ( )

Definition at line 260 of file Mint.cpp.

 {
     ReleaseDenominations();
 
     m_CashAccountID.Release();
 
     if (m_pReserveAcct) {
         delete m_pReserveAcct;
         m_pReserveAcct = nullptr;
     }
 }

void opentxs::Mint::ReleaseDenominations ( )

Definition at line 237 of file Mint.cpp.

 {
     while (!m_mapPublic.empty()) {
         OTASCIIArmor* pArmor = m_mapPublic.begin()->second;
         m_mapPublic.erase(m_mapPublic.begin());
         delete pArmor;
         pArmor = nullptr;
     }
     while (!m_mapPrivate.empty()) {
         OTASCIIArmor* pArmor = m_mapPrivate.begin()->second;
         m_mapPrivate.erase(m_mapPrivate.begin());
         delete pArmor;
         pArmor = nullptr;
     }
 }

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

virtual

Implements opentxs::OTContract.

Definition at line 969 of file Mint.cpp.

 {
     return true;
 }

bool opentxs::Mint::SaveMint ( const char * szAppend = nullptr )

Definition at line 440 of file Mint.cpp.

 {
     if (!m_strFoldername.Exists()) m_strFoldername.Set(OTFolders::Mint().Get());
 
     const OTString strServerID(m_ServerID), strAssetTypeID(m_AssetID);
 
     if (!m_strFilename.Exists()) {
         if (nullptr != szAppend)
             m_strFilename.Format("%s%s%s%s", strServerID.Get(),
                                  OTLog::PathSeparator(), // server side
                                  strAssetTypeID.Get(), szAppend);
         else
             m_strFilename.Format("%s%s%s", strServerID.Get(),
                                  OTLog::PathSeparator(),
                                  strAssetTypeID.Get()); // client side
     }
 
     OTString strFilename;
     if (nullptr != szAppend)
         strFilename.Format("%s%s", strAssetTypeID.Get(), szAppend);
     else
         strFilename = strAssetTypeID.Get();
 
     const char* szFolder1name = OTFolders::Mint().Get();
     const char* szFolder2name = strServerID.Get();
     const char* szFilename = strFilename.Get();
 
     OTString strRawFile;
 
     if (!SaveContractRaw(strRawFile)) {
         otErr << "Mint::SaveMint: Error saving Mintfile (to string):\n"
               << szFolder1name << OTLog::PathSeparator() << szFolder2name
               << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     OTString strFinal;
     OTASCIIArmor ascTemp(strRawFile);
 
     if (false ==
         ascTemp.WriteArmoredString(strFinal, m_strContractType.Get())) {
         otErr << "Mint::SaveMint: Error saving mint (failed writing armored "
                  "string):\n" << szFolder1name << OTLog::PathSeparator()
               << szFolder2name << OTLog::PathSeparator() << szFilename << "\n";
         return false;
     }
 
     bool bSaved =
         OTDB::StorePlainString(strFinal.Get(), szFolder1name, szFolder2name,
                                szFilename); // <=== SAVING TO LOCAL DATA STORE.
     if (!bSaved) {
         if (nullptr != szAppend)
             otErr << "Mint::SaveMint: Error writing to file: " << szFolder1name
                   << OTLog::PathSeparator() << szFolder2name
                   << OTLog::PathSeparator() << szFilename << szAppend << "\n";
         else
             otErr << "Mint::SaveMint: Error writing to file: " << szFolder1name
                   << OTLog::PathSeparator() << szFolder2name
                   << OTLog::PathSeparator() << szFilename << "\n";
 
         return false;
     }
 
     return true;
 }

void opentxs::Mint::SetAssetID ( const OTIdentifier & newID )

inline

Definition at line 294 of file Mint.hpp.

     {
         m_AssetID = newID;
     }

void opentxs::Mint::SetSavePrivateKeys ( bool bDoIt = true )

inline

Definition at line 267 of file Mint.hpp.

     {
         m_bSavePrivateKeys = bDoIt;
     }

virtual EXPORT bool opentxs::Mint::SignToken	(	OTPseudonym &	theNotary,
		Token &	theToken,
		OTString &	theOutput,
		int32_t	nTokenIndex
	)

pure virtual

Implemented in opentxs::MintLucre.

void opentxs::Mint::UpdateContents ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 635 of file Mint.cpp.

 {
     OT_ASSERT(nullptr != m_pKeyPublic);
 
     OTString SERVER_ID(m_ServerID), SERVER_NYM_ID(m_ServerNymID),
         ASSET_ID(m_AssetID), CASH_ACCOUNT_ID(m_CashAccountID);
 
     int64_t lFrom = OTTimeGetSecondsFromTime(m_VALID_FROM);
     int64_t lTo = OTTimeGetSecondsFromTime(m_VALID_TO);
     int64_t lExpiration = OTTimeGetSecondsFromTime(m_EXPIRATION);
 
     // 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("<mint version=\"%s\"\n"
                               " serverID=\"%s\"\n"
                               " serverNymID=\"%s\"\n"
                               " assetTypeID=\"%s\"\n"
                               " cashAcctID=\"%s\"\n"
                               " series=\"%d\"\n"
                               " expiration=\"%" PRId64 "\"\n"
                               " validFrom=\"%" PRId64 "\"\n"
                               " validTo=\"%" PRId64 "\""
                               " >\n\n",
                               m_strVersion.Get(), SERVER_ID.Get(),
                               SERVER_NYM_ID.Get(), ASSET_ID.Get(),
                               CASH_ACCOUNT_ID.Get(), m_nSeries, lExpiration,
                               lFrom, lTo);
 
     OTASCIIArmor armorPublicKey;
     m_pKeyPublic->GetPublicKey(armorPublicKey);
     m_xmlUnsigned.Concatenate("<mintPublicKey>\n%s</mintPublicKey>\n\n",
                               armorPublicKey.Get());
 
     if (m_nDenominationCount) {
         if (m_bSavePrivateKeys) {
             m_bSavePrivateKeys = false; // reset this back to false again. Use
                                         // SetSavePrivateKeys() to set it true.
 
             for (auto& it : m_mapPrivate) {
                 OTASCIIArmor* pArmor = it.second;
                 OT_ASSERT_MSG(nullptr != pArmor, "nullptr private mint pointer "
                                                  "in "
                                                  "Mint::UpdateContents.\n");
 
                 m_xmlUnsigned.Concatenate(
                     "<mintPrivateInfo denomination=\"%lld\">\n"
                     "%s</mintPrivateInfo>\n\n",
                     it.first, pArmor->Get());
             }
         }
         for (auto& it : m_mapPublic) {
             OTASCIIArmor* pArmor = it.second;
             OT_ASSERT_MSG(
                 nullptr != pArmor,
                 "nullptr public mint pointer in Mint::UpdateContents.\n");
 
             m_xmlUnsigned.Concatenate("<mintPublicInfo denomination=\"%lld\">\n"
                                       "%s</mintPublicInfo>\n\n",
                                       it.first, pArmor->Get());
         }
     }
 
     m_xmlUnsigned.Concatenate("</mint>\n");
 }

bool opentxs::Mint::VerifyContractID ( ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 535 of file Mint.cpp.

 {
     // I use the == operator here because there is no != operator at this time.
     // That's why you see the ! outside the parenthesis.
     if (!(m_ID == m_AssetID)) {
         OTString str1(m_ID), str2(m_AssetID);
 
         otErr << "\nMint ID does NOT match Asset Type ID in "
                  "Mint::VerifyContractID.\n" << str1 << "\n" << str2 << "\n";
         //                "\nRAW FILE:\n--->" << m_strRawFile << "<---"
         return false;
     }
     else {
         OTString str1(m_ID);
         otInfo << "\nMint ID *SUCCESSFUL* match to Asset Contract ID:\n" << str1
                << "\n\n";
         return true;
     }
 }

bool opentxs::Mint::VerifyMint ( const OTPseudonym & theOperator )

Definition at line 508 of file Mint.cpp.

 {
     // Make sure that the supposed Contract ID that was set is actually
     // a hash of the contract file, signatures and all.
     if (!VerifyContractID()) {
         otErr << "Error comparing Mint ID to Asset Contract ID in "
                  "Mint::VerifyMint\n";
         return false;
     }
     else if (!VerifySignature(theOperator)) {
         otErr << "Error verifying signature on mint in Mint::VerifyMint.\n";
         return false;
     }
 
     otLog3 << "\nWe now know that...\n"
               "1) The Asset Contract ID matches the Mint ID loaded from the "
               "Mint file.\n"
               "2) The SIGNATURE VERIFIED.\n\n";
     return true;
 }

virtual EXPORT bool opentxs::Mint::VerifyToken	(	OTPseudonym &	theNotary,
		OTString &	theCleartextToken,
		int64_t	lDenomination
	)

pure virtual

Implemented in opentxs::MintLucre.

Member Data Documentation

OTIdentifier opentxs::Mint::m_AssetID

protected

Definition at line 174 of file Mint.hpp.

bool opentxs::Mint::m_bSavePrivateKeys

protected

Definition at line 180 of file Mint.hpp.

OTIdentifier opentxs::Mint::m_CashAccountID

protected

Definition at line 199 of file Mint.hpp.

time64_t opentxs::Mint::m_EXPIRATION

protected

Definition at line 196 of file Mint.hpp.

mapOfArmor opentxs::Mint::m_mapPrivate

protected

Definition at line 160 of file Mint.hpp.

mapOfArmor opentxs::Mint::m_mapPublic

protected

Definition at line 164 of file Mint.hpp.

int32_t opentxs::Mint::m_nDenominationCount

protected

Definition at line 176 of file Mint.hpp.

int32_t opentxs::Mint::m_nSeries

protected

Definition at line 186 of file Mint.hpp.

OTAsymmetricKey* opentxs::Mint::m_pKeyPublic

protected

Definition at line 172 of file Mint.hpp.

OTAccount* opentxs::Mint::m_pReserveAcct

protected

Definition at line 202 of file Mint.hpp.

OTIdentifier opentxs::Mint::m_ServerID

protected

Definition at line 167 of file Mint.hpp.

OTIdentifier opentxs::Mint::m_ServerNymID

protected

Definition at line 169 of file Mint.hpp.

time64_t opentxs::Mint::m_VALID_FROM

protected

Definition at line 192 of file Mint.hpp.

time64_t opentxs::Mint::m_VALID_TO

protected

Definition at line 194 of file Mint.hpp.

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation