#include <TokenLucre.hpp>

Inheritance diagram for opentxs::Token_Lucre:

Collaboration diagram for opentxs::Token_Lucre:

Public Member Functions
virtual EXPORT bool	ProcessToken (const OTPseudonym &theNym, Mint &theMint, Token &theRequest)

virtual EXPORT	~Token_Lucre ()

Public Member Functions inherited from opentxs::Token
virtual EXPORT	~Token ()

EXPORT void	Release_Token ()

virtual void	Release ()

EXPORT void	ReleasePrototokens ()

virtual void	UpdateContents ()

void	SetSavePrivateKeys ()

EXPORT bool	ReassignOwnership (OTNym_or_SymmetricKey &oldOwner, OTNym_or_SymmetricKey &newOwner)

const OTASCIIArmor &	GetSpendable () const

void	SetSpendable (const OTASCIIArmor &theArmor)

EXPORT bool	GetSpendableString (OTNym_or_SymmetricKey theOwner, OTString &theString) const

Token::tokenState	GetState () const

int32_t	GetSeries () const

void	SetSeriesAndExpiration (int32_t nSeries, time64_t VALID_FROM, time64_t VALID_TO)

EXPORT bool	VerifyToken (OTPseudonym &theNotary, Mint &theMint)

EXPORT bool	IsTokenAlreadySpent (OTString &theCleartextToken)

EXPORT bool	RecordTokenAsSpent (OTString &theCleartextToken)

EXPORT void	SetSignature (const OTASCIIArmor &theSignature, int32_t nTokenIndex)

EXPORT bool	GetSignature (OTASCIIArmor &theSignature) const

int64_t	GetDenomination () const

void	SetDenomination (int64_t lVal)

EXPORT bool	GetPrototoken (OTASCIIArmor &ascPrototoken, int32_t nTokenIndex)

EXPORT bool	GetPrivatePrototoken (OTASCIIArmor &ascPrototoken, int32_t nTokenIndex)

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

Public Member Functions inherited from opentxs::OTInstrument
EXPORT	OTInstrument ()

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

virtual EXPORT	~OTInstrument ()

void	Release_Instrument ()

EXPORT bool	VerifyCurrentDate ()

EXPORT bool	IsExpired ()

time64_t	GetValidFrom () const

time64_t	GetValidTo () const

const OTIdentifier &	GetAssetID () const

const OTIdentifier &	GetServerID () const

void	InitInstrument ()

Public Member Functions inherited from opentxs::OTScriptable
virtual EXPORT void	SetDisplayLabel (const std::string *pstrLabel=nullptr)

int32_t	GetPartyCount () const

int32_t	GetBylawCount () const

virtual EXPORT bool	AddParty (OTParty &theParty)

virtual EXPORT bool	AddBylaw (OTBylaw &theBylaw)

virtual EXPORT bool	ConfirmParty (OTParty &theParty)

EXPORT OTParty *	GetParty (std::string str_party_name) const

EXPORT OTBylaw *	GetBylaw (std::string str_bylaw_name) const

EXPORT OTClause *	GetClause (std::string str_clause_name) const

EXPORT OTParty *	GetPartyByIndex (int32_t nIndex) const

EXPORT OTBylaw *	GetBylawByIndex (int32_t nIndex) const

EXPORT OTParty *	FindPartyBasedOnNymAsAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

EXPORT OTParty *	FindPartyBasedOnNymAsAuthAgent (OTPseudonym &theNym, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccount (OTAccount &theAccount, OTPartyAccount **ppPartyAccount=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnNymIDAsAuthAgent (const OTIdentifier &theNymID, OTAgent **ppAgent=nullptr) const

OTParty *	FindPartyBasedOnAccountID (const OTIdentifier &theAcctID, OTPartyAccount **ppPartyAccount=nullptr) const

OTAgent *	GetAgent (std::string str_agent_name) const

OTPartyAccount *	GetPartyAccount (std::string str_acct_name) const

OTPartyAccount *	GetPartyAccountByID (const OTIdentifier &theAcctID) const

EXPORT int32_t	GetCountTransNumsNeededForAgent (std::string str_agent_name) const

virtual EXPORT bool	VerifyNymAsAgent (OTPseudonym &theNym, OTPseudonym &theSignerNym, mapOfNyms *pmap_ALREADY_LOADED=nullptr) const

virtual EXPORT bool	VerifyNymAsAgentForAccount (OTPseudonym &theNym, OTAccount &theAccount) const

bool	VerifyPartyAuthorization (OTParty &theParty, OTPseudonym &theSignerNym, const OTString &strServerID, mapOfNyms pmap_ALREADY_LOADED=nullptr, mapOfNyms pmap_NEWLY_LOADED=nullptr, bool bBurnTransNo=false)

bool	VerifyPartyAcctAuthorization (OTPartyAccount &thePartyAcct, OTPseudonym &theSignerNym, const OTString &strServerID, bool bBurnTransNo=false)

EXPORT bool	VerifyThisAgainstAllPartiesSignedCopies ()

EXPORT bool	AllPartiesHaveSupposedlyConfirmed ()

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

void	ClearTemporaryPointers ()

bool	GetHooks (std::string str_HookName, mapOfClauses &theResults)

OTClause *	GetCallback (std::string str_CallbackName)

OTVariable *	GetVariable (std::string str_VarName)

bool	IsDirty () const

bool	IsDirtyImportant () const

void	SetAsClean ()

EXPORT bool	SendNoticeToAllParties (bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const OTString &strReference, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr) const

EXPORT bool	CanExecuteClause (std::string str_party_name, std::string str_clause_name)

bool	ExecuteCallback (OTClause &theCallbackClause, mapOfVariables &theParameters, OTVariable &varReturnVal)

virtual EXPORT void	RegisterOTNativeCallsWithScript (OTScript &theScript)

virtual EXPORT bool	Compare (OTScriptable &rhs) const

	OTScriptable ()

virtual	~OTScriptable ()

void	UpdateContentsToString (OTString &strAppend, bool bCalculatingID) const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

void	Release_Scriptable ()

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

virtual EXPORT bool	LoadContract ()

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 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
EXPORT	Token_Lucre ()

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

EXPORT	Token_Lucre (const Purse &thePurse)

virtual EXPORT bool	GenerateTokenRequest (const OTPseudonym &theNym, Mint &theMint, int64_t lDenomination, int32_t nTokenCount=Token::GetMinimumPrototokenCount())

Protected Member Functions inherited from opentxs::Token
virtual int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

void	InitToken ()

bool	ChooseIndex (int32_t nIndex)

EXPORT	Token ()

EXPORT Token &	operator= (const Token &rhs)

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

EXPORT	Token (const Purse &thePurse)

Protected Member Functions inherited from opentxs::OTInstrument
void	SetValidFrom (time64_t TIME_FROM)

void	SetValidTo (time64_t TIME_TO)

void	SetAssetID (const OTIdentifier &ASSET_ID)

void	SetServerID (const OTIdentifier &SERVER_ID)

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

Friends
class	Token

Additional Inherited Members
Public Types inherited from opentxs::Token
enum	tokenState { blankToken, protoToken, signedToken, spendableToken, verifiedToken, errorToken }

Static Public Member Functions inherited from opentxs::Token
static EXPORT int32_t	GetMinimumPrototokenCount ()

static EXPORT Token *	TokenFactory (OTString strInput)

static EXPORT Token *	TokenFactory (OTString strInput, const Purse &thePurse)

static EXPORT Token *	TokenFactory (OTString strInput, const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

static EXPORT Token *	LowLevelInstantiate (const Purse &thePurse)

static EXPORT Token *	LowLevelInstantiate (const OTString &strFirstLine)

static EXPORT Token *	LowLevelInstantiate (const OTString &strFirstLine, const Purse &thePurse)

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

static EXPORT Token *	InstantiateAndGenerateTokenRequest (const Purse &thePurse, const OTPseudonym &theNym, Mint &theMint, int64_t lDenomination, int32_t nTokenCount=Token::GetMinimumPrototokenCount())

Static Public Member Functions inherited from opentxs::OTScriptable
static EXPORT OTScriptable *	InstantiateScriptable (const OTString &strInput)

static bool	ValidateName (std::string str_name)

static std::string	GetTime ()

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::Token
bool	m_bPasswordProtected

OTASCIIArmor	m_ascSpendable

OTASCIIArmor	m_Signature

int64_t	m_lDenomination

mapOfPrototokens	m_mapPublic

mapOfPrototokens	m_mapPrivate

int32_t	m_nTokenCount

int32_t	m_nChosenIndex

int32_t	m_nSeries

tokenState	m_State

bool	m_bSavePrivateKeys

Protected Attributes inherited from opentxs::OTInstrument
OTIdentifier	m_AssetTypeID

OTIdentifier	m_ServerID

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

Protected Attributes inherited from opentxs::OTScriptable
mapOfParties	m_mapParties

mapOfBylaws	m_mapBylaws

bool	m_bCalculatingID

bool	m_bSpecifyAssetID

bool	m_bSpecifyParties

OTString	m_strLabel

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 196 of file TokenLucre.hpp.

Constructor & Destructor Documentation

opentxs::Token_Lucre::Token_Lucre ( )

protected

Definition at line 159 of file TokenLucre.cpp.

     : ot_super()
 {
 }

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

protected

Definition at line 164 of file TokenLucre.cpp.

     : ot_super(SERVER_ID, ASSET_ID)
 {
 }

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

protected

Definition at line 170 of file TokenLucre.cpp.

     : ot_super(thePurse)
 {
 }

opentxs::Token_Lucre::~Token_Lucre ( )

virtual

Definition at line 175 of file TokenLucre.cpp.

176 {

177 }

Member Function Documentation

bool opentxs::Token_Lucre::GenerateTokenRequest	(	const OTPseudonym &	theNym,
		Mint &	theMint,
		int64_t	lDenomination,
		int32_t	nTokenCount = `Token::GetMinimumPrototokenCount()`
	)

protectedvirtual

Implements opentxs::Token.

Definition at line 183 of file TokenLucre.cpp.

 {
     //    otErr << "%s <bank public info> <coin request private output file>
     // <coin request public output file>\n", argv[0]);
     //
     if (Token::blankToken != m_State) {
         otErr << "Token_Lucre::GenerateTokenRequest: Blank token expected.\n";
         return false;
     }
 
     LucreDumper setDumper; // todo security.
 
     OpenSSL_BIO bioBank = BIO_new(
         BIO_s_mem()); // Input. We must supply the bank's public lucre info
 
     // This version base64-DECODES the ascii-armored string passed in,
     // and then sets the decoded plaintext string onto the string.
     // OTString::OTString(const OTASCIIArmor & strValue)
     OTASCIIArmor ascPublicMint;
 
     theMint.GetPublic(ascPublicMint, lDenomination);
     //    otErr << "DEBUG: OTToken  public asc: \n%s\n", ascPublicMint.Get());
 
     OTString strPublicMint(ascPublicMint);
     //    otErr << "DEBUG: OTToken  public str: \n%s\n", strPublicMint.Get());
 
     // Get the bank's public key (now decoded in strPublicMint)
     // and put it into bioBank so we can use it with Lucre.
     BIO_puts(bioBank, strPublicMint.Get());
 
     // Instantiate a PublicBank (Lucre) object.
     // We will use it to generate all the prototokens in the loop below.
     PublicBank bank;
     bank.ReadBIO(bioBank);
 
     Release(); // note: why is this here? I guess to release the prototokens,
                // the signature (is there one?) and m_ascSpendable (exists?
                // doubt it.) This WAS also doing "InitToken" (no longer) which
                // WAS setting series and expiration range back to 0 (no longer.)
                // Which was causing problems for all series above 0. I'm leaving
                // this call here, to do the stuff I guess it was put here for.
                // But things such as the series, expiration date range, and
                // token count, etc are no longer (inadvertantly) set to 0 here
                // on this line. I'm also moving the SetSeriesAndExpiration call
                // to be BELOW this line, since it's not apparently needed above
                // this line anyway.
 
     // We are supposed to set these values here.
     // The server actually sets them again, for security reasons.
     // But we should still set them since server may choose to reject the
     // request.
     // Update: the series information on this token IS used by the server, since
     // more than
     // one mint may be currently valid, and since the server has to process the
     // request using
     // the proper mint, corresponding to the same mint that was used to GENERATE
     // that request.
     // So the server uses the series value from this token in order to choose
     // which mint is loaded,
     // on the server side. When this call WAS above the Release() call above,
     // these values were
     // getting wiped in Release back to 0. So I've moved it below the Release()
     // call. (I've also
     // stopped wiping them in Release.)
     //
     SetSeriesAndExpiration(theMint.GetSeries(), theMint.GetValidFrom(),
                            theMint.GetValidTo());
 
     const int32_t nFinalTokenCount =
         (nTokenCount < Token::GetMinimumPrototokenCount())
             ? Token::GetMinimumPrototokenCount()
             : nTokenCount;
 
     // Token count is actually 1 (always) with Lucre, although this lib has
     // potential to work with
     // multiple proto-tokens, you can see this loop as though it always executes
     // just once.
     for (int32_t i = 0; i < nFinalTokenCount; i++) {
         OpenSSL_BIO bioCoin = BIO_new(BIO_s_mem()); // These two are output. We
                                                     // must write these bios,
                                                     // after
         OpenSSL_BIO bioPublicCoin = BIO_new(
             BIO_s_mem()); // the operation, back into some form we can use
 
         CoinRequest req(bank);
 
         // write the private coin request to BIO
         req.WriteBIO(bioCoin);
 
         // write the public coin request to BIO
         ((PublicCoinRequest*)&req)->WriteBIO(bioPublicCoin);
 
         // Convert the two bios to our format
         char privateCoinBuffer[4096],
             publicCoinBuffer[4096]; // todo stop hardcoding these string lengths
         int32_t privatecoinLen = BIO_read(bioCoin, privateCoinBuffer,
                                           4000); // cutting it a little short on
                                                  // purpose, with the buffer.
                                                  // Just makes me feel more
                                                  // comfortable for some reason.
         int32_t publiccoinLen = BIO_read(bioPublicCoin, publicCoinBuffer, 4000);
 
         if (privatecoinLen && publiccoinLen) {
             // With this, we have the Lucre public and private bank info
             // converted to OTStrings
             OTString strPublicCoin;
             strPublicCoin.Set(publicCoinBuffer, publiccoinLen);
             OTString strPrivateCoin;
             strPrivateCoin.Set(privateCoinBuffer, privatecoinLen);
 
             OTASCIIArmor* pArmoredPublic = new OTASCIIArmor(strPublicCoin);
             OTASCIIArmor* pArmoredPrivate = new OTASCIIArmor();
 
             OT_ASSERT_MSG(
                 ((nullptr != pArmoredPublic) && (nullptr != pArmoredPrivate)),
                 "ERROR: Unable to allocate memory in "
                 "Token_Lucre::GenerateTokenRequest\n");
 
             // Change the state. It's no longer a blank token, but a prototoken.
             m_State = Token::protoToken;
 
             // Seal the private coin info up into an encrypted Envelope
             // and set it onto pArmoredPrivate (which was just added to our
             // internal map, above.)
             OTEnvelope theEnvelope;
             theEnvelope.Seal(theNym, strPrivateCoin); // Todo check the return
                                                       // values on these two
                                                       // functions
             theEnvelope.GetAsciiArmoredData(*pArmoredPrivate);
 
             m_mapPublic[i] = pArmoredPublic;
             m_mapPrivate[i] = pArmoredPrivate;
 
             m_nTokenCount = nFinalTokenCount;
             SetDenomination(lDenomination);
         }
         else {
             // Error condition todo
         }
     }
 
     return true;
 }

bool opentxs::Token_Lucre::ProcessToken	(	const OTPseudonym &	theNym,
		Mint &	theMint,
		Token &	theRequest
	)

virtual

Implements opentxs::Token.

Definition at line 332 of file TokenLucre.cpp.

 {
     //    otErr << "%s <bank public info> <private coin request> <signed coin
     // request> <coin>\n",
     bool bReturnValue = false;
 
     // When the Mint has signed a token and sent it back to the client,
     // the client must unblind the token and set it as spendable. Thus,
     // this function is only performed on tokens in the signedToken state.
     if (Token::signedToken != m_State) {
         otErr << "Signed token expected in Token_Lucre::ProcessToken\n";
         return false;
     }
 
     // Lucre
     LucreDumper setDumper; // todo security.
 
     OpenSSL_BIO bioBank = BIO_new(BIO_s_mem());           // input
     OpenSSL_BIO bioSignature = BIO_new(BIO_s_mem());      // input
     OpenSSL_BIO bioPrivateRequest = BIO_new(BIO_s_mem()); // input
     OpenSSL_BIO bioCoin = BIO_new(BIO_s_mem());           // output
 
     // Get the bank's public key (decoded into strPublicMint)
     // and put it into bioBank so we can use it with Lucre.
     //
     OTASCIIArmor ascPublicMint;
     theMint.GetPublic(ascPublicMint, GetDenomination());
     OTString strPublicMint(ascPublicMint);
     BIO_puts(bioBank, strPublicMint.Get());
 
     // Get the existing signature into a bio.
     //    otErr << "DEBUGGING, m_Signature: -------------%s--------------\n",
     // m_Signature.Get());
     OTString strSignature(m_Signature);
     BIO_puts(bioSignature, strSignature.Get());
 
     // I need the Private coin request also. (Only the client has this private
     // coin request data.)
     OTASCIIArmor thePrototoken; // The server sets m_nChosenIndex when it signs
                                 // the token.
     bool bFoundToken =
         theRequest.GetPrivatePrototoken(thePrototoken, m_nChosenIndex);
 
     if (bFoundToken) {
         //        otErr << "THE PRIVATE REQUEST ARMORED
         // CONTENTS:\n------------------>%s<-----------------------\n",
         //                thePrototoken.Get());
 
         // Decrypt the prototoken
         OTString strPrototoken;
         OTEnvelope theEnvelope(thePrototoken);
         theEnvelope.Open(theNym, strPrototoken); // todo check return value.
 
         //        otErr << "THE PRIVATE REQUEST
         // CONTENTS:\n------------------>%s<-----------------------\n",
         //                strPrototoken.Get());
 
         // copy strPrototoken to a BIO
         BIO_puts(bioPrivateRequest, strPrototoken.Get());
 
         // ------- Okay, the BIOs are all loaded.... let's process...
 
         PublicBank bank(bioBank);
         CoinRequest req(bioPrivateRequest);
 
         // TODO make sure I'm not leaking memory with these ReadNumbers
         // Probably need to be calling some free function for each one.
 
         // Apparently reading the request id here and then just discarding it...
         ReadNumber(bioSignature, "request=");
 
         // Versus the signature data, which is read into bnSignature apparently.
         BIGNUM* bnSignature = ReadNumber(bioSignature, "signature=");
         DumpNumber("signature=", bnSignature);
 
         // Produce the final unblinded token in Coin coin, and write it to
         // bioCoin...
         Coin coin; // Coin Request, processes into Coin, with Bank and Signature
                    // passed in.
         req.ProcessResponse(&coin, bank, bnSignature); // Notice still
                                                        // apparently "request"
                                                        // info is discarded.
         coin.WriteBIO(bioCoin);
 
         // convert bioCoin to a C-style string...
         char CoinBuffer[1024]; // todo stop hardcoding these string lengths
         int32_t coinLen =
             BIO_read(bioCoin, CoinBuffer, 1000); // cutting it a little short on
                                                  // purpose, with the buffer.
                                                  // Just makes me feel more
                                                  // comfortable for some reason.
 
         if (coinLen) {
             // ...to OTString...
             OTString strCoin;
             strCoin.Set(CoinBuffer, coinLen);
 
             //            otErr << "Processing token...\n%s\n", strCoin.Get());
 
             // ...to Envelope stored in m_ascSpendable (encrypted and
             // base64-encoded)
             OTEnvelope theEnvelope;
             theEnvelope.Seal(theNym, strCoin); // Todo check the return values
                                                // on these two functions
             theEnvelope.GetAsciiArmoredData(
                 m_ascSpendable); // Here's the final product.
 
             //            otErr << "NEW SPENDABLE
             // token...\n--------->%s<----------------\n",
             // m_ascSpendable.Get());
 
             // Now the coin is encrypted from here on out, and otherwise
             // ready-to-spend.
             m_State = Token::spendableToken;
             bReturnValue = true;
 
             // Lastly, we free the signature data, which is no longer needed,
             // and which could be
             // otherwise used to trace the token. (Which we don't want.)
             m_Signature.Release();
         }
     }
     // Todo log error here if the private prototoken is not found. (Very strange
     // if so!!)
     //  else {}
 
     return bReturnValue;
 }

Friends And Related Function Documentation

friend class Token

friend

Definition at line 200 of file TokenLucre.hpp.

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

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

Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation