#include <OTAccount.hpp>

Inheritance diagram for opentxs::OTAccount:

Collaboration diagram for opentxs::OTAccount:

Public Types
enum	AccountType { simple, issuer, basket, basketsub, mint, voucher, stash, err_acct }

Public Member Functions
EXPORT	OTAccount (const OTIdentifier &userId, const OTIdentifier &accountId, const OTIdentifier &serverId, const OTString &name)

EXPORT	OTAccount (const OTIdentifier &userId, const OTIdentifier &accountId, const OTIdentifier &serverId)

virtual EXPORT	~OTAccount ()

virtual EXPORT void	Release ()

virtual EXPORT bool	LoadContract ()

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

virtual EXPORT bool	SaveContractWallet (OTString &contents) const

virtual EXPORT bool	DisplayStatistics (OTString &contents) const

void	MarkForDeletion ()

bool	IsMarkedForDeletion () const

EXPORT bool	IsInternalServerAcct () const

EXPORT bool	IsOwnedByUser () const

EXPORT bool	IsOwnedByEntity () const

EXPORT bool	IsAllowedToGoNegative () const

EXPORT bool	IsIssuer () const

EXPORT bool	IsStashAcct () const

EXPORT const int64_t &	GetStashTransNum () const

EXPORT void	SetStashTransNum (const int64_t &transNum)

EXPORT void	InitAccount ()

EXPORT void	Release_Account ()

EXPORT bool	GenerateNewAccount (const OTPseudonym &server, const OTMessage &message, AccountType acctType=simple, int64_t stashTransNum=0)

EXPORT OTLedger *	LoadInbox (OTPseudonym &nym) const

EXPORT OTLedger *	LoadOutbox (OTPseudonym &nym) const

EXPORT bool	SaveInbox (OTLedger &box, OTIdentifier *hash=nullptr)

EXPORT bool	SaveOutbox (OTLedger &box, OTIdentifier *nash=nullptr)

EXPORT const OTIdentifier &	GetAssetTypeID () const

EXPORT int64_t	GetBalance () const

EXPORT bool	Debit (const int64_t &amount)

EXPORT bool	Credit (const int64_t &amount)

EXPORT bool	VerifyOwner (const OTPseudonym &candidate) const

EXPORT bool	VerifyOwnerByID (const OTIdentifier &nymId) const

EXPORT bool	SaveAccount ()

EXPORT void	SetInboxHash (const OTIdentifier &input)

EXPORT bool	GetInboxHash (OTIdentifier &output)

EXPORT void	SetOutboxHash (const OTIdentifier &input)

EXPORT bool	GetOutboxHash (OTIdentifier &output)

EXPORT char const *	GetTypeString () 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)

virtual EXPORT void	CalculateNumberOfOrigin ()

virtual EXPORT int64_t	GetNumberOfOrigin ()

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

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	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 OTAccount *	GenerateNewAccount (const OTIdentifier &userId, const OTIdentifier &serverId, const OTPseudonym &serverNym, const OTMessage &message, AccountType acctType=simple, int64_t stashTransNum=0)

static EXPORT OTAccount *	LoadExistingAccount (const OTIdentifier &accountId, const OTIdentifier &serverId)

static EXPORT char const *	_GetTypeString (AccountType accountType)

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)

Protected Member Functions
	OTAccount (const OTIdentifier &userId, const OTIdentifier &serverId)

	OTAccount ()

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

OTIdentifier	acctAssetTypeId_

OTString	balanceDate_

OTString	balanceAmount_

int64_t	stashTransNum_

bool	markForDeletion_

OTIdentifier	inboxHash_

OTIdentifier	outboxHash_

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

Detailed Description

Definition at line 148 of file OTAccount.hpp.

Member Enumeration Documentation

enum opentxs::OTAccount::AccountType

Enumerator
simple
issuer
basket
basketsub
mint
voucher
stash
err_acct

Definition at line 156 of file OTAccount.hpp.

                      {
         simple,    // used by users
         issuer,    // used by issuers    (these can only go negative.)
         basket,    // issuer acct used by basket currencies (these can only go
                    // negative)
         basketsub, // used by the server (to store backing reserves for basket
                    // sub-accounts)
         mint,      // used by mints (to store backing reserves for cash)
         voucher,   // used by the server (to store backing reserves for
                    // vouchers)
         stash,     // used by the server (to store backing reserves for stashes,
                    // for smart contracts.)
         err_acct
     };

Constructor & Destructor Documentation

opentxs::OTAccount::OTAccount	(	const OTIdentifier &	userId,
		const OTIdentifier &	accountId,
		const OTIdentifier &	serverId,
		const OTString &	name
	)

Definition at line 194 of file OTAccount.cpp.

     : OTTransactionType(userId, accountId, serverId)
     , stashTransNum_(0)
     , markForDeletion_(false)
 {
     InitAccount();
     m_strName = name;
 }

opentxs::OTAccount::OTAccount	(	const OTIdentifier &	userId,
		const OTIdentifier &	accountId,
		const OTIdentifier &	serverId
	)

Definition at line 204 of file OTAccount.cpp.

     : OTTransactionType(userId, accountId, serverId)
     , stashTransNum_(0)
     , markForDeletion_(false)
 {
     InitAccount();
 }

opentxs::OTAccount::~OTAccount ( )

virtual

Definition at line 213 of file OTAccount.cpp.

 {
     Release_Account();
 }

opentxs::OTAccount::OTAccount	(	const OTIdentifier &	userId,
		const OTIdentifier &	serverId
	)

protected

Definition at line 175 of file OTAccount.cpp.

     : OTTransactionType()
     , stashTransNum_(0)
     , markForDeletion_(false)
 {
     InitAccount();
     SetUserID(userId);
     SetRealServerID(serverId);
     SetPurportedServerID(serverId);
 }

opentxs::OTAccount::OTAccount ( )

protected

Definition at line 186 of file OTAccount.cpp.

     : OTTransactionType()
     , stashTransNum_(0)
     , markForDeletion_(false)
 {
     InitAccount();
 }

Member Function Documentation

char const * opentxs::OTAccount::_GetTypeString ( AccountType accountType )

static

Definition at line 218 of file OTAccount.cpp.

 {
     int32_t index = static_cast<int32_t>(accountType);
     return __TypeStrings[index];
 }

bool opentxs::OTAccount::Credit ( const int64_t & amount )

Definition at line 415 of file OTAccount.cpp.

 {
     int64_t oldBalance = atol(balanceAmount_.Get());
     // The PLUS here is the big difference between Debit and Credit.
     int64_t newBalance = oldBalance + amount;
 
     // If the balance gets too big, it may flip to negative due to us using
     // int64_t int32_t.
     // We'll maybe explicitly check that it's not negative in order to prevent
     // that. TODO.
     //    if (newBalance > 0 || (OTAccount::simple != acctType_))
     //    {
     //        balanceAmount_.Format("%lld", newBalance);
     //        return true;
     //    }
 
     // This is where issuer accounts get a pass. They just go negative.
     // IF the new balance is less than zero...
     // AND it's a normal account... (not an issuer)
     // AND the new balance is even less than the old balance...
     // THEN FAIL. The "new less than old" requirement is recent,
     if (newBalance < 0 && !IsAllowedToGoNegative() && newBalance < oldBalance) {
         return false;
     }
     // and it means that we now allow <0 credits on normal accounts,
     // AS LONG AS the result is a HIGHER BALANCE  :-)
     else {
         balanceAmount_.Format("%lld", newBalance);
         time64_t t = OTTimeGetCurrentTime(); // Today, now.
         balanceDate_.Format("%d", t);
         return true;
     }
 }

bool opentxs::OTAccount::Debit ( const int64_t & amount )

Definition at line 388 of file OTAccount.cpp.

 {
     int64_t oldBalance = atol(balanceAmount_.Get());
     // The MINUS here is the big difference between Debit and Credit
     int64_t newBalance = oldBalance - amount;
 
     // This is where issuer accounts get a pass. They just go negative.
     //
     // IF the new balance is less than zero...
     // AND it's a normal account... (not an issuer)
     // AND the new balance is even less than the old balance...
     // THEN FAIL. The "new less than old" requirement is recent,
     if (newBalance < 0 && !IsAllowedToGoNegative() && newBalance < oldBalance) {
         return false;
     }
     // and it means that we now allow <0 debits on normal accounts,
     // AS LONG AS the result is a HIGHER BALANCE  :-)
     else {
         balanceAmount_.Format("%lld", newBalance);
         time64_t t = OTTimeGetCurrentTime(); // Today, now.
         balanceDate_.Format("%d", t);
         return true;
     }
 }

bool opentxs::OTAccount::DisplayStatistics ( OTString & contents ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 728 of file OTAccount.cpp.

 {
     OTString strAccountID(GetPurportedAccountID());
     OTString strServerID(GetPurportedServerID());
     OTString strUserID(GetUserID());
     OTString strAssetTypeID(acctAssetTypeId_);
 
     OTString acctType;
     TranslateAccountTypeToString(acctType_, acctType);
 
     contents.Concatenate(" Asset Account (%s) Name: %s\n"
                          " Last retrieved Balance: %s  on date: %s\n"
                          " accountID: %s\n"
                          " userID: %s\n"
                          " serverID: %s\n"
                          " assetTypeID: %s\n"
                          "\n",
                          acctType.Get(), m_strName.Get(), balanceAmount_.Get(),
                          balanceDate_.Get(), strAccountID.Get(),
                          strUserID.Get(), strServerID.Get(),
                          strAssetTypeID.Get());
 
     return true;
 }

OTAccount * opentxs::OTAccount::GenerateNewAccount	(	const OTIdentifier &	userId,
		const OTIdentifier &	serverId,
		const OTPseudonym &	serverNym,
		const OTMessage &	message,
		OTAccount::AccountType	acctType = `simple`,
		int64_t	stashTransNum = `0`
	)

static

Definition at line 531 of file OTAccount.cpp.

 {
     OTAccount* account = new OTAccount(userId, serverId);
 
     if (account) {
         // This is only for stash accounts.
         if (account->GenerateNewAccount(serverNym, message, acctType,
                                         stashTransNum)) {
             return account;
         }
 
         delete account;
         account = nullptr;
     }
 
     return nullptr;
 }

bool opentxs::OTAccount::GenerateNewAccount	(	const OTPseudonym &	server,
		const OTMessage &	message,
		OTAccount::AccountType	acctType = `simple`,
		int64_t	stashTransNum = `0`
	)

Definition at line 560 of file OTAccount.cpp.

 {
     // First we generate a secure random number into a binary object...
     OTPayload payload;
     // TODO: hardcoding. Plus: is 100 bytes of random a little much here?
     if (!payload.Randomize(100)) {
         otErr << __FUNCTION__ << ": Failed trying to acquire random numbers.\n";
         return false;
     }
 
     // Next we calculate that binary object into a message digest (an
     // OTIdentifier).
     OTIdentifier newID;
     if (!newID.CalculateDigest(payload)) {
         otErr << __FUNCTION__ << ": Error generating new account ID.\n";
         return false;
     }
 
     // Next we get that digest (which is a binary hash number)
     // and extract a human-readable standard string format of that hash,
     // into an OTString.
     OTString strID(newID);
 
     // Set the account number based on what we just generated.
     SetRealAccountID(newID);
     // Might as well set them both. (Safe here to do so, for once.)
     SetPurportedAccountID(newID);
     // So it's not blank. The user can always change it.
     m_strName.Set(strID);
 
     // Next we create the full path filename for the account using the ID.
     m_strFoldername = OTFolders::Account().Get();
     m_strFilename = strID.Get();
 
     // Then we try to load it, in order to make sure that it doesn't already
     // exist.
     if (OTDB::Exists(m_strFoldername.Get(), m_strFilename.Get())) {
         otErr << __FUNCTION__ << ": Account already exists: " << m_strFilename
               << "\n";
         return false;
     }
 
     // Set up the various important starting values of the account.
     // Account type defaults to OTAccount::simple.
     // But there are also issuer accts.
     acctType_ = acctType;
 
     // basket, basketsub, mint, voucher, and stash
     // accounts are all "owned" by the server.
     if (IsInternalServerAcct()) {
         server.GetIdentifier(m_AcctUserID);
     }
     else {
         m_AcctUserID.SetString(message.m_strNymID);
     }
 
     acctAssetTypeId_.SetString(message.m_strAssetID);
 
     otLog3 << __FUNCTION__ << ": Creating new account, type:\n"
            << message.m_strAssetID << "\n";
 
     OTIdentifier serverId(message.m_strServerID);
     // TODO: this assumes the serverID on the message
     // is correct. It's vetted, but still...
     SetRealServerID(serverId);
     SetPurportedServerID(serverId);
 
     time64_t t = OTTimeGetCurrentTime(); // Today, now.
     balanceDate_.Format("%d", t);
 
     balanceAmount_.Set("0");
 
     if (IsStashAcct()) {
         OT_ASSERT_MSG(stashTransNum > 0, "You created a stash account, but "
                                          "with a zero-or-negative transaction "
                                          "number for its cron item.");
         stashTransNum_ = stashTransNum;
     }
 
     // Sign the Account (so we know that we did)... Otherwise someone could put
     // a fake
     // account file on the server if the code wasn't designed to verify the
     // signature on the
     // account.
     SignContract(server);
     SaveContract();
 
     // Save the Account to storage (based on its ID.)
     SaveAccount();
 
     // Don't know why I had this here. Putting SaveAccount() instead.
     //    OTString strFilename(m_strFilename);
     //    SaveContract(strFilename.Get()); // Saves the account to a specific
     // filename
 
     // No need to create the inbox and outbox ledgers...they will be created
     // automatically if they do not exist when they are needed.
 
     return true;
 }

const OTIdentifier & opentxs::OTAccount::GetAssetTypeID ( ) const

Definition at line 449 of file OTAccount.cpp.

 {
     return acctAssetTypeId_;
 }

int64_t opentxs::OTAccount::GetBalance ( ) const

Definition at line 664 of file OTAccount.cpp.

 {
     if (balanceAmount_.Exists()) {
         return atol(balanceAmount_.Get());
     }
     return 0;
 }

bool opentxs::OTAccount::GetInboxHash ( OTIdentifier & output )

Definition at line 317 of file OTAccount.cpp.

 {
     output.Release();
 
     if (!inboxHash_.IsEmpty()) {
         output = inboxHash_;
         return true;
     }
     else if (!GetUserID().IsEmpty() && !GetRealAccountID().IsEmpty() &&
                !GetRealServerID().IsEmpty()) {
         OTLedger inbox(GetUserID(), GetRealAccountID(), GetRealServerID());
 
         if (inbox.LoadInbox() && inbox.CalculateInboxHash(output)) {
             SetInboxHash(output);
             return true;
         }
     }
 
     return false;
 }

bool opentxs::OTAccount::GetOutboxHash ( OTIdentifier & output )

Definition at line 343 of file OTAccount.cpp.

 {
     output.Release();
 
     if (!outboxHash_.IsEmpty()) {
         output = outboxHash_;
         return true;
     }
     else if (!GetUserID().IsEmpty() && !GetRealAccountID().IsEmpty() &&
                !GetRealServerID().IsEmpty()) {
         OTLedger outbox(GetUserID(), GetRealAccountID(), GetRealServerID());
 
         if (outbox.LoadOutbox() && outbox.CalculateOutboxHash(output)) {
             SetOutboxHash(output);
             return true;
         }
     }
 
     return false;
 }

EXPORT const int64_t& opentxs::OTAccount::GetStashTransNum ( ) const

inline

Definition at line 210 of file OTAccount.hpp.

     {
         return stashTransNum_;
     }

EXPORT char const* opentxs::OTAccount::GetTypeString ( ) const

inline

Definition at line 271 of file OTAccount.hpp.

     {
         return _GetTypeString(acctType_);
     }

void opentxs::OTAccount::InitAccount ( )

Definition at line 454 of file OTAccount.cpp.

 {
     m_strContractType = "ACCOUNT";
     acctType_ = OTAccount::simple;
 }

bool opentxs::OTAccount::IsAllowedToGoNegative ( ) const

Definition at line 1041 of file OTAccount.cpp.

 {
     switch (acctType_) {
     // issuer acct controlled by a user
     case OTAccount::issuer:
     // basket issuer acct controlled by the server (for a basket currency)
     case OTAccount::basket:
         return true;
     // user asset acct
     case OTAccount::simple:
     // internal server acct for storing reserves for basket sub currencies
     case OTAccount::basketsub:
     // internal server acct for storing reserves for cash withdrawals
     case OTAccount::mint:
     // internal server acct for storing reserves for
     // vouchers (like cashier's cheques)
     case OTAccount::voucher:
     // internal server acct for storing reserves for
     // smart contract stashes. (Money stashed IN the contract.)
     case OTAccount::stash:
         return false;
     default:
         otErr << "OTAccount::IsAllowedToGoNegative: Unknown account type.\n";
         return false;
     }
     return false;
 }

bool opentxs::OTAccount::IsInternalServerAcct ( ) const

Definition at line 993 of file OTAccount.cpp.

 {
     switch (acctType_) {
     case OTAccount::simple:
     case OTAccount::issuer:
         return false;
     case OTAccount::basket:
     case OTAccount::basketsub:
     case OTAccount::mint:
     case OTAccount::voucher:
     case OTAccount::stash:
         return true;
     default:
         otErr << "OTAccount::IsInternalServerAcct: Unknown account type.\n";
         return false;
     }
     return false;
 }

bool opentxs::OTAccount::IsIssuer ( ) const

Definition at line 1036 of file OTAccount.cpp.

 {
     return OTAccount::issuer == acctType_;
 }

bool opentxs::OTAccount::IsMarkedForDeletion ( ) const

inline

Definition at line 191 of file OTAccount.hpp.

     {
         return markForDeletion_;
     }

bool opentxs::OTAccount::IsOwnedByEntity ( ) const

Definition at line 1031 of file OTAccount.cpp.

 {
     return false;
 }

bool opentxs::OTAccount::IsOwnedByUser ( ) const

Definition at line 1012 of file OTAccount.cpp.

 {
     switch (acctType_) {
     case OTAccount::simple:
     case OTAccount::issuer:
         return true;
     case OTAccount::basket:
     case OTAccount::basketsub:
     case OTAccount::mint:
     case OTAccount::voucher:
     case OTAccount::stash:
         return false;
     default:
         otErr << "OTAccount::IsOwnedByUser: Unknown account type.\n";
         return false;
     }
     return false;
 }

EXPORT bool opentxs::OTAccount::IsStashAcct ( ) const

inline

Definition at line 205 of file OTAccount.hpp.

     {
         return (acctType_ == stash);
     }

bool opentxs::OTAccount::LoadContract ( )

virtual

Reimplemented from opentxs::OTContract.

Definition at line 372 of file OTAccount.cpp.

 {
     OTString id;
     GetIdentifier(id);
     return OTContract::LoadContract(OTFolders::Account().Get(), id.Get());
 }

OTAccount * opentxs::OTAccount::LoadExistingAccount	(	const OTIdentifier &	accountId,
		const OTIdentifier &	serverId
	)

static

Definition at line 480 of file OTAccount.cpp.

 {
     bool folderAlreadyExist = false;
     bool folderIsNew = false;
 
     OTString strDataFolder = "";
     OTString strAccountPath = "";
     if (!OTDataFolder::Get(strDataFolder)) {
         OT_FAIL;
     }
     if (!OTPaths::AppendFolder(strAccountPath, strDataFolder,
                                OTFolders::Account())) {
         OT_FAIL;
     }
 
     if (!OTPaths::ConfirmCreateFolder(strAccountPath, folderAlreadyExist,
                                       folderIsNew)) {
         otErr << "Unable to find or create accounts folder: "
               << OTFolders::Account() << "\n";
         return nullptr;
     }
 
     OTAccount* account = new OTAccount();
     OT_ASSERT(account != nullptr);
 
     account->SetRealAccountID(accountId);
     account->SetRealServerID(serverId);
 
     OTString strAcctID(accountId);
 
     account->m_strFoldername = OTFolders::Account().Get();
     account->m_strFilename = strAcctID.Get();
 
     if (!OTDB::Exists(account->m_strFoldername.Get(),
                       account->m_strFilename.Get())) {
         otInfo << "OTAccount::LoadExistingAccount: File does not exist: "
                << account->m_strFoldername << OTLog::PathSeparator()
                << account->m_strFilename << "\n";
         delete account;
         return nullptr;
     }
 
     if (account->LoadContract() && account->VerifyContractID()) {
         return account;
     }
 
     delete account;
     return nullptr;
 }

OTLedger * opentxs::OTAccount::LoadInbox ( OTPseudonym & nym ) const

Definition at line 225 of file OTAccount.cpp.

 {
     auto* box =
         new OTLedger(GetUserID(), GetRealAccountID(), GetRealServerID());
     OT_ASSERT(box != nullptr);
 
     if (box->LoadInbox() && box->VerifyAccount(nym)) {
         return box;
     }
 
     OTString strUserID(GetUserID()), strAcctID(GetRealAccountID());
     otInfo << "Unable to load or verify inbox:\n" << strAcctID
            << "\n For user:\n" << strUserID << "\n";
     return nullptr;
 }

OTLedger * opentxs::OTAccount::LoadOutbox ( OTPseudonym & nym ) const

Definition at line 242 of file OTAccount.cpp.

 {
     auto* box =
         new OTLedger(GetUserID(), GetRealAccountID(), GetRealServerID());
     OT_ASSERT(nullptr != box);
 
     if (box->LoadOutbox() && box->VerifyAccount(nym)) {
         return box;
     }
 
     OTString strUserID(GetUserID()), strAcctID(GetRealAccountID());
     otInfo << "Unable to load or verify outbox:\n" << strAcctID
            << "\n For user:\n" << strUserID << "\n";
     return nullptr;
 }

void opentxs::OTAccount::MarkForDeletion ( )

inline

Definition at line 186 of file OTAccount.hpp.

     {
         markForDeletion_ = true;
     }

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

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 854 of file OTAccount.cpp.

 {
     int32_t retval = 0;
 
     OTString strNodeName(xml->getNodeName());
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note you can choose not to call the parent if
     // you don't want to use any of those xml tags.
     // As I do below, in the case of OTAccount.
     // if (retval = OTTransactionType::ProcessXMLNode(xml))
     //    return retval;
 
     if (strNodeName.Compare("assetAccount")) {
         OTString acctType;
 
         m_strVersion = xml->getAttributeValue("version");
         acctType = xml->getAttributeValue("type");
 
         if (!acctType.Exists()) {
             otErr << "OTAccount::ProcessXMLNode: Failed: Empty assetAccount "
                      "'type' attribute.\n";
             return -1;
         }
 
         acctType_ = TranslateAccountTypeStringToEnum(acctType);
 
         if (OTAccount::err_acct == acctType_) {
             otErr << "OTAccount::ProcessXMLNode: Failed: assetAccount 'type' "
                      "attribute contains unknown value.\n";
             return -1;
         }
 
         OTString strAcctAssetType = xml->getAttributeValue("assetTypeID");
 
         if (strAcctAssetType.Exists()) {
             acctAssetTypeId_.SetString(strAcctAssetType);
         }
         OTString strAccountID(xml->getAttributeValue("accountID"));
         OTString strServerID(xml->getAttributeValue("serverID"));
         OTString strAcctUserID(xml->getAttributeValue("userID"));
 
         OTIdentifier ACCOUNT_ID(strAccountID);
         OTIdentifier SERVER_ID(strServerID);
         OTIdentifier USER_ID(strAcctUserID);
 
         SetPurportedAccountID(ACCOUNT_ID);
         SetPurportedServerID(SERVER_ID);
         SetUserID(USER_ID);
 
         OTString strAssetTypeID(acctAssetTypeId_);
         otLog3 << "\n\nAccount Type: " << acctType
                << "\nAccountID: " << strAccountID
                << "\nUserID: " << strAcctUserID
                << "\n"
                   "AssetTypeID: " << strAssetTypeID
                << "\nServerID: " << strServerID << "\n";
 
         retval = 1;
     }
     else if (strNodeName.Compare("inboxHash")) {
 
         OTString strHash = xml->getAttributeValue("value");
         if (strHash.Exists()) {
             inboxHash_.SetString(strHash);
         }
         otLog3 << "Account inboxHash: " << strHash << "\n";
 
         retval = 1;
     }
     else if (strNodeName.Compare("outboxHash")) {
 
         OTString strHash = xml->getAttributeValue("value");
         if (strHash.Exists()) {
             outboxHash_.SetString(strHash);
         }
         otLog3 << "Account outboxHash: " << strHash << "\n";
 
         retval = 1;
     }
     else if (strNodeName.Compare("MARKED_FOR_DELETION")) {
         markForDeletion_ = true;
         otLog3 << "This asset account has been MARKED_FOR_DELETION (at some "
                   "point prior.)\n";
 
         retval = 1;
     }
     else if (strNodeName.Compare("balance")) {
         balanceDate_ = xml->getAttributeValue("date");
         balanceAmount_ = xml->getAttributeValue("amount");
 
         // I convert to integer / int64_t and back to string.
         // (Just an easy way to keep the data clean.)
 
         int32_t date = atoi(balanceDate_.Get());
         int64_t amount = atol(balanceAmount_.Get());
 
         balanceDate_.Format("%d", date);
         balanceAmount_.Format("%lld", amount);
 
         otLog3 << "\nBALANCE  --  " << balanceAmount_ << "\nDATE     --  "
                << balanceDate_ << "\n";
 
         retval = 1;
     }
     else if (strNodeName.Compare("stashinfo")) {
         if (!IsStashAcct()) {
             otErr << "OTAccount::ProcessXMLNode: Error: Encountered stashinfo "
                      "tag while loading NON-STASH account. \n";
             return -1;
         }
 
         int64_t lTransNum = 0;
         OTString strStashTransNum = xml->getAttributeValue("cronItemNum");
         if (!strStashTransNum.Exists() ||
             ((lTransNum = atol(strStashTransNum.Get())) <= 0)) {
             stashTransNum_ = 0;
             otErr << "OTAccount::ProcessXMLNode: Error: Bad transaction number "
                      "for supposed corresponding cron item: " << lTransNum
                   << " \n";
             return -1;
         }
         else {
             stashTransNum_ = lTransNum;
         }
 
         otLog3 << "\nSTASH INFO:   CronItemNum     --  " << stashTransNum_
                << "\n";
 
         retval = 1;
     }
 
     return retval;
 }

void opentxs::OTAccount::Release ( )

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 1077 of file OTAccount.cpp.

 {
     Release_Account();
     OTTransactionType::Release();
 }

void opentxs::OTAccount::Release_Account ( )

Definition at line 1069 of file OTAccount.cpp.

 {
     balanceDate_.Release();
     balanceAmount_.Release();
     inboxHash_.Release();
     outboxHash_.Release();
 }

bool opentxs::OTAccount::SaveAccount ( )

Definition at line 379 of file OTAccount.cpp.

 {
     OTString id;
     GetIdentifier(id);
     return SaveContract(OTFolders::Account().Get(), id.Get());
 }

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

virtual

Reimplemented from opentxs::OTTransactionType.

Definition at line 782 of file OTAccount.cpp.

 {
     OTString strOutput;
 
     if (SaveContractWallet(strOutput)) {
         ofs << strOutput;
         return true;
     }
     return false;
 }

bool opentxs::OTAccount::SaveContractWallet ( OTString & contents ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 753 of file OTAccount.cpp.

 {
     OTString strAccountID(GetPurportedAccountID());
     OTString strServerID(GetPurportedServerID());
     OTString strUserID(GetUserID());
     OTString strAssetTypeID(acctAssetTypeId_);
 
     OTString acctType;
     TranslateAccountTypeToString(acctType_, acctType);
 
     OTASCIIArmor ascName;
     // name is in the clear in memory, and base64 in storage.
     if (m_strName.Exists()) {
         ascName.SetString(m_strName, false); // linebreaks == false
     }
 
     contents.Concatenate(
         "<!-- Last retrieved balance: %s on date: %s -->\n"
         "<!-- Account type: %s --><assetAccount name=\"%s\"\n"
         " accountID=\"%s\"\n"
         " userID=\"%s\"\n"
         " serverID=\"%s\" />\n"
         "<!-- assetTypeID: %s -->\n\n",
         balanceAmount_.Get(), balanceDate_.Get(), acctType.Get(),
         m_strName.Exists() ? ascName.Get() : "", strAccountID.Get(),
         strUserID.Get(), strServerID.Get(), strAssetTypeID.Get());
     return true;
 }

bool opentxs::OTAccount::SaveInbox	(	OTLedger &	box,
		OTIdentifier *	hash = `nullptr`
	)

Definition at line 260 of file OTAccount.cpp.

 {
     if (!IsSameAccount(box)) {
         OTString strAcctID(GetRealAccountID());
         OTString strServerID(GetRealServerID());
         OTString strBoxAcctID(box.GetRealAccountID());
         OTString strBoxSvrID(box.GetRealServerID());
         otErr << "OTAccount::SaveInbox: ERROR: The ledger passed in, isn't "
                  "even for this account!\n"
                  "   Acct ID: " << strAcctID << "\n  Other ID: " << strBoxAcctID
               << "\n Server ID: " << strServerID
               << "\n Other ID: " << strBoxSvrID << "\n";
         return false;
     }
 
     OTIdentifier theHash;
     if (hash == nullptr) hash = &theHash;
 
     bool success = box.SaveInbox(hash);
 
     if (success) SetInboxHash(*hash);
 
     return success;
 }

bool opentxs::OTAccount::SaveOutbox	(	OTLedger &	box,
		OTIdentifier *	nash = `nullptr`
	)

Definition at line 287 of file OTAccount.cpp.

 {
     if (!IsSameAccount(box)) {
         OTString strAcctID(GetRealAccountID());
         OTString strServerID(GetRealServerID());
         OTString strBoxAcctID(box.GetRealAccountID());
         OTString strBoxSvrID(box.GetRealServerID());
         otErr << "OTAccount::SaveOutbox: ERROR: The ledger passed in, isn't "
                  "even for this account!\n"
                  "   Acct ID: " << strAcctID << "\n  Other ID: " << strBoxAcctID
               << "\n Server ID: " << strServerID
               << "\n Other ID: " << strBoxSvrID << "\n";
         return false;
     }
 
     OTIdentifier theHash;
     if (hash == nullptr) hash = &theHash;
 
     bool success = box.SaveOutbox(hash);
 
     if (success) SetOutboxHash(*hash);
 
     return success;
 }

void opentxs::OTAccount::SetInboxHash ( const OTIdentifier & input )

Definition at line 312 of file OTAccount.cpp.

 {
     inboxHash_ = input;
 }

void opentxs::OTAccount::SetOutboxHash ( const OTIdentifier & input )

Definition at line 338 of file OTAccount.cpp.

 {
     outboxHash_ = input;
 }

EXPORT void opentxs::OTAccount::SetStashTransNum ( const int64_t & transNum )

inline

Definition at line 215 of file OTAccount.hpp.

     {
         stashTransNum_ = transNum;
     }

void opentxs::OTAccount::UpdateContents ( )

protectedvirtual

Reimplemented from opentxs::OTContract.

Definition at line 804 of file OTAccount.cpp.

 {
     OTString strAssetTYPEID(acctAssetTypeId_);
 
     OTString ACCOUNT_ID(GetPurportedAccountID());
     OTString SERVER_ID(GetPurportedServerID());
     OTString USER_ID(GetUserID());
 
     OTString acctType;
     TranslateAccountTypeToString(acctType_, acctType);
 
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     m_xmlUnsigned.Concatenate("<?xml version=\"%s\"?>\n\n", "1.0");
 
     m_xmlUnsigned.Concatenate("<assetAccount\n version=\"%s\"\n type=\"%s\"\n "
                               "accountID=\"%s\"\n userID=\"%s\"\n"
                               " serverID=\"%s\"\n assetTypeID=\"%s\" >\n\n",
                               m_strVersion.Get(), acctType.Get(),
                               ACCOUNT_ID.Get(), USER_ID.Get(), SERVER_ID.Get(),
                               strAssetTYPEID.Get());
     if (IsStashAcct()) {
         m_xmlUnsigned.Concatenate("<stashinfo cronItemNum=\"%lld\"/>\n\n",
                                   stashTransNum_);
     }
     if (!inboxHash_.IsEmpty()) {
         OTString strHash(inboxHash_);
         m_xmlUnsigned.Concatenate("<inboxHash value=\"%s\"/>\n\n",
                                   strHash.Get());
     }
     if (!outboxHash_.IsEmpty()) {
         OTString strHash(outboxHash_);
         m_xmlUnsigned.Concatenate("<outboxHash value=\"%s\"/>\n\n",
                                   strHash.Get());
     }
 
     m_xmlUnsigned.Concatenate("<balance date=\"%s\" amount=\"%s\"/>\n\n",
                               balanceDate_.Get(), balanceAmount_.Get());
 
     if (markForDeletion_) {
         m_xmlUnsigned.Concatenate(
             "<MARKED_FOR_DELETION>\n"
             "%s</MARKED_FOR_DELETION>\n\n",
             "THIS ACCOUNT HAS BEEN MARKED FOR DELETION AT ITS OWN REQUEST");
     }
     m_xmlUnsigned.Concatenate("</assetAccount>\n");
 }

bool opentxs::OTAccount::VerifyOwner ( const OTPseudonym & candidate ) const

Definition at line 463 of file OTAccount.cpp.

 {
     OTIdentifier ID_CANDIDATE;
     // ID_CANDIDATE now contains the ID of the Nym we're testing.
     candidate.GetIdentifier(ID_CANDIDATE);
     return m_AcctUserID == ID_CANDIDATE;
 }

bool opentxs::OTAccount::VerifyOwnerByID ( const OTIdentifier & nymId ) const

Definition at line 472 of file OTAccount.cpp.

 {
     return nymId == m_AcctUserID;
 }

Friends And Related Function Documentation

OTTransactionType* OTTransactionType::TransactionFactory ( OTString input )

friend

Member Data Documentation

OTIdentifier opentxs::OTAccount::acctAssetTypeId_

protected

Definition at line 288 of file OTAccount.hpp.

AccountType opentxs::OTAccount::acctType_

protected

Definition at line 286 of file OTAccount.hpp.

OTString opentxs::OTAccount::balanceAmount_

protected

Definition at line 290 of file OTAccount.hpp.

OTString opentxs::OTAccount::balanceDate_

protected

Definition at line 289 of file OTAccount.hpp.

OTIdentifier opentxs::OTAccount::inboxHash_

protected

Definition at line 299 of file OTAccount.hpp.

bool opentxs::OTAccount::markForDeletion_

protected

Definition at line 295 of file OTAccount.hpp.

OTIdentifier opentxs::OTAccount::outboxHash_

protected

Definition at line 302 of file OTAccount.hpp.

int64_t opentxs::OTAccount::stashTransNum_

protected

Definition at line 293 of file OTAccount.hpp.

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

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

Public Types

Public Member Functions

Static Public Member Functions

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