#include <MintLucre.hpp>

Inheritance diagram for opentxs::MintLucre:

Collaboration diagram for opentxs::MintLucre:

Public Member Functions
virtual bool	AddDenomination (OTPseudonym &theNotary, int64_t lDenomination, int32_t nPrimeLength=1024)

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

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

virtual EXPORT	~MintLucre ()

Public Member Functions inherited from opentxs::Mint
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)

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 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

Protected Member Functions
	MintLucre ()

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

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

Protected Member Functions inherited from opentxs::Mint
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 ()

Friends
class	Mint

Additional Inherited Members
Static Public Member Functions inherited from opentxs::Mint
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 Attributes inherited from opentxs::Mint
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 151 of file MintLucre.hpp.

Constructor & Destructor Documentation

opentxs::MintLucre::MintLucre ( )

protected

Definition at line 154 of file MintLucre.cpp.

     : ot_super()
 {
 }

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

protected

Definition at line 159 of file MintLucre.cpp.

     : ot_super(strServerID, strAssetTypeID)
 {
 }

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

protected

Definition at line 165 of file MintLucre.cpp.

     : ot_super(strServerID, strServerNymID, strAssetTypeID)
 {
 }

opentxs::MintLucre::~MintLucre ( )

virtual

Definition at line 172 of file MintLucre.cpp.

173 {

174 }

Member Function Documentation

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

virtual

Implements opentxs::Mint.

Definition at line 192 of file MintLucre.cpp.

 {
     OT_ASSERT(nullptr != m_pKeyPublic);
 
     bool bReturnValue = false;
 
     // Let's make sure it doesn't already exist
     OTASCIIArmor theArmor;
     if (GetPublic(theArmor, lDenomination)) {
         // it already exists.
         otErr << "Error: Denomination public already exists in "
                  "OTMint::AddDenomination\n";
         return false;
     }
     if (GetPrivate(theArmor, lDenomination)) {
         // it already exists.
         otErr << "Error: Denomination private already exists in "
                  "OTMint::AddDenomination\n";
         return false;
     }
 
     //        otErr << "%s <size of bank prime in bits> <bank data file> <bank
     // public data file>\n",
 
     if ((nPrimeLength / 8) < (MIN_COIN_LENGTH + DIGEST_LENGTH)) {
         otErr << "Prime must be at least "
               << (MIN_COIN_LENGTH + DIGEST_LENGTH) * 8 << " bits\n";
         return false;
     }
 
     if (nPrimeLength % 8) {
         otErr << "Prime length must be a multiple of 8\n";
         return false;
     }
 
 #ifdef _WIN32
     SetMonitor("openssl.dump");
 #else
     SetMonitor(stderr);
 #endif
 
     OpenSSL_BIO bio = BIO_new(BIO_s_mem());
     OpenSSL_BIO bioPublic = BIO_new(BIO_s_mem());
 
     // Generate the mint private key information
     Bank bank(nPrimeLength / 8);
     bank.WriteBIO(bio);
 
     // Generate the mint public key information
     PublicBank pbank(bank);
     pbank.WriteBIO(bioPublic);
 
     // Copy from BIO back to a normal OTString or Ascii-Armor
     char privateBankBuffer[4096],
         publicBankBuffer[4096]; // todo stop hardcoding these string lengths
     int32_t privatebankLen =
         BIO_read(bio, privateBankBuffer, 4000); // cutting it a little short on
                                                 // purpose, with the buffer.
     int32_t publicbankLen =
         BIO_read(bioPublic, publicBankBuffer,
                  4000); // Just makes me feel more comfortable for some reason.
 
     if (privatebankLen && publicbankLen) {
         // With this, we have the Lucre public and private bank info converted
         // to OTStrings
         OTString strPublicBank;
         strPublicBank.Set(publicBankBuffer, publicbankLen);
         OTString strPrivateBank;
         strPrivateBank.Set(privateBankBuffer, privatebankLen);
 
         OTASCIIArmor* pPublic = new OTASCIIArmor();
         OTASCIIArmor* pPrivate = new OTASCIIArmor();
 
         OT_ASSERT(nullptr != pPublic);
         OT_ASSERT(nullptr != pPrivate);
 
         // Set the public bank info onto pPublic
         pPublic->SetString(strPublicBank, true); // linebreaks = true
 
         // Seal the private bank info up into an encrypted Envelope
         // and set it onto pPrivate
         OTEnvelope theEnvelope;
         theEnvelope.Seal(theNotary, strPrivateBank); // Todo check the return
                                                      // values on these two
                                                      // functions
         theEnvelope.GetAsciiArmoredData(*pPrivate);
 
         // Add the new key pair to the maps, using denomination as the key
         m_mapPublic[lDenomination] = pPublic;
         m_mapPrivate[lDenomination] = pPrivate;
 
         // Grab the Server Nym ID and save it with this Mint
         theNotary.GetIdentifier(m_ServerNymID);
 
         // Grab the Server's public key and save it with this Mint
         //
         const OTAsymmetricKey& theNotaryPubKey = theNotary.GetPublicSignKey();
         delete m_pKeyPublic;
         m_pKeyPublic = theNotaryPubKey.ClonePubKey();
 
         m_nDenominationCount++;
         // ---------------------------
         // Success!
         bReturnValue = true;
         otWarn << "Successfully added denomination: " << lDenomination << "\n";
     }
 
     return bReturnValue;
 }

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

virtual

Implements opentxs::Mint.

Definition at line 343 of file MintLucre.cpp.

 {
     bool bReturnValue = false;
 
     // otErr << "%s <bank file> <coin request> <coin signature> [<signature
     // repeats>]\n",
     LucreDumper setDumper;
 
     //    otErr << "OTMint::SignToken!!\nnTokenIndex: %d\n Denomination:
     // %lld\n", nTokenIndex, theToken.GetDenomination());
 
     OpenSSL_BIO bioBank = BIO_new(BIO_s_mem());      // input
     OpenSSL_BIO bioRequest = BIO_new(BIO_s_mem());   // input
     OpenSSL_BIO bioSignature = BIO_new(BIO_s_mem()); // output
 
     OTASCIIArmor thePrivate;
     GetPrivate(thePrivate, theToken.GetDenomination());
 
     // The Mint private info is encrypted in
     // m_mapPrivates[theToken.GetDenomination()].
     // So I need to extract that first before I can use it.
     OTEnvelope theEnvelope(thePrivate);
 
     OTString strContents; // output from opening the envelope.
     // Decrypt the Envelope into strContents
     if (!theEnvelope.Open(theNotary, strContents)) return false;
 
     // copy strContents to a BIO
     BIO_puts(bioBank, strContents.Get());
 
     //    otErr << "BANK CONTENTS:\n%s--------------------------------------\n",
     // strContents.Get());
 
     // Instantiate the Bank with its private key
     Bank bank(bioBank);
     //    otErr << "BANK INSTANTIATED.--------------------------------------\n";
 
     // I need the request. the prototoken.
     OTASCIIArmor ascPrototoken;
     bool bFoundToken = theToken.GetPrototoken(ascPrototoken, nTokenIndex);
 
     if (bFoundToken) {
         // base64-Decode the prototoken
         OTString strPrototoken(ascPrototoken);
 
         //        otErr << "\n--------------------------------------\nDEBUG:
         // PROTOTOKEN CONTENTS:\n"
         //                "-----------------%s---------------------\n",
         // strPrototoken.Get() );
 
         // copy strPrototoken to a BIO
         BIO_puts(bioRequest, strPrototoken.Get());
 
         // Load up the coin request from the bio (the prototoken)
         PublicCoinRequest req(bioRequest);
         //        otErr << "PROTOTOKEN
         // INSTANTIATED.--------------------------------------\n";
 
         // Sign it with the bank we previously instantiated.
         // results will be in bnSignature (BIGNUM)
         BIGNUM* bnSignature = bank.SignRequest(req);
 
         if (nullptr == bnSignature) {
             otErr << "MAJOR ERROR!: Bank.SignRequest failed in "
                      "MintLucre::SignToken\n";
         }
         else {
             //            otErr << "BANK.SIGNREQUEST
             // SUCCESSFUL.--------------------------------------\n";
 
             // Write the request contents, followed by the signature contents,
             // to the Signature bio. Then free the BIGNUM.
             req.WriteBIO(bioSignature); // the original request contents
             DumpNumber(bioSignature, "signature=",
                        bnSignature); // the new signature contents
             BN_free(bnSignature);
 
             // Read the signature bio into a C-style buffer...
             char sig_buf[1024]; // todo stop hardcoding these string lengths
             //            memset(sig_buf, 0, 1024); // zero it out. (I had this
             // commented out, but the size was 2048, so maybe it's safe now at
             // 1024.)
 
             int32_t sig_len = BIO_read(bioSignature, sig_buf,
                                        1000); // cutting it a little short on
                                               // purpose, with the buffer. Just
                                               // makes me feel more comfortable
                                               // for some reason.
 
             // Add the null terminator by hand (just in case.)
             sig_buf[sig_len] = '\0';
 
             if (sig_len) { // ***********************************************
                            //                otErr <<
                            // "\n--------------------------------------\n"
                 //                        "*** Siglen is %d. sig_str_len is
                 // %d.\nsig buf:\n------------%s------------\nLAST "
                 //                        "CHARACTER IS '%c'  SECOND TO LAST
                 // CHARACTER IS '%c'\n",
                 //                        sig_len, sig_str_len, sig_buf,
                 // sig_buf[sig_str_len-1], sig_buf[sig_str_len-2]);
 
                 // Copy the original coin request into the spendable field of
                 // the token object.
                 // (It won't actually be spendable until the client processes
                 // it, though.)
                 theToken.SetSpendable(ascPrototoken);
 
                 //                otErr << "***
                 // SPENDABLE:\n-----------%s---------------------\n",
                 // ascPrototoken.Get());
 
                 // Base64-encode the signature contents into
                 // theToken.m_Signature.
                 OTString strSignature(sig_buf);
                 //            strSignature.Set(sig_buf, sig_len-1); // sig_len
                 // includes null terminator, whereas Set() adds 1 for it.
 
                 //                otErr << "SIGNATURE:\n--------------------%s"
                 //                        "------------------\n",
                 // strSignature.Get());
 
                 // Here we pass the signature back to the caller.
                 // He will probably set it onto the token.
                 theOutput.Set(sig_buf, sig_len);
                 bReturnValue = true;
 
                 // This is also where we set the expiration date on the token.
                 // The client should have already done this, but we are
                 // explicitly
                 // setting the values here to prevent any funny business.
                 theToken.SetSeriesAndExpiration(m_nSeries, m_VALID_FROM,
                                                 m_VALID_TO);
             }
         }
     }
 
     return bReturnValue;
 }

bool opentxs::MintLucre::VerifyToken	(	OTPseudonym &	theNotary,
		OTString &	theCleartextToken,
		int64_t	lDenomination
	)

virtual

Implements opentxs::Mint.

Definition at line 487 of file MintLucre.cpp.

 {
     bool bReturnValue = false;
     //    otErr << "%s <bank info> <coin>\n", argv[0]);
     LucreDumper setDumper;
 
     OpenSSL_BIO bioBank = BIO_new(BIO_s_mem()); // input
     OpenSSL_BIO bioCoin = BIO_new(BIO_s_mem()); // input
 
     // --- copy theCleartextToken to bioCoin so lucre can load it
     BIO_puts(bioCoin, theCleartextToken.Get());
 
     // --- The Mint private info is encrypted in m_mapPrivate[lDenomination].
     // So I need to extract that first before I can use it.
     OTASCIIArmor theArmor;
     GetPrivate(theArmor, lDenomination);
     OTEnvelope theEnvelope(theArmor);
 
     OTString strContents; // will contain output from opening the envelope.
     // Decrypt the Envelope into strContents
     if (theEnvelope.Open(theNotary, strContents)) {
         // copy strContents to a BIO
         BIO_puts(bioBank, strContents.Get());
 
         // ---- Now the bank and coin bios are both ready to go...
 
         Bank bank(bioBank);
         Coin coin(bioCoin);
 
         if (bank.Verify(coin)) // Here's the boolean output: coin is verified!
         {
             bReturnValue = true;
 
             // (Done): When a token is redeemed, need to store it in the spent
             // token database.
             // Right now I can verify the token, but unless I check it against a
             // database, then
             // even though the signature verifies, it doesn't stop people from
             // redeeming the same
             // token again and again and again.
             //
             // (done): also need to make sure issuer has double-entries for
             // total amount outstanding.
             //
             // UPDATE: These are both done now.  The Spent Token database is
             // implemented in the transaction server,
             // (not OTLib proper) and the same server also now keeps a cash
             // account to match all cash withdrawals.
             // (Meaning, if 10,000 clams total have been withdrawn by various
             // users, then the server actually has
             // a clam account containing 10,000 clams. As the cash comes in for
             // redemption, the server debits it from
             // this account again before sending it to its final destination.
             // This way the server tracks total outstanding
             // amount, as an additional level of security after the blind
             // signature itself.)
         }
     }
 
     return bReturnValue;
 }

Friends And Related Function Documentation

friend class Mint

friend

Definition at line 155 of file MintLucre.hpp.

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

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

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation