#include <OTItem.hpp>

Inheritance diagram for opentxs::OTItem:

Collaboration diagram for opentxs::OTItem:

Public Types
enum	itemType { transfer, atTransfer, acceptTransaction, atAcceptTransaction, acceptMessage, atAcceptMessage, acceptNotice, atAcceptNotice, acceptPending, atAcceptPending, rejectPending, atRejectPending, acceptCronReceipt, atAcceptCronReceipt, acceptItemReceipt, atAcceptItemReceipt, disputeCronReceipt, atDisputeCronReceipt, disputeItemReceipt, atDisputeItemReceipt, acceptFinalReceipt, atAcceptFinalReceipt, acceptBasketReceipt, atAcceptBasketReceipt, disputeFinalReceipt, atDisputeFinalReceipt, disputeBasketReceipt, atDisputeBasketReceipt, serverfee, atServerfee, issuerfee, atIssuerfee, balanceStatement, atBalanceStatement, transactionStatement, atTransactionStatement, withdrawal, atWithdrawal, deposit, atDeposit, withdrawVoucher, atWithdrawVoucher, depositCheque, atDepositCheque, payDividend, atPayDividend, marketOffer, atMarketOffer, paymentPlan, atPaymentPlan, smartContract, atSmartContract, cancelCronItem, atCancelCronItem, exchangeBasket, atExchangeBasket, chequeReceipt, voucherReceipt, marketReceipt, paymentReceipt, transferReceipt, finalReceipt, basketReceipt, replyNotice, successNotice, notice, error_state }

enum	itemStatus { request, acknowledgement, rejection, error_status }

Public Member Functions
EXPORT bool	AddBlankNumbersToItem (const OTNumList &theAddition)

int64_t	GetClosingNum () const

void	SetClosingNum (int64_t lClosingNum)

virtual EXPORT int64_t	GetNumberOfOrigin ()

virtual EXPORT void	CalculateNumberOfOrigin ()

listOfItems &	GetItemList ()

OTItem *	GetItem (int32_t nIndex)

OTItem *	GetItemByTransactionNum (int64_t lTransactionNumber)

OTItem *	GetFinalReceiptItemByReferenceNum (int64_t lReferenceNumber)

int32_t	GetItemCountInRefTo (int64_t lReference)

int32_t	GetItemCount () const

void	AddItem (OTItem &theItem)

void	ReleaseItems ()

void	Release_Item ()

virtual void	Release ()

void	SetNewOutboxTransNum (int64_t lTransNum)

int64_t	GetNewOutboxTransNum () const

EXPORT bool	VerifyBalanceStatement (int64_t lActualAdjustment, OTPseudonym &THE_NYM, OTLedger &THE_INBOX, OTLedger &THE_OUTBOX, const OTAccount &THE_ACCOUNT, OTTransaction &TARGET_TRANSACTION, int64_t lOutboxTrnsNum=0)

EXPORT bool	VerifyTransactionStatement (OTPseudonym &THE_NYM, OTTransaction &TARGET_TRANSACTION, bool bIsRealTransaction=true)

OTItem::itemStatus	GetStatus () const

void	SetStatus (const OTItem::itemStatus &theVal)

OTItem::itemType	GetType () const

void	SetType (OTItem::itemType theType)

int64_t	GetAmount () const

void	SetAmount (int64_t lAmount)

EXPORT void	GetNote (OTString &theStr) const

EXPORT void	SetNote (const OTString &theStr)

EXPORT void	GetAttachment (OTString &theStr) const

EXPORT void	SetAttachment (const OTString &theStr)

const OTIdentifier &	GetDestinationAcctID () const

void	SetDestinationAcctID (const OTIdentifier &theID)

void	GetTypeString (OTString &strType) const

	OTItem (const OTIdentifier &theUserID, const OTItem &theOwner)

	OTItem (const OTIdentifier &theUserID, const OTTransaction &theOwner)

	OTItem (const OTIdentifier &theUserID, const OTTransaction &theOwner, OTItem::itemType theType, const OTIdentifier *pDestinationAcctID=nullptr)

virtual	~OTItem ()

void	InitItem ()

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

Public Member Functions inherited from opentxs::OTTransactionType
EXPORT void	GetNumList (OTNumList &theOutput)

bool	Contains (const OTString &strContains)

EXPORT bool	Contains (const char *szContains)

bool	IsSameAccount (const OTTransactionType &rhs) const

void	SetLoadInsecure ()

const OTIdentifier &	GetUserID () const

void	SetUserID (const OTIdentifier &theID)

const OTIdentifier &	GetRealAccountID () const

void	SetRealAccountID (const OTIdentifier &theID)

const OTIdentifier &	GetPurportedAccountID () const

void	SetPurportedAccountID (const OTIdentifier &theID)

const OTIdentifier &	GetRealServerID () const

void	SetRealServerID (const OTIdentifier &theID)

const OTIdentifier &	GetPurportedServerID () const

void	SetPurportedServerID (const OTIdentifier &theID)

virtual EXPORT bool	VerifyContractID () const

virtual bool	VerifyAccount (const OTPseudonym &theNym)

	OTTransactionType (const OTIdentifier &theUserID, const OTIdentifier &theAccountID, const OTIdentifier &theServerID)

	OTTransactionType (const OTIdentifier &theUserID, const OTIdentifier &theAccountID, const OTIdentifier &theServerID, int64_t lTransactionNum)

void	InitTransactionType ()

virtual	~OTTransactionType ()

void	Release_TransactionType ()

EXPORT int64_t	GetTransactionNum () const

void	SetTransactionNum (int64_t lTransactionNum)

EXPORT int64_t	GetRawNumberOfOrigin () const

EXPORT void	SetNumberOfOrigin (int64_t lTransactionNum)

EXPORT void	SetNumberOfOrigin (OTTransactionType &setFrom)

EXPORT bool	VerifyNumberOfOrigin (OTTransactionType &compareTo)

EXPORT int64_t	GetReferenceToNum () const

EXPORT void	SetReferenceToNum (int64_t lTransactionNum)

EXPORT void	GetReferenceString (OTString &theStr) const

EXPORT void	SetReferenceString (const OTString &theStr)

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 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 OTItem *	CreateItemFromString (const OTString &strItem, const OTIdentifier &theServerID, int64_t lTransactionNumber)

static EXPORT OTItem *	CreateItemFromTransaction (const OTTransaction &theOwner, OTItem::itemType theType, const OTIdentifier *pDestinationAcctID=nullptr)

static EXPORT void	GetStringFromType (OTItem::itemType theType, OTString &strType)

Static Public Member Functions inherited from opentxs::OTTransactionType
static EXPORT OTTransactionType *	TransactionFactory (OTString strInput)

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)

Public Attributes
OTASCIIArmor	m_ascNote

OTASCIIArmor	m_ascAttachment

Protected Member Functions
	OTItem ()

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

virtual void	UpdateContents ()

Protected Member Functions inherited from opentxs::OTTransactionType
	OTTransactionType ()

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

Protected Attributes
OTIdentifier	m_AcctToID

int64_t	m_lAmount

listOfItems	m_listItems

itemType	m_Type

itemStatus	m_Status

int64_t	m_lNewOutboxTransNum

int64_t	m_lClosingTransactionNo

Protected Attributes inherited from opentxs::OTTransactionType
OTIdentifier	m_AcctID

OTIdentifier	m_ServerID

OTIdentifier	m_AcctServerID

OTIdentifier	m_AcctUserID

int64_t	m_lTransactionNum

int64_t	m_lInReferenceToTransaction

int64_t	m_lNumberOfOrigin

OTASCIIArmor	m_ascInReferenceTo

bool	m_bLoadSecurely

OTNumList	m_Numlist

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

Friends
OTTransactionType *	OTTransactionType::TransactionFactory (OTString strInput)

Detailed Description

Definition at line 160 of file OTItem.hpp.

Member Enumeration Documentation

enum opentxs::OTItem::itemStatus

Enumerator
request
acknowledgement
rejection
error_status

Definition at line 326 of file OTItem.hpp.

                     {
         request,         // This item is a request from the client
         acknowledgement, // This item is an acknowledgment from the server. (The
                          // server has signed it.)
         rejection,   // This item represents a rejection of the request by the
                      // server. (Server will not sign it.)
         error_status // error status versus error state
     };

enum opentxs::OTItem::itemType

Enumerator
transfer
atTransfer
acceptTransaction
atAcceptTransaction
acceptMessage
atAcceptMessage
acceptNotice
atAcceptNotice
acceptPending
atAcceptPending
rejectPending
atRejectPending
acceptCronReceipt
atAcceptCronReceipt
acceptItemReceipt
atAcceptItemReceipt
disputeCronReceipt
atDisputeCronReceipt
disputeItemReceipt
atDisputeItemReceipt
acceptFinalReceipt
atAcceptFinalReceipt
acceptBasketReceipt
atAcceptBasketReceipt
disputeFinalReceipt
atDisputeFinalReceipt
disputeBasketReceipt
atDisputeBasketReceipt
serverfee
atServerfee
issuerfee
atIssuerfee
balanceStatement
atBalanceStatement
transactionStatement
atTransactionStatement
withdrawal
atWithdrawal
deposit
atDeposit
withdrawVoucher
atWithdrawVoucher
depositCheque
atDepositCheque
payDividend
atPayDividend
marketOffer
atMarketOffer
paymentPlan
atPaymentPlan
smartContract
atSmartContract
cancelCronItem
atCancelCronItem
exchangeBasket
atExchangeBasket
chequeReceipt
voucherReceipt
marketReceipt
paymentReceipt
transferReceipt
finalReceipt
basketReceipt
replyNotice
successNotice
notice
error_state

Definition at line 169 of file OTItem.hpp.

                   {
         // TRANSFER
         transfer,   // this item is an outgoing transfer, probably part of an
                     // outoing transaction.
         atTransfer, // Server reply.
 
         // NYMBOX RESOLUTION
         acceptTransaction, // this item is a client-side acceptance of a
                            // transaction number (a blank) in my Nymbox
         atAcceptTransaction,
         acceptMessage, // this item is a client-side acceptance of a message in
                        // my Nymbox
         atAcceptMessage,
         acceptNotice, // this item is a client-side acceptance of a server
                       // notification in my Nymbox
         atAcceptNotice,
 
         // INBOX RESOLUTION
         acceptPending, // this item is a client-side acceptance of a pending
                        // transfer
         atAcceptPending,
         rejectPending, // this item is a client-side rejection of a pending
                        // transfer
         atRejectPending,
 
         // RECEIPT ACKNOWLEDGMENT / DISPUTE
         acceptCronReceipt,   // this item is a client-side acceptance of a cron
                              // receipt in his inbox.
         atAcceptCronReceipt, // this item is a server reply to that acceptance.
         acceptItemReceipt,   // this item is a client-side acceptance of an item
                              // receipt in his inbox.
         atAcceptItemReceipt, // this item is a server reply to that acceptance.
         disputeCronReceipt,  // this item is a client dispute of a cron receipt
                              // in his inbox.
         atDisputeCronReceipt, // Server reply to dispute message.
         disputeItemReceipt, // this item is a client dispute of an item receipt
                             // in his inbox.
         atDisputeItemReceipt, // Server reply to dispute message.
 
         // Sometimes the attachment will be an OTItem, and sometimes it will be
         // an OTPaymentPlan or OTTrade.  These different types above help the
         // code to differentiate.
         acceptFinalReceipt, // this item is a client-side acceptance of a final
                             // receipt in his inbox. (All related receipts must
                             // also be closed!)
         atAcceptFinalReceipt,  // server reply
         acceptBasketReceipt,   // this item is a client-side acceptance of a
                                // basket receipt in his inbox.
         atAcceptBasketReceipt, // server reply
         disputeFinalReceipt, // this item is a client-side rejection of a final
                              // receipt in his inbox. (All related receipts must
                              // also be closed!)
         atDisputeFinalReceipt,  // server reply
         disputeBasketReceipt,   // this item is a client-side rejection of a
                                 // basket receipt in his inbox.
         atDisputeBasketReceipt, // server reply
 
         // FEEs
         serverfee, // this item is a fee from the transaction server (per
                    // contract)
         atServerfee,
         issuerfee, // this item is a fee from the issuer (per contract)
         atIssuerfee,
         // INFO (BALANCE, HASH, etc) these are still all messages with replies.
         balanceStatement, // this item is a statement of balance. (For asset
                           // account.)
         atBalanceStatement,
         transactionStatement, // this item is a transaction statement. (For Nym
                               // -- which numbers are assigned to him.)
         atTransactionStatement,
         // CASH WITHDRAWAL / DEPOSIT
         withdrawal, // this item is a cash withdrawal (of chaumian blinded
                     // tokens)
         atWithdrawal,
         deposit, // this item is a cash deposit (of a purse containing blinded
                  // tokens.)
         atDeposit,
         // CHEQUES AND VOUCHERS
         withdrawVoucher, // this item is a request to purchase a voucher (a
                          // cashier's cheque)
         atWithdrawVoucher,
         depositCheque,   // this item is a request to deposit a cheque
         atDepositCheque, // this item is a server response to that request.
         // PAYING DIVIDEND ON SHARES OF STOCK
         payDividend,   // this item is a request to pay a dividend.
         atPayDividend, // the server reply to that request.
         // TRADING ON MARKETS
         marketOffer,   // this item is an offer to be put on a market.
         atMarketOffer, // server reply or updated notification regarding a
                        // market offer.
         // PAYMENT PLANS
         paymentPlan,   // this item is a new payment plan
         atPaymentPlan, // server reply or updated notification regarding a
                        // payment plan.
         // SMART CONTRACTS
         smartContract,   // this item is a new smart contract
         atSmartContract, // server reply or updated notification regarding a
                          // smart contract.
         // CANCELLING: Market Offers and Payment Plans.
         cancelCronItem,   // this item is intended to cancel a market offer or
                           // payment plan.
         atCancelCronItem, // reply from the server regarding said cancellation.
         // EXCHANGE IN/OUT OF A BASKET CURRENCY
         exchangeBasket, // this item is an exchange in/out of a basket currency.
         atExchangeBasket, // reply from the server regarding said exchange.
         // Now these three receipts have a dual use:  as the receipts in the
         // inbox, and also
         // as the representation for transactions in the inbox report (for
         // balance statements.)
         // Actually chequeReceipt is ONLY used for inbox report, and otherwise
         // is not actually
         // needed for real cheque receipts.  marketReceipt and paymentReceipt
         // are used as real
         // receipts, and also in inbox reports to represent transaction items in
         // an inbox.
         chequeReceipt, // Currently don't create an OTItem for cheque receipt in
                        // inbox. Not needed.
         // I also don't create one for the transfer receipt, currently.
         // (Although near the top, I do have item types to go in a processInbox
         // message and
         // clear those transaction types out of my inbox.)
         voucherReceipt, // Newest addition. This is so users can close a
                         // transaction number used on a voucher.
         marketReceipt,  // server receipt dropped into inbox as result of market
                         // trading.
         paymentReceipt, // server receipt dropped into an inbox as result of
                         // payment occuring.
         transferReceipt, // server receipt dropped into an inbox as result of
                          // transfer being accepted.
         finalReceipt, // server receipt dropped into inbox / nymbox as result of
                       // cron item expiring or being canceled.
         basketReceipt, // server receipt dropped into inbox as result of a
                        // basket exchange.
         replyNotice,   // server notice of a reply that nym should have already
                        // received as a response to a request.
         // (Some are so important, a copy of the server reply is dropped to your
         // nymbox, to make SURE you got it and processed it.)
         successNotice, // server notice dropped into nymbox as result of a
                        // transaction# being successfully signed out.
         notice,        // server notice dropped into nymbox as result of a smart
                        // contract processing.
         // Also could be used for ballots / elections, corporate meetings /
         // minutes, etc.
         // finalReceipt is also basically a notice (in the Nymbox, anyway) but
         // it still is
         // information that you have to act on as soon as you receive it,
         // whereas THIS kind
         // of notice isn't so hardcore. It's more laid-back.
         error_state // error state versus error status
     };

Constructor & Destructor Documentation

opentxs::OTItem::OTItem ( )

protected

Definition at line 1542 of file OTItem.cpp.

     : OTTransactionType()
     , m_lAmount(0)
     , m_Type(OTItem::error_state)
     , m_Status(OTItem::request)
     , m_lNewOutboxTransNum(0)
     , m_lClosingTransactionNo(0)
 {
     InitItem();
 }

opentxs::OTItem::OTItem	(	const OTIdentifier &	theUserID,
		const OTItem &	theOwner
	)

Definition at line 1568 of file OTItem.cpp.

     : OTTransactionType(theUserID, theOwner.GetRealAccountID(),
                         theOwner.GetRealServerID(),
                         theOwner.GetTransactionNum())
     , m_lAmount(0)
     , m_Type(OTItem::error_state)
     , m_Status(OTItem::request)
     , m_lNewOutboxTransNum(0)
     , m_lClosingTransactionNo(0)
 {
     InitItem();
 }

opentxs::OTItem::OTItem	(	const OTIdentifier &	theUserID,
		const OTTransaction &	theOwner
	)

Definition at line 1554 of file OTItem.cpp.

     : OTTransactionType(theUserID, theOwner.GetRealAccountID(),
                         theOwner.GetRealServerID(),
                         theOwner.GetTransactionNum())
     , m_lAmount(0)
     , m_Type(OTItem::error_state)
     , m_Status(OTItem::request)
     , m_lNewOutboxTransNum(0)
     , m_lClosingTransactionNo(0)
 {
     InitItem();
 }

opentxs::OTItem::OTItem	(	const OTIdentifier &	theUserID,
		const OTTransaction &	theOwner,
		OTItem::itemType	theType,
		const OTIdentifier *	pDestinationAcctID = `nullptr`
	)

Definition at line 1581 of file OTItem.cpp.

     : OTTransactionType(theUserID, theOwner.GetRealAccountID(),
                         theOwner.GetRealServerID(),
                         theOwner.GetTransactionNum())
     , m_lAmount(0)
     , m_Type(OTItem::error_state)
     , m_Status(OTItem::request)
     , m_lNewOutboxTransNum(0)
     , m_lClosingTransactionNo(0)
 {
     InitItem();
 
     m_Type = theType; // This has to be below the InitItem() call that appears
                       // just above
 
     // Most transactions items don't HAVE a "to" account, just a primary
     // account.
     // (If you deposit, or withdraw, you don't need a "to" account.)
     // But for the ones that do, you can pass the "to" account's ID in
     // as a pointer, and we'll set that too....
     if (nullptr != pDestinationAcctID) {
         m_AcctToID = *pDestinationAcctID;
     }
 }

opentxs::OTItem::~OTItem ( )

virtual

Definition at line 1607 of file OTItem.cpp.

 {
     Release_Item();
 }

Member Function Documentation

bool opentxs::OTItem::AddBlankNumbersToItem ( const OTNumList & theAddition )

Definition at line 1125 of file OTItem.cpp.

 {
     return m_Numlist.Add(theAddition);
 }

void opentxs::OTItem::AddItem ( OTItem & theItem )

Definition at line 1052 of file OTItem.cpp.

 {
     m_listItems.push_back(&theItem);
 }

void opentxs::OTItem::CalculateNumberOfOrigin ( )

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 1180 of file OTItem.cpp.

 {
     switch (GetType()) {
     case acceptTransaction:   // this item is a client-side acceptance of a
                               // transaction number (a blank) in my Nymbox
     case atAcceptTransaction: // server reply
     case acceptMessage: // this item is a client-side acceptance of a message in
                         // my Nymbox
     case atAcceptMessage: // server reply
     case acceptNotice:    // this item is a client-side acceptance of a server
                           // notification in my Nymbox
     case atAcceptNotice:  // server reply
     case replyNotice:   // server notice of a reply that nym should have already
                         // received as a response to a request. (Copy dropped in
                         // nymbox.)
     case successNotice: // server notice dropped into nymbox as result of a
                         // transaction# being successfully signed out.
     case notice: // server notice dropped into nymbox as result of a smart
                  // contract processing.
     case transferReceipt: // Currently don't create an OTItem for transfer
                           // receipt in inbox. Used only for inbox report.
     case chequeReceipt:   // Currently don't create an OTItem for cheque receipt
                           // in inbox. Used only for inbox report.
     case voucherReceipt: // Currently don't create an OTItem for voucher receipt
                          // in inbox. Used only for inbox report.
 
         SetNumberOfOrigin(0); // Not applicable.
         break;
 
     case acceptPending: // this item is a client-side acceptance of a pending
                         // transfer
     case rejectPending: // this item is a client-side rejection of a pending
                         // transfer
     case acceptCronReceipt:  // this item is a client-side acceptance of a cron
                              // receipt in his inbox.
     case acceptItemReceipt:  // this item is a client-side acceptance of an item
                              // receipt in his inbox.
     case disputeCronReceipt: // this item is a client dispute of a cron receipt
                              // in his inbox.
     case disputeItemReceipt: // this item is a client dispute of an item receipt
                              // in his inbox.
 
     case acceptFinalReceipt: // this item is a client-side acceptance of a final
                              // receipt in his inbox. (All related receipts must
                              // also be closed!)
     case acceptBasketReceipt: // this item is a client-side acceptance of a
                               // basket receipt in his inbox.
     case disputeFinalReceipt: // this item is a client-side rejection of a final
                               // receipt in his inbox. (All related receipts
                               // must also be closed!)
     case disputeBasketReceipt: // this item is a client-side rejection of a
                                // basket receipt in his inbox.
 
         otErr << __FUNCTION__ << ": In this case, you can't calculate the "
                                  "origin number, you must set it explicitly.\n";
         SetNumberOfOrigin(0); // Not applicable.
         // Comment this out later so people can't use it to crash the server:
         OT_FAIL_MSG("In this case, you can't calculate the origin number, you "
                     "must set it explicitly.");
         break;
 
     case marketReceipt: // server receipt dropped into inbox as result of market
                         // trading. Also used in inbox report.
     case paymentReceipt: // server receipt dropped into an inbox as result of
                          // payment occuring. Also used in inbox report.
     case finalReceipt:   // server receipt dropped into inbox / nymbox as result
                          // of cron item expiring or being canceled.
     case basketReceipt:  // server receipt dropped into inbox as result of a
                          // basket exchange.
 
         SetNumberOfOrigin(GetReferenceToNum()); // pending is in
                                                 // reference to the
                                                 // original
                                                 // transfer.
         break;
 
     case depositCheque: // this item is a request to deposit a cheque.
     {
         OTCheque theCheque;
         OTString strAttachment;
         GetAttachment(strAttachment);
 
         if (!theCheque.LoadContractFromString(strAttachment))
             otErr << __FUNCTION__ << ": ERROR loading cheque from string:\n"
                   << strAttachment << "\n";
         else
             SetNumberOfOrigin(theCheque.GetTransactionNum());
     } break;
 
     case atDepositCheque:     // this item is a server response to that request.
     case atAcceptPending:     // server reply to acceptPending.
     case atRejectPending:     // server reply to rejectPending.
     case atAcceptCronReceipt: // this item is a server reply to that acceptance.
     case atAcceptItemReceipt: // this item is a server reply to that acceptance.
     case atDisputeCronReceipt:   // Server reply to dispute message.
     case atDisputeItemReceipt:   // Server reply to dispute message.
     case atAcceptFinalReceipt:   // server reply
     case atAcceptBasketReceipt:  // server reply
     case atDisputeFinalReceipt:  // server reply
     case atDisputeBasketReceipt: // server reply
     {
         OTString strReference;
         GetReferenceString(strReference);
 
         // "In reference to" number is my original deposit trans#, which I use
         // here to load my
         // original depositCheque item, which I use to get the cheque, which
         // contains the number
         // of origin as its transaction number.
         //
         std::unique_ptr<OTItem> pOriginalItem(OTItem::CreateItemFromString(
             strReference, GetPurportedServerID(), GetReferenceToNum()));
         OT_ASSERT(nullptr != pOriginalItem);
 
         if (((m_Type == atDepositCheque) &&
              (OTItem::depositCheque != pOriginalItem->GetType())) ||
             ((m_Type == atAcceptPending) &&
              (OTItem::acceptPending != pOriginalItem->GetType())) ||
             ((m_Type == atRejectPending) &&
              (OTItem::rejectPending != pOriginalItem->GetType())) ||
             ((m_Type == atAcceptCronReceipt) &&
              (OTItem::acceptCronReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atAcceptItemReceipt) &&
              (OTItem::acceptItemReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atDisputeCronReceipt) &&
              (OTItem::disputeCronReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atDisputeItemReceipt) &&
              (OTItem::disputeItemReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atAcceptFinalReceipt) &&
              (OTItem::acceptFinalReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atAcceptBasketReceipt) &&
              (OTItem::acceptBasketReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atDisputeFinalReceipt) &&
              (OTItem::disputeFinalReceipt != pOriginalItem->GetType())) ||
             ((m_Type == atDisputeBasketReceipt) &&
              (OTItem::disputeBasketReceipt != pOriginalItem->GetType()))) {
             OTString strType;
             pOriginalItem->GetTypeString(strType);
             otErr << __FUNCTION__
                   << ": ERROR: Wrong item type as 'in reference to' string on "
                   << strType << " item.\n";
             SetNumberOfOrigin(0);
             return;
         }
 
         // Else:
         SetNumberOfOrigin(pOriginalItem->GetNumberOfOrigin());
     } break;
 
     // FEEs
     case serverfee: // this item is a fee from the transaction server (per
                     // contract)
     case atServerfee:
     case issuerfee: // this item is a fee from the issuer (per contract)
     case atIssuerfee:
 
     // INFO (BALANCE, HASH, etc) these are still all messages with replies.
     case balanceStatement: // this item is a statement of balance. (For asset
                            // account.)
     case atBalanceStatement:
     case transactionStatement: // this item is a transaction statement. (For Nym
                                // -- which numbers are assigned to him.)
     case atTransactionStatement:
 
     // TRANSFER
     case transfer:   // This item is an outgoing transfer, probably part of an
                      // outoing transaction.
     case atTransfer: // Server reply.
 
     // CASH WITHDRAWAL / DEPOSIT
     case withdrawal: // this item is a cash withdrawal (of chaumian blinded
                      // tokens)
     case atWithdrawal:
     case deposit: // this item is a cash deposit (of a purse containing blinded
                   // tokens.)
     case atDeposit:
 
     // CHEQUES AND VOUCHERS
     case withdrawVoucher: // this item is a request to purchase a voucher (a
                           // cashier's cheque)
     case atWithdrawVoucher:
 
     // PAYING DIVIDEND ON SHARES OF STOCK
     case payDividend:   // this item is a request to pay a dividend.
     case atPayDividend: // the server reply to that request.
 
     // TRADING ON MARKETS
     case marketOffer:   // this item is an offer to be put on a market.
     case atMarketOffer: // server reply or updated notification regarding a
                         // market offer.
 
     // PAYMENT PLANS
     case paymentPlan:   // this item is a new payment plan
     case atPaymentPlan: // server reply or updated notification regarding a
                         // payment plan.
 
     // SMART CONTRACTS
     case smartContract:   // this item is a new smart contract
     case atSmartContract: // server reply or updated notification regarding a
                           // smart contract.
 
     // CANCELLING: Market Offers and Payment Plans.
     case cancelCronItem:   // this item is intended to cancel a market offer or
                            // payment plan.
     case atCancelCronItem: // reply from the server regarding said cancellation.
 
     // EXCHANGE IN/OUT OF A BASKET CURRENCY
     case exchangeBasket:   // this item is an exchange in/out of a basket
                            // currency.
     case atExchangeBasket: // reply from the server regarding said exchange.
 
     default:
         SetNumberOfOrigin(GetTransactionNum());
         break;
     } // switch
 }

OTItem * opentxs::OTItem::CreateItemFromString	(	const OTString &	strItem,
		const OTIdentifier &	theServerID,
		int64_t	lTransactionNumber
	)

static

Definition at line 1473 of file OTItem.cpp.

 {
     if (!strItem.Exists()) {
         otErr << "OTItem::CreateItemFromString: strItem is empty. (Expected an "
                  "item.)\n";
         return nullptr;
     }
 
     OTItem* pItem = new OTItem();
 
     // So when it loads its own server ID, we can compare to this one.
     pItem->SetRealServerID(theServerID);
 
     // This loads up the purported account ID and the user ID.
     if (pItem->LoadContractFromString(strItem)) {
         const OTIdentifier& ACCOUNT_ID = pItem->GetPurportedAccountID();
         pItem->SetRealAccountID(ACCOUNT_ID); // I do this because it's all we've
                                              // got in this case. It's what's in
                                              // the
         // xml, so it must be right. If it's a lie, the signature will fail or
         // the
         // user will not show as the owner of that account. But remember, the
         // server
         // sent the message in the first place.
 
         pItem->SetTransactionNum(lTransactionNumber);
 
         if (pItem->VerifyContractID()) // this compares purported and real
                                        // account IDs, as well as server IDs.
         {
             return pItem;
         }
         else {
             delete pItem;
             pItem = nullptr;
         }
     }
 
     return nullptr;
 }

OTItem * opentxs::OTItem::CreateItemFromTransaction	(	const OTTransaction &	theOwner,
		OTItem::itemType	theType,
		const OTIdentifier *	pDestinationAcctID = `nullptr`
	)

static

Definition at line 1451 of file OTItem.cpp.

 {
     OTItem* pItem =
         new OTItem(theOwner.GetUserID(), theOwner, theType, pDestinationAcctID);
 
     if (pItem) {
         pItem->SetPurportedAccountID(theOwner.GetPurportedAccountID());
         pItem->SetPurportedServerID(theOwner.GetPurportedServerID());
         return pItem;
     }
     return nullptr;
 }

int64_t opentxs::OTItem::GetAmount ( ) const

inline

Definition at line 475 of file OTItem.hpp.

     {
         return m_lAmount;
     }

void opentxs::OTItem::GetAttachment ( OTString & theStr ) const

Definition at line 1397 of file OTItem.cpp.

 {
     m_ascAttachment.GetString(theStr);
 }

int64_t opentxs::OTItem::GetClosingNum ( ) const

Definition at line 2012 of file OTItem.cpp.

 {
     return m_lClosingTransactionNo;
 }

const OTIdentifier& opentxs::OTItem::GetDestinationAcctID ( ) const

inline

Definition at line 487 of file OTItem.hpp.

     {
         return m_AcctToID;
     }

OTItem * opentxs::OTItem::GetFinalReceiptItemByReferenceNum ( int64_t lReferenceNumber )

Definition at line 1110 of file OTItem.cpp.

 {
     for (auto& it : m_listItems) {
         OTItem* pItem = it;
         OT_ASSERT(nullptr != pItem);
 
         if (OTItem::finalReceipt != pItem->GetType()) continue;
         if (pItem->GetReferenceToNum() == lReferenceNumber) return pItem;
     }
 
     return nullptr;
 }

OTItem * opentxs::OTItem::GetItem ( int32_t nIndex )

Definition at line 1059 of file OTItem.cpp.

 {
     int32_t nTempIndex = (-1);
 
     for (auto& it : m_listItems) {
         OTItem* pItem = it;
         OT_ASSERT(nullptr != pItem);
 
         nTempIndex++; // first iteration this becomes 0 here.
 
         if (nTempIndex == nIndex) return pItem;
     }
 
     return nullptr;
 }

OTItem * opentxs::OTItem::GetItemByTransactionNum ( int64_t lTransactionNumber )

Definition at line 1076 of file OTItem.cpp.

 {
     for (auto& it : m_listItems) {
         OTItem* pItem = it;
         OT_ASSERT(nullptr != pItem);
 
         if (pItem->GetTransactionNum() == lTransactionNumber) return pItem;
     }
 
     return nullptr;
 }

int32_t opentxs::OTItem::GetItemCount ( ) const

inline

Definition at line 413 of file OTItem.hpp.

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

int32_t opentxs::OTItem::GetItemCountInRefTo ( int64_t lReference )

Definition at line 1092 of file OTItem.cpp.

 {
     int32_t nCount = 0;
 
     for (auto& it : m_listItems) {
         OTItem* pItem = it;
         OT_ASSERT(nullptr != pItem);
 
         if (pItem->GetReferenceToNum() == lReference) nCount++;
     }
 
     return nCount;
 }

listOfItems& opentxs::OTItem::GetItemList ( )

inline

Definition at line 391 of file OTItem.hpp.

     {
         return m_listItems;
     }

int64_t opentxs::OTItem::GetNewOutboxTransNum ( ) const

inline

Definition at line 430 of file OTItem.hpp.

     {
         return m_lNewOutboxTransNum;
     }                       // See above comment in protected section.

void opentxs::OTItem::GetNote ( OTString & theStr ) const

Definition at line 1430 of file OTItem.cpp.

 {
     if (m_ascNote.GetLength() > 2) {
         m_ascNote.GetString(theStr);
 
         if (theStr.Contains(OTASSCIIARMOR_PADDING_TEXT))
             theStr.Truncate(theStr.GetLength() -
                             MINIMUM_CLEARTEXT_SIZE_OTASCIIARMOR);
     }
     else {
         theStr.Release();
     }
 }

int64_t opentxs::OTItem::GetNumberOfOrigin ( )

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 1132 of file OTItem.cpp.

 {
 
     if (0 == m_lNumberOfOrigin) {
         switch (GetType()) {
         case acceptPending: // this item is a client-side acceptance of a
                             // pending transfer
         case rejectPending: // this item is a client-side rejection of a pending
                             // transfer
         case acceptCronReceipt:  // this item is a client-side acceptance of a
                                  // cron receipt in his inbox.
         case acceptItemReceipt:  // this item is a client-side acceptance of an
                                  // item receipt in his inbox.
         case disputeCronReceipt: // this item is a client dispute of a cron
                                  // receipt in his inbox.
         case disputeItemReceipt: // this item is a client dispute of an item
                                  // receipt in his inbox.
 
         case acceptFinalReceipt:   // this item is a client-side acceptance of a
                                    // final receipt in his inbox. (All related
                                    // receipts must also be closed!)
         case acceptBasketReceipt:  // this item is a client-side acceptance of a
                                    // basket receipt in his inbox.
         case disputeFinalReceipt:  // this item is a client-side rejection of a
                                    // final receipt in his inbox. (All related
                                    // receipts must also be closed!)
         case disputeBasketReceipt: // this item is a client-side rejection of a
                                    // basket receipt in his inbox.
 
             otErr << __FUNCTION__ << ": In this case, you can't calculate the "
                                      "origin number, you must set it "
                                      "explicitly.\n";
             // Comment this out later so people can't use it to crash the
             // server:
             OT_FAIL_MSG("In this case, you can't calculate the origin number, "
                         "you must set it explicitly.");
             break;
         default:
             break;
         }
 
         CalculateNumberOfOrigin();
     }
 
     return m_lNumberOfOrigin;
 }

OTItem::itemStatus opentxs::OTItem::GetStatus ( ) const

inline

Definition at line 459 of file OTItem.hpp.

     {
         return m_Status;
     }

void opentxs::OTItem::GetStringFromType	(	OTItem::itemType	theType,
		OTString &	strType
	)

static

Definition at line 2022 of file OTItem.cpp.

 {
     switch (theType) {
     case OTItem::transfer:
         strType.Set("transfer");
         break;
     case OTItem::acceptTransaction:
         strType.Set("acceptTransaction");
         break;
     case OTItem::acceptMessage:
         strType.Set("acceptMessage");
         break;
     case OTItem::acceptNotice:
         strType.Set("acceptNotice");
         break;
     case OTItem::acceptPending:
         strType.Set("acceptPending");
         break;
     case OTItem::rejectPending:
         strType.Set("rejectPending");
         break;
     case OTItem::acceptCronReceipt:
         strType.Set("acceptCronReceipt");
         break;
     case OTItem::disputeCronReceipt:
         strType.Set("disputeCronReceipt");
         break;
     case OTItem::acceptItemReceipt:
         strType.Set("acceptItemReceipt");
         break;
     case OTItem::disputeItemReceipt:
         strType.Set("disputeItemReceipt");
         break;
     case OTItem::acceptFinalReceipt:
         strType.Set("acceptFinalReceipt");
         break;
     case OTItem::acceptBasketReceipt:
         strType.Set("acceptBasketReceipt");
         break;
     case OTItem::disputeFinalReceipt:
         strType.Set("disputeFinalReceipt");
         break;
     case OTItem::disputeBasketReceipt:
         strType.Set("disputeBasketReceipt");
         break;
     case OTItem::serverfee:
         strType.Set("serverfee");
         break;
     case OTItem::issuerfee:
         strType.Set("issuerfee");
         break;
     case OTItem::withdrawal:
         strType.Set("withdrawal");
         break;
     case OTItem::deposit:
         strType.Set("deposit");
         break;
     case OTItem::withdrawVoucher:
         strType.Set("withdrawVoucher");
         break;
     case OTItem::depositCheque:
         strType.Set("depositCheque");
         break;
     case OTItem::payDividend:
         strType.Set("payDividend");
         break;
     case OTItem::marketOffer:
         strType.Set("marketOffer");
         break;
     case OTItem::paymentPlan:
         strType.Set("paymentPlan");
         break;
     case OTItem::smartContract:
         strType.Set("smartContract");
         break;
     case OTItem::balanceStatement:
         strType.Set("balanceStatement");
         break;
     case OTItem::transactionStatement:
         strType.Set("transactionStatement");
         break;
 
     case OTItem::cancelCronItem:
         strType.Set("cancelCronItem");
         break;
     case OTItem::exchangeBasket:
         strType.Set("exchangeBasket");
         break;
 
     case OTItem::atCancelCronItem:
         strType.Set("atCancelCronItem");
         break;
     case OTItem::atExchangeBasket:
         strType.Set("atExchangeBasket");
         break;
 
     case OTItem::chequeReceipt: // used for inbox statements in balance
                                 // agreement.
         strType.Set("chequeReceipt");
         break;
     case OTItem::voucherReceipt: // used for inbox statements in balance
                                  // agreement.
         strType.Set("voucherReceipt");
         break;
     case OTItem::marketReceipt: // used as market receipt, and also for inbox
                                 // statement containing market receipt will use
                                 // this as well.
         strType.Set("marketReceipt");
         break;
     case OTItem::paymentReceipt: // used as payment receipt, also used in inbox
                                  // statement as payment receipt.
         strType.Set("paymentReceipt");
         break;
     case OTItem::transferReceipt: // used in inbox statement as transfer
                                   // receipt.
         strType.Set("transferReceipt");
         break;
 
     case OTItem::finalReceipt: // used for final receipt. Also used in inbox
                                // statement as final receipt. (For expiring or
                                // cancelled Cron Item.)
         strType.Set("finalReceipt");
         break;
     case OTItem::basketReceipt: // used in inbox statement as basket receipt.
                                 // (For exchange.)
         strType.Set("basketReceipt");
         break;
 
     case OTItem::notice: // used in Nymbox statement as notification from
                          // server.
         strType.Set("notice");
         break;
     case OTItem::replyNotice: // some server replies (to your request) have a
                               // copy dropped into your nymbox, to make sure you
                               // received it.
         strType.Set("replyNotice");
         break;
     case OTItem::successNotice: // used in Nymbox statement as notification from
                                 // server of successful sign-out of a trans#.
         strType.Set("successNotice");
         break;
 
     case OTItem::atTransfer:
         strType.Set("atTransfer");
         break;
     case OTItem::atAcceptTransaction:
         strType.Set("atAcceptTransaction");
         break;
     case OTItem::atAcceptMessage:
         strType.Set("atAcceptMessage");
         break;
     case OTItem::atAcceptNotice:
         strType.Set("atAcceptNotice");
         break;
     case OTItem::atAcceptPending:
         strType.Set("atAcceptPending");
         break;
     case OTItem::atRejectPending:
         strType.Set("atRejectPending");
         break;
     case OTItem::atAcceptCronReceipt:
         strType.Set("atAcceptCronReceipt");
         break;
     case OTItem::atDisputeCronReceipt:
         strType.Set("atDisputeCronReceipt");
         break;
     case OTItem::atAcceptItemReceipt:
         strType.Set("atAcceptItemReceipt");
         break;
     case OTItem::atDisputeItemReceipt:
         strType.Set("atDisputeItemReceipt");
         break;
 
     case OTItem::atAcceptFinalReceipt:
         strType.Set("atAcceptFinalReceipt");
         break;
     case OTItem::atAcceptBasketReceipt:
         strType.Set("atAcceptBasketReceipt");
         break;
     case OTItem::atDisputeFinalReceipt:
         strType.Set("atDisputeFinalReceipt");
         break;
     case OTItem::atDisputeBasketReceipt:
         strType.Set("atDisputeBasketReceipt");
         break;
 
     case OTItem::atServerfee:
         strType.Set("atServerfee");
         break;
     case OTItem::atIssuerfee:
         strType.Set("atIssuerfee");
         break;
     case OTItem::atWithdrawal:
         strType.Set("atWithdrawal");
         break;
     case OTItem::atDeposit:
         strType.Set("atDeposit");
         break;
     case OTItem::atWithdrawVoucher:
         strType.Set("atWithdrawVoucher");
         break;
     case OTItem::atDepositCheque:
         strType.Set("atDepositCheque");
         break;
     case OTItem::atPayDividend:
         strType.Set("atPayDividend");
         break;
     case OTItem::atMarketOffer:
         strType.Set("atMarketOffer");
         break;
     case OTItem::atPaymentPlan:
         strType.Set("atPaymentPlan");
         break;
     case OTItem::atSmartContract:
         strType.Set("atSmartContract");
         break;
     case OTItem::atBalanceStatement:
         strType.Set("atBalanceStatement");
         break;
     case OTItem::atTransactionStatement:
         strType.Set("atTransactionStatement");
         break;
 
     default:
         strType.Set("error-unknown");
         break;
     }
 }

OTItem::itemType opentxs::OTItem::GetType ( ) const

inline

Definition at line 467 of file OTItem.hpp.

     {
         return m_Type;
     }

void opentxs::OTItem::GetTypeString ( OTString & strType ) const

inline

Definition at line 504 of file OTItem.hpp.

     {
         GetStringFromType(GetType(), strType);
     }

void opentxs::OTItem::InitItem ( )

Definition at line 1516 of file OTItem.cpp.

 {
     m_lAmount = 0; // Accounts default to ZERO.  They can only change that
                    // amount by receiving from another account.
     m_Type = OTItem::error_state;
     m_Status =
         OTItem::request; // (Unless an issuer account, which can create currency
     m_lNewOutboxTransNum = 0; // When the user puts a "1" in his outbox for a
                               // balance agreement (since he doesn't know what
                               // trans# the actual outbox item
     // will have if the transaction is successful, since the server hasn't
     // issued it yet) then the balance receipt will have 1 in
     // the user's portion for that outbox transaction, and the balance receipt
     // will also have, say, #34 (the actual number) here
     // in this variable, in the server's reply portion of that same receipt.
 
     m_lClosingTransactionNo = 0;
 
     m_strContractType = "TRANSACTION ITEM"; // CONTRACT, MESSAGE, TRANSACTION,
                                             // LEDGER, TRANSACTION ITEM
 }

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

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 1803 of file OTItem.cpp.

 {
     if (!strcmp("item", xml->getNodeName())) {
         OTString strType, strStatus;
 
         strType = xml->getAttributeValue("type");
         strStatus = xml->getAttributeValue("status");
 
         // Type
         m_Type = GetItemTypeFromString(strType); // just above.
 
         // Status
         if (strStatus.Compare("request"))
             m_Status = OTItem::request;
         else if (strStatus.Compare("acknowledgement"))
             m_Status = OTItem::acknowledgement;
         else if (strStatus.Compare("rejection"))
             m_Status = OTItem::rejection;
         else
             m_Status = OTItem::error_status;
 
         OTString strAcctFromID, strAcctToID, strServerID, strUserID,
             strOutboxNewTransNum;
 
         strAcctFromID = xml->getAttributeValue("fromAccountID");
         strAcctToID = xml->getAttributeValue("toAccountID");
         strServerID = xml->getAttributeValue("serverID");
         strUserID = xml->getAttributeValue("userID");
 
         strOutboxNewTransNum = xml->getAttributeValue("outboxNewTransNum");
 
         if (strOutboxNewTransNum.Exists())
             m_lNewOutboxTransNum = atol(strOutboxNewTransNum.Get());
 
         // an OTTransaction::blank may now contain 20 or 100 new numbers.
         // Therefore, the OTItem::acceptTransaction must contain the same list,
         // otherwise you haven't actually SIGNED for the list, have you!
         //
         if (OTItem::acceptTransaction == m_Type) {
             const OTString strTotalList =
                 xml->getAttributeValue("totalListOfNumbers");
             m_Numlist.Release();
 
             if (strTotalList.Exists())
                 m_Numlist.Add(strTotalList); // (Comma-separated list of numbers
                                              // now becomes std::set<int64_t>.)
         }
 
         OTIdentifier ACCOUNT_ID(strAcctFromID), SERVER_ID(strServerID),
             DESTINATION_ACCOUNT(strAcctToID), USER_ID(strUserID);
 
         SetPurportedAccountID(ACCOUNT_ID); // OTTransactionType::m_AcctID  the
                                            // PURPORTED Account ID
         SetPurportedServerID(SERVER_ID);   // OTTransactionType::m_AcctServerID
                                            // the PURPORTED Server ID
         SetDestinationAcctID(DESTINATION_ACCOUNT);
         SetUserID(USER_ID);
 
         if (!m_bLoadSecurely) {
             SetRealAccountID(ACCOUNT_ID);
             SetRealServerID(SERVER_ID);
         }
 
         OTString strTemp;
 
         strTemp = xml->getAttributeValue("numberOfOrigin");
         if (strTemp.Exists()) SetNumberOfOrigin(atol(strTemp.Get()));
 
         strTemp = xml->getAttributeValue("transactionNum");
         if (strTemp.Exists()) SetTransactionNum(atol(strTemp.Get()));
 
         strTemp = xml->getAttributeValue("inReferenceTo");
         if (strTemp.Exists()) SetReferenceToNum(atol(strTemp.Get()));
 
         m_lAmount = atol(xml->getAttributeValue("amount"));
 
         otLog3 << "Loaded transaction Item, transaction num "
                << GetTransactionNum()
                << ", In Reference To: " << GetReferenceToNum()
                << ", type: " << strType << ", status: " << strStatus << "\n";
         //                "fromAccountID:\n%s\n UserID:\n%s\n toAccountID:\n%s\n
         // serverID:\n%s\n----------\n",
         //                strAcctFromID.Get(), strUserID.Get(),
         // strAcctToID.Get(), strServerID.Get()
 
         return 1;
     }
     else if (!strcmp("note", xml->getNodeName())) {
         if (!OTContract::LoadEncodedTextField(xml, m_ascNote)) {
             otErr << "Error in OTItem::ProcessXMLNode: note field without "
                      "value.\n";
             return (-1); // error condition
         }
 
         return 1;
     }
     else if (!strcmp("inReferenceTo", xml->getNodeName())) {
         if (false ==
             OTContract::LoadEncodedTextField(xml, m_ascInReferenceTo)) {
             otErr << "Error in OTItem::ProcessXMLNode: inReferenceTo field "
                      "without value.\n";
             return (-1); // error condition
         }
 
         return 1;
     }
     else if (!strcmp("attachment", xml->getNodeName())) {
         if (!OTContract::LoadEncodedTextField(xml, m_ascAttachment)) {
             otErr << "Error in OTItem::ProcessXMLNode: attachment field "
                      "without value.\n";
             return (-1); // error condition
         }
 
         return 1;
     }
     else if (!strcmp("transactionReport", xml->getNodeName())) {
         if ((OTItem::balanceStatement == m_Type) ||
             (OTItem::atBalanceStatement == m_Type)) {
             // Notice it initializes with the wrong transaction number, in this
             // case.
             // That's okay, because I'm setting it below with
             // pItem->SetTransactionNum...
             OTItem* pItem = new OTItem(GetUserID(), *this); // But I've also got
                                                             // ITEM types with
                                                             // the same names...
             // That way, it will translate the string and set the type
             // correctly.
             OT_ASSERT(nullptr != pItem); // That way I can use each item to
                                          // REPRESENT an inbox transaction
 
             // Type
             OTString strType;
             strType = xml->getAttributeValue(
                 "type"); // it's reading a TRANSACTION type: chequeReceipt,
                          // voucherReceipt, marketReceipt, or paymentReceipt.
                          // But I also have the same names for item types.
 
             pItem->SetType(GetItemTypeFromString(
                 strType)); // It's actually translating a transaction type to an
                            // item type. (Same names in the case of the 3
                            // receipts that matter for inbox reports for balance
                            // agreements.)
 
             pItem->SetAmount(atol(xml->getAttributeValue("adjustment")));
 
             // Status
             pItem->SetStatus(OTItem::acknowledgement); // I don't need this, but
                                                        // I'd rather it not say
                                                        // error state. This way
                                                        // if it changes to
                                                        // error_state later, I
                                                        // know I had a problem.
 
             OTString strAccountID, strServerID, strUserID;
 
             strAccountID = xml->getAttributeValue("accountID");
             strServerID = xml->getAttributeValue("serverID");
             strUserID = xml->getAttributeValue("userID");
 
             OTIdentifier ACCOUNT_ID(strAccountID), SERVER_ID(strServerID),
                 USER_ID(strUserID);
 
             pItem->SetPurportedAccountID(
                 ACCOUNT_ID); // OTTransactionType::m_AcctID  the PURPORTED
                              // Account ID
             pItem->SetPurportedServerID(
                 SERVER_ID); // OTTransactionType::m_AcctServerID the PURPORTED
                             // Server ID
             pItem->SetUserID(USER_ID);
 
             OTString strTemp;
 
             strTemp = xml->getAttributeValue("numberOfOrigin");
             if (strTemp.Exists()) pItem->SetNumberOfOrigin(atol(strTemp.Get()));
 
             strTemp = xml->getAttributeValue("transactionNum");
             if (strTemp.Exists()) pItem->SetTransactionNum(atol(strTemp.Get()));
 
             strTemp = xml->getAttributeValue("inReferenceTo");
             if (strTemp.Exists()) pItem->SetReferenceToNum(atol(strTemp.Get()));
 
             strTemp = xml->getAttributeValue(
                 "closingTransactionNum"); // only used in the inbox report for
                                           // balance agreement.
             if (strTemp.Exists()) pItem->SetClosingNum(atol(strTemp.Get()));
 
             AddItem(*pItem); // <======= adding to list.
 
             otLog3 << "Loaded transactionReport Item, transaction num "
                    << pItem->GetTransactionNum()
                    << ", In Reference To: " << pItem->GetReferenceToNum()
                    << ", type: " << strType << "\n";
             //                         "fromAccountID:\n%s\n UserID:\n%s\n
             // toAccountID:\n%s\n serverID:\n%s\n----------\n",
             //                         strAcctFromID.Get(), strUserID.Get(),
             // strAcctToID.Get(), strServerID.Get()
         }
         else {
             otErr << "Outbox hash in item wrong type (expected "
                      "balanceStatement or atBalanceStatement.\n";
         }
 
         return 1;
     }
 
     return 0;
 }

void opentxs::OTItem::Release ( )

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 1612 of file OTItem.cpp.

 {
     Release_Item();
 
     ot_super::Release();
 }

void opentxs::OTItem::Release_Item ( )

Definition at line 1619 of file OTItem.cpp.

 {
     ReleaseItems();
 
     m_AcctToID.Release();
     m_lAmount = 0;
     m_lNewOutboxTransNum = 0;
     m_lClosingTransactionNo = 0;
 }

void opentxs::OTItem::ReleaseItems ( )

Definition at line 1629 of file OTItem.cpp.

 {
 
     while (!m_listItems.empty()) {
         OTItem* pItem = m_listItems.front();
         m_listItems.pop_front();
         delete pItem;
     }
 }

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

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 2397 of file OTItem.cpp.

 {
     return true;
 }

void opentxs::OTItem::SetAmount ( int64_t lAmount )

inline

Definition at line 479 of file OTItem.hpp.

     {
         m_lAmount = lAmount;
     }

void opentxs::OTItem::SetAttachment ( const OTString & theStr )

Definition at line 1402 of file OTItem.cpp.

 {
     m_ascAttachment.SetString(theStr);
 }

void opentxs::OTItem::SetClosingNum ( int64_t lClosingNum )

Definition at line 2017 of file OTItem.cpp.

 {
     m_lClosingTransactionNo = lClosingNum;
 }

void opentxs::OTItem::SetDestinationAcctID ( const OTIdentifier & theID )

inline

Definition at line 491 of file OTItem.hpp.

     {
         m_AcctToID = theID;
     }

void opentxs::OTItem::SetNewOutboxTransNum ( int64_t lTransNum )

inline

Definition at line 426 of file OTItem.hpp.

     {
         m_lNewOutboxTransNum = lTransNum;
     }

void opentxs::OTItem::SetNote ( const OTString & theStr )

Definition at line 1413 of file OTItem.cpp.

 {
     if (theStr.Exists() && theStr.GetLength() > 2) {
         OTString theString(theStr);
         if (theStr.GetLength() < MINIMUM_CLEARTEXT_SIZE_OTASCIIARMOR) {
             OTString strPadding(OTASSCIIARMOR_PADDING_TEXT);
 
             theString.Concatenate(strPadding);
         }
 
         m_ascNote.SetString(theString);
     }
     else {
         m_ascNote.Release();
     }
 }

void opentxs::OTItem::SetStatus ( const OTItem::itemStatus & theVal )

inline

Definition at line 463 of file OTItem.hpp.

     {
         m_Status = theVal;
     }

void opentxs::OTItem::SetType ( OTItem::itemType theType )

inline

Definition at line 471 of file OTItem.hpp.

     {
         m_Type = theType;
     }

void opentxs::OTItem::UpdateContents ( )

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 2251 of file OTItem.cpp.

 {
     OTString strListOfBlanks; // IF this item is "acceptTransaction" then this
                               // will serialize the list of transaction numbers
                               // being accepted. (They now support multiple
                               // numbers.)
 
     switch (m_Type) {
     case OTItem::acceptTransaction: {
         if (m_Numlist.Count() >
             0) // This is always 0, except for OTItem::acceptTransaction.
         {
             OTString strNumbers;
             if (true == m_Numlist.Output(strNumbers))
                 strListOfBlanks.Format(" totalListOfNumbers=\"%s\"\n",
                                        strNumbers.Get());
             else // (False just means m_Numlist was empty.)
                 strListOfBlanks.Set("");
         }
     }
     default:
         break;
     }
 
     OTString strFromAcctID(GetPurportedAccountID()),
         strToAcctID(GetDestinationAcctID()),
         strServerID(GetPurportedServerID()), strType, strStatus,
         strUserID(GetUserID());
 
     GetStringFromType(m_Type, strType);
 
     switch (m_Status) {
     case OTItem::request:
         strStatus.Set("request");
         break;
     case OTItem::acknowledgement:
         strStatus.Set("acknowledgement");
         break;
     case OTItem::rejection:
         strStatus.Set("rejection");
         break;
     default:
         strStatus.Set("error-unknown");
         break;
     }
 
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     if (m_lNewOutboxTransNum > 0)
         m_xmlUnsigned.Concatenate(
             "<item type=\"%s\"\n status=\"%s\"\n"
             " outboxNewTransNum=\"%lld\"\n" // only used in server reply item:
                                             // atBalanceStatement. In cases
                                             // where the statement includes a
                                             // new outbox item, this variable is
                                             // used to transport the new
                                             // transaction number (generated on
                                             // server side for that new outbox
                                             // item) back to the client, so the
                                             // client knows the transaction
                                             // number to verify when he is
                                             // verifying the outbox against the
                                             // last signed receipt.
             " numberOfOrigin=\"%lld\"\n"
             " transactionNum=\"%lld\"\n"
             " serverID=\"%s\"\n"
             " userID=\"%s\"\n"
             " fromAccountID=\"%s\"\n"
             " toAccountID=\"%s\"\n"
             " inReferenceTo=\"%lld\"\n"
             " amount=\"%lld\" >\n\n",
             strType.Get(), strStatus.Get(), m_lNewOutboxTransNum,
             GetRawNumberOfOrigin(), // GetRaw so it doesn't calculate.
             GetTransactionNum(), strServerID.Get(), strUserID.Get(),
             strFromAcctID.Get(), strToAcctID.Get(), GetReferenceToNum(),
             m_lAmount);
     else
         m_xmlUnsigned.Concatenate(
             "<item type=\"%s\"\n status=\"%s\"\n"
             " numberOfOrigin=\"%lld\"\n"
             " transactionNum=\"%lld\"\n%s"
             " serverID=\"%s\"\n"
             " userID=\"%s\"\n"
             " fromAccountID=\"%s\"\n"
             " toAccountID=\"%s\"\n"
             " inReferenceTo=\"%lld\"\n"
             " amount=\"%lld\" >\n\n",
             strType.Get(), strStatus.Get(),
             GetRawNumberOfOrigin(), // GetRaw so it doesn't calculate.
             GetTransactionNum(), strListOfBlanks.Get(), strServerID.Get(),
             strUserID.Get(), strFromAcctID.Get(), strToAcctID.Get(),
             GetReferenceToNum(), m_lAmount);
 
     if (m_ascNote.GetLength() > 2) {
         m_xmlUnsigned.Concatenate("<note>\n%s</note>\n\n", m_ascNote.Get());
     }
 
     if (m_ascInReferenceTo.GetLength() > 2) {
         m_xmlUnsigned.Concatenate("<inReferenceTo>\n%s</inReferenceTo>\n\n",
                                   m_ascInReferenceTo.Get());
     }
 
     if (m_ascAttachment.GetLength() > 2) {
         m_xmlUnsigned.Concatenate("<attachment>\n%s</attachment>\n\n",
                                   m_ascAttachment.Get());
     }
 
     if ((OTItem::balanceStatement == m_Type) ||
         (OTItem::atBalanceStatement == m_Type)) {
 
         // loop through the sub-items (only used for balance agreement.)
         //
         for (auto& it : m_listItems) {
             OTItem* pItem = it;
             OT_ASSERT(nullptr != pItem);
 
             OTString strAcctID(pItem->GetPurportedAccountID()),
                 strServerID(pItem->GetPurportedServerID()),
                 strUserID(pItem->GetUserID());
 
             OTString strReceiptType;
             GetStringFromType(pItem->GetType(), strReceiptType);
 
             m_xmlUnsigned.Concatenate(
                 "<transactionReport type=\"%s\"\n"
                 " adjustment=\"%lld\"\n"
                 " accountID=\"%s\"\n"
                 " userID=\"%s\"\n"
                 " serverID=\"%s\"\n"
                 " numberOfOrigin=\"%lld\"\n"
                 " transactionNum=\"%lld\"\n"
                 " closingTransactionNum=\"%lld\"\n"
                 " inReferenceTo=\"%lld\" />\n\n",
                 strReceiptType.Exists() ? strReceiptType.Get() : "error_state",
                 pItem->GetAmount(), strAcctID.Get(), strUserID.Get(),
                 strServerID.Get(), pItem->GetRawNumberOfOrigin(),
                 pItem->GetTransactionNum(), pItem->GetClosingNum(),
                 pItem->GetReferenceToNum());
         }
     }
 
     m_xmlUnsigned.Concatenate("</item>\n");
 }

bool opentxs::OTItem::VerifyBalanceStatement	(	int64_t	lActualAdjustment,
		OTPseudonym &	THE_NYM,
		OTLedger &	THE_INBOX,
		OTLedger &	THE_OUTBOX,
		const OTAccount &	THE_ACCOUNT,
		OTTransaction &	TARGET_TRANSACTION,
		int64_t	lOutboxTrnsNum = `0`
	)

Definition at line 358 of file OTItem.cpp.

 { // doesn't know the outbox trans# in advance, so he sends
     if (GetType() != OTItem::balanceStatement) // a dummy number (currently '1')
                                                // which we verify against
     { // the actual outbox trans# successfully, only in that special case.
         otOut << "OTItem::" << __FUNCTION__ << ": wrong item type.\n";
         return false;
     }
 
     // We need to verify:
     //
     // 1) That THE_ACCOUNT.GetBalance() + lActualAdjustment equals the amount in
     // GetAmount().
 
     if ((THE_ACCOUNT.GetBalance() + lActualAdjustment) !=
         GetAmount()) // GetAmount() contains what the balance WOULD
                      // be AFTER successful transaction.
     {
         otOut << "OTItem::" << __FUNCTION__
               << ": This balance statement has a value of " << GetAmount()
               << ", but expected "
               << (THE_ACCOUNT.GetBalance() + lActualAdjustment)
               << ". "
                  "(Acct balance of " << THE_ACCOUNT.GetBalance()
               << " plus actualAdjustment of " << lActualAdjustment << ".)\n";
         return false;
     }
 
     // 2) That the inbox transactions and outbox transactions match up to the
     // list of sub-items
     //    on THIS balance item.
 
     int32_t nInboxItemCount = 0, nOutboxItemCount = 0;
 
     const char* szInbox = "Inbox";
     const char* szOutbox = "Outbox";
 
     const char* pszLedgerType = nullptr;
 
     //    otWarn << "OTItem::VerifyBalanceStatement: (ENTERING LOOP)... INBOX
     // COUNT: %d\n"
     //                   "# of inbox/outbox items on this balance statement:
     // %d\n",
     //                   THE_INBOX.GetTransactionCount(), GetItemCount());
 
     for (int32_t i = 0; i < GetItemCount(); i++) {
         OTItem* pSubItem = GetItem(i);
         OT_ASSERT(nullptr != pSubItem);
         //      otWarn << "OTItem::VerifyBalanceStatement: TOP OF LOOP (through
         // sub-items).......\n");
 
         int64_t lReceiptAmountMultiplier = 1; // needed for outbox items.
 
         OTLedger* pLedger = nullptr;
 
         switch (pSubItem->GetType()) {
         case OTItem::voucherReceipt:
         case OTItem::chequeReceipt:
         case OTItem::marketReceipt:
         case OTItem::paymentReceipt:
         case OTItem::transferReceipt:
         case OTItem::basketReceipt:
         case OTItem::finalReceipt:
             nInboxItemCount++;
             pLedger = &THE_INBOX;
             pszLedgerType = szInbox;
 
         //              otWarn << "OTItem::VerifyBalanceStatement: Subitem is
         // Inbox receipt item (NOT pending transfer)....\n");
 
         case OTItem::transfer:
             break;
         default: {
             OTString strItemType;
             GetTypeString(strItemType);
             otWarn << "OTItem::" << __FUNCTION__ << ": Ignoring " << strItemType
                    << " item in balance statement while verifying it against "
                       "inbox.\n";
         }
             continue;
         }
 
         switch (pSubItem->GetType()) {
         case OTItem::transfer:
             if (pSubItem->GetAmount() < 0) // it's an outbox item
             {
                 //                  otWarn << "OTItem::VerifyBalanceStatement:
                 // Subitem is pending transfer (in outbox)....\n");
 
                 lReceiptAmountMultiplier =
                     -1; // transfers out always reduce your balance.
                 nOutboxItemCount++;
                 pLedger = &THE_OUTBOX;
                 pszLedgerType = szOutbox;
             }
             else {
                 //                  otWarn << "OTItem::VerifyBalanceStatement:
                 // Subitem is pending transfer (in inbox)....\n");
 
                 lReceiptAmountMultiplier =
                     1; // transfers in always increase your balance.
                 nInboxItemCount++;
                 pLedger = &THE_INBOX;
                 pszLedgerType = szInbox;
             }
             break;
         case OTItem::finalReceipt:
         // Here: If there is a finalReceipt on this balance statement, then ALL
         // the other
         // related receipts in the inbox (with same "reference to" value) had
         // better ALSO
         // be on the same balance statement!
 
         // HMM that is true, but NOT HERE... That's only true when PROCESSING
         // the final Receipt
         // from the inbox (in that case, all the marketReceipts must also be
         // processed with it.)
         // But here, I am looping through the inbox report, and there happens to
         // be a finalReceipt
         // on it. (Which doesn't mean necessarily that it's being processed
         // out...)
         case OTItem::basketReceipt:
 
         case OTItem::transferReceipt:
         case OTItem::voucherReceipt:
         case OTItem::chequeReceipt:
         case OTItem::marketReceipt:
         case OTItem::paymentReceipt:
             lReceiptAmountMultiplier = 1;
             break;
         default:
             otErr << "OTItem::" << __FUNCTION__
                   << ": Bad Subitem type (SHOULD NEVER HAPPEN)....\n";
 
             continue; // This will never happen, due to the first continue above
                       // in the first switch.
         }
 
         OTTransaction* pTransaction = nullptr;
 
         // In the special case of account transfer, the user has put an outbox
         // transaction
         // into his balance agreement with the special number '1', since he has
         // no idea what
         // actual number will be generated on the server side (for the outbox)
         // when his
         // message is received by the server.
         //
         // When that happens (ONLY in account transfer) then lOutboxTrnsNum will
         // be passed
         // in with the new transaction number chosen by the server (a real
         // number, like 18736
         // or whatever, instead of the default of 0 that will otherwise be
         // passed in here.)
         //
         // Therefore, if lOutboxTrnsNum is larger than 0, AND if we're on an
         // outbox item,
         // then we can expect lOutboxTrnsNum to contain an actual transaction
         // number, and
         // we can expect there is a CHANCE that the sub-item will be trans# 1.
         // (It might
         // NOT be number 1, since there may be other outbox items-we're looping
         // through them
         // right now in this block.) So we'll check to see if this is the '1'
         // and if so,
         // we'll look up pTransaction from the outbox using the real transaction
         // number,
         // instead of '1' which of course would not find it (since the version
         // in the ledger
         // contains the ACTUAL number now, since the server just issued it.)
         //
         if ((lOutboxTrnsNum > 0) && (&THE_OUTBOX == pLedger) &&
             (pSubItem->GetTransactionNum() == 1)) // TODO use a constant for
                                                   // this 1.
         {
             otLog3 << "OTItem::" << __FUNCTION__
                    << ": Subitem is new Outbox Transaction... retrieving by "
                       "special ID: " << lOutboxTrnsNum << "\n";
 
             pTransaction = pLedger->GetTransaction(lOutboxTrnsNum);
         }
         else {
             otLog4 << "OTItem::" << __FUNCTION__
                    << ": Subitem is normal Transaction... retrieving by ID: "
                    << pSubItem->GetTransactionNum() << "\n";
 
             pTransaction =
                 pLedger->GetTransaction(pSubItem->GetTransactionNum());
         }
 
         // Make sure that the transaction number of each sub-item is found
         // on the appropriate ledger (inbox or outbox).
         if (nullptr == pTransaction) {
             otOut << "OTItem::" << __FUNCTION__ << ": Expected "
                   << pszLedgerType << " transaction (serv " << lOutboxTrnsNum
                   << ", client " << pSubItem->GetTransactionNum()
                   << ") "
                      "not found. (Amount " << pSubItem->GetAmount() << ".)\n";
             return false;
         }
         // pTransaction is set below this point.
 
         if (pSubItem->GetReferenceToNum() !=
             pTransaction->GetReferenceToNum()) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") mismatch Reference Num: "
                   << pSubItem->GetReferenceToNum() << ", expected "
                   << pTransaction->GetReferenceToNum() << "\n";
             return false;
         }
 
         if (pSubItem->GetRawNumberOfOrigin() !=
             pTransaction->GetRawNumberOfOrigin()) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") mismatch Origin Num: "
                   << pSubItem->GetRawNumberOfOrigin() << ", expected "
                   << pTransaction->GetRawNumberOfOrigin() << "\n";
 
             // THE BELOW STUFF IS JUST FOR DEBUGGING PURPOSES.
             // ERASE IT.
 
             /*
             OTString strTempType;
             pSubItem->GetTypeString(strTempType);
 
             int64_t lTempAmount = pSubItem->GetAmount();
 
             OTIdentifier ACCOUNT_ID, SERVER_ID, USER_ID;
 
             ACCOUNT_ID = pSubItem->GetPurportedAccountID();
             SERVER_ID  = pSubItem->GetPurportedServerID();
             USER_ID    = pSubItem->GetUserID();
 
             const OTString strAccountID(ACCOUNT_ID), strServerID(SERVER_ID),
             strUserID(USER_ID);
 
 
             int64_t lTempNumOfOrigin = pSubItem->GetNumberOfOrigin();
             int64_t lTempTransNum    = pSubItem->GetTransactionNum();
             int64_t lTempRefNum      = pSubItem->GetReferenceToNum();
             int64_t lTempClosingNum  = pSubItem->GetClosingNum();
 
 
             const OTString strTrans(*pTransaction);
             otOut << "OTItem::%s: %s transaction (%lld) mismatch Origin Num:
             %lld, expected %lld\n\nTRANSACTION:\n%s\n\n"
                            "SubItem Type: %s  Amount: %lld\nAccount: %s\nServer:
             %s\nUser: %s\n"
                            " Number of Origin: %lld\n Transaction Num: %lld\n In
             Reference To: %lld\n Closing Num: %d\n",
                            __FUNCTION__, pszLedgerType,
             pSubItem->GetTransactionNum(),
                            pSubItem->GetRawNumberOfOrigin(),
             pTransaction->GetRawNumberOfOrigin(),
                            strTrans.Get(),
                            strTempType.Get(), lTempAmount, strAccountID.Get(),
             strServerID.Get(), strUserID.Get(),
                            lTempNumOfOrigin, lTempTransNum, lTempRefNum,
             lTempClosingNum
                            );
              */
             return false;
         }
 
         int64_t lTransactionAmount = pTransaction->GetReceiptAmount();
         lTransactionAmount *= lReceiptAmountMultiplier;
 
         if (pSubItem->GetAmount() != lTransactionAmount) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") "
                      "amounts don't match: report amount is "
                   << pSubItem->GetAmount() << ", but expected "
                   << lTransactionAmount
                   << ". Trans Receipt Amt: " << pTransaction->GetReceiptAmount()
                   << " (GetAmount() == " << GetAmount() << ".)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::transfer) &&
             (pTransaction->GetType() != OTTransaction::pending)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (transfer block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::chequeReceipt) &&
             (pTransaction->GetType() != OTTransaction::chequeReceipt)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (chequeReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::voucherReceipt) &&
             (pTransaction->GetType() != OTTransaction::voucherReceipt)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (voucherReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::marketReceipt) &&
             (pTransaction->GetType() != OTTransaction::marketReceipt)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (marketReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::paymentReceipt) &&
             (pTransaction->GetType() != OTTransaction::paymentReceipt)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (paymentReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::transferReceipt) &&
             (pTransaction->GetType() != OTTransaction::transferReceipt)) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type. (transferReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::basketReceipt) &&
             ((pTransaction->GetType() != OTTransaction::basketReceipt) ||
              (pSubItem->GetClosingNum() != pTransaction->GetClosingNum()))) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type or closing num ("
                   << pSubItem->GetClosingNum() << "). "
                                                   "(basketReceipt block)\n";
             return false;
         }
 
         if ((pSubItem->GetType() == OTItem::finalReceipt) &&
             ((pTransaction->GetType() != OTTransaction::finalReceipt) ||
              (pSubItem->GetClosingNum() != pTransaction->GetClosingNum()))) {
             otOut << "OTItem::" << __FUNCTION__ << ": " << pszLedgerType
                   << " transaction (" << pSubItem->GetTransactionNum()
                   << ") wrong type or closing num ("
                   << pSubItem->GetClosingNum() << "). "
                                                   "(finalReceipt block)\n";
             return false;
         }
     }
 
     // By this point, I have an accurate count of the inbox items, and outbox
     // items, represented
     // by this. let's compare those counts to the actual inbox and outbox on my
     // side:
 
     if ((nInboxItemCount != THE_INBOX.GetTransactionCount()) ||
         (nOutboxItemCount != THE_OUTBOX.GetTransactionCount())) {
         otOut << "OTItem::" << __FUNCTION__
               << ": Inbox or Outbox mismatch in expected transaction count.\n"
                  " --- THE_INBOX count: " << THE_INBOX.GetTransactionCount()
               << " --- THE_OUTBOX count: " << THE_OUTBOX.GetTransactionCount()
               << "\n"
                  "--- nInboxItemCount count: " << nInboxItemCount
               << " --- nOutboxItemCount count: " << nOutboxItemCount << "\n\n";
 
         return false;
     }
 
     // Now I KNOW that the inbox and outbox counts are the same, AND I know that
     // EVERY transaction number
     // on the balance item (this) was also found in the inbox or outbox,
     // wherever it was expected to be found.
     // I also know:
     // the amount was correct,
     // the "in reference to" number was correct,
     // and the type was correct.
     //
     // So if the caller was planning to remove a number, or clear a receipt from
     // the inbox, he'll have to do
     // so first before calling this function, and then ADD IT AGAIN if this
     // function fails.  (Because the new
     // Balance Agreement is always the user signing WHAT THE NEW VERSION WILL BE
     // AFTER THE TRANSACTION IS PROCESSED.
     // Thus, if the transaction fails to process, the action hasn't really
     // happened, so need to add it back again.)
 
     // 3) Also need to verify the transactions on the Nym, against the
     // transactions stored on this
     //    (in a message Nym attached to this.)  Check for presence of each, then
     // compare count, like above.
 
     OTPseudonym theRemovedNym;
 
     OTString SERVER_ID(GetPurportedServerID());
 
     // GetTransactionNum() is the ID for this balance agreement, THUS it's also
     // the ID
     // for whatever actual transaction is being attempted. If that ID is not
     // verified as
     // on my issued list, then the whole transaction is invalid (not
     // authorized.)
     //
     bool bIWasFound = THE_NYM.VerifyIssuedNum(SERVER_ID, GetTransactionNum());
 
     if (!bIWasFound) {
         otOut << "OTItem::" << __FUNCTION__ << ": Transaction has # that "
                                                "doesn't appear on Nym's issued "
                                                "list.\n";
         return false;
     }
 
     // BELOW THIS POINT, WE *KNOW* THE ISSUED NUM IS CURRENTLY ON THE LIST...
     //
     // (SO I CAN remove it and add it again, KNOWING that I'm never re-adding a
     // num that wasn't there in the first place.
 
     // For process inbox, deposit, and withdrawal, the client will remove from
     // issued list as soon as he
     // receives my acknowledgment OR rejection. He expects server (me) to
     // remove, so he signs a balance
     // agreement to that effect. (With the number removed from issued list.)
     //
     // Therefore, to verify the balance agreement, we remove it on our side as
     // well, so that they will match.
     // The picture thus formed is what would be correct assuming a successful
     // transaction. That way if
     // the transaction goes through, we have our signed receipt showing the new
     // state of things (without
     // which we would not permit the transaction to go through :)
     //
     // This allows the client side to then ACTUALLY remove the number when they
     // receive our response,
     // as well as permits me (server) to actually remove from issued list.
     //
     // If ANYTHING ELSE fails during this verify process (other than
     // processInbox, deposit, and withdraw)
     // then we have to ADD THE # AGAIN since we still don't have a valid
     // signature on that number. So
     // you'll see this code repeated a few times in reverse, down inside this
     // function. For example,
     //
     switch (TARGET_TRANSACTION.GetType()) {
     case OTTransaction::processInbox:
     case OTTransaction::withdrawal:
     case OTTransaction::deposit:
     case OTTransaction::payDividend:
     case OTTransaction::cancelCronItem:
     case OTTransaction::exchangeBasket:
         // We DID verify the issued num (above) but I'm still just being safe
         // here...
         // ... since theRemovedNym contains numbers being re-added, just wanna
         // make sure
         // they were there in the first place.
         //
         if (THE_NYM.RemoveIssuedNum(SERVER_ID,
                                     GetTransactionNum())) // doesn't save.
             theRemovedNym.AddIssuedNum(SERVER_ID, GetTransactionNum());
         break;
 
     case OTTransaction::transfer:
     case OTTransaction::marketOffer:
     case OTTransaction::paymentPlan:
     case OTTransaction::smartContract:
         // These, assuming success, do NOT remove an issued number. So no need
         // to anticipate setting up the list that way, to get a match.
         break;
     default:
         // Error
         otErr << "OTItem::" << __FUNCTION__
               << ": wrong target transaction type: "
               << TARGET_TRANSACTION.GetTypeString() << "\n";
         break;
     }
     int32_t nNumberOfTransactionNumbers1 = 0; // The Nym on this side
     int32_t nNumberOfTransactionNumbers2 = 0; // The Message Nym.
 
     OTString strMessageNym;
 
     // First, loop through the Nym on my side, and count how many numbers total
     // he has...
     //
     for (auto& it : THE_NYM.GetMapIssuedNum()) {
         std::string strServerID = it.first;
         dequeOfTransNums* pDeque = it.second;
         OT_ASSERT(nullptr != pDeque);
 
         const OTIdentifier theServerID(strServerID.c_str());
 
         if (!(pDeque->empty()) && (theServerID == GetPurportedServerID())) {
             nNumberOfTransactionNumbers1 +=
                 static_cast<int32_t>(pDeque->size());
             break; // There's only one, in this loop, that would/could/should
                    // match. (Therefore, break after finding it.)
         }
     } // for
 
     // Next, loop through theMessageNym, and count his numbers as well...
     // But ALSO verify that each one exists on THE_NYM, so that each individual
     // number is checked.
     GetAttachment(strMessageNym);
     OTPseudonym theMessageNym;
 
     if ((strMessageNym.GetLength() > 2) &&
         theMessageNym.LoadFromString(strMessageNym)) {
         for (auto& it : theMessageNym.GetMapIssuedNum()) {
             std::string strServerID = it.first;
             dequeOfTransNums* pDeque = it.second;
             OT_ASSERT(nullptr != pDeque);
 
             const OTIdentifier theServerID(strServerID.c_str());
             const OTString OTstrServerID(theServerID);
 
             if (!(pDeque->empty()) && (theServerID == GetPurportedServerID())) {
                 nNumberOfTransactionNumbers2 +=
                     static_cast<int32_t>(pDeque->size());
 
                 for (uint32_t i = 0; i < pDeque->size(); i++) {
                     int64_t lTransactionNumber = pDeque->at(i);
                     if (false ==
                         THE_NYM.VerifyIssuedNum(OTstrServerID,
                                                 lTransactionNumber)) // FAILURE
                     {
                         otOut << "OTItem::" << __FUNCTION__
                               << ": Issued transaction # " << lTransactionNumber
                               << " from Message Nym not found on this side.\n";
 
                         // I have to do this whenever I RETURN :-(
                         switch (TARGET_TRANSACTION.GetType()) {
                         case OTTransaction::processInbox:
                         case OTTransaction::withdrawal:
                         case OTTransaction::deposit:
                         case OTTransaction::payDividend:
                         case OTTransaction::cancelCronItem:
                         case OTTransaction::exchangeBasket:
                             // Should only actually iterate once, in this case.
                             for (int32_t i = 0;
                                  i < theRemovedNym.GetIssuedNumCount(
                                          GetPurportedServerID());
                                  i++) {
                                 int64_t lTemp = theRemovedNym.GetIssuedNum(
                                     GetPurportedServerID(), i);
 
                                 if (i > 0)
                                     otErr << "OTItem::" << __FUNCTION__
                                           << ": THIS SHOULD NOT HAPPEN.\n";
                                 else if (false ==
                                          THE_NYM.AddIssuedNum(
                                              SERVER_ID, lTemp)) // doesn't save.
                                     otErr << "OTItem::" << __FUNCTION__
                                           << ": Failed adding issued number "
                                              "back to THE_NYM.\n";
                             }
                             break;
 
                         case OTTransaction::transfer:
                         case OTTransaction::marketOffer:
                         case OTTransaction::paymentPlan:
                         case OTTransaction::smartContract:
                             break;
                         default:
                             // Error
                             otErr << "OTItem::" << __FUNCTION__
                                   << ": wrong target transaction type: "
                                   << TARGET_TRANSACTION.GetTypeString() << "\n";
                             break;
                         }
 
                         return false;
                     }
                 }      // for (numbers for a specific server.)
                 break; // Only one server ID should match, so we can break after
                        // finding it.
             }          // If the server ID matches
         }              // for (deques of numbers for each server)
     }
 
     // Finally, verify that the counts match...
     if (nNumberOfTransactionNumbers1 != nNumberOfTransactionNumbers2) {
         otOut << "OTItem::" << __FUNCTION__
               << ": Transaction # Count mismatch: "
               << nNumberOfTransactionNumbers1 << " and "
               << nNumberOfTransactionNumbers2 << "\n";
 
         // I have to do this whenever I RETURN :-(
         switch (TARGET_TRANSACTION.GetType()) {
         case OTTransaction::processInbox:
         case OTTransaction::withdrawal:
         case OTTransaction::deposit:
         case OTTransaction::payDividend:
         case OTTransaction::cancelCronItem:
         case OTTransaction::exchangeBasket:
             // Should only actually iterate once, in this case.
             for (int32_t i = 0;
                  i < theRemovedNym.GetIssuedNumCount(GetPurportedServerID());
                  i++) {
                 int64_t lTemp =
                     theRemovedNym.GetIssuedNum(GetPurportedServerID(), i);
 
                 if (i > 0)
                     otErr << "OTItem::" << __FUNCTION__
                           << ": THIS SHOULD NOT HAPPEN.\n";
                 else if (false ==
                          THE_NYM.AddIssuedNum(SERVER_ID,
                                               lTemp)) // doesn't save.
                     otErr << "OTItem::" << __FUNCTION__
                           << ": Failed adding issued number back to THE_NYM.\n";
             }
             break;
 
         case OTTransaction::transfer:
         case OTTransaction::marketOffer:
         case OTTransaction::paymentPlan:
         case OTTransaction::smartContract:
             break;
         default:
             // Error
             otErr << "OTItem::" << __FUNCTION__
                   << ": wrong target transaction type: "
                   << TARGET_TRANSACTION.GetTypeString() << "\n";
             break;
         }
 
         return false;
     }
 
     // By this point, I know the local Nym has the same number of transactions
     // as the message nym, and that
     // EVERY ONE OF THEM was found individually.
 
     // Might want to consider saving the Nym here.
     // Also want to save the latest signed receipt, since it VERIFIES.
     // Or maybe let caller decide?
 
     // I have to do this whenever I RETURN :-(
     // EVEN IF SUCCESS, we have only succeeded to verify the balance statement.
     // We must still go on to verify the transaction itself, and ONLY THEN will
     // we (possibly) remove the issued number from the list. And the decision
     // will
     // change from situation to situation, depending on the instrument.
     // Therefore I add it back here as well. We only fiddled with it in the
     // first place
     // in order to verify the balance statement. Done. So now let the other
     // pieces decide
     // their own logic from there.
     //
     switch (TARGET_TRANSACTION.GetType()) {
     case OTTransaction::processInbox:
     case OTTransaction::withdrawal:
     case OTTransaction::deposit:
     case OTTransaction::payDividend:
     case OTTransaction::cancelCronItem:
     case OTTransaction::exchangeBasket:
         // Should only actually iterate once, in this case.
         for (int32_t i = 0;
              i < theRemovedNym.GetIssuedNumCount(GetPurportedServerID()); i++) {
             int64_t lTemp =
                 theRemovedNym.GetIssuedNum(GetPurportedServerID(), i);
 
             if (i > 0)
                 otErr << "OTItem::" << __FUNCTION__
                       << ": THIS SHOULD NOT HAPPEN.\n";
             else if (false ==
                      THE_NYM.AddIssuedNum(SERVER_ID, lTemp)) // doesn't save.
                 otErr << "OTItem::" << __FUNCTION__
                       << ": Failed adding issued number back to THE_NYM.\n";
         }
         break;
 
     case OTTransaction::transfer:
     case OTTransaction::marketOffer:
     case OTTransaction::paymentPlan:
     case OTTransaction::smartContract:
         break;
     default:
         // Error
         otErr << "OTItem::" << __FUNCTION__
               << ": wrong target transaction type: "
               << TARGET_TRANSACTION.GetTypeString() << "\n";
         break;
     }
 
     return true;
 }

bool opentxs::OTItem::VerifyTransactionStatement	(	OTPseudonym &	THE_NYM,
		OTTransaction &	TARGET_TRANSACTION,
		bool	bIsRealTransaction = `true`
	)

Definition at line 181 of file OTItem.cpp.

 {
     if (GetType() != OTItem::transactionStatement) {
         otOut << __FUNCTION__
               << ": wrong item type. Expected OTItem::transactionStatement.\n";
         return false;
     }
 
     //
     // So if the caller was planning to remove a number, or clear a receipt from
     // the inbox, he'll have to do
     // so first before calling this function, and then ADD IT AGAIN if this
     // function fails.  (Because the new
     // Balance Agreement is always the user signing WHAT THE NEW VERSION WILL BE
     // AFTER THE TRANSACTION IS PROCESSED.)
     //
     const OTString SERVER_ID(GetPurportedServerID());
 
     OTPseudonym theRemovedNym;
 
     if (bIsRealTransaction) // Sometimes my "transaction number" is 0 since
                             // we're accepting numbers from the Nymbox (which is
                             // done by message, not transaction.)
     { //  In such cases, there's no point in checking the server-side to "make
         // sure it has number 0!" (because it won't.)
         bool bIWasFound =
             THE_NYM.VerifyIssuedNum(SERVER_ID, GetTransactionNum());
 
         if (!bIWasFound) {
             otOut << __FUNCTION__ << ": Transaction# (" << GetTransactionNum()
                   << ") doesn't appear on Nym's issued list.\n";
             return false;
         }
 
         // In the case that this is a real transaction, it must be a
         // cancelCronItem, payment plan or
         // market offer (since the other transaction types require a balance
         // statement, not a transaction
         // statement.) Also this might not be a transaction at all, but in that
         // case we won't enter this
         // block anyway.
         //
         switch (TARGET_TRANSACTION.GetType()) {
         // In the case of cancelCronItem(), we'd expect, if success, the number
         // would be removed, so we have
         // to remove it now, to simulate success for the verification. Then we
         // add it again afterwards, before
         // returning.
         //
         case OTTransaction::cancelCronItem:
             // Only adding it to theRemovedNym here since VerifyIssuedNum() is
             // called just above.
             // (Don't want to "add it back" if it wasn't there in the first
             // place!)
             //
             if (THE_NYM.RemoveIssuedNum(SERVER_ID,
                                         GetTransactionNum())) // doesn't save.
                 theRemovedNym.AddIssuedNum(SERVER_ID, GetTransactionNum());
             else
                 otOut << "OTItem::VerifyTransactionStatemen: Expected THE_NYM "
                          "to have trans# " << GetTransactionNum()
                       << " but didn't find it.\n";
             break;
 
         // IN the case of the offer/plan, we do NOT want to remove from issued
         // list. That only happens when
         // the plan or offer is removed from Cron and closed. As the plan or
         // offer continues processing,
         // the user is responsible for its main transaction number until he
         // signs off on final closing,
         // after many receipts have potentially been received.
         //
         case OTTransaction::marketOffer:
         case OTTransaction::paymentPlan:
         case OTTransaction::smartContract:
             //              THE_NYM.RemoveIssuedNum(SERVER_ID,
             // GetTransactionNum()); // commented out, explained just
             // above.
             break;
         default:
             otErr << "OTItem::VerifyTransactionStatement: Unexpected "
                      "transaction type.\n";
             break;
         }
 
         // Client side will NOT remove from issued list in this case (market
         // offer, payment plan, which are
         // the only transactions that use a transactionStatement, which is
         // otherwise used for Nymbox.)
     }
 
     // VERIFY that the Nyms have a matching list of transaction numbers...
 
     bool bSuccess = false;
 
     OTString strMessageNym;
 
     GetAttachment(strMessageNym);
     OTPseudonym theMessageNym;
 
     if ((strMessageNym.GetLength() > 2) &&
         theMessageNym.LoadFromString(strMessageNym)) {
         // If success, I know the server-side copy of the user's Nym (THE_NYM)
         // has the same number
         // of transactions as the message nym, and that EVERY ONE OF THEM was
         // found individually.
         //
         bSuccess = THE_NYM.VerifyIssuedNumbersOnNym(
             theMessageNym); // <==== ************************************
     }
 
     // NOW let's set things back how they were before, so we can RETURN.
     //
     if (bIsRealTransaction) {
         switch (TARGET_TRANSACTION.GetType()) {
         case OTTransaction::cancelCronItem:
             // Should only actually iterate once, in this case.
             for (int32_t i = 0;
                  i < theRemovedNym.GetIssuedNumCount(GetPurportedServerID());
                  i++) {
                 int64_t lTemp =
                     theRemovedNym.GetIssuedNum(GetPurportedServerID(), i);
 
                 if (i > 0)
                     otErr << "OTItem::VerifyTransactionStatement: THIS SHOULD "
                              "NOT HAPPEN.\n";
                 else if (false ==
                          THE_NYM.AddIssuedNum(SERVER_ID,
                                               lTemp)) // doesn't save.
                     otErr << "Failed adding issued number back to THE_NYM in "
                              "OTItem::VerifyTransactionStatement.\n";
             }
             break;
 
         case OTTransaction::marketOffer:
         case OTTransaction::paymentPlan:
         case OTTransaction::smartContract:
         default:
             //              THE_NYM.RemoveIssuedNum(SERVER_ID,
             // GetTransactionNum()); // commented out, explained just
             // above.
             break;
         }
     }
 
     // Might want to consider saving the Nym here.
     // Also want to save the latest signed receipt, since it VERIFIES.
     // Or maybe let caller decide?
 
     return bSuccess;
 }

Friends And Related Function Documentation

OTTransactionType* OTTransactionType::TransactionFactory ( OTString strInput )

friend

Member Data Documentation

OTIdentifier opentxs::OTItem::m_AcctToID

protected

Definition at line 352 of file OTItem.hpp.

OTASCIIArmor opentxs::OTItem::m_ascAttachment

Definition at line 437 of file OTItem.hpp.

OTASCIIArmor opentxs::OTItem::m_ascNote

Definition at line 434 of file OTItem.hpp.

int64_t opentxs::OTItem::m_lAmount

protected

Definition at line 354 of file OTItem.hpp.

int64_t opentxs::OTItem::m_lClosingTransactionNo

protected

Definition at line 376 of file OTItem.hpp.

listOfItems opentxs::OTItem::m_listItems

protected

Definition at line 356 of file OTItem.hpp.

int64_t opentxs::OTItem::m_lNewOutboxTransNum

protected

Definition at line 363 of file OTItem.hpp.

itemStatus opentxs::OTItem::m_Status

protected

Definition at line 362 of file OTItem.hpp.

itemType opentxs::OTItem::m_Type

protected

Definition at line 360 of file OTItem.hpp.

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation