#include <OTSmartContract.hpp>

Inheritance diagram for opentxs::OTSmartContract:

Collaboration diagram for opentxs::OTSmartContract:

Public Member Functions
virtual void	SetDisplayLabel (const std::string *pstrLabel=nullptr)

const OTString &	GetLastSenderUserID () const

const OTString &	GetLastSenderAcctID () const

const OTString &	GetLastRecipientUserID () const

const OTString &	GetLastRecipientAcctID () const

int32_t	GetCountStashes () const

int32_t	GetCountStashAccts () const

virtual bool	Compare (OTScriptable &rhs) const

virtual bool	CanRemoveItemFromCron (OTPseudonym &theNym)

virtual void	HarvestOpeningNumber (OTPseudonym &theNym)

virtual void	HarvestClosingNumbers (OTPseudonym &theNym)

void	CloseoutOpeningNumbers (OTPseudonym *pSignerNym=nullptr)

void	HarvestClosingNumbers (OTPseudonym pSignerNym=nullptr, std::set< OTParty > *pFailedParties=nullptr)

virtual bool	ProcessCron ()

virtual bool	HasTransactionNum (const int64_t &lInput) const

virtual void	GetAllTransactionNumbers (OTNumList &numlistOutput) const

virtual bool	AddParty (OTParty &theParty)

virtual bool	ConfirmParty (OTParty &theParty)

EXPORT bool	SetServerIDIfEmpty (const OTIdentifier &theID)

EXPORT bool	VerifySmartContract (OTPseudonym &theNym, OTAccount &theAcct, OTPseudonym &theServerNym, bool bBurnTransNo=false)

EXPORT void	PrepareToActivate (const int64_t &lOpeningTransNo, const int64_t &lClosingTransNo, const OTIdentifier &theUserID, const OTIdentifier &theAcctID)

bool	CanCancelContract (std::string str_party_name)

void	SetRemainingTimer (std::string str_seconds_from_now)

std::string	GetRemainingTimer () const

bool	MoveAcctFundsStr (std::string from_acct_name, std::string to_acct_name, std::string str_Amount)

bool	StashAcctFunds (std::string from_acct_name, std::string to_stash_name, std::string str_Amount)

bool	UnstashAcctFunds (std::string to_acct_name, std::string from_stash_name, std::string str_Amount)

std::string	GetAcctBalance (std::string from_acct_name)

std::string	GetStashBalance (std::string stash_name, std::string asset_type_id)

std::string	GetAssetTypeIDofAcct (std::string from_acct_name)

bool	SendNoticeToParty (std::string party_name)

bool	SendANoticeToAllParties ()

void	DeactivateSmartContract ()

virtual void	RegisterOTNativeCallsWithScript (OTScript &theScript)

OTStash *	GetStash (std::string str_stash_name)

EXPORT void	ExecuteClauses (mapOfClauses &theClauses, OTString *pParam=nullptr)

EXPORT bool	StashFunds (const mapOfNyms &map_NymsAlreadyLoaded, const int64_t &lAmount, const OTIdentifier &PARTY_ACCT_ID, const OTIdentifier &PARTY_USER_ID, OTStash &theStash)

EXPORT	OTSmartContract ()

EXPORT	OTSmartContract (const OTIdentifier &SERVER_ID)

virtual EXPORT	~OTSmartContract ()

void	InitSmartContract ()

virtual void	Release ()

void	Release_SmartContract ()

void	ReleaseStashes ()

virtual bool	IsValidOpeningNumber (const int64_t &lOpeningNum) const

virtual int64_t	GetOpeningNumber (const OTIdentifier &theNymID) const

virtual int64_t	GetClosingNumber (const OTIdentifier &theAcctID) const

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

virtual void	UpdateContents ()

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

Public Member Functions inherited from opentxs::OTCronItem
	OTCronItem ()

bool	DropFinalReceiptToInbox (const OTIdentifier &USER_ID, const OTIdentifier &ACCOUNT_ID, const int64_t &lNewTransactionNumber, const int64_t &lClosingNumber, const OTString &strOrigCronItem, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTAccount *pActualAcct=nullptr)

bool	DropFinalReceiptToNymbox (const OTIdentifier &USER_ID, const int64_t &lNewTransactionNumber, const OTString &strOrigCronItem, OTString pstrNote=nullptr, OTString pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)

void	HookActivationOnCron (OTPseudonym *pActivator, bool bForTheFirstTime=false)

void	HookRemovalFromCron (OTPseudonym *pRemover, int64_t newTransactionNo)

bool	IsFlaggedForRemoval () const

void	FlagForRemoval ()

void	SetCronPointer (OTCron &theCron)

void	SetCreationDate (const time64_t &CREATION_DATE)

const time64_t &	GetCreationDate () const

EXPORT bool	SetDateRange (time64_t VALID_FROM=OT_TIME_ZERO, time64_t VALID_TO=OT_TIME_ZERO)

void	SetLastProcessDate (const time64_t &THE_DATE)

const time64_t &	GetLastProcessDate () const

void	SetProcessInterval (const int64_t &THE_DATE)

const int64_t &	GetProcessInterval () const

OTCron *	GetCron () const

void	setServerNym (OTPseudonym *serverNym)

void	setServerId (OTIdentifier *serverId)

EXPORT bool	SaveCronReceipt ()

EXPORT bool	SaveActiveCronReceipt (const OTIdentifier &theNymID)

virtual	~OTCronItem ()

void	InitCronItem ()

void	Release_CronItem ()

EXPORT bool	GetCancelerID (OTIdentifier &theOutput) const

EXPORT bool	IsCanceled () const

EXPORT bool	CancelBeforeActivation (OTPseudonym &theCancelerNym)

EXPORT int64_t	GetClosingTransactionNoAt (uint32_t nIndex) const

EXPORT int32_t	GetCountClosingNumbers () const

EXPORT void	AddClosingTransactionNo (const int64_t &lClosingTransactionNo)

EXPORT int64_t	GetOpeningNum () const

EXPORT int64_t	GetClosingNum () const

Public Member Functions inherited from opentxs::OTTrackable
	OTTrackable ()

	OTTrackable (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

	OTTrackable (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &ACCT_ID, const OTIdentifier &USER_ID)

virtual	~OTTrackable ()

void	InitTrackable ()

void	Release_Trackable ()

int64_t	GetTransactionNum () const

void	SetTransactionNum (int64_t lTransactionNum)

const OTIdentifier &	GetSenderAcctID () const

const OTIdentifier &	GetSenderUserID () const

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

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

virtual EXPORT	~OTInstrument ()

void	Release_Instrument ()

EXPORT bool	VerifyCurrentDate ()

EXPORT bool	IsExpired ()

time64_t	GetValidFrom () const

time64_t	GetValidTo () const

const OTIdentifier &	GetAssetID () const

const OTIdentifier &	GetServerID () const

void	InitInstrument ()

Public Member Functions inherited from opentxs::OTScriptable
int32_t	GetPartyCount () const

int32_t	GetBylawCount () const

virtual EXPORT bool	AddBylaw (OTBylaw &theBylaw)

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

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

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

EXPORT OTParty *	GetPartyByIndex (int32_t nIndex) const

EXPORT OTBylaw *	GetBylawByIndex (int32_t nIndex) const

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

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

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

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

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

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

OTAgent *	GetAgent (std::string str_agent_name) const

OTPartyAccount *	GetPartyAccount (std::string str_acct_name) const

OTPartyAccount *	GetPartyAccountByID (const OTIdentifier &theAcctID) const

EXPORT int32_t	GetCountTransNumsNeededForAgent (std::string str_agent_name) const

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

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

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

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

EXPORT bool	VerifyThisAgainstAllPartiesSignedCopies ()

EXPORT bool	AllPartiesHaveSupposedlyConfirmed ()

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

void	ClearTemporaryPointers ()

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

OTClause *	GetCallback (std::string str_CallbackName)

OTVariable *	GetVariable (std::string str_VarName)

bool	IsDirty () const

bool	IsDirtyImportant () const

void	SetAsClean ()

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

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

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

	OTScriptable ()

virtual	~OTScriptable ()

void	UpdateContentsToString (OTString &strAppend, bool bCalculatingID) const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

void	Release_Scriptable ()

Public Member Functions inherited from opentxs::OTContract
const char *	GetHashType () const

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

EXPORT	OTContract (const OTString &name, const OTString &foldername, const OTString &filename, const OTString &strID)

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

virtual EXPORT bool	CreateContract (const OTString &strContract, const OTPseudonym &theSigner)

EXPORT bool	InsertNym (const OTString &strKeyName, const OTString &strKeyValue)

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT bool	VerifyContract ()

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

virtual EXPORT bool	LoadContract ()

EXPORT bool	LoadContract (const char szFoldername, const char szFilename)

EXPORT bool	LoadContractFromString (const OTString &theStr)

bool	LoadContractRawFile ()

EXPORT bool	ParseRawFile ()

EXPORT bool	SaveToContractFolder ()

EXPORT bool	SaveContractRaw (OTString &strOutput) const

EXPORT bool	RewriteContract (OTString &strOutput) const

EXPORT bool	SaveContract ()

EXPORT bool	SaveContract (const char szFoldername, const char szFilename)

virtual EXPORT void	CreateContents ()

EXPORT void	CreateInnerContents ()

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

virtual EXPORT bool	SaveContractWallet (OTString &strContents) const

virtual EXPORT bool	DisplayStatistics (OTString &strContents) const

virtual EXPORT bool	SaveContents (OTString &strContents) const

virtual EXPORT bool	SignContract (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContractAuthent (const OTPseudonym &theNym, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const OTAsymmetricKey &theKey, OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr)

EXPORT bool	SignContract (const char szFoldername, const char szFilename, OTSignature &theSignature, const OTPasswordData *pPWData=nullptr)

virtual EXPORT bool	VerifyContractID () const

virtual EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

virtual EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifyWithKey (const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySigAuthent (const OTPseudonym &theNym, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const OTAsymmetricKey &theKey, const OTSignature &theSignature, const OTString &strHashType, const OTPasswordData *pPWData=nullptr) const

EXPORT bool	VerifySignature (const char szFoldername, const char szFilename, const OTSignature &theSignature, const OTPasswordData *pPWData=nullptr) const

EXPORT const OTAsymmetricKey *	GetContractPublicKey () const

EXPORT const OTPseudonym *	GetContractPublicNym () const

Static Public Member Functions
static void	CleanupNyms (mapOfNyms &theMap)

static void	CleanupAccts (mapOfAccounts &theMap)

Static Public Member Functions inherited from opentxs::OTCronItem
static EXPORT OTCronItem *	NewCronItem (const OTString &strCronItem)

static EXPORT OTCronItem *	LoadCronReceipt (const int64_t &lTransactionNum)

static EXPORT OTCronItem *	LoadActiveCronReceipt (const int64_t &lTransactionNum, const OTIdentifier &serverID)

static EXPORT bool	EraseActiveCronReceipt (const int64_t &lTransactionNum, const OTIdentifier &nymID, const OTIdentifier &serverID)

static EXPORT bool	GetActiveCronTransNums (OTNumList &output, const OTIdentifier &nymID, const OTIdentifier &serverID)

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

static bool	ValidateName (std::string str_name)

static std::string	GetTime ()

Static Public Member Functions inherited from opentxs::OTContract
static EXPORT bool	DearmorAndTrim (const OTString &strInput, OTString &strOutput, OTString &strFirstLine)

static bool	AddBookendsAroundContent (OTString &strOutput, const OTString &strContents, const OTString &strContractType, const OTString &strHashType, const listOfSignatures &listSignatures)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTASCIIArmor &ascOutput)

static EXPORT bool	LoadEncodedTextField (irr::io::IrrXMLReader *&xml, OTString &strOutput)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTASCIIArmor &ascOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	LoadEncodedTextFieldByName (irr::io::IrrXMLReader &xml, OTString &strOutput, const char &szName, OTString::Map *pmapExtraVars=nullptr)

static bool	SkipToElement (irr::io::IrrXMLReader *&xml)

static bool	SkipToTextField (irr::io::IrrXMLReader *&xml)

static bool	SkipAfterLoadingField (irr::io::IrrXMLReader *&xml)

static EXPORT bool	SignFlatText (OTString &strFlatText, const OTString &strContractType, const OTPseudonym &theSigner, OTString &strOutput)

Protected Member Functions
virtual void	onActivate ()

virtual void	onFinalReceipt (OTCronItem &theOrigCronItem, const int64_t &lNewTransactionNumber, OTPseudonym &theOriginator, OTPseudonym *pRemover)

virtual void	onRemovalFromCron ()

void	ReleaseLastSenderRecipientIDs ()

void	SetNextProcessDate (const time64_t &tNEXT_DATE)

const time64_t &	GetNextProcessDate () const

Protected Member Functions inherited from opentxs::OTCronItem
	OTCronItem (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID)

	OTCronItem (const OTIdentifier &SERVER_ID, const OTIdentifier &ASSET_ID, const OTIdentifier &ACCT_ID, const OTIdentifier &USER_ID)

void	ClearClosingNumbers ()

Protected Member Functions inherited from opentxs::OTTrackable
void	SetSenderAcctID (const OTIdentifier &ACCT_ID)

void	SetSenderUserID (const OTIdentifier &USER_ID)

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

void	SetValidTo (time64_t TIME_TO)

void	SetAssetID (const OTIdentifier &ASSET_ID)

void	SetServerID (const OTIdentifier &SERVER_ID)

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

Additional Inherited Members
Protected Attributes inherited from opentxs::OTCronItem
std::deque< int64_t >	m_dequeClosingNumbers

OTIdentifier *	m_pCancelerNymID

bool	m_bCanceled

bool	m_bRemovalFlag

Protected Attributes inherited from opentxs::OTTrackable
int64_t	m_lTransactionNum

OTIdentifier	m_SENDER_ACCT_ID

OTIdentifier	m_SENDER_USER_ID

Protected Attributes inherited from opentxs::OTInstrument
OTIdentifier	m_AssetTypeID

OTIdentifier	m_ServerID

time64_t	m_VALID_FROM

time64_t	m_VALID_TO

Protected Attributes inherited from opentxs::OTScriptable
mapOfParties	m_mapParties

mapOfBylaws	m_mapBylaws

bool	m_bCalculatingID

bool	m_bSpecifyAssetID

bool	m_bSpecifyParties

OTString	m_strLabel

Protected Attributes inherited from opentxs::OTContract
OTString	m_strName

OTString	m_strFoldername

OTString	m_strFilename

OTIdentifier	m_ID

OTStringXML	m_xmlUnsigned

OTString	m_strRawFile

OTString	m_strSigHashType

OTString	m_strContractType

mapOfNyms	m_mapNyms

listOfSignatures	m_listSignatures

OTString	m_strVersion

OTString	m_strEntityShortName

OTString	m_strEntityLongName

OTString	m_strEntityEmail

OTString::Map	m_mapConditions

Detailed Description

Definition at line 150 of file OTSmartContract.hpp.

Constructor & Destructor Documentation

opentxs::OTSmartContract::OTSmartContract ( )

Definition at line 5335 of file OTSmartContract.cpp.

     : ot_super()
     , m_StashAccts(OTAccount::stash)
     , m_tNextProcessDate(OT_TIME_ZERO)
 {
     InitSmartContract();
 }

opentxs::OTSmartContract::OTSmartContract ( const OTIdentifier & SERVER_ID )

Definition at line 5343 of file OTSmartContract.cpp.

     : ot_super()
     , m_StashAccts(OTAccount::stash)
     , m_tNextProcessDate(OT_TIME_ZERO)
 {
     OTInstrument::SetServerID(SERVER_ID);
     InitSmartContract();
 }

opentxs::OTSmartContract::~OTSmartContract ( )

virtual

Definition at line 5352 of file OTSmartContract.cpp.

 {
     Release_SmartContract();
 }

Member Function Documentation

bool opentxs::OTSmartContract::AddParty ( OTParty & theParty )

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 5193 of file OTSmartContract.cpp.

 {
     if (!theParty.HasActiveAgent()) {
         otOut << "OTSmartContract::AddParty: Party doesn't have an active "
                  "agent -- who will sign for this smart contract?\n";
         return false;
     }
 
     // MIGHT move this below (1).. OR this might turn out to be important going
     // first...
     //
     if (!OTScriptable::AddParty(theParty)) {
         otOut << "OTSmartContract::AddParty: Failed adding party.\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTSmartContract::CanCancelContract ( std::string str_party_name )

Definition at line 3969 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     OTParty* pParty = GetParty(str_party_name);
 
     if (nullptr == pParty) {
         otOut
             << "OTSmartContract::CanCancelContract: Unable to find this party: "
             << str_party_name << "\n";
         return false;
     }
     // Below this point, pParty is good.
 
     // ...This WILL check to see if pParty has its Opening number verified as
     // issued.
     // (If the opening number is > 0 then VerifyPartyAuthorization() is smart
     // enough to verify it.)
     //
     // To KNOW that a party has the right to even ASK the script to cancel a
     // contract, MEANS that
     // (1) The party is listed as a party on the contract. (2) The party's copy
     // of that contract
     // is signed by the authorizing agent for that party. and (3) The opening
     // transaction number for
     // that party is verified as issued for authorizing agent. (2 and 3 are both
     // performed at the same
     // time, in VerifyPartyAuthorization(), since the agent may need to be
     // loaded in order to verify
     // them.) 1 is already done by this point, as it's performed above.
     //
     // Done: notice this code appears in CanCancelContract() (this function) as
     // well as
     // OTScriptable::CanExecuteClause.
     // Therefore I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY
     // SINGLE TIME THE SCRIPT
     // CALLS ANY CLAUSE OR OT NATIVE FUNCTION.  Since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     // Also todo:  Need to implement MOVE CONSTRUCTORS and MOVE COPY
     // CONSTRUCTORS all over the place,
     // once I'm sure C++0x build environments are available for all of the
     // various OT platforms. That should
     // be another great performance boost!
     //
     //    FINAL DECISION: Redundant. See comment in
     // OTSmartContract::StashAcctFunds()
     //
 
     // IF NO CALLBACK IS PROVIDED, The default answer to this function is:
     //     YES, this party MAY cancel this contract! (Assuming he's a real
     // party,
     //     which we have verified by this point.)
     //
     // But... first we check to see if this OTScriptable has a clause named:
     //          "callback_party_may_cancel_contract"
     // ...and if so, we ask the CALLBACK to make the decision instead. This way,
     // people can define
     // in their own scripts any rules they want about which parties may cancel
     // the contract.
 
     //
     const std::string str_CallbackName(SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL);
 
     OTClause* pCallbackClause =
         GetCallback(str_CallbackName); // See if there is a script clause
                                        // registered for this callback.
 
     if (nullptr != pCallbackClause) // Found it! There's a clause registered for
                                     // this callback. Let's call it...
     {
         otOut << "OTSmartContract::CanCancelContract: Found script for: "
               << SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL << ". Asking...\n";
 
         // The function we're IN defaults to TRUE, if there's no script
         // available.
         // However, if the script IS available, then our default return value
         // starts as FALSE.
         // (The script itself will then have to set it to true, if that's what
         // it wants.)
         //
         OTVariable theReturnVal("return_val", false);
 
         OTVariable param1(
             "param_party_name", str_party_name,
             OTVariable::Var_Constant); // script can reference param_party_name
 
         mapOfVariables theParameters;
         theParameters.insert(
             std::pair<std::string, OTVariable*>("param_party_name", &param1));
 
         if (false ==
             ExecuteCallback(
                 *pCallbackClause, theParameters,
                 theReturnVal)) // <============================================
         {
             otErr << "OTSmartContract::CanCancelContract: Error while running "
                      "callback script "
                   << SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL << ", clause "
                   << pCallbackClause->GetName() << " \n";
             return false;
         }
         else {
             otOut << "OTSmartContract::CanCancelContract: Success executing "
                      "callback script "
                   << SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL
                   << ", clause: " << pCallbackClause->GetName() << ".\n\n";
 
             return theReturnVal.CopyValueBool();
         }
 
     }
     else {
         otOut
             << "OTSmartContract::CanCancelContract: Unable to find script for: "
             << SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL
             << ". Therefore, default return value is: TRUE.\n";
     }
 
     return true;
 }

bool opentxs::OTSmartContract::CanRemoveItemFromCron ( OTPseudonym & theNym )

virtual

See if theNym has rights to remove this item from Cron.

Reimplemented from opentxs::OTCronItem.

Definition at line 4106 of file OTSmartContract.cpp.

 {
     // You don't just go willy-nilly and remove a cron item from a market unless
     // you check first
     // and make sure the Nym who requested it actually has said number (or a
     // related closing number)
     // signed out to him on his last receipt...
     //
     // Note: overrode parent method and NOT calling it.
     // We do it our own way here, and call a script if it's available.
 
     // IT'S ASSUMED that the opening and closing numbers WILL be verified in
     // order to
     // insure they are CURRENTLY ISSUED.
     //
     // theNym.VerifyIssuedNum(strServerID, GetOpeningNum();
     // theNym.VerifyIssuedNum(strServerID, GetClosingNum();
     //
     // The default version OTCronItem does this for theNym, and the PaymentPlan
     // version
     // has to be a little smarter: it has to figure out whether theNym is the
     // Sender or Recipient,
     // so that it knows where to verify the numbers from, before allowing theNym
     // to do the removal.
     //
     //
     // ===> THIS version (OTSmartContract) will look up pParty using theNym via:
     // OTParty * OTScriptable::FindPartyBasedOnNymAsAgent(const OTPseudonym&
     // theNym, OTAgent ** ppAgent=nullptr);
     //
     // ...Then it WILL check to see if pParty has its Opening number verified as
     // issued.
     // ...It COULD ALSO loop the partyaccounts and see if pAgent is authorized
     // agent for any of them.
     //    (If so, pAcct->VerifyClosingNumber() or pAgent->VerifyClosingNumber()
     // as well.)
     //
     //
     OTAgent* pAgent = nullptr;
     OTParty* pParty = FindPartyBasedOnNymAsAgent(
         theNym, &pAgent); // This sets a pointer to theNym inside pAgent, so
                           // pParty can use it later.
 
     if (nullptr == pParty) {
         otOut << "OTSmartContract::CanRemoveItemFromCron: Warning: theNym is "
                  "not an agent "
                  "for any party to this contract, yet tried to remove it.\n";
         return false;
     }
     OT_ASSERT(nullptr != pAgent); // With one comes the other.
 
     // Below this point, pAgent is not only good, but it contains a secret
     // hidden pointer now to theNym.
     // That way, when the SCRIPT asks the party to verify issued number, without
     // even having a reference to theNym,
     // the party will internally still be able to handle it. This always works
     // in cases where it's needed because
     // we used theNym to look up pParty, and the lookup function is what sets
     // that pointer. That's why I clean
     // the pointer again after I'm done. (AT THE BOTTOM OF THIS FUNCTION.)
     //
 
     // NOTE: You can see OTCronItem looks up the relevant numbers by trying to
     // figure out if theNym
     // is sender or receiver, and then calling these methods:
     // if (GetCountClosingNumbers() < 1)
     // if (GetRecipientCountClosingNumbers() < 2)
     // Etc.
     //
     // But OTSmartContract doesn't use those functions, except where it has to
     // in order to
     // work within the existing OTCronItem system. (That is, the ORIGINATOR who
     // actually activates
     // a smart contract must still provide at least an opening number, which is
     // stored in the old
     // system and used by it.)
     // Instead, OTSmartContract keeps its own records (via its parent class
     // OTScriptable) of all the
     // parties to the contract, and all of their opening transaction #s, as well
     // as the accounts that
     // are party to the contract, and the closing transaction #s for each of
     // those.
     //
     // ===> Therefore, when it comes to verifying whether the Nym has CERTAIN
     // RIGHTS regarding the
     // contract, OTSmartContract doesn't actually use the old system for that,
     // but instead queries its
     // own, superior system.
     //
     // In order to prevent infinite recursion I think I will be adding THAT code
     // into:
     //      OTSmartContract::CanCancelContract(party_name)
 
     bool bReturnValue = false;
     bool bPartyHasName = false;
     const std::string str_party_name = pParty->GetPartyName(&bPartyHasName);
 
     if (bPartyHasName &&
         CanCancelContract(str_party_name)) // Here is where it calls the
                                            // script, inside this call.
     {
         otOut << "OTSmartContract::CanRemoveItemFromCron: Looks like theNym "
                  "represents a party (" << str_party_name
               << ") and "
                  "IS allowed by this contract to cancel it whenever he "
                  "chooses.\n";
         bReturnValue = true;
     }
 
     pParty->ClearTemporaryPointers(); // FindPartyBasedOnNymAsAgent() set the
                                       // party's agent's nym pointer to theNym.
                                       // This clears it.
 
     return bReturnValue;
 }

void opentxs::OTSmartContract::CleanupAccts ( mapOfAccounts & theMap )

static

Definition at line 5164 of file OTSmartContract.cpp.

 {
 
     while (!theMap.empty()) {
         OTAccount* pAcct = theMap.begin()->second;
         OT_ASSERT(nullptr != pAcct);
 
         delete pAcct;
         pAcct = nullptr;
 
         theMap.erase(theMap.begin());
     }
 }

void opentxs::OTSmartContract::CleanupNyms ( mapOfNyms & theMap )

static

Definition at line 5149 of file OTSmartContract.cpp.

 {
 
     while (!theMap.empty()) {
         OTPseudonym* pNym = theMap.begin()->second;
         OT_ASSERT(nullptr != pNym);
 
         delete pNym;
         pNym = nullptr;
 
         theMap.erase(theMap.begin());
     }
 }

void opentxs::OTSmartContract::CloseoutOpeningNumbers ( OTPseudonym * pSignerNym = nullptr )

Definition at line 4976 of file OTSmartContract.cpp.

 {
     const OTString strServerID(GetServerID());
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "OTSmartContract::CloseoutOpeningNumbers:"
                       " Unexpected nullptr pointer in party map.");
 
         // Closeout the opening transaction numbers:
         //
         if (GetTransactionNum() !=
             pParty->GetOpeningTransNo()) // We skip the activating Nym. (His is
                                          // already closed-out in
                                          // NotarizeTransaction.)
             pParty->CloseoutOpeningNumber(strServerID, true, // bSave=true
                                           pSignerNym);
     }
 }

bool opentxs::OTSmartContract::Compare ( OTScriptable & rhs ) const

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 5417 of file OTSmartContract.cpp.

 {
     if (!OTScriptable::Compare(rhs)) return false;
 
     if (GetCountStashes() > 0) {
         otErr << "OTSmartContract::Compare: Error: How is this function EVER "
                  "being called when there are stashes present? Only the server "
                  "can create stashes.\n";
         return false;
     }
 
     if (GetCountStashAccts() > 0) {
         otErr << "OTSmartContract::Compare: Error: How is this function EVER "
                  "being called when there are "
                  "stash accounts present? Only the server can create stash "
                  "accounts.\n";
         return false;
     }
 
     // Compare OTSmartContract specific info here.
     const OTSmartContract* pSmartContract =
         dynamic_cast<const OTSmartContract*>(&rhs);
 
     if (nullptr != pSmartContract) {
         if (pSmartContract->GetCountStashes() > 0) {
             otErr << "OTSmartContract::Compare: Error: How is this function "
                      "EVER being called when there are stashes present on rhs? "
                      "Only the server can create stashes.\n";
             return false;
         }
 
         if (pSmartContract->GetCountStashAccts() > 0) {
             otErr << "OTSmartContract::Compare: Error: How is this function "
                      "EVER being called when there are stash accounts present "
                      "on rhs? Only the server can create stash accounts.\n";
             return false;
         }
 
         if ((GetServerID() == pSmartContract->GetServerID()) &&
             (GetValidFrom() == pSmartContract->GetValidFrom()) &&
             (GetValidTo() == pSmartContract->GetValidTo()))
             return true;
     }
 
     return false;
 }

bool opentxs::OTSmartContract::ConfirmParty ( OTParty & theParty )

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 5230 of file OTSmartContract.cpp.

 {
     if (!theParty.HasActiveAgent()) {
         otOut << "OTSmartContract::ConfirmParty: Party doesn't have an active "
                  "agent -- who will sign for this smart contract?\n";
         return false;
     }
 
     // Let's RESERVE however many transaction numbers we need to confirm this
     // smartcontract...
     //
     const OTString strServerID(GetServerID());
 
     // ReserveTransNumsForConfirm() sets aside the Opening # for the party,
     // as well as the Closing #s for all the asset accounts for that party.
     //
     // This MUST be done before calling OTScriptable::ConfirmParty, because
     // *this will get SIGNED in there, and so must have its final data in
     // place already. If the confirmation fails, we will harvest the numbers
     // back again.
     //
     if (!theParty.ReserveTransNumsForConfirm(strServerID)) {
         otOut << "OTSmartContract::ConfirmParty: Failure trying to reserve "
                  "transaction numbers for "
                  "the smart contract. (Nym needs more numbers than he has.)\n";
         return false;
     }
     // Note: BELOW THIS POINT, the transaction numbers have been set aside, and
     // must be retrieved,
     // below this point, in the event of any failure, using this call:
     // theParty.HarvestAllTransactionNumbers(strServerID);
 
     // Since EVERY party keeps his own signed copy, then we reset the creation
     // date
     // before EACH signature. That way, we have the date of signing for EVERY
     // signer.
     // (The final date will be set upon activation.)
     //
     const time64_t& CURRENT_TIME = OTTimeGetCurrentTime(),
                     OLD_TIME = GetCreationDate();
 
     // Set the Creation Date.
     SetCreationDate(CURRENT_TIME);
 
     // THIS IS where the SIGNED COPY is SAVED, so all final changes must occur
     // ABOVE this point.
     //
     if (!OTScriptable::ConfirmParty(theParty)) {
         otOut << "OTSmartContract::ConfirmParty: Failed confirming party.\n";
         SetCreationDate(OLD_TIME); // Might as well set this back.
         theParty.HarvestAllTransactionNumbers(strServerID); // If it failed,
                                                             // grab BACK the
                                                             // numbers that we
                                                             // reserved above.
         return false;
     }
 
     // SUCCESS!!
     //
     return true;
 
     // Are we good? The contract is compared against the other parties' signed
     // contracts; my own party and
     // transaction #s are added, and a signed copy of everything is saved in my
     // party. Then the entire contract
     // is re-signed (saving its updated contents) and then sent on to the next
     // party, who is free to release that
     // signature since I already have a signed copy in my party.
     //
     // Assuming all parties have signed AND provided valid transaction #s, then
     // the server is free to get started
     // immediately upon activation, and furthermore to cancel whenever it wants
     // (and probably just according to
     // the terms.)  There should be a standard call for seeing if a person can
     // cancel the agreement, and if it's
     // not overridden in the contract, then it defaults to return true. (Note:
     // that is done now.)
     //
     // Technically ANY party's authorizing agent could become the originator by
     // activating the contract, but
     // only if all parties have validly signed.  (Server needs to verify.)
 }

void opentxs::OTSmartContract::DeactivateSmartContract ( )

Definition at line 970 of file OTSmartContract.cpp.

 {
     // WARNING: If a party has the right to execute a clause that calls
     // DeactivateSmartContract(),
     // then that party can deactivate the smartcontract by calling that clause,
     // regardless of what
     // "CanPartyCancelClause()" says he can do.
     // (And by default, any legitimate party can trigger any clause, at any
     // time, unless your script
     // override says differently.)
 
     otOut << "OTSmartContract::DeactivateSmartContract: deactivate_contract() "
              "was called from within the script. "
              "Flagging smartcontract for removal from Cron ("
           << GetTransactionNum() << ").\n";
 
     FlagForRemoval(); // Remove it from future Cron processing, please.
 }

void opentxs::OTSmartContract::ExecuteClauses	(	mapOfClauses &	theClauses,
		OTString *	pParam = `nullptr`
	)

Definition at line 3761 of file OTSmartContract.cpp.

 {
     // Loop through the clauses passed in, and execute them all.
     for (auto& it_clauses : theClauses) {
         const std::string str_clause_name = it_clauses.first;
         OTClause* pClause = it_clauses.second;
         OT_ASSERT((nullptr != pClause) && (str_clause_name.size() > 0));
         OTBylaw* pBylaw = pClause->GetBylaw();
         OT_ASSERT(nullptr != pBylaw);
 
         // By this point, we have the clause we are executing as pClause,
         // and we have the Bylaw it belongs to, as pBylaw.
 
         const std::string str_code =
             pClause->GetCode(); // source code for the script.
         const std::string str_language =
             pBylaw->GetLanguage(); // language it's in. (Default is "chai")
 
         std::shared_ptr<OTScript> pScript =
             OTScriptFactory(str_language, str_code);
 
         std::unique_ptr<OTVariable> theVarAngel;
 
         //
         // SET UP THE NATIVE CALLS, REGISTER THE PARTIES, REGISTER THE
         // VARIABLES, AND EXECUTE THE SCRIPT.
         //
         if (pScript) {
             // Register the special server-side native OT calls we make
             // available to all scripts.
             //
             RegisterOTNativeCallsWithScript(*pScript);
 
             // Register all the parties with the script.
             //
             for (auto& it : m_mapParties) {
                 const std::string str_party_name = it.first;
                 OTParty* pParty = it.second;
                 OT_ASSERT((nullptr != pParty) && (str_party_name.size() > 0));
 
                 pScript->AddParty(str_party_name, *pParty); // This also
                                                             // registers all of
                                                             // Party's accounts
                                                             // with pScript.
             }
 
             // Also need to loop through the Variables on pBylaw and register
             // those as well.
             //
             pBylaw->RegisterVariablesForExecution(
                 *pScript); // This also sets all the variables as CLEAN so we
                            // can check for dirtiness after execution.
 
             // A parameter might also be passed in, so we add that to the script
             // as well.
             // (Like if a client is sending a triggerClause message to a server,
             // and passing
             // a string parameter to that clause as input.)
             //
             const std::string str_Name("param_string");
             std::string str_Value("");
 
             // See if param_string variable is already found on the bylaw...
             //
             if (nullptr !=
                 pBylaw->GetVariable(str_Name)) // disallow duplicate names.
             {
                 otErr << "OTSmartContract::ExecuteClauses: While preparing to "
                          "run smartcontract trans# " << GetTransactionNum()
                       << ", clause: " << str_clause_name
                       << ".  Error: Parameter variable named " << str_Name
                       << " already exists. (Skipping the parameter actually "
                          "passed in.)\n";
             }
             else // The param_string variable isn't already there. (So we add
                    // it as blank, if a value wasn't passed in.)
             {
                 if (nullptr != pParam) // if a param was passed in...
                     str_Value = pParam->Get();
                 // else (it's already "")
 
                 OTVariable* pVar = new OTVariable(str_Name, str_Value,
                                                   OTVariable::Var_Constant);
                 OT_ASSERT(nullptr != pVar);
                 theVarAngel.reset(pVar);
 
                 pVar->RegisterForExecution(*pScript); // This causes pVar to
                                                       // keep a pointer to the
                                                       // script so it can remove
                                                       // itself from the script
                                                       // upon destruction.
                 //                pScript->AddVariable(str_Name, *pVar);
             }
 
             // TEMP FOR TESTING (HARDCODED CLAUSE NAME HERE...)
             //            OTVariable theReturnVal("return_val", false); //
             // initial value is: false.
 
             SetDisplayLabel(&str_clause_name);
 
             pScript->SetDisplayFilename(m_strLabel.Get());
 
             if (!pScript->ExecuteScript()) // If I passed theReturnVal
                                            // in here, then it'd be
                                            // assumed a bool is expected
                                            // to be returned inside it.
                                            //            if (false ==
             // pScript->ExecuteScript((str_clause_name.compare("process_clause")
             // == 0) ? &theReturnVal : nullptr))
             {
                 otErr << "OTSmartContract::ExecuteClauses: Error while running "
                          "smartcontract trans# " << GetTransactionNum()
                       << ", clause: " << str_clause_name << " \n\n";
             }
             else
                 otOut << "OTSmartContract::ExecuteClauses: Success executing "
                          "smartcontract trans# " << GetTransactionNum()
                       << ", clause: " << str_clause_name << " \n\n";
 
             //            For now, I've decided to allow ALL clauses to trigger
             // on the hook. The flag only matters after
             //            they are done, and not between scripts. Otherwise
             // problems could arise, such as order of execution.
             //            Remember, there is nothing stopping people from using
             // their own variables and ending all behavior
             //          after that flag is set.  Todo security: revisit this
             // just in case.
             //
         }
         else {
             otErr << "OTSmartContract::ExecuteClauses: Error instantiating "
                      "script!\n";
         }
     }
 
     // "Important" variables.
     // (If any of them have changed, then I need to notice the parties.)
     //
     // TODO: Fix IsDirtyImportant() so that it checks for changed STASHES
     // as well. (Or have another function to do it, which is also called here.)
     //
     // I'd like to get to where I can just call IsDirty() here, and then SAVE
     // CRON HERE,
     // so I'm not having to save it after EACH change, which is currently
     // occuring in the
     // StashAcctFunds / MoveAcctFunds functions. Todo.
     //
     if (IsDirtyImportant()) // This tells us if any "Important" variables
                             // have changed since executing the scripts.
     {
         OTCron* pCron = GetCron();
         OT_ASSERT(nullptr != pCron);
 
         OTPseudonym* pServerNym = pCron->GetServerNym();
         OT_ASSERT(nullptr != pServerNym);
 
         const int64_t lNewTransactionNumber = pCron->GetNextTransactionNumber();
 
         //        OT_ASSERT(lNewTransactionNumber > 0); // this can be my
         // reminder.
         if (0 == lNewTransactionNumber) {
             otErr << "OTSmartContract::ExecuteClauses: ** ERROR: Notice not "
                      "sent to parties, since no "
                      "transaction numbers were available!\n";
         }
         else {
             ReleaseSignatures();
             SignContract(*pServerNym);
             SaveContract();
 
             const OTString strReference(*this);
             bool bDroppedNotice = SendNoticeToAllParties(
                 true, // bSuccessMsg=true
                 *pServerNym, GetServerID(), lNewTransactionNumber,
                 strReference); // pstrNote and pstrAttachment aren't used in
                                // this case.
 
             otOut << __FUNCTION__
                   << ": FYI, 'Important' variables were changed during the "
                      "execution of this script.\n"
                   << (bDroppedNotice ? "Success" : "Failure")
                   << " dropping notifications into all parties' nymboxes.\n";
         }
     }
 }

std::string opentxs::OTSmartContract::GetAcctBalance ( std::string from_acct_name )

Definition at line 1182 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
     //
 
     if (from_acct_name.size() <= 0) {
         otErr << "OTSmartContract::GetAcctBalance: error: from_acct_name is "
                  "non-existent.\n";
         return 0;
     }
 
     // Below this point, these are all good:
     //
     //        from_acct_name,
     //        pServerNym, pCron.
 
     OTPartyAccount* pFromAcct = GetPartyAccount(from_acct_name);
 
     if (nullptr == pFromAcct) {
         otOut << "OTSmartContract::GetAcctBalances: error: from_acct ("
               << from_acct_name << ") not found on any party.\n";
         return 0;
     }
 
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,
     //        pServerNym, pCron.
 
     OTAgent* pFromAgent =
         pFromAcct->GetAuthorizedAgent(); // This searches the account's party
                                          // for the account's authorized agent.
     // (That way it's impossible to get an agent for any other party.)
 
     if (nullptr == pFromAgent) {
         otOut << "OTSmartContract::GetAcctBalance: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") not found for from_acct ("
               << from_acct_name << ") on acct's party.\n";
         return 0;
     }
 
     if (!pFromAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::GetAcctBalance: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") for from_acct ("
               << from_acct_name << ") is not an active agent.\n";
         return 0;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,
     //        pServerNym, pCron.
 
     OTParty* pFromParty = pFromAgent->GetParty();
 
     if (nullptr == pFromParty) {
         otErr
             << "OTSmartContract::GetAcctBalance: error: Party pointer nullptr "
                "on authorized agent (" << pFromAcct->GetAgentName()
             << ") for from_acct (" << from_acct_name << ").\n";
         return 0;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,    pFromParty,
     //        pServerNym, pCron.
 
     // Done: I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY SINGLE
     // TIME THE SCRIPT
     // CALLS MOVE FUNDS.  Maybe that's good, but since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     //
     //    FINAL DECISION: Redundant, already verified upon activation on cron.
     //  See longer comment in OTSmartContract::StashAcctFunds()
     //
     //    const OTString strServerID(GetServerID());
     //
     //    mapOfNyms    map_Nyms_Already_Loaded;
     //    RetrieveNymPointers(map_Nyms_Already_Loaded);
     //
     //
     //    if (!VerifyPartyAuthorization(*pFromParty, *pServerNym,
     // strServerID, &map_Nyms_Already_Loaded))
     //    {
     //        otErr << "OTSmartContract::GetAcctBalance: error: 'From' Party
     // (%s) not authorized for this contract.\n",
     //                      pFromParty->GetPartyName().c_str());
     //        return 0;
     //    }
 
     // A party might have many agents who are only voting groups, and cannot
     // actually sign for things
     // the way that nyms can. But at least ONE of those agents IS a Nym --
     // because there must have been
     // an authorizing agent who initially signed to accept the agreement, and
     // who fronted the opening
     // transaction number that activated it.
     //
     // Similarly, the authorized agent for any given party's account (each
     // account has its own authorized
     // agent) MUST be an active agent (an active agent is one with a
     // Nym--whether that Nym is representing
     // himself as the party, or whether representing some entity as an employee
     // in a role). Why MUST the
     // authorized agent be an active agent? Because when funds are moved, that
     // Nym must be loaded since
     // the account must show that Nym as a legal owner/agent. The MoveFunds will
     // cause a paymentReceipt to
     // drop into the Inbox for the relevant asset accounts, and that
     // paymentReceipt can ONLY be accepted
     // by that same Nym, who must use a transaction # that he signed for
     // previously and received through
     // his nymbox. There is actually no justification at all to take funds from
     // that account, since the
     // new balance has not yet been signed, UNLESS THE PAYMENTRECEIPT CONTAINS A
     // VALID, SIGNED AUTHORIZATION
     // FROM THE ACCOUNT HOLDER. *That* is why the authorizing agent must either
     // be the Party's Owner himself
     // (representing himself as an agent, which most will do) in which case he
     // will appear as the valid
     // owner of the account, OR he MUST be a Nym working in a Valid Role for an
     // Entity, where said Entity is
     // the valid owner on the account in question. Either OT, it will be
     // possible in OT for him to sign for
     // the paymentReceipts when they come in, and impossible for him to escape
     // liability for them.
     // (That's the idea anyway.)
     //
     // Since we know that the Authorized Agent for an account must be an ACTIVE
     // agent (one way or the other)
     // then we can error out here if he's not.  We can then pass in his Nym ID.
     //
 
     OTIdentifier theFromAgentID;
     const bool bFromAgentID = pFromAgent->GetSignerID(theFromAgentID);
 
     if (!bFromAgentID) {
         otErr << "OTSmartContract::GetAcctBalance: Failed to find FromAgent's "
                  "Signer ID: " << pFromAgent->GetName() << " \n";
         return 0;
     }
 
     if (!pFromAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::GetAcctBalance: Error: FromAcct has empty "
                  "AcctID: " << from_acct_name << " \n";
         return 0;
     }
 
     const OTIdentifier theFromAcctID(pFromAcct->GetAcctID());
     //
     // BELOW THIS POINT, theFromAcctID and theFromAgentID available.
 
     const OTIdentifier SERVER_ID(pCron->GetServerID());
     const OTIdentifier SERVER_USER_ID(*pServerNym);
 
     const std::string str_party_id = pFromParty->GetPartyID();
     const OTString strPartyID(str_party_id);
     const OTIdentifier PARTY_USER_ID(strPartyID);
 
     const OTIdentifier PARTY_ACCT_ID(pFromAcct->GetAcctID());
 
     // Load up the party's account so we can get the balance.
     //
     OTAccount* pPartyAssetAcct =
         OTAccount::LoadExistingAccount(PARTY_ACCT_ID, SERVER_ID);
 
     if (nullptr == pPartyAssetAcct) {
         otOut << "OTSmartContract::GetAcctBalance: ERROR verifying existence "
                  "of source account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return 0;
     }
     else if (!pPartyAssetAcct->VerifySignature(*pServerNym)) {
         otOut << "OTSmartContract::GetAcctBalance: ERROR failed to verify the "
                  "server's signature on the party's account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return 0;
     }
     else if (!pPartyAssetAcct->VerifyOwnerByID(PARTY_USER_ID)) {
         otOut << "OTSmartContract::GetAcctBalance: ERROR failed to verify "
                  "party user ownership of party account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return 0;
     }
     // Past this point we know pPartyAssetAcct is good and will clean itself up.
     std::unique_ptr<OTAccount> theSourceAcctSmrtPtr(pPartyAssetAcct);
 
     OTString strBalance;
     strBalance.Format("%lld", pPartyAssetAcct->GetBalance());
 
     return strBalance.Get();
 }

void opentxs::OTSmartContract::GetAllTransactionNumbers ( OTNumList & numlistOutput ) const

virtual

Reimplemented from opentxs::OTTrackable.

Definition at line 1052 of file OTSmartContract.cpp.

 {
     for (const auto& it : m_mapParties) {
         const OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         pParty->GetAllTransactionNumbers(numlistOutput);
     }
 }

std::string opentxs::OTSmartContract::GetAssetTypeIDofAcct ( std::string from_acct_name )

Definition at line 1394 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
     //
 
     std::string str_return_value;
 
     if (from_acct_name.size() <= 0) {
         otErr << "OTSmartContract::GetAssetTypeIDofAcct: error: from_acct_name "
                  "is non-existent.\n";
         return str_return_value;
     }
 
     // Below this point, these are all good:
     //
     //        from_acct_name,
     //        pServerNym, pCron.
 
     OTPartyAccount* pFromAcct = GetPartyAccount(from_acct_name);
 
     if (nullptr == pFromAcct) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: error: from_acct ("
               << from_acct_name << ") not found on any party.\n";
         return str_return_value;
     }
 
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,
     //        pServerNym, pCron.
 
     OTAgent* pFromAgent =
         pFromAcct->GetAuthorizedAgent(); // This searches the account's party
                                          // for the account's authorized agent.
     // (That way it's impossible to get an agent for any other party.)
 
     if (nullptr == pFromAgent) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: error: authorized "
                  "agent (" << pFromAcct->GetAgentName()
               << ") not found for from_acct (" << from_acct_name
               << ") on acct's party.\n";
         return str_return_value;
     }
 
     if (!pFromAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: error: authorized "
                  "agent (" << pFromAcct->GetAgentName() << ") for from_acct ("
               << from_acct_name << ") is not an active agent.\n";
         return str_return_value;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,
     //        pServerNym, pCron.
 
     OTParty* pFromParty = pFromAgent->GetParty();
 
     if (nullptr == pFromParty) {
         otErr << "OTSmartContract::GetAssetTypeIDofAcct: error: Party pointer "
                  "nullptr on authorized agent (" << pFromAcct->GetAgentName()
               << ") for from_acct (" << from_acct_name << ").\n";
         return str_return_value;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,    pFromParty,
     //        pServerNym, pCron.
 
     // Done: I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY SINGLE
     // TIME THE SCRIPT
     // CALLS MOVE FUNDS.  Maybe that's good, but since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     //
     // FINAL DECISION: Redunant, already done upon activation onto cron.
     // Furthermore, expects no stashes to exist,
     // since they can only be created after activation. (Interfered with script
     // operations by complaining whenever
     // there was a stash.) See longer comment in StashAcctFunds().
     //
     //    const OTString strServerID(GetServerID());
     //
     //    mapOfNyms    map_Nyms_Already_Loaded;
     //    RetrieveNymPointers(map_Nyms_Already_Loaded);
     //
     //
     //    if (!VerifyPartyAuthorization(*pFromParty, *pServerNym,
     // strServerID, &map_Nyms_Already_Loaded))
     //    {
     //        otErr << "OTSmartContract::GetAssetTypeIDofAcct: error: 'From'
     // Party (%s) not authorized for this contract.\n",
     //                      pFromParty->GetPartyName().c_str());
     //        return str_return_value;
     //    }
 
     // A party might have many agents who are only voting groups, and cannot
     // actually sign for things
     // the way that nyms can. But at least ONE of those agents IS a Nym --
     // because there must have been
     // an authorizing agent who initially signed to accept the agreement, and
     // who fronted the opening
     // transaction number that activated it.
     //
     // Similarly, the authorized agent for any given party's account (each
     // account has its own authorized
     // agent) MUST be an active agent (an active agent is one with a
     // Nym--whether that Nym is representing
     // himself as the party, or whether representing some entity as an employee
     // in a role). Why MUST the
     // authorized agent be an active agent? Because when funds are moved, that
     // Nym must be loaded since
     // the account must show that Nym as a legal owner/agent. The MoveFunds will
     // cause a paymentReceipt to
     // drop into the Inbox for the relevant asset accounts, and that
     // paymentReceipt can ONLY be accepted
     // by that same Nym, who must use a transaction # that he signed for
     // previously and received through
     // his nymbox. There is actually no justification at all to take funds from
     // that account, since the
     // new balance has not yet been signed, UNLESS THE PAYMENTRECEIPT CONTAINS A
     // VALID, SIGNED AUTHORIZATION
     // FROM THE ACCOUNT HOLDER. *That* is why the authorizing agent must either
     // be the Party's Owner himself
     // (representing himself as an agent, which most will do) in which case he
     // will appear as the valid
     // owner of the account, OR he MUST be a Nym working in a Valid Role for an
     // Entity, where said Entity is
     // the valid owner on the account in question. Either OT, it will be
     // possible in OT for him to sign for
     // the paymentReceipts when they come in, and impossible for him to escape
     // liability for them.
     // (That's the idea anyway.)
     //
     // Since we know that the Authorized Agent for an account must be an ACTIVE
     // agent (one way or the other)
     // then we can error out here if he's not.  We can then pass in his Nym ID.
     //
 
     OTIdentifier theFromAgentID;
     const bool bFromAgentID = pFromAgent->GetSignerID(theFromAgentID);
 
     if (!bFromAgentID) {
         otErr << "OTSmartContract::GetAssetTypeIDofAcct: Failed to find "
                  "FromAgent's Signer ID: " << pFromAgent->GetName() << " \n";
         return str_return_value;
     }
 
     if (!pFromAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::GetAssetTypeIDofAcct: Error: FromAcct has "
                  "empty AcctID: " << from_acct_name << " \n";
         return str_return_value;
     }
 
     const OTIdentifier theFromAcctID(pFromAcct->GetAcctID());
     //
     // BELOW THIS POINT, theFromAcctID and theFromAgentID available.
 
     const OTIdentifier SERVER_ID(pCron->GetServerID());
     const OTIdentifier SERVER_USER_ID(*pServerNym);
 
     const std::string str_party_id = pFromParty->GetPartyID();
     const OTString strPartyID(str_party_id);
     const OTIdentifier PARTY_USER_ID(strPartyID);
 
     const OTIdentifier PARTY_ACCT_ID(pFromAcct->GetAcctID());
 
     // Load up the party's account and get the asset type.
     //
     OTAccount* pPartyAssetAcct =
         OTAccount::LoadExistingAccount(PARTY_ACCT_ID, SERVER_ID);
 
     if (nullptr == pPartyAssetAcct) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: ERROR verifying "
                  "existence of source account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return str_return_value;
     }
     else if (!pPartyAssetAcct->VerifySignature(*pServerNym)) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: ERROR failed to "
                  "verify the server's signature on the party's account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return str_return_value;
     }
     else if (!pPartyAssetAcct->VerifyOwnerByID(PARTY_USER_ID)) {
         otOut << "OTSmartContract::GetAssetTypeIDofAcct: ERROR failed to "
                  "verify party user ownership of party account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return str_return_value;
     }
     // Past this point we know pPartyAssetAcct is good and will clean itself up.
     std::unique_ptr<OTAccount> theSourceAcctSmrtPtr(pPartyAssetAcct);
 
     const OTString strAssetTypeID(pPartyAssetAcct->GetAssetTypeID());
     str_return_value = strAssetTypeID.Get();
 
     return str_return_value;
 }

int64_t opentxs::OTSmartContract::GetClosingNumber ( const OTIdentifier & theAcctID ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 1077 of file OTSmartContract.cpp.

 {
     OTPartyAccount* pPartyAcct =
         GetPartyAccountByID(theAcctID); // from OTScriptable.
 
     if (nullptr != pPartyAcct) {
         return pPartyAcct->GetClosingTransNo();
     }
 
     return 0;
 }

int32_t opentxs::OTSmartContract::GetCountStashAccts ( ) const

Definition at line 5407 of file OTSmartContract.cpp.

 {
     return m_StashAccts.GetCountAccountIDs();
 }

int32_t opentxs::OTSmartContract::GetCountStashes ( ) const

Definition at line 5402 of file OTSmartContract.cpp.

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

const OTString& opentxs::OTSmartContract::GetLastRecipientAcctID ( ) const

inline

Definition at line 261 of file OTSmartContract.hpp.

     {
         return m_strLastRecipientAcct;
     }

const OTString& opentxs::OTSmartContract::GetLastRecipientUserID ( ) const

inline

Definition at line 257 of file OTSmartContract.hpp.

     {
         return m_strLastRecipientUser;
     }

const OTString& opentxs::OTSmartContract::GetLastSenderAcctID ( ) const

inline

Definition at line 253 of file OTSmartContract.hpp.

     {
         return m_strLastSenderAcct;
     }

const OTString& opentxs::OTSmartContract::GetLastSenderUserID ( ) const

inline

Definition at line 249 of file OTSmartContract.hpp.

     {
         return m_strLastSenderUser;
     }

const time64_t& opentxs::OTSmartContract::GetNextProcessDate ( ) const

inlineprotected

Definition at line 232 of file OTSmartContract.hpp.

     {
         return m_tNextProcessDate;
     }

int64_t opentxs::OTSmartContract::GetOpeningNumber ( const OTIdentifier & theNymID ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 1062 of file OTSmartContract.cpp.

 {
     OTAgent* pAgent = nullptr;
     OTParty* pParty = FindPartyBasedOnNymIDAsAgent(theNymID, &pAgent);
 
     if (nullptr != pParty) {
         OT_ASSERT_MSG(nullptr != pAgent,
                       "OT_ASSERT: nullptr != pAgent in "
                       "OTSmartContract::GetOpeningNumber.\n");
         return pParty->GetOpeningTransNo();
     }
 
     return 0;
 }

std::string opentxs::OTSmartContract::GetRemainingTimer ( ) const

Definition at line 1124 of file OTSmartContract.cpp.

 {
     const time64_t& tNextDate = GetNextProcessDate();
     const time64_t tCurrent = OTTimeGetCurrentTime();
 
     OTString strReturnVal("0"); // the default return value is "0".
 
     if (tNextDate > OT_TIME_ZERO) {
         const int64_t tSecondsLeft = OTTimeGetTimeInterval(tNextDate, tCurrent);
         strReturnVal.Format("%" PRId64 "", tSecondsLeft);
     }
 
     return strReturnVal.Get();
 }

OTStash * opentxs::OTSmartContract::GetStash ( std::string str_stash_name )

Definition at line 5315 of file OTSmartContract.cpp.

 {
     auto it = m_mapStashes.find(str_stash_name);
 
     if (m_mapStashes.end() == it) // It's not there. Create it.
     {
         OTStash* pStash = new OTStash(str_stash_name);
         OT_ASSERT(nullptr != pStash);
 
         m_mapStashes.insert(
             std::pair<std::string, OTStash*>(str_stash_name, pStash));
         return pStash;
     }
 
     OTStash* pStash = it->second;
     OT_ASSERT(nullptr != pStash);
 
     return pStash;
 }

std::string opentxs::OTSmartContract::GetStashBalance	(	std::string	stash_name,
		std::string	asset_type_id
	)

Definition at line 1611 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
     //
 
     if (from_stash_name.size() <= 0) {
         otErr << "OTSmartContract::GetStashBalance: error: from_stash_name is "
                  "non-existent.\n";
         return 0;
     }
     if (asset_type_id.size() <= 0) {
         otErr << "OTSmartContract::GetStashBalance: error: asset_type_id is "
                  "non-existent.\n";
         return 0;
     }
 
     // Below this point, these are all good:
     //
     //        from_stash_name,
     //        asset_type_id
     //        pServerNym, pCron.
     //
 
     OTStash* pStash = GetStash(from_stash_name); // This ALWAYS succeeds.
                                                  // (It will OT_ASSERT()
                                                  // if failure.)
 
     //
     // Below this point, these are all good:
     //
     //        pStash,        from_stash_name,
     //        asset_type_id
     //        pServerNym, pCron.
     //
     OTString strBalance;
     strBalance.Format("%lld", pStash->GetAmount(asset_type_id));
     return strBalance.Get();
 }

void opentxs::OTSmartContract::HarvestClosingNumbers ( OTPseudonym & theNym )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 5069 of file OTSmartContract.cpp.

 {
     // We do NOT call the parent version.
     //  OTCronItem::HarvestClosingNumbers(theNym);
 
     // For payment plan, the parent (OTCronItem) grabs the sender's #s, and then
     // the subclass's
     // override (OTAgreement::HarvestClosingNumbers) grabs the recipient's #s.
     // But with SMART
     // CONTRACTS, there are only "the parties" and they ALL burned an opening #,
     // plus they can
     // ALL harvest their closing #s if activation failed. In fact, done: might
     // as well send them
     // all a notification if it fails, so they can all AUTOMATICALLY remove said
     // numbers from
     // their future balance agreements.
     //
 
     const OTString strServerID(GetServerID());
     const int32_t nTransNumCount = theNym.GetTransactionNumCount(
         GetServerID()); // save this to see if it changed, later.
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "Unexpected nullptr pointer in party map.");
 
         pParty->HarvestClosingNumbers(theNym, strServerID);
     }
 
     // It changed, so let's save it.
     if (nTransNumCount != theNym.GetTransactionNumCount(GetServerID()))
         theNym.SaveSignedNymfile(theNym);
 }

void opentxs::OTSmartContract::HarvestClosingNumbers	(	OTPseudonym *	pSignerNym = `nullptr`,
		std::set< OTParty * > *	pFailedParties = `nullptr`
	)

Definition at line 5008 of file OTSmartContract.cpp.

 {
     const OTString strServerID(GetServerID());
 
     for (auto& it : m_mapParties) {
         const std::string str_party_name = it.first;
         OTParty* pParty = it.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "OTSmartContract::HarvestClosingNumbers: "
                       "Unexpected nullptr pointer in party map.");
 
         // If certain parties failed verification, then
         // OTSmartContract::VerifySmartContract() is smart enough
         // not to bother verifying the accounts of those parties. Thus, the
         // closing numbers for those accounts
         // could NOT have been marked as "used" (since they were skipped). So we
         // passed that same set of failed
         // parties into this function here, so that we can skip them here as
         // well, when harvesting the closing
         // numbers back again.
         //
         if (nullptr != pFailedParties) // There are failed parties.
         {
 
             // Skip failed parties...
             //
             auto it_failed = pFailedParties->find(pParty);
 
             if (pFailedParties->end() != it_failed) // this means pParty was
                                                     // found on the FAILED list.
                                                     // (So we can skip it here.)
             {
                 otOut << __FUNCTION__ << ": FYI, at least one party ("
                       << str_party_name
                       << ") has failed verification, so right now I'm skipping "
                          "harvesting of his "
                          "closing transaction numbers. (Since he failed, we "
                          "never verified his accounts, so we never grabbed "
                          "those closing "
                          "numbers in the first place, so there's no need to "
                          "grab them back now.)\n";
                 continue;
             }
         }
 
         // For all non-failed parties, now we harvest the closing transaction
         // numbers:
         //
         pParty->HarvestClosingNumbers(
             strServerID, // <==============  (THE HARVEST.)
             true,        // bSave=true
             pSignerNym);
     }
 }

void opentxs::OTSmartContract::HarvestOpeningNumber ( OTPseudonym & theNym )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 5113 of file OTSmartContract.cpp.

 {
     // We do NOT call the parent version.
     //  OTCronItem::HarvestOpeningNumber(theNym);
 
     // For payment plan, the parent (OTCronItem) grabs the sender's #s, and then
     // the subclass's
     // override (OTAgreement::HarvestClosingNumbers) grabs the recipient's #s.
     // But with SMART
     // CONTRACTS, there are only "the parties" and they ALL burned an opening #,
     // plus they can
     // ALL harvest their closing #s if activation failed. In fact, todo: might
     // as well send them
     // all a notification if it fails, so they can all AUTOMATICALLY remove said
     // numbers from
     // their future balance agreements.
     //
 
     const OTString strServerID(GetServerID());
     const int32_t nTransNumCount = theNym.GetTransactionNumCount(
         GetServerID()); // save this to see if it changed, later.
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "Unexpected nullptr pointer in party map.");
 
         pParty->HarvestOpeningNumber(theNym, strServerID);
     }
 
     // It changed, so let's save it.
     if (nTransNumCount != theNym.GetTransactionNumCount(GetServerID()))
         theNym.SaveSignedNymfile(theNym);
 }

bool opentxs::OTSmartContract::HasTransactionNum ( const int64_t & lInput ) const

virtual

Reimplemented from opentxs::OTTrackable.

Definition at line 1040 of file OTSmartContract.cpp.

 {
     for (const auto& it : m_mapParties) {
         const OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasTransactionNum(lInput)) return true;
     }
 
     return false;
 }

void opentxs::OTSmartContract::InitSmartContract ( )

Definition at line 5357 of file OTSmartContract.cpp.

 {
     m_strContractType = "SMARTCONTRACT";
 
     SetProcessInterval(
         SMART_CONTRACT_PROCESS_INTERVAL); // Smart contracts current default is
                                           // 30 seconds. Actual default will
                                           // probably be configurable in config
                                           // file, and most contracts will also
                                           // probably override this.
 }

bool opentxs::OTSmartContract::IsValidOpeningNumber ( const int64_t & lOpeningNum ) const

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 1024 of file OTSmartContract.cpp.

 {
     for (const auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->GetOpeningTransNo() == lOpeningNum) return true;
     }
 
     return false;
 }

bool opentxs::OTSmartContract::MoveAcctFundsStr	(	std::string	from_acct_name,
		std::string	to_acct_name,
		std::string	str_Amount
	)

Definition at line 3119 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
 
     if (str_Amount.size() < 1) {
         otOut << "OTSmartContract::MoveAcctFunds: Error: empty amount.\n";
         return false;
     }
 
     const int64_t lAmount = atol(str_Amount.c_str());
 
     if (lAmount <= 0) {
         otOut << "OTSmartContract::MoveAcctFunds: Error: lAmount cannot be 0 "
                  "or <0. (Value passed in was " << lAmount << ".)\n";
         return false;
     }
 
     if (from_acct_name.size() <= 0) {
         otErr << "OTSmartContract::MoveAcctFunds: error: from_acct_name is "
                  "non-existent.\n";
         return false;
     }
     if (to_acct_name.size() <= 0) {
         otErr << "OTSmartContract::MoveAcctFunds: error: to_acct_name is "
                  "non-existent.\n";
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        from_acct_name,
     //        to_acct_name,
     //        pServerNym, pCron.
 
     OTPartyAccount* pFromAcct = GetPartyAccount(from_acct_name);
     OTPartyAccount* pToAcct = GetPartyAccount(to_acct_name);
 
     if (nullptr == pFromAcct) {
         otOut << "OTSmartContract::MoveAcctFunds: error: from_acct ("
               << from_acct_name << ") not found on any party.\n";
         otOut << "FULL CONTRACT:  \n" << m_xmlUnsigned << " \n\n";
         return false;
     }
     if (nullptr == pToAcct) {
         otOut << "OTSmartContract::MoveAcctFunds: error: to_acct ("
               << to_acct_name << ") not found on any party.\n";
         otOut << "FULL CONTRACT:  \n" << m_xmlUnsigned << " \n\n";
 
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,
     //        pToAcct,    to_acct_name,
     //        pServerNym, pCron.
 
     OTAgent* pFromAgent =
         pFromAcct->GetAuthorizedAgent(); // This searches the account's party
                                          // for the account's authorized agent.
     OTAgent* pToAgent =
         pToAcct->GetAuthorizedAgent(); // (That way it's impossible to get an
                                        // agent for any other party.)
 
     if (nullptr == pFromAgent) {
         otOut << "OTSmartContract::MoveAcctFunds: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") not found for from_acct ("
               << from_acct_name << ") on acct's party.\n";
         return false;
     }
     if (nullptr == pToAgent) {
         otOut << "OTSmartContract::MoveAcctFunds: error: authorized agent ("
               << pToAcct->GetAgentName() << ") not found for to_acct ("
               << to_acct_name << ") on acct's party.\n";
         return false;
     }
 
     if (!pFromAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::MoveAcctFunds: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") for from_acct ("
               << from_acct_name << ") is not an active agent.\n";
         return false;
     }
     if (!pToAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::MoveAcctFunds: error: authorized agent ("
               << pToAcct->GetAgentName() << ") for to_acct (" << to_acct_name
               << ") is not an active agent.\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,
     //        pToAcct,    to_acct_name,    pToAgent,
     //        pServerNym, pCron.
 
     OTParty* pFromParty = pFromAgent->GetParty();
     OTParty* pToParty = pToAgent->GetParty();
 
     if (nullptr == pFromParty) {
         otErr << "OTSmartContract::MoveAcctFunds: error: Party pointer nullptr "
                  "on "
                  "authorized agent (" << pFromAcct->GetAgentName()
               << ") for from_acct (" << from_acct_name << ").\n";
         return false;
     }
     if (nullptr == pToParty) {
         otErr << "OTSmartContract::MoveAcctFunds: error: Party pointer nullptr "
                  "on "
                  "authorized agent (" << pToAcct->GetAgentName()
               << ") for to_acct (" << to_acct_name << ").\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,    pFromParty,
     //        pToAcct,    to_acct_name,    pToAgent,    pToParty,
     //        pServerNym, pCron.
 
     // Done: I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY SINGLE
     // TIME THE SCRIPT
     // CALLS MOVE FUNDS.  Maybe that's good, but since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     // FINAL DECISION: Redundant.  See comment in
     // OTSmartContract::StashAcctFunds()
     //
     // A party might have many agents who are only voting groups, and cannot
     // actually sign for things
     // the way that nyms can. But at least ONE of those agents IS a Nym --
     // because there must have been
     // an authorizing agent who initially signed to accept the agreement, and
     // who fronted the opening
     // transaction number that activated it.
     //
     // Similarly, the authorized agent for any given party's account (each
     // account has its own authorized
     // agent) MUST be an active agent (an active agent is one with a
     // Nym--whether that Nym is representing
     // himself as the party, or whether representing some entity as an employee
     // in a role). Why MUST the
     // authorized agent be an active agent? Because when funds are moved, that
     // Nym must be loaded since
     // the account must show that Nym as a legal owner/agent. The MoveFunds will
     // cause a paymentReceipt to
     // drop into the Inbox for the relevant asset accounts, and that
     // paymentReceipt can ONLY be accepted
     // by that same Nym, who must use a transaction # that he signed for
     // previously and received through
     // his nymbox. There is actually no justification at all to take funds from
     // that account, since the
     // new balance has not yet been signed, UNLESS THE PAYMENTRECEIPT CONTAINS A
     // VALID, SIGNED AUTHORIZATION
     // FROM THE ACCOUNT HOLDER. *That* is why the authorizing agent must either
     // be the Party's Owner himself
     // (representing himself as an agent, which most will do) in which case he
     // will appear as the valid
     // owner of the account, OR he MUST be a Nym working in a Valid Role for an
     // Entity, where said Entity is
     // the valid owner on the account in question. Either OT, it will be
     // possible in OT for him to sign for
     // the paymentReceipts when they come in, and impossible for him to escape
     // liability for them.
     // (That's the idea anyway.)
     //
     // Since we know that the Authorized Agent for an account must be an ACTIVE
     // agent (one way or the other)
     // then we can error out here if he's not.  We can then pass in his Nym ID
     //
 
     OTIdentifier theFromAgentID, theToAgentID;
     const bool bFromAgentID = pFromAgent->GetSignerID(theFromAgentID);
     const bool bToAgentID = pToAgent->GetSignerID(theToAgentID);
 
     if (!bFromAgentID) {
         otErr << "OTSmartContract::MoveAcctFunds: Failed to find FromAgent's "
                  "Signer ID: " << pFromAgent->GetName() << " \n";
         return false;
     }
     if (!bToAgentID) {
         otErr << "OTSmartContract::MoveAcctFunds: Failed to find ToAgent's "
                  "Signer ID: " << pToAgent->GetName() << " \n";
         return false;
     }
 
     if (!pFromAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::MoveAcctFunds: Error: FromAcct has empty "
                  "AcctID: " << from_acct_name << " \n";
         return false;
     }
     if (!pToAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::MoveAcctFunds: Error: ToAcct has empty "
                  "AcctID: " << to_acct_name << " \n";
         return false;
     }
 
     const OTIdentifier theFromAcctID(pFromAcct->GetAcctID()),
         theToAcctID(pToAcct->GetAcctID());
     //
     // BELOW THIS POINT, theFromAcctID, theFromAgentID, theToAcctID, and
     // theToAgentID are all available.
 
     // WE SET THESE HERE SO THE RECEIPT SHOWS, SUCCESS OR FAIL,
     // WHO THE INTENDED SENDER / RECIPIENT ARE FOR THAT RECEIPT.
     //
     ReleaseLastSenderRecipientIDs();
 
     theFromAgentID.GetString(m_strLastSenderUser); // This is the last User ID
                                                    // of a party who SENT money.
     theFromAcctID.GetString(m_strLastSenderAcct); // This is the last Acct ID of
                                                   // a party who SENT money.
     theToAgentID.GetString(m_strLastRecipientUser); // This is the last User ID
                                                     // of a party who RECEIVED
                                                     // money.
     theToAcctID.GetString(m_strLastRecipientAcct);  // This is the last Acct ID
                                                     // of a party who RECEIVED
                                                     // money.
 
     mapOfNyms map_Nyms_Already_Loaded;
     RetrieveNymPointers(map_Nyms_Already_Loaded);
 
     bool bMoved = MoveFunds(map_Nyms_Already_Loaded, lAmount, theFromAcctID,
                             theFromAgentID, theToAcctID, theToAgentID);
     if (!bMoved) {
         otOut << "OTSmartContract::MoveAcctFunds: Failed in call to MoveFunds. "
                  "from_acct: " << from_acct_name
               << "   to_acct: " << to_acct_name << "\n";
         return false;
     }
 
     return true;
 }

void opentxs::OTSmartContract::onActivate ( )

protectedvirtual

Reimplemented from opentxs::OTCronItem.

Definition at line 1156 of file OTSmartContract.cpp.

 {
     OT_ASSERT(nullptr != GetCron());
 
     if (GetCron()->GetTransactionCount() < 1) {
         otOut << __FUNCTION__ << ": Failed to process smart contract "
               << GetTransactionNum() << ": Out of transaction numbers for "
                                         "receipts! Flagging for removal.\n";
         FlagForRemoval();
         return;
     }
 
     // Execute the scripts (clauses) that have registered for this hook.
 
     const std::string str_HookName(SMARTCONTRACT_HOOK_ON_ACTIVATE);
     mapOfClauses theMatchingClauses;
 
     if (GetHooks(str_HookName, theMatchingClauses)) {
         otOut << "Cron: Processing smart contract clauses for hook: "
               << SMARTCONTRACT_HOOK_ON_ACTIVATE << " \n";
 
         ExecuteClauses(
             theMatchingClauses); // <============================================
     }
 }

void opentxs::OTSmartContract::onFinalReceipt	(	OTCronItem &	theOrigCronItem,
		const int64_t &	lNewTransactionNumber,
		OTPseudonym &	theOriginator,
		OTPseudonym *	pRemover
	)

protectedvirtual

Reimplemented from opentxs::OTCronItem.

Definition at line 3377 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     const OTString strServerID(GetServerID());
 
     // The finalReceipt Item's ATTACHMENT contains the UPDATED Cron Item.
     // (With the SERVER's signature on it!)
     //
     OTString strUpdatedCronItem(*this);
     OTString* pstrAttachment = &strUpdatedCronItem;
 
     const OTString strOrigCronItem(theOrigCronItem);
 
     // IF server is originator and/or remover then swap it in for it/them so I
     // don't load it twice.
     // (already handled before this function is called.)
 
     // THIS FUNCTION:
     //
     //
     // LOOP through all parties.
     // For each party:
     // If party is server or originator or ActingNym, etc then set pointer
     // appropriately for that party.
     // Find opening and closing numbers for that party.
     // Drop finalReceipt to Inboxes for each asset account, using closing
     // numbers.
     // Drop finalReceipt to Nymbox for that party, using opening number.
     //
     // A similar process should happen whenever ANY contract action occurs. (Not
     // just finalReceipt)
     // We loop through all the parties and give them a receipt in the relevant
     // accounts.
     // And perhaps all notices should be numbered (similar to request number) so
     // that
     // people can prove which notices they have received.
     // Receipts are given based on?
     // The asset accounts that are CHANGED should definitely get an
     // agreementReceipt for the
     // balance change.  + All Nymboxes should receive a notice at that time.
     // They should receive
     // additional notice for any change in any variable as well. Maybe let
     // parties register for
     // various notices.
     // What about if a clause processes, but no asset accounts are changed, (no
     // inbox notice)
     // and no other variables are changed (no nymbox notices at all...) In that
     // case,
     // no other receipts are dropped, right? There will be some standard by
     // which DIRTY flags
     // are set onto the various parties and asset accounts, and then notices
     // will be sent based
     // upon those.
     //
     // For those, instead of:
     // "theOriginator" (GetSenderUserID()) and "pRemover" and pRecipient,
     //
     // We would have:
     // "theOriginator" (GetSenderUserID()) and "pActingNym" and pParty /
     // pPartyNym (for Party[0..n])
     //
     // Just like here:
     //
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "Unexpected nullptr pointer in party map.");
 
         // The Nym who is actively requesting to remove a cron item will be
         // passed in as pActingNym.
         // However, sometimes there is no Nym... perhaps it just expired and
         // pActingNym is nullptr.
         // The originating Nym (if different than pActingNym) is loaded up.
         // Otherwise theOriginator
         // just points to *pActingNym also.
         //
         OTPseudonym* pPartyNym = nullptr;
         std::unique_ptr<OTPseudonym> thePartyNymAngel;
 
         // See if the serverNym is an agent on this party.
         //
         if (pParty->HasAuthorizingAgent(*pServerNym)) // This should set the
                                                       // temp nym ptr inside the
                                                       // agent also, so I don't
                                                       // have to search twice.
         {
             pPartyNym = pServerNym; // Just in case the party's agent's Nym is
                                     // also the server Nym.
         }
         //
         // If pActingNym is NOT nullptr, and HE is an agent on this party...
         // then set the pointer accordingly.
         //
         else if ((nullptr != pActingNym) &&
                  pParty->HasAuthorizingAgent(*pActingNym)) // There is only one
                                                            // authorizing agent
                                                            // per party.
         {
             pPartyNym = pActingNym; // <======== now both pointers are set (to
                                     // same Nym). DONE!
         }
 
         // Still not found?
         if (nullptr == pPartyNym) {
             // Of all of a party's Agents, the "authorizing agent" is the one
             // who originally activated
             // the agreement for this party (and fronted the opening trans#.) If
             // we're ending the agreement,
             // Then we need to free that number from him. (Even if he was since
             // fired from the role!)
             //
             // Perhaps need to figure out if the Role itself stores the opening
             // number, and if so, treat
             // the Nym's signature as the role's, even though the Nym himself
             // doesn't actually store the #.
             // Anyway, I'll deal with that when I get to entities and roles.
             // Todo.
             //
             pPartyNym = pParty->LoadAuthorizingAgentNym(*pServerNym);
             thePartyNymAngel.reset(pPartyNym);
         }
 
         // Every party SHOULD have an authorizing agent (otherwise how did that
         // party sign on in the first
         // place??) So this should never fail. That's why there's an error
         // message below if it's still nullptr.
         //
 
         if ((nullptr != pPartyNym) && (pParty->GetOpeningTransNo() > 0) &&
             // Todo: once entities and roles are added, Parties should have
             // their OWN "verify" function
             // (Instead of me having to directly find the Nym and verify it
             // myself.)
             //
             pPartyNym->VerifyIssuedNum(
                 strServerID,
                 pParty->GetOpeningTransNo()) // <=====================
             ) {
             // The Nym (server side) stores a list of all opening and closing
             // cron #s.
             // So when the number is released from the Nym, we also take it off
             // that list.
             //
             std::set<int64_t>& theIDSet = pPartyNym->GetSetOpenCronItems();
             theIDSet.erase(pParty->GetOpeningTransNo());
 
             // the RemoveIssued call means the original transaction# (to find
             // this cron item on cron) is now CLOSED.
             // But the Transaction itself is still OPEN. How? Because the
             // CLOSING number is still signed out.
             // The closing number is also USED, since the smart contract was
             // initially activated, but it remains
             // ISSUED, until the final receipt itself is accepted during a
             // process inbox.
             //
             pPartyNym->RemoveIssuedNum(*pServerNym, strServerID,
                                        pParty->GetOpeningTransNo(),
                                        false); // bSave=false
             pPartyNym->SaveSignedNymfile(*pServerNym);
         }
         else {
             otErr
                 << "OTSmartContract::" << __FUNCTION__
                 << ": Failed verifying "
                    "pPartyNym != nullptr && pParty->GetOpeningTransNo() > 0 && "
                    " "
                    "pPartyNym->VerifyIssuedNum(pParty->GetOpeningTransNo())\n";
         }
 
         // NOTIFY ALL AGENTS for this party, with a copy of the finalReceipt in
         // their Nymbox.
         //
         // TOdo: if the above block fails, should I still go dropping these
         // receipts?
         //
         if ((false ==
              pParty->DropFinalReceiptToNymboxes(
                  lNewTransactionNumber, // new, owned by the server.
                                         // For notices.
                  strOrigCronItem, nullptr, pstrAttachment, pPartyNym))) {
             otErr << "OTSmartContract::" << __FUNCTION__
                   << ": Failure dropping final receipt into nymbox for even a "
                      "single agent.\n";
         }
 
         // So the same Nym doesn't get loaded twice on accident. (We pass in
         // pointers to nyms that
         // are already loaded, so the called function can use them instead of
         // loading, if it came
         // to that.)
         //
         //        typedef std::map    <std::string, OTPseudonym *>    mapOfNyms;
 
         mapOfNyms nym_map;
 
         // pServerNym
         {
             const OTIdentifier theServerNymID(*pServerNym);
             const OTString strServerNymID(theServerNymID);
 
             if (nym_map.end() == nym_map.find(strServerNymID.Get()))
                 nym_map.insert(std::pair<std::string, OTPseudonym*>(
                     strServerNymID.Get(), pServerNym));
         }
 
         // theOriginator
         {
             const OTIdentifier theOriginatorNymID(theOriginator);
             const OTString strOriginatorNymID(theOriginatorNymID);
 
             if (nym_map.end() == nym_map.find(strOriginatorNymID.Get()))
                 nym_map.insert(std::pair<std::string, OTPseudonym*>(
                     strOriginatorNymID.Get(), &theOriginator));
         }
 
         if (nullptr != pActingNym) {
             const OTIdentifier theActingNymID(*pActingNym);
             const OTString strActingNymID(theActingNymID);
 
             if (nym_map.end() == nym_map.find(strActingNymID.Get()))
                 nym_map.insert(std::pair<std::string, OTPseudonym*>(
                     strActingNymID.Get(), pActingNym));
         }
 
         if (nullptr != pPartyNym) {
             const OTIdentifier thePartyNymID(*pPartyNym);
             const OTString strPartyNymID(thePartyNymID);
 
             if (nym_map.end() == nym_map.find(strPartyNymID.Get()))
                 nym_map.insert(std::pair<std::string, OTPseudonym*>(
                     strPartyNymID.Get(), pPartyNym));
         }
 
         // NOTIFY the agent for EACH ACCOUNT listed by this party,
         // with a copy of the finalReceipt in the Inbox for each asset acct.
         //
         // Also for each, if he has a Nym (HE SHOULD), and if
         // (CLOSING_NUMBER_HERE > 0), then call:
         //
         // pNym->VerifyIssuedNum(strServerID, lClosingNumber)
         // (This happens in OTAgent::DropFinalReceipt, FYI.)
         //
 
         if (false ==
             pParty->DropFinalReceiptToInboxes(
                 &nym_map, // contains any Nyms who might already be
                           // loaded, mapped by ID.
                 strServerID, *pServerNym, lNewTransactionNumber,
                 strOrigCronItem, nullptr, pstrAttachment)) {
             otErr << "OTSmartContract::onFinalReceipt: Failure dropping final "
                      "receipt into all inboxes. (Missed at least one.)\n";
         }
 
         pParty->ClearTemporaryPointers();
     }
 }

void opentxs::OTSmartContract::onRemovalFromCron ( )

protectedvirtual

Reimplemented from opentxs::OTCronItem.

Definition at line 1141 of file OTSmartContract.cpp.

 {
     // Not much needed here.  Done, I guess.
 
     otErr << "FYI:  OTSmartContract::onRemovalFromCron was just called. \n";
 
     // Trigger a script maybe.
     // OR maybe it's too late for scripts.
     // I give myself an onRemoval() here in C++, but perhaps I cut
     // off the SCRIPTS after onFinalReceipt(). I think that's best.
 }

void opentxs::OTSmartContract::PrepareToActivate	(	const int64_t &	lOpeningTransNo,
		const int64_t &	lClosingTransNo,
		const OTIdentifier &	theUserID,
		const OTIdentifier &	theAcctID
	)

Definition at line 5589 of file OTSmartContract.cpp.

 {
     SetTransactionNum(lOpeningTransNo);
 
     ClearClosingNumbers(); // Just in case. Should be unnecessary, but you never
                            // know how people might screw around.
     AddClosingTransactionNo(lClosingTransNo);
 
     SetSenderUserID(theUserID); // This is the activator of the contract. (NOT
                                 // the actual "sender" of any single payment, in
                                 // the case of smart contracts anyway.)
     SetSenderAcctID(theAcctID); // This is an account provided by the activator
                                 // so a closing number and final receipt are
                                 // guaranteed for this smart contract.
 
     ReleaseLastSenderRecipientIDs(); // These should be blank starting out
                                      // anyway.
 
     // You shouldn't have any of these anyway; the server only creates
     // them after a smart contract is activated.
     //
     ReleaseStashes();
 }

bool opentxs::OTSmartContract::ProcessCron ( )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 3649 of file OTSmartContract.cpp.

 {
     OT_ASSERT(nullptr != GetCron());
 
     // Right now Cron is called 10 times per second.
     // I'm going to slow down all trades so they are once every
     // GetProcessInterval()
     // Todo: Create separate lists in Cron.  10*/sec list, 1/second list, 1 min
     // list, 1 hour, 1 day, 1 month.
     // That way I'm not looping through ALL cron items 10*/second, but only the
     // ones who are paying for those
     // kinds of resources. (Different lists will cost different server fees.)
     //
     if (GetLastProcessDate() > OT_TIME_ZERO) {
         // Default ProcessInternal is 1 second, but Trades will use 10 seconds,
         // and Payment
         // Plans will use an hour or day. Smart contracts are currently 30
         // seconds. (For testing.)
         //
         if (OTTimeGetTimeInterval(OTTimeGetCurrentTime(),
                                   GetLastProcessDate()) <= GetProcessInterval())
             return true;
     }
     // Keep a record of the last time this was processed.
     // (NOT saved to storage, only used while the software is running.)
     // (Thus no need to release signatures, sign contract, save contract, etc.)
     SetLastProcessDate(OTTimeGetCurrentTime());
 
     // END DATE --------------------------------
     // First call the parent's version (which this overrides) so it has
     // a chance to check its stuff.
     // Currently it calls IsExpired().
     //
     if (!ot_super::ProcessCron()) {
         otLog3 << "Cron job has expired.\n";
         return false; // It's expired or flagged for removal--remove it from
                       // Cron.
     }
 
     // START DATE --------------------------------
     // Okay, so it's not expired. But might not have reached START DATE yet...
     if (!VerifyCurrentDate())
         return true; // The Payment Plan is not yet valid, so we return. BUT, we
                      // also
     // return TRUE, so it will STAY on Cron until it BECOMES valid.
 
     // Make sure there are transaction numbers available in Cron.
     // (Can't do anything without those....)
     //
     if (GetCron()->GetTransactionCount() < 1) {
         otOut << "Failed to process smart contract: Cron is out of transaction "
                  "numbers!\n";
         return true;
     }
 
     // Make sure, if the script set a timer, that we don't process Cron until
     // that timer
     // is reached. (If the timer's not set, then we go ahead and process every
     // time.)
     //
     const time64_t& tNextProcessDate = GetNextProcessDate();
 
     if (tNextProcessDate > OT_TIME_ZERO) // IF there is a timer set (as to when
                                          // the next "onProcess" should
                                          // occur)...
     {
         if (OTTimeGetCurrentTime() <=
             tNextProcessDate) // AND if the current time has NOT YET reached
                               // that date (the date in the timer)...
         {
             // ...Then RETURN (since the timer hasn't popped yet)
             // But return TRUE, so that this cron item stays active for now.
             //
             return true;
         }
         else // else it HAS now reached the official timer date...
         {
             SetNextProcessDate(OT_TIME_ZERO); // Therefore timer has triggered,
                                               // so we will continue processing.
         } // We also reset timer to 0 again since it has now "binged".
     }     // Continuing on....
 
     // Execute the scripts (clauses) that have registered for this hook.
 
     const std::string str_HookName(SMARTCONTRACT_HOOK_ON_PROCESS);
     mapOfClauses theMatchingClauses;
 
     if (GetHooks(str_HookName, theMatchingClauses)) {
         otOut << "Cron: Processing smart contract clauses for hook: "
               << SMARTCONTRACT_HOOK_ON_PROCESS << " \n";
 
         ExecuteClauses(
             theMatchingClauses); // <============================================
     }
 
     if (IsFlaggedForRemoval()) {
         otLog3 << "OTSmartContract::ProcessCron: Removing smart contract from "
                   "cron processing...\n";
         return false; // false means "remove this cron item from cron"
     }
 
     return true;
 }

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

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 5617 of file OTSmartContract.cpp.

 {
     const OTString strNodeName(xml->getNodeName());
 
     int32_t nReturnVal = 0;
 
     // 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.
     //
     // OTSmartContract::ProcessXMLNode calls OTCronItem::ProcessXMLNode,
     // which calls OTScriptable... Meaning:
     //
     // NO NEED to explicitly load OTScriptable stuff here!
     //
     nReturnVal = ot_super::ProcessXMLNode(xml);
 
     if (0 != (nReturnVal)) {
         return nReturnVal;
     }
 
     if (strNodeName.Compare("smartContract")) {
         m_strVersion = xml->getAttributeValue("version");
 
         const OTString strServerID(xml->getAttributeValue("serverID"));
         const OTString strActivatorUserID(
             xml->getAttributeValue("activatorUserID"));
         const OTString strActivatorAcctID(
             xml->getAttributeValue("activatorAcctID"));
         const OTString strCanceled(xml->getAttributeValue("canceled"));
         const OTString strCancelerUserID(
             xml->getAttributeValue("cancelerUserID"));
 
         if (strServerID.Exists()) {
             const OTIdentifier SERVER_ID(strServerID);
             SetServerID(SERVER_ID);
         }
         if (strActivatorUserID.Exists()) {
             const OTIdentifier ACTIVATOR_USER_ID(strActivatorUserID);
             SetSenderUserID(ACTIVATOR_USER_ID);
         }
         if (strActivatorAcctID.Exists()) {
             const OTIdentifier ACTIVATOR_ACCT_ID(strActivatorAcctID);
             SetSenderAcctID(ACTIVATOR_ACCT_ID);
         }
 
         if (strCanceled.Exists() && strCanceled.Compare("true")) {
             m_bCanceled = true;
 
             if (strCancelerUserID.Exists())
                 m_pCancelerNymID->SetString(strCancelerUserID);
             // else log
         }
         else {
             m_bCanceled = false;
             m_pCancelerNymID->Release();
         }
 
         const OTString strTransNum = xml->getAttributeValue("transactionNum");
 
         SetTransactionNum(strTransNum.Exists() ? atol(strTransNum.Get()) : 0);
 
         const OTString str_valid_from = xml->getAttributeValue("validFrom");
         const OTString str_valid_to = xml->getAttributeValue("validTo");
         const OTString str_creation = xml->getAttributeValue("creationDate");
         const OTString str_next_process =
             xml->getAttributeValue("nextProcessDate");
 
         int64_t tValidFrom = str_valid_from.ToLong();
         int64_t tValidTo = str_valid_to.ToLong();
         int64_t tCreation = str_creation.ToLong();
         int64_t tNextProcess = str_next_process.ToLong();
 
         SetValidFrom(OTTimeGetTimeFromSeconds(tValidFrom));
         SetValidTo(OTTimeGetTimeFromSeconds(tValidTo));
         SetCreationDate(OTTimeGetTimeFromSeconds(tCreation));
         SetNextProcessDate(OTTimeGetTimeFromSeconds(tNextProcess));
 
         // These are stored for RECEIPTS, so if there is an inbox receipt with
         // an amount,
         // we will know who was sending and receiving.  If sender or receiver is
         // blank, that
         // means the source/destination was a STASH instead of an account. FYI.
         //
         m_strLastSenderUser = xml->getAttributeValue(
             "lastSenderUserID"); // Last User ID of a party who SENT money.
         m_strLastSenderAcct = xml->getAttributeValue(
             "lastSenderAcctID"); // Last Acct ID of a party who SENT money.
         m_strLastRecipientUser =
             xml->getAttributeValue("lastRecipientUserID"); // Last User ID of a
                                                            // party who RECEIVED
                                                            // money.
         m_strLastRecipientAcct =
             xml->getAttributeValue("lastRecipientAcctID"); // Last Acct ID of a
                                                            // party who RECEIVED
                                                            // money.
 
         otWarn << "\n\n Smartcontract. Transaction Number: "
                << m_lTransactionNum << "\n";
 
         otInfo << " Creation Date: " << tCreation
                << "   Valid From: " << tValidFrom << "\n Valid To: " << tValidTo
                << "\n"
                   " ServerID: " << strServerID
                << "\n"
                   " activatorUserID: " << strActivatorUserID << "\n ";
 
         nReturnVal = 1;
     }
     else if (strNodeName.Compare("accountList")) // the stash reserve account
                                                    // IDs.
     {
         const OTString strAcctType = xml->getAttributeValue("type");
         const OTString strAcctCount = xml->getAttributeValue("count");
 
         if ((-1) ==
             m_StashAccts.ReadFromXMLNode(xml, strAcctType, strAcctCount)) {
             otErr << "OTSmartContract::ProcessXMLNode: Error loading stash "
                      "accountList.\n";
             nReturnVal = (-1);
         }
         else
             nReturnVal = 1;
     }
     else if (strNodeName.Compare("stash")) // the actual stashes.
     {
         const OTString strStashName = xml->getAttributeValue("name");
         const OTString strItemCount = xml->getAttributeValue("count");
 
         const std::string str_stash_name = strStashName.Get();
         OTStash* pStash = new OTStash(str_stash_name);
         OT_ASSERT(nullptr != pStash);
 
         if ((-1) == pStash->ReadFromXMLNode(xml, strStashName, strItemCount)) {
             otErr << "OTSmartContract::ProcessXMLNode: Error loading stash: "
                   << strStashName << "\n";
             delete pStash;
             nReturnVal = (-1);
         }
         else {
             // Success
             //
             m_mapStashes.insert(
                 std::pair<std::string, OTStash*>(strStashName.Get(), pStash));
 
             nReturnVal = 1;
         }
     }
 
     return nReturnVal;
 }

void opentxs::OTSmartContract::RegisterOTNativeCallsWithScript ( OTScript & theScript )

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 859 of file OTSmartContract.cpp.

 {
     // CALL THE PARENT
     OTScriptable::RegisterOTNativeCallsWithScript(theScript);
 
 #ifdef OT_USE_SCRIPT_CHAI
     using namespace chaiscript;
 
     OTScriptChai* pScript = dynamic_cast<OTScriptChai*>(&theScript);
 
     if (nullptr != pScript) {
         OT_ASSERT(nullptr != pScript->chai)
 
         // OT NATIVE FUNCTIONS
         // (These functions can be called from INSIDE the scripted clauses.)
         //                                                                                        //
         // Parameters must match as described below. Return value will be as
         // described below.
         //
         //        pScript->chai->add(base_class<OTScriptable,
         // OTSmartContract>());
 
         pScript->chai->add(
             fun<OT_SM_RetBool_ThrStr>(&OTSmartContract::MoveAcctFundsStr, this),
             "move_funds");
 
         pScript->chai->add(fun(&OTSmartContract::StashAcctFunds, this),
                            "stash_funds");
         pScript->chai->add(fun(&OTSmartContract::UnstashAcctFunds, this),
                            "unstash_funds");
         pScript->chai->add(fun(&OTSmartContract::GetAcctBalance, this),
                            "get_acct_balance");
         pScript->chai->add(fun(&OTSmartContract::GetAssetTypeIDofAcct, this),
                            "get_acct_asset_type_id");
         pScript->chai->add(fun(&OTSmartContract::GetStashBalance, this),
                            "get_stash_balance");
         pScript->chai->add(fun(&OTSmartContract::SendNoticeToParty, this),
                            "send_notice");
         pScript->chai->add(fun(&OTSmartContract::SendANoticeToAllParties, this),
                            "send_notice_to_parties");
         pScript->chai->add(fun(&OTSmartContract::SetRemainingTimer, this),
                            "set_seconds_until_timer");
         pScript->chai->add(fun(&OTSmartContract::GetRemainingTimer, this),
                            "get_remaining_timer");
 
         pScript->chai->add(fun(&OTSmartContract::DeactivateSmartContract, this),
                            "deactivate_contract");
 
         // CALLBACKS
         // (Called by OT at key moments) todo security: What if these are
         // recursive? Need to lock down, put the smack down, on these smart
         // contracts.
         //
         // FYI:    pScript->chai->add(fun(&(OTScriptable::CanExecuteClause),
         // (*this)), "party_may_execute_clause");    // From OTScriptable (FYI)
         // param_party_name and param_clause_name will be available inside
         // script. Script must return bool.
         // FYI:    #define SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE
         // "callback_party_may_execute_clause"   <=== THE CALLBACK WITH THIS
         // NAME must be connected to a script clause, and then the clause will
         // trigger when the callback is needed.
 
         pScript->chai->add(fun(&OTSmartContract::CanCancelContract, this),
                            "party_may_cancel_contract"); // param_party_name
                                                          // will be available
                                                          // inside script.
                                                          // Script must return
                                                          // bool.
         // FYI:    #define SMARTCONTRACT_CALLBACK_PARTY_MAY_CANCEL
         // "callback_party_may_cancel_contract"  <=== THE CALLBACK WITH THIS
         // NAME must be connected to a script clause, and then the clause will
         // trigger when the callback is needed.
 
         // Callback USAGE:    Your clause, in your smart contract, may have
         // whatever name you want. (Within limits.)
         //                    There must be a callback entry in the smart
         // contract, linking your clause the the appropriate callback.
         //                    The CALLBACK ENTRY uses the names
         // "callback_party_may_execute_clause" and
         // "callback_party_may_cancel_contract".
         //                    If you want to call these from INSIDE YOUR SCRIPT,
         // then use the names "party_may_execute_clause" and
         // "party_may_cancel_contract".
 
         // HOOKS:
         //
         // Hooks are not native calls needing to be registered with the script.
         // (Like the above functions are.)
         // Rather, hooks are SCRIPT CLAUSES, that you have a CHOICE to provide
         // inside your SMART CONTRACT.
         // *IF* you have provided those clauses, then OT *WILL* call them, at
         // the appropriate times. (When
         // specific events occur.) Specifically, Hook entries must be in your
         // smartcontract, linking the below
         // standard hooks to your clauses.
         //
         // FYI:    #define SMARTCONTRACT_HOOK_ON_PROCESS        "cron_process"
         // // Called regularly in OTSmartContract::ProcessCron() based on
         // SMART_CONTRACT_PROCESS_INTERVAL.
         // FYI:    #define SMARTCONTRACT_HOOK_ON_ACTIVATE        "cron_activate"
         // // Done. This is called when the contract is first activated.
     }
     else
 #endif // OT_USE_SCRIPT_CHAI
     {
         otErr << "OTSmartContract::RegisterOTNativeCallsWithScript: Failed "
                  "dynamic casting OTScript to OTScriptChai \n";
     }
 
 } // void function

void opentxs::OTSmartContract::Release ( void )

virtual

Reimplemented from opentxs::OTCronItem.

Definition at line 5391 of file OTSmartContract.cpp.

 {
     Release_SmartContract();
 
     ot_super::Release(); // since I've overridden the base class, I call it
                          // now...
 
     // Then I call this to re-initialize everything
     InitSmartContract();
 }

void opentxs::OTSmartContract::Release_SmartContract ( )

Definition at line 5385 of file OTSmartContract.cpp.

 {
 
     ReleaseStashes();
 }

void opentxs::OTSmartContract::ReleaseLastSenderRecipientIDs ( )

protected

Definition at line 5571 of file OTSmartContract.cpp.

 {
     m_strLastSenderUser.Release();    // This is the last User ID of a party who
                                       // SENT money.
     m_strLastSenderAcct.Release();    // This is the last Acct ID of a party who
                                       // SENT money.
     m_strLastRecipientUser.Release(); // This is the last User ID of a party who
                                       // RECEIVED money.
     m_strLastRecipientAcct.Release(); // This is the last Acct ID of a party who
                                       // RECEIVED money.
 }

void opentxs::OTSmartContract::ReleaseStashes ( )

Definition at line 5369 of file OTSmartContract.cpp.

 {
 
     while (!m_mapStashes.empty()) {
         OTStash* pStash = m_mapStashes.begin()->second;
         OT_ASSERT(nullptr != pStash);
 
         delete pStash;
         pStash = nullptr;
 
         m_mapStashes.erase(m_mapStashes.begin());
     }
 
     m_StashAccts.Release();
 }

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

virtual

Reimplemented from opentxs::OTInstrument.

Definition at line 5770 of file OTSmartContract.cpp.

 {
     return true;
 }

bool opentxs::OTSmartContract::SendANoticeToAllParties ( )

Definition at line 1659 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
     //
 
     const int64_t lNewTransactionNumber = pCron->GetNextTransactionNumber();
     bool bDroppedNotice = false;
 
     //    OT_ASSERT(lNewTransactionNumber > 0); // this can be my reminder.
     if (0 == lNewTransactionNumber) {
         otErr << __FUNCTION__ << ": ** ERROR: Notice not sent to parties, "
                                  "since no transaction numbers were "
                                  "available!\n";
     }
     else {
         ReleaseSignatures();
         SignContract(*pServerNym);
         SaveContract();
 
         const OTString strReference(*this);
         bDroppedNotice = SendNoticeToAllParties(
             true, // bSuccessMsg=true
             *pServerNym, GetServerID(), lNewTransactionNumber,
             // GetTransactionNum(), // each party has its own opening number.
             strReference); // pstrNote and pstrAttachment aren't used in this
                            // case.
 
         otOut << __FUNCTION__
               << ": Dropping notifications into all parties' nymboxes: "
               << (bDroppedNotice ? "Success" : "Failure") << "\n";
     }
 
     return bDroppedNotice;
 }

bool opentxs::OTSmartContract::SendNoticeToParty ( std::string party_name )

Definition at line 1702 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
 
     OTParty* pParty = GetParty(party_name);
 
     if (nullptr == pParty) {
         otOut << __FUNCTION__ << ": Unable to find this party: " << party_name
               << "\n";
         return false;
     }
     // Below this point, pParty is good.
 
     // ...This WILL check to see if pParty has its Opening number verified as
     // issued.
     // (If the opening number is > 0 then VerifyPartyAuthorization() is smart
     // enough to verify it.)
     //
     // To KNOW that a party has the right to even ASK the script to cancel a
     // contract, MEANS that
     // (1) The party is listed as a party on the contract. (2) The party's copy
     // of that contract
     // is signed by the authorizing agent for that party. and (3) The opening
     // transaction number for
     // that party is verified as issued for authorizing agent. (2 and 3 are both
     // performed at the same
     // time, in VerifyPartyAuthorization(), since the agent may need to be
     // loaded in order to verify
     // them.) 1 is already done by this point, as it's performed above.
     //
     // Done: notice this code appears in CanCancelContract() (this function) as
     // well as
     // OTScriptable::CanExecuteClause.
     // Therefore I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY
     // SINGLE TIME THE SCRIPT
     // CALLS ANY CLAUSE OR OT NATIVE FUNCTION.  Since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     // Also todo:  Need to implement MOVE CONSTRUCTORS and MOVE COPY
     // CONSTRUCTORS all over the place,
     // once I'm sure C++0x build environments are available for all of the
     // various OT platforms. That should
     // be another great performance boost!
     //
     //    FINAL DECISION: See longer comment in
     // OTSmartContract::StashAcctFunds(). This is redundant and was
     //  removed. It expects itself to be executed only upon the initial
     // activation of a smart contract, and
     //  not again after. (For example, it disallows stashes, which cannot exist
     // prior to activation.)
     //
     bool bDroppedNotice = false;
     const int64_t lNewTransactionNumber = pCron->GetNextTransactionNumber();
 
     //    OT_ASSERT(lNewTransactionNumber > 0); // this can be my reminder.
     if (0 == lNewTransactionNumber) {
         otErr << __FUNCTION__ << ": ** ERROR: Notice not sent to party, since "
                                  "no transaction numbers were available!\n";
     }
     else {
         ReleaseSignatures();
         SignContract(*pServerNym);
         SaveContract();
 
         const OTString strReference(*this);
 
         bDroppedNotice = pParty->SendNoticeToParty(
             true, // bSuccessMsg=true. True in general means "success" and false
                   // means "failure."
             *pServerNym, GetServerID(), lNewTransactionNumber,
             // GetTransactionNum(), // each party has its own opening trans #
             // and supplies it internally.
             strReference);
 
         otOut << __FUNCTION__ << ": "
               << (bDroppedNotice ? "Success" : "Failure")
               << " dropping notification into party's nymbox: "
               << pParty->GetPartyName() << "\n";
     }
 
     return bDroppedNotice;
 }

void opentxs::OTSmartContract::SetDisplayLabel ( const std::string * pstrLabel = nullptr )

virtual

Reimplemented from opentxs::OTScriptable.

Definition at line 3754 of file OTSmartContract.cpp.

 {
     m_strLabel.Format("smartcontract trans# %lld, clause: %s",
                       GetTransactionNum(),
                       (nullptr != pstrLabel) ? pstrLabel->c_str() : "");
 }

void opentxs::OTSmartContract::SetNextProcessDate ( const time64_t & tNEXT_DATE )

inlineprotected

Definition at line 228 of file OTSmartContract.hpp.

     {
         m_tNextProcessDate = tNEXT_DATE;
     }

void opentxs::OTSmartContract::SetRemainingTimer ( std::string str_seconds_from_now )

Definition at line 1102 of file OTSmartContract.cpp.

 {
     if (str_seconds_from_now.size() <= 0) // string length...
     {
         otOut << "OTSmartContract::" << __FUNCTION__
               << ": blank input (str_seconds_from_now).\n";
     }
     else {
         const int64_t tPlus = OTString::StringToLong(str_seconds_from_now);
 
         if (tPlus > 0)
             SetNextProcessDate(
                 OTTimeAddTimeInterval(OTTimeGetCurrentTime(), tPlus));
         else
             SetNextProcessDate(OT_TIME_ZERO); // This way, you can deactivate
                                               // the timer, by setting the next
                                               // process date to 0.
     }
 }

bool opentxs::OTSmartContract::SetServerIDIfEmpty ( const OTIdentifier & theID )

Definition at line 1015 of file OTSmartContract.cpp.

 {
     if (GetServerID().IsEmpty()) {
         SetServerID(theID);
         return true;
     }
     return false;
 }

bool opentxs::OTSmartContract::StashAcctFunds	(	std::string	from_acct_name,
		std::string	to_stash_name,
		std::string	str_Amount
	)

Definition at line 1819 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
 
     if (str_Amount.size() < 1) {
         otOut << "OTSmartContract::StashAcctFunds: Error: empty amount.\n";
         return false;
     }
 
     const int64_t lAmount = atol(str_Amount.c_str());
 
     if (lAmount <= 0) {
         otOut << "OTSmartContract::StashAcctFunds: Error: lAmount cannot be 0 "
                  "or <0. (Value passed in was " << lAmount << ".)\n";
         return false;
     }
 
     if (from_acct_name.size() <= 0) {
         otErr << "OTSmartContract::StashAcctFunds: error: from_acct_name is "
                  "non-existent.\n";
         return false;
     }
     if (to_stash_name.size() <= 0) {
         otErr << "OTSmartContract::StashAcctFunds: error: to_stash_name is "
                  "non-existent.\n";
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        from_acct_name,
     //        to_stash_name,
     //        pServerNym, pCron.
     //
 
     OTPartyAccount* pFromAcct = GetPartyAccount(from_acct_name);
     OTStash* pStash = GetStash(to_stash_name); // This ALWAYS succeeds.
                                                // (It will OT_ASSERT() if
                                                // failure.)
 
     if (nullptr == pFromAcct) {
         otOut << "OTSmartContract::StashAcctFunds: error: from_acct ("
               << from_acct_name << ") not found on any party.\n";
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,
     //        pStash,        to_stash_name,
     //        pServerNym, pCron.
     //
 
     OTAgent* pFromAgent =
         pFromAcct->GetAuthorizedAgent(); // This searches the account's party
                                          // for the account's authorized agent.
     // (That way it's impossible to get an agent for any other party.)
 
     if (nullptr == pFromAgent) {
         otOut << "OTSmartContract::StashAcctFunds: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") not found for from_acct ("
               << from_acct_name << ") on acct's party.\n";
         return false;
     }
 
     if (!pFromAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::StashAcctFunds: error: authorized agent ("
               << pFromAcct->GetAgentName() << ") for from_acct ("
               << from_acct_name << ") is not an active agent.\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,
     //        pStash,        to_stash_name,
     //        pServerNym, pCron.
 
     OTParty* pFromParty = pFromAgent->GetParty();
 
     if (nullptr == pFromParty) {
         otErr
             << "OTSmartContract::StashAcctFunds: error: Party pointer nullptr "
                "on authorized agent (" << pFromAcct->GetAgentName()
             << ") for from_acct (" << from_acct_name << ").\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pFromAcct,    from_acct_name,    pFromAgent,    pFromParty,
     //        pStash,        to_stash_name,
     //        pServerNym, pCron.
 
     // DONE: Problem: I can see that THIS VERIFICATION CODE WILL GET CALLED
     // EVERY SINGLE TIME THE SCRIPT
     // CALLS MOVE FUNDS.  Maybe that's good, but since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     //
     //    const OTString strServerID(GetServerID());
 
     //    mapOfNyms    map_Nyms_Already_Loaded;
     //    RetrieveNymPointers(map_Nyms_Already_Loaded);
 
     // FINAL DECISION: Since this verification is already done for the smart
     // contract to have been activated onto
     // cron in the first place, it is redundant to have it here.
     // Furthermore, what if a single clause calls stash_funds 30 times in a
     // loop? Does that mean we need to verify
     // all the parties and accounts 30 times, every single time we call that
     // clause? CLearly such is redundant, and
     // would be targeted in any optimization effort.
     // Furthermore, since actually running the software, it's become apparent
     // that it is no longer even appropriate
     // to Verify anymore, since stashes can exist after a smartcontract has been
     // activated, while this function
     // specifically verifies that no stashes exist, since it presumes that it is
     // only called during the initial
     // activation of the cron item, when no stashes SHOULD exist (since they are
     // only created after activation, by
     // the server itself, at the behest of the scripts.)
 
     // A party might have many agents who are only voting groups, and cannot
     // actually sign for things
     // the way that nyms can. But at least ONE of those agents IS a Nym --
     // because there must have been
     // an authorizing agent who initially signed to accept the agreement, and
     // who fronted the opening
     // transaction number that activated it.
     //
     // Similarly, the authorized agent for any given party's account (each
     // account has its own authorized
     // agent) MUST be an active agent (an active agent is one with a
     // Nym--whether that Nym is representing
     // himself as the party, or whether representing some entity as an employee
     // in a role). Why MUST the
     // authorized agent be an active agent? Because when funds are moved, that
     // Nym must be loaded since
     // the account must show that Nym as a legal owner/agent. The MoveFunds will
     // cause a paymentReceipt to
     // drop into the Inbox for the relevant asset accounts, and that
     // paymentReceipt can ONLY be accepted
     // by that same Nym, who must use a transaction # that he signed for
     // previously and received through
     // his nymbox. There is actually no justification at all to take funds from
     // that account, since the
     // new balance has not yet been signed, UNLESS THE PAYMENTRECEIPT CONTAINS A
     // VALID, SIGNED AUTHORIZATION
     // FROM THE ACCOUNT HOLDER. *That* is why the authorizing agent must either
     // be the Party's Owner himself
     // (representing himself as an agent, which most will do) in which case he
     // will appear as the valid
     // owner of the account, OR he MUST be a Nym working in a Valid Role for an
     // Entity, where said Entity is
     // the valid owner on the account in question. Either OT, it will be
     // possible in OT for him to sign for
     // the paymentReceipts when they come in, and impossible for him to escape
     // liability for them.
     // (That's the idea anyway.)
     //
     // Since we know that the Authorized Agent for an account must be an ACTIVE
     // agent (one way or the other)
     // then we can error out here if he's not.  We can then pass in his Nym ID.
     //
 
     OTIdentifier theFromAgentID;
     const bool bFromAgentID = pFromAgent->GetSignerID(theFromAgentID);
 
     if (!bFromAgentID) {
         otErr << "OTSmartContract::StashAcctFunds: Failed to find FromAgent's "
                  "Signer ID: " << pFromAgent->GetName() << " \n";
         return false;
     }
 
     if (!pFromAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::StashAcctFunds: Error: FromAcct has empty "
                  "AcctID: " << from_acct_name << " \n";
         return false;
     }
 
     const OTIdentifier theFromAcctID(pFromAcct->GetAcctID());
     //
     // BELOW THIS POINT, theFromAcctID and theFromAgentID available.
 
     // WE SET THESE HERE SO THE RECEIPT SHOWS, SUCCESS OR FAIL,
     // WHO THE INTENDED SENDER / RECIPIENT ARE FOR THAT RECEIPT.
     //
     ReleaseLastSenderRecipientIDs();
 
     theFromAgentID.GetString(m_strLastSenderUser); // This is the last User ID
                                                    // of a party who SENT money.
     theFromAcctID.GetString(m_strLastSenderAcct); // This is the last Acct ID of
                                                   // a party who SENT money.
     //    theToAgentID.GetString(m_strLastRecipientUser);    // This is the last
     // User ID of a party who RECEIVED money.
     //    theToAcctID.GetString(m_strLastRecipientAcct);    // This is the last
     // Acct ID of a party who RECEIVED money.
     // Above: the ToAgent and ToAcct are commented out,
     // since the funds are going into a stash.
 
     mapOfNyms map_Nyms_Already_Loaded;
     RetrieveNymPointers(map_Nyms_Already_Loaded);
 
     bool bMoved = StashFunds(map_Nyms_Already_Loaded, lAmount, theFromAcctID,
                              theFromAgentID, *pStash);
     if (!bMoved) {
         otOut << "OTSmartContract::StashAcctFunds: Failed in final call. "
                  "Values: from_acct: " << from_acct_name
               << ", to_stash: " << to_stash_name << ", lAmount: " << lAmount
               << ". \n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTSmartContract::StashFunds	(	const mapOfNyms &	map_NymsAlreadyLoaded,
		const int64_t &	lAmount,
		const OTIdentifier &	PARTY_ACCT_ID,
		const OTIdentifier &	PARTY_USER_ID,
		OTStash &	theStash
	)

Definition at line 2291 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     if (0 == lAmount) {
         otOut << "OTSmartContract::StashFunds: a zero amount is not allowed.\n";
         return false;
     }
 
     const OTIdentifier SERVER_ID(pCron->GetServerID());
     const OTIdentifier SERVER_USER_ID(*pServerNym);
 
     // Load up the party's account and get the asset type, so we know which
     // stash to get off the stash.
     //
     OTAccount* pPartyAssetAcct =
         OTAccount::LoadExistingAccount(PARTY_ACCT_ID, SERVER_ID);
 
     if (nullptr == pPartyAssetAcct) {
         otOut << "OTSmartContract::StashFunds: ERROR verifying existence of "
                  "source account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return false;
     }
     else if (!pPartyAssetAcct->VerifySignature(*pServerNym)) {
         otOut << "OTSmartContract::StashFunds: ERROR failed to verify the "
                  "server's signature on the party's account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return false;
     }
     else if (!pPartyAssetAcct->VerifyOwnerByID(PARTY_USER_ID)) {
         otOut << "OTSmartContract::StashFunds: ERROR failed to verify party "
                  "user ownership of party account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return false;
     }
     // Past this point we know pPartyAssetAcct is good and will clean itself up.
     std::unique_ptr<OTAccount> theSourceAcctSmrtPtr(pPartyAssetAcct);
 
     //
     // There could be many stashes, each with a name. (One was passed in
     // here...)
     // And inside each one is a stash for each asset type. So let's get the one
     // for the asset type matching the party's account.
     //
     const OTString strAssetTypeID(pPartyAssetAcct->GetAssetTypeID());
     const std::string str_asset_type_id = strAssetTypeID.Get();
 
     OTStashItem* pStashItem = theStash.GetStash(str_asset_type_id);
     OT_ASSERT(nullptr !=
               pStashItem); // should never happen. Creates if non-existent.
 
     // Below this point, pStashItem is good, and has the right asset_type_id.
 
     //
     const bool bUnstashing =
         (lAmount < 0); // If the amount is negative, then we're UNSTASHING.
     const int64_t lAbsoluteAmount =
         bUnstashing
             ? (lAmount * (-1))
             : lAmount; // NEGATIVE AMOUNT SHOULD BEHAVE AS "UNSTASH FUNDS" !!
 
     // Normally if you stash 10 clams, then your account is -10 clams, and your
     // stash is +10 clams.
     // Therefore if you unstash 5 gg, then your gg acct is +5 grams and your
     // stash is -5 grams.
     //
     // Thus if lAmount is > 0, as normal, that amount should be DEBITED from the
     // Party Acct, and CREDITED to the Stash Acct.
     // Whereas if lAmount were < 0, then that amount should be DEBITED from the
     // Stash Acct, and CREDITED to the Party Acct.
 
     // Below this point, lAbsoluteAmount is always a positive number.
     // Whereas if lAmount < 0, that means we are doing an UNSTASH in this
     // function.
     //
 
     // Whether the funds are coming from the party's acct, or from the stash,
     // WHEREVER they
     // are coming from, is that source LARGE enough to accommodate the amount
     // we're trying to move?
     //
 
     const int64_t lPartyAssetBalance = pPartyAssetAcct->GetBalance();
     const int64_t lStashItemAmount = pStashItem->GetAmount();
 
     const int64_t lSourceAmount =
         bUnstashing ? lStashItemAmount : lPartyAssetBalance;
 
     // If the source, minus amount, is less than 0, then it CANNOT accommodate
     // the action.
     //
     if ((lSourceAmount - lAbsoluteAmount) < 0) {
         otOut << "OTSmartContract::StashFunds: Not enough funds available in "
                  "the source to accommodate this action.\n";
         return false;
     }
 
     bool bWasAcctCreated = false; // GetOrCreateAccount() will verifyContractID
                                   // and verifySignature on the account
                                   // internally.
     std::shared_ptr<OTAccount> pStashAccount = m_StashAccts.GetOrCreateAccount(
         *pServerNym, SERVER_USER_ID, pPartyAssetAcct->GetAssetTypeID(),
         SERVER_ID, bWasAcctCreated, GetTransactionNum());
 
     if (!pStashAccount) {
         OT_FAIL_MSG("ASSERT in OTSmartContract::StashFunds: returned nullptr "
                     "pointer (should never happen.)\n");
     }
 
     if (bWasAcctCreated) {
         OTString strAcctID;
         pStashAccount->GetIdentifier(strAcctID);
 
         otOut << "OTSmartContract::StashFunds: Successfully created stash "
                  "account ID: " << strAcctID
               << "\n (Stash acct has Asset Type ID: " << strAssetTypeID
               << ") \n";
 
         // Todo: Some kind of save here?
         // It's kind of unnecessary, since I've already verified that there's
         // enough funds at the source
         // to successfully do the transfer, AND I will already save at the end
         // of this call, since funds are
         // being moved.
     }
 
     if (!pStashAccount) {
         OT_FAIL_MSG("ASSERT in OTSmartContract::StashFunds: returned nullptr "
                     "pointer (should never happen.)\n");
     }
 
     // This code is similar to above, but it checks the stash ACCT itself
     // instead of the stash entry.
     //
     // Whether the funds are coming from the party's acct, or from the stash
     // acct, WHEREVER they
     // are coming from, is that source LARGE enough to accommodate the amount
     // we're trying to move?
     //
     const int64_t lSourceAmount2 = bUnstashing ? pStashAccount->GetBalance()
                                                : pPartyAssetAcct->GetBalance();
 
     // If the source, minus amount, is less than 0, then it CANNOT accommodate
     // the action.
     //
     if ((lSourceAmount2 - lAbsoluteAmount) < 0) {
         otOut << "OTSmartContract::StashFunds: Not enough funds available in "
                  "the stash acct to accommodate this action.\n";
         return false; // THIS SHOULD NEVER HAPPEN, SINCE WE ALREADY VERIFIED THE
                       // AMOUNT BEFORE LOADING THE ACCOUNT. FYI.
     }
 
     // Make sure they're not the same Account IDs ...
     // Otherwise we would have to take care not to load them twice, like with
     // the Nyms below.
     // (Instead I just disallow it entirely. After all, even if I DID allow the
     // account to transfer
     // to itself, there would be no difference in balance than disallowing it.)
     //
     const OTIdentifier STASH_ACCT_ID(pStashAccount->GetRealAccountID());
 
     if (PARTY_ACCT_ID == STASH_ACCT_ID) {
         otErr << "OTSmartContract::StashFunds: ERROR: both account IDs were "
                  "identical.\n";
         FlagForRemoval(); // Remove from Cron
         return false; // TODO: should have a "Validate Scripts" function that
                       // weeds this crap out before we even get here. (There are
                       // other examples...)
     }
 
     // SHOULD NEVER HAPPEN
     if (pPartyAssetAcct->GetAssetTypeID() != pStashAccount->GetAssetTypeID()) {
         otErr << "OTSmartContract::StashFunds: Aborted stash: Asset type ID "
                  "doesn't match. THIS SHOULD NEVER HAPPEN.\n";
         FlagForRemoval(); // Remove from Cron
         return false;
     }
 
     if (!pStashAccount->VerifyOwnerByID(SERVER_USER_ID)) {
         otErr << "OTSmartContract::StashFunds: Error: Somehow the stash "
                  "account isn't server-nym owned.\n";
         FlagForRemoval(); // Remove from Cron
         return false;
     }
     const OTIdentifier STASH_USER_ID(pStashAccount->GetUserID());
 
     bool bSuccess = false; // The return value.
 
     OTString strPartyUserID(PARTY_USER_ID), strStashUserID(STASH_USER_ID),
         strPartyAcctID(PARTY_ACCT_ID), strStashAcctID(STASH_ACCT_ID),
         strServerNymID(SERVER_USER_ID);
 
     // Need to load up the ORIGINAL VERSION OF THIS SMART CONTRACT
     // Will need to verify the party's signature, as well as attach a copy of it
     // to the receipt.
 
     // OTCronItem::LoadCronReceipt loads the original version with the user's
     // signature.
     // (Updated versions, as processing occurs, are signed by the server.)
     std::unique_ptr<OTCronItem> pOrigCronItem(
         OTCronItem::LoadCronReceipt(GetTransactionNum()));
 
     OT_ASSERT(nullptr != pOrigCronItem); // How am I processing it now if the
                                          // receipt wasn't saved in the first
                                          // place??
     // TODO: Decide global policy for handling situations where the hard drive
     // stops working, etc.
 
     // strOrigPlan is a String copy (a PGP-signed XML file, in string form) of
     // the original smart contract activation request...
     OTString strOrigPlan(*pOrigCronItem); // <====== Farther down in the code, I
                                           // attach this string to the receipts.
 
     // -------------- Make sure have both nyms loaded and checked out.
     // --------------------------------------------------
     // WARNING: The party's Nym could be also the Server Nym. But the Stash Nym
     // is ALWAYS the server.
     // In all of those different cases, I don't want to load the same file twice
     // and overwrite it with itself, losing
     // half of all my changes. I have to check all three IDs carefully and set
     // the pointers accordingly, and then operate
     // using the pointers from there.
 
     OTPseudonym thePartyNym;
 
     // Find out if party Nym is actually also the server nym.
     const bool bPartyNymIsServerNym =
         ((PARTY_USER_ID == SERVER_USER_ID) ? true : false);
 
     OTPseudonym* pPartyNym = nullptr;
     //    OTPseudonym * pStashNym            = pServerNym;
 
     const std::string str_party_id = strPartyUserID.Get();
     auto it_party = map_NymsAlreadyLoaded.find(str_party_id);
 
     if (map_NymsAlreadyLoaded.end() !=
         it_party) // found the party in list of Nyms that are already loaded.
     {
         pPartyNym = it_party->second;
         OT_ASSERT((nullptr != pPartyNym) &&
                   (pPartyNym->CompareID(PARTY_USER_ID)));
     }
 
     // Figure out if party Nym is also Server Nym.
     if (bPartyNymIsServerNym) {
         // If the First Nym is the server, then just point to that.
         pPartyNym = pServerNym;
     }
     else if (nullptr == pPartyNym) // Else load the First Nym from storage, if
                                      // still not found.
     {
         thePartyNym.SetIdentifier(PARTY_USER_ID); // thePartyNym is pPartyNym
 
         if (!thePartyNym.LoadPublicKey()) {
             otErr << "OTSmartContract::StashFunds: Failure loading party Nym "
                      "public key: " << strPartyUserID << "\n";
             FlagForRemoval(); // Remove it from future Cron processing, please.
             return false;
         }
 
         if (thePartyNym.VerifyPseudonym() &&
             thePartyNym.LoadSignedNymfile(*pServerNym)) // ServerNym here is not
                                                         // thePartyNym's
                                                         // identity, but merely
                                                         // the signer on this
                                                         // file.
         {
             otWarn << "OTSmartContract::StashFunds: Loading party Nym, since "
                       "he apparently wasn't already loaded.\n"
                       "(On a cron item processing, this is normal. But if you "
                       "triggered a clause directly, then your Nym SHOULD be "
                       "already loaded...)\n";
             pPartyNym = &thePartyNym; //  <=====
         }
         else {
             otErr << "OTSmartContract::StashFunds: Failure loading or "
                      "verifying party Nym public key: " << strPartyUserID
                   << "\n";
             FlagForRemoval(); // Remove it from future Cron processing, please.
             return false;
         }
     }
     // Below this point, both Nyms are loaded and good-to-go.
 
     mapOfNyms map_ALREADY_LOADED; // I know I passed in one of these, but now I
                                   // have processed the Nym pointers (above) and
                                   // have better data here now.
     map_ALREADY_LOADED.insert(std::pair<std::string, OTPseudonym*>(
         strServerNymID.Get(),
         pServerNym)); // Add Server Nym to list of Nyms already loaded.
 
     auto it_temp = map_ALREADY_LOADED.find(strPartyUserID.Get());
     if (map_ALREADY_LOADED.end() == it_temp)
         map_ALREADY_LOADED.insert(std::pair<std::string, OTPseudonym*>(
             strPartyUserID.Get(),
             pPartyNym)); // Add party Nym to list of Nyms already loaded.
 
     // In this function, pStashNym and pServerNym are always the same.
 
     if (!pOrigCronItem->VerifyNymAsAgent(
             *pPartyNym, *pServerNym,
             // In case it needs to load the AUTHORIZING agent, and that agent
             // is already loaded, it will have access here.
             &map_ALREADY_LOADED)) {
         otErr << "OTSmartContract::StashFunds: Failed authorization for party "
                  "Nym: " << strPartyUserID << "\n";
         FlagForRemoval(); // Remove it from Cron.
         return false;
     }
 
     // AT THIS POINT, I have:    pServerNym, pPartyNym, and pStashNym,
     // PLUS:                    pStashAccount and pPartyAssetAcct
 
     // VerifySignature, VerifyContractID, and VerifyOwner have all been called
     // already
     // by this point. This is new:
     // (They might fall away in favor of this, once I start building.)
     //
     if (!VerifyNymAsAgentForAccount(*pPartyNym, *pPartyAssetAcct)) {
         otOut << "OTSmartContract::StashFunds: ERROR verifying ownership on "
                  "source account.\n";
         FlagForRemoval(); // Remove it from future Cron processing, please.
         return false;
     }
     else {
         // Okay then, everything checks out. Let's add a receipt to the party's
         // inbox.
         // (No need for the stash's inbox -- the server owns it.)
 
         // Load the inbox in case it already exists
         OTLedger thePartyInbox(PARTY_USER_ID, PARTY_ACCT_ID, SERVER_ID);
 
         // ALL inboxes -- no outboxes. All will receive notification of
         // something ALREADY DONE.
         bool bSuccessLoadingPartyInbox = thePartyInbox.LoadInbox();
 
         // ...or generate them otherwise...
 
         if (true == bSuccessLoadingPartyInbox)
             bSuccessLoadingPartyInbox =
                 thePartyInbox.VerifyAccount(*pServerNym);
         else
             otErr << "OTSmartContract::StashFunds: Failed trying to load "
                      "party's inbox.\n";
         //            OT_FAIL_MSG("ASSERT:  TRYING TO GENERATE INBOX IN STASH
         // FUNDS!!!\n");
         //            bSuccessLoadingPartyInbox        =
         // thePartyInbox.GenerateLedger(PARTY_ACCT_ID, SERVER_ID,
         // OTLedger::inbox, true); // bGenerateFile=true
 
         if (!bSuccessLoadingPartyInbox) {
             otErr << "OTSmartContract::StashFunds: ERROR loading or generating "
                      "inbox ledger.\n";
         }
         else {
             // Generate new transaction numbers for these new transactions
             int64_t lNewTransactionNumber = pCron->GetNextTransactionNumber();
 
             //            OT_ASSERT(lNewTransactionNumber > 0); // this can be
             // my reminder.
             if (0 == lNewTransactionNumber) {
                 otOut << "OTSmartContract::StashFunds: Aborted move: There are "
                          "no more transaction numbers available in Cron.\n";
                 // (Here I do NOT flag for removal.)
                 return false;
             }
 
             OTTransaction* pTransParty = OTTransaction::GenerateTransaction(
                 thePartyInbox, OTTransaction::paymentReceipt,
                 lNewTransactionNumber);
             // (No need to OT_ASSERT on the above new transaction since it
             // occurs in GenerateTransaction().)
 
             // The party's inbox will get a receipt with a new transaction ID on
             // it, owned by the server.
             // It will have a "In reference to" field containing the original
             // signed smart contract.
             // (with all party's signatures from their authorizing agents.)
 
             // set up the transaction item (each transaction may have multiple
             // items... but not in this case.)
             //
             OTItem* pItemParty = OTItem::CreateItemFromTransaction(
                 *pTransParty, OTItem::paymentReceipt);
             OT_ASSERT(nullptr !=
                       pItemParty); //  may be unnecessary, I'll have to
                                    // check CreateItemFromTransaction.
                                    // I'll leave for now.
 
             pItemParty->SetStatus(OTItem::rejection); // the default.
 
             //            const int64_t lPartyTransRefNo    =
             // GetTransactionNum();
             const int64_t lPartyTransRefNo = GetOpeningNumber(PARTY_USER_ID);
 
             // Here I make sure that each receipt (each inbox notice) references
             // the original
             // transaction number that was used to set the cron item into
             // place...
             // This number is used to track all cron items. (All Cron items
             // require a transaction
             // number from the user in order to add them to Cron in the first
             // place.)
             //
             // The number is also used to uniquely identify all other
             // transactions, as you
             // might guess from its name.
             //
             // UPDATE: Notice I'm now looking up a different number based on the
             // UserID.
             // This is to support smart contracts, which have many parties,
             // agents, and accounts.
             //
             //            pItemParty->SetReferenceToNum(lPartyTransRefNo);
             pTransParty->SetReferenceToNum(lPartyTransRefNo);
 
             // The TRANSACTION (a receipt in my inbox) will be sent with "In
             // Reference To" information
             // containing the ORIGINAL SIGNED SMARTCONTRACT. (With all parties'
             // original signatures on it.)
             //
             // Whereas the TRANSACTION ITEM will include an "attachment"
             // containing the UPDATED
             // SMART CONTRACT (this time with the SERVER's signature on it.)
             //
             // Here's the original one going onto the transaction:
             //
             pTransParty->SetReferenceString(strOrigPlan);
 
             //
             // MOVE THE DIGITAL ASSETS FROM ONE ACCOUNT TO ANOTHER...
             //
             // Calculate the amount and debit/ credit the accounts
             // Make sure each Account can afford it, and roll back in case of
             // failure.
 
             // Normally if you stash 10 clams, then your account is -10 clams,
             // and your stash is +10 clams.
             // Therefore if you unstash 5 gg, then your gg acct is +5 grams and
             // your stash is -5 grams.
             //
             // Thus if lAmount is > 0, as normal, that amount should be DEBITED
             // from the Party Acct, and CREDITED to the Stash Acct.
             // Whereas if lAmount were < 0, then that amount should be DEBITED
             // from the Stash Acct, and CREDITED to the Party Acct.
 
             bool bMoveParty = false;
             bool bMoveStash = false;
 
             if (bUnstashing) //  Debit Stash, Credit Party
             {
                 if (pStashAccount->GetBalance() >= lAbsoluteAmount) {
                     // Debit the stash account.
                     bMoveStash = pStashAccount->Debit(
                         lAbsoluteAmount); // <====== DEBIT FUNDS
 
                     // IF success, credit the party.
                     if (bMoveStash) {
                         bMoveParty = pPartyAssetAcct->Credit(
                             lAbsoluteAmount); // <=== CREDIT FUNDS
 
                         // Okay, we already took it from the stash account.
                         // But if we FAIL to credit the party, then we need to
                         // PUT IT BACK in the stash acct.
                         // (EVEN THOUGH we'll just "NOT SAVE" after any failure,
                         // so it's really superfluous.)
                         //
                         if (!bMoveParty) {
                             bool bErr = pStashAccount->Credit(
                                 lAbsoluteAmount); // put the money back
 
                             otErr << "OTSmartContract::StashFunds: While "
                                      "succeeded debiting the stash account, "
                                      "FAILED in: "
                                      "pPartyAssetAcct->Credit(lAbsoluteAmount);"
                                      " \n"
                                      "Also, tried to credit stash account back "
                                      "again. Result: "
                                   << (bErr ? "success" : "failure") << ".\n";
                         }
                         else { // SUCCESS!
                             //
                             bool bStashSuccess = pStashItem->DebitStash(
                                 lAbsoluteAmount); // we already verified above
                                                   // that this stash item has
                                                   // enough funds to
                                                   // successfully debit.
 
                             if (bStashSuccess)
                                 bSuccess = true;
                             else
                                 otErr << "OTSmartContract::StashFunds: ERROR: "
                                          "Debited stash account and credited "
                                          "party account, but "
                                          "then unable to debit the stash "
                                          "record inside the smart contract "
                                          "itself.\n";
                         }
                     }
                     else {
                         otErr << "OTSmartContract::StashFunds: FAILED in:  "
                                  "pStashAccount->Debit(lAbsoluteAmount);\n";
                     }
                 }
             }
             else // Debit party, Credit Stash
             {
                 if (pPartyAssetAcct->GetBalance() >= lAbsoluteAmount) {
                     // Debit the party account.
                     bMoveParty = pPartyAssetAcct->Debit(
                         lAbsoluteAmount); // <====== DEBIT FUNDS
 
                     // IF success, credit the Stash.
                     if (bMoveParty) {
                         bMoveStash = pStashAccount->Credit(
                             lAbsoluteAmount); // <=== CREDIT FUNDS
 
                         // Okay, we already took it from the party account.
                         // But if we FAIL to credit the Stash, then we need to
                         // PUT IT BACK in the party acct.
                         // (EVEN THOUGH we'll just "NOT SAVE" after any failure,
                         // so it's really superfluous.)
                         //
                         if (!bMoveStash) {
                             bool bErr = pPartyAssetAcct->Credit(
                                 lAbsoluteAmount); // put the money back
 
                             otErr << "OTSmartContract::StashFunds: While "
                                      "succeeded debiting the asset account, "
                                      "FAILED in: "
                                      "pStashAccount->Credit(lAbsoluteAmount); "
                                      "\n"
                                      "Also, tried to credit asset account back "
                                      "again. Result: "
                                   << (bErr ? "success" : "failure") << ".\n";
                         }
                         else { // SUCCESS!
                             //
                             bool bStashSuccess = pStashItem->CreditStash(
                                 lAbsoluteAmount); // we already verified above
                                                   // that this stash item has
                                                   // enough funds to
                                                   // successfully debit.
 
                             if (bStashSuccess)
                                 bSuccess = true;
                             else
                                 otErr << "OTSmartContract::StashFunds: ERROR: "
                                          "Debited party account and credited "
                                          "stash account, but "
                                          "then unable to credit the stash "
                                          "record inside the smart contract "
                                          "itself.\n";
                         }
                     }
                     else {
                         otErr << "OTSmartContract::StashFunds: FAILED in:  "
                                  "pPartyAssetAcct->Debit(lAbsoluteAmount);\n";
                     }
                 }
             }
 
             // If ANY of these failed, then roll them all back and break.
             // (In fact we could just be checking bSuccess here, I wager.
             // Might as well be thorough.)
             //
             if (!bMoveParty || !bMoveStash) {
                 // No need to roll back pStashItem here, since it is never
                 // changed in the
                 // first place unless BOTH of the above bools were successful.
 
                 otErr << "OTSmartContract::StashFunds: Very strange! Funds "
                          "were available but "
                          "debit " << ((bUnstashing) ? "stash" : "party")
                       << " or credit " << ((bUnstashing) ? "party" : "stash")
                       << " failed while performing move.\n";
                 // We won't save the files anyway, if this failed.
                 bSuccess = false;
             }
 
             // DO NOT SAVE ACCOUNTS if bSuccess is false.
             // We only save these accounts if bSuccess == true.
             // (But we do save the inboxes either way, since payment failures
             // always merit an inbox notice.)
             //
             if (true == bSuccess) // The payment succeeded.
             {
                 // The party needs to get a receipt in his inbox.
                 //
                 pItemParty->SetStatus(
                     OTItem::acknowledgement); // pPartyAssetAcct
 
                 const int64_t lReceiptAmount = (lAmount * (-1));
 
                 //                pItemParty->SetAmount(lAmount);    // lAmount
                 // is already negative or positive by the time it's passed into
                 // this function.
                 pItemParty->SetAmount(lReceiptAmount); // However, if we are
                                                        // stashing 100, that
                                                        // means my account is
                                                        // -100. Therefore
                                                        // multiply by (-1)
                                                        // EITHER WAY.
                 //                pItemParty->SetAmount(lAbsoluteAmount*(-1));
                 // // "paymentReceipt" is otherwise ambigious about whether you
                 // are paying or being paid.
                 // This is also like market receipts, which use negative and
                 // positive amounts.
 
                 otOut << "OTSmartContract::StashFunds: Move performed.\n";
 
                 // (I do NOT save m_pCron here, since that already occurs after
                 // this function is called.)
             }
             else // bSuccess = false.  The payment failed.
             {
                 pItemParty->SetStatus(OTItem::rejection); // pPartyAssetAcct
                                                           // // These are
                                                           // already initialized
                                                           // to false.
                 pItemParty->SetAmount(
                     0); // No money changed hands. Just being explicit.
 
                 otOut << "OTSmartContract::StashFunds: Move failed.\n";
             }
 
             // Everytime a payment processes, a receipt is put in the user's
             // inbox, containing a
             // CURRENT copy of the cron item (which took just money from the
             // user's acct, or not,
             // and either way thus updated its status -- so its internal state
             // has changed.)
             //
             // It will also contain a copy of the user's ORIGINAL signed cron
             // item, where the data
             // has NOT changed, (so the user's original signature is still
             // good.) Although in the case of
             // smart contracts, each party stores their own signed copy anyway,
             // so it doesn't matter as
             // much.
             //
             // In order for it to export the RIGHT VERSION of the CURRENT smart
             // contract, which has just
             // changed (above), then I need to re-sign it and save it first.
             // (The original version I'll
             // load from a separate file using
             // OTSmartContract::LoadCronReceipt(lTransactionNum).
             //
             // I should be able to call a method on the original cronitem, where
             // I ask it to verify a certain
             // nym as being acceptable to that cron item as an agent, based on
             // the signature of the original
             // authorizing agent for that party. UPDATE: I believe the function
             // described in this paragraph
             // is now done.
             //
 
             ReleaseSignatures();
             SignContract(*pServerNym);
             SaveContract();
 
             //
             // EVERYTHING BELOW is just about notifying the party, by dropping
             // the receipt in his
             // inbox. The rest is done.  The two accounts and the inbox will all
             // be saved at the same time.
             //
             // The Smart Contract is entirely updated and saved by this point,
             // and Cron will
             // also be saved in the calling function once we return (no matter
             // what.)
             //
 
             // Basically I load up the INBOX, which is actually a LEDGER, and
             // then I create
             // a new transaction, with a new transaction item, for that ledger.
             // (That's where the receipt information goes.)
             //
 
             // The TRANSACTION will be sent with "In Reference To" information
             // containing the
             // ORIGINAL SIGNED SMART CONTRACT. (With both of the users' original
             // signatures on it.)
             //
             // Whereas the TRANSACTION ITEM will include an "attachment"
             // containing the UPDATED
             // SMART CONTRACT (this time with the SERVER's signature on it.)
 
             // (Lucky I just signed and saved the updated smart contract
             // (above), or it would still have
             // have the old data in it.)
 
             // I also already loaded the original smart contact. Remember this
             // from above,
             // near the top of the function:
             //  OTSmartContract * pOrigCronItem    = nullptr;
             //     OTString strOrigPlan(*pOrigCronItem); // <====== Farther down
             // in the code, I attach this string to the receipts.
             //  ... then lower down...
             // pTransParty->SetReferenceString(strOrigPlan);
             //
             // So the original plan is already loaded and copied to the
             // Transaction as the "In Reference To"
             // Field. Now let's add the UPDATED plan as an ATTACHMENT on the
             // Transaction ITEM:
             //
 
             //
 
             OTString strUpdatedCronItem(*this);
 
             // Set the updated cron item as the attachment on the transaction
             // item.
             // (With the SERVER's signature on it!)
             // (As a receipt for the party, so they can see their smartcontract
             // updating.)
             //
             pItemParty->SetAttachment(strUpdatedCronItem);
 
             // Success OR failure, either way I want a receipt in the inbox.
             // ===> But if FAILURE, I do NOT want to save the Accounts, JUST the
             // inbox!!
             //
             // (So the inbox happens either way, but the accounts are saved only
             // on success.)
 
             // sign the item
             pItemParty->SignContract(*pServerNym);
             pItemParty->SaveContract();
 
             // the Transaction "owns" the item now and will handle cleaning it
             // up.
             pTransParty->AddItem(*pItemParty);
             pTransParty->SignContract(*pServerNym);
             pTransParty->SaveContract();
 
             // Here, the transaction we just created is actually added to the
             // inbox ledger.
             // This happens either way, success or fail.
 
             thePartyInbox.AddTransaction(*pTransParty);
 
             // Release any signatures that were there before (They won't
             // verify anymore anyway, since the content has changed.)
             //
             thePartyInbox.ReleaseSignatures();
             thePartyInbox.SignContract(*pServerNym);
             thePartyInbox.SaveContract();
 
             pPartyAssetAcct->SaveInbox(thePartyInbox);
 
             // This corresponds to the AddTransaction() call just above.
             // These are stored in a separate file now.
             //
             pTransParty->SaveBoxReceipt(thePartyInbox);
 
             // If success, save the accounts with new balance. (Save inboxes
             // with receipts either way,
             // and the receipts will contain a rejection or acknowledgment
             // stamped by the Server Nym.)
             //
             if (true == bSuccess) {
                 // SAVE THE ACCOUNTS.
 
                 // Release any signatures that were there before (They won't
                 // verify anymore anyway, since the content has changed.)
                 //
                 pPartyAssetAcct->ReleaseSignatures();
                 pStashAccount->ReleaseSignatures();
 
                 // Sign both of them.
                 pPartyAssetAcct->SignContract(*pServerNym);
                 pStashAccount->SignContract(*pServerNym);
 
                 // Save both of them internally
                 pPartyAssetAcct->SaveContract();
                 pStashAccount->SaveContract();
 
                 // TODO: Better rollback capabilities in case of failures here:
 
                 // Save both accounts to storage.
                 pPartyAssetAcct->SaveAccount();
                 pStashAccount->SaveAccount();
                 // NO NEED TO LOG HERE, since success / failure is already
                 // logged above.
             }
         } // the inbox was successfully loaded or generated.
     } // By the time we enter this block, accounts and nyms are already loaded.
       // As we begin, inboxes are instantiated.
 
     // Either way, Cron should save, since it just updated.
     // The above function call WILL change this smart contract
     // and re-sign it and save it, no matter what. So I just
     // call this here to keep it simple:
 
     pCron->SaveCron(); // TODO No need to call this here if I can make sure it's
                        // being called higher up somewhere
     // (Imagine a script that has 10 account moves in it -- maybe don't need to
     // save cron until
     // after all 10 are done. Or maybe DO need to do in between. Todo research
     // this. Optimization.)
     return bSuccess;
 }

bool opentxs::OTSmartContract::UnstashAcctFunds	(	std::string	to_acct_name,
		std::string	from_stash_name,
		std::string	str_Amount
	)

Definition at line 2072 of file OTSmartContract.cpp.

 {
     OTCron* pCron = GetCron();
     OT_ASSERT(nullptr != pCron);
 
     OTPseudonym* pServerNym = pCron->GetServerNym();
     OT_ASSERT(nullptr != pServerNym);
 
     // Below this point, these are all good:
     //
     //        pServerNym, pCron.
     //
 
     if (str_Amount.size() < 1) {
         otOut << "OTSmartContract::UnstashAcctFunds: Error: empty amount.\n";
         return false;
     }
 
     const int64_t lAmount = atol(str_Amount.c_str());
 
     if (lAmount <= 0) {
         otOut << "OTSmartContract::UnstashAcctFunds: Error: lAmount cannot be "
                  "0 or <0. (Value passed in was " << lAmount << ".)\n";
         return false;
     }
 
     if (to_acct_name.size() <= 0) {
         otErr << "OTSmartContract::UnstashAcctFunds: error: to_acct_name is "
                  "non-existent.\n";
         return false;
     }
     if (from_stash_name.size() <= 0) {
         otErr << "OTSmartContract::UnstashAcctFunds: error: from_stash_name is "
                  "non-existent.\n";
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        to_acct_name,
     //        from_stash_name,
     //        pServerNym, pCron.
 
     OTPartyAccount* pToAcct = GetPartyAccount(to_acct_name);
     OTStash* pStash = GetStash(from_stash_name); // This ALWAYS succeeds.
                                                  // (It will OT_ASSERT()
                                                  // if failure.)
 
     if (nullptr == pToAcct) {
         otOut << "OTSmartContract::UnstashAcctFunds: error: to_acct ("
               << to_acct_name << ") not found on any party.\n";
         return false;
     }
 
     // Below this point, these are all good:
     //
     //        pToAcct,    to_acct_name,
     //        pStash,        from_stash_name,
     //        pServerNym, pCron.
 
     OTAgent* pToAgent =
         pToAcct->GetAuthorizedAgent(); // This searches the account's party for
                                        // the account's authorized agent.
     // (That way it's impossible to get an agent for any other party.)
 
     if (nullptr == pToAgent) {
         otOut << "OTSmartContract::UnstashAcctFunds: error: authorized agent ("
               << pToAcct->GetAgentName().Get() << ") not found for to_acct ("
               << to_acct_name << ") on acct's party.\n";
         return false;
     }
 
     if (!pToAgent->IsAnIndividual()) {
         otOut << "OTSmartContract::UnstashAcctFunds: error: authorized agent ("
               << pToAcct->GetAgentName().Get() << ") for to_acct ("
               << to_acct_name << ") is not an active agent.\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pToAcct,    to_acct_name,        pToAgent,
     //        pStash,        from_stash_name,
     //        pServerNym, pCron.
 
     OTParty* pToParty = pToAgent->GetParty();
 
     if (nullptr == pToParty) {
         otErr << "OTSmartContract::UnstashAcctFunds: error: Party pointer "
                  "nullptr "
                  "on authorized agent (" << pToAcct->GetAgentName()
               << ") for to_acct (" << to_acct_name << ").\n";
         return false;
     }
     //
     // Below this point, these are all good:
     //
     //        pToAcct,    to_acct_name,        pToAgent,    pToParty,
     //        pStash,        from_stash_name,
     //        pServerNym, pCron.
 
     // Done: I can see that THIS VERIFICATION CODE WILL GET CALLED EVERY SINGLE
     // TIME THE SCRIPT
     // CALLS MOVE FUNDS.  Maybe that's good, but since technically this only
     // needs to be verified before the
     // first call, and not for EVERY call during any of a script's runs, I
     // should probably move this verification
     // higher, such as each time the OTCronItem triggers, plus each time a party
     // triggers a clause directly
     // through the API (server message). As long as those are covered, I will be
     // able to remove it from here
     // which should be a significant improvement for performance.
     // It will be at the bottom of those same functions that
     // "ClearTemporaryPointers()" should finally be called.
     //
     // FINAL DECISION: Redundant, removed. See comments in StashAcctFunds().
     //
     // A party might have many agents who are only voting groups, and cannot
     // actually sign for things
     // the way that nyms can. But at least ONE of those agents IS a Nym --
     // because there must have been
     // an authorizing agent who initially signed to accept the agreement, and
     // who fronted the opening
     // transaction number that activated it.
     //
     // Similarly, the authorized agent for any given party's account (each
     // account has its own authorized
     // agent) MUST be an active agent (an active agent is one with a
     // Nym--whether that Nym is representing
     // himself as the party, or whether representing some entity as an employee
     // in a role). Why MUST the
     // authorized agent be an active agent? Because when funds are moved, that
     // Nym must be loaded since
     // the account must show that Nym as a legal owner/agent. The MoveFunds will
     // cause a paymentReceipt to
     // drop into the Inbox for the relevant asset accounts, and that
     // paymentReceipt can ONLY be accepted
     // by that same Nym, who must use a transaction # that he signed for
     // previously and received through
     // his nymbox. There is actually no justification at all to take funds from
     // that account, since the
     // new balance has not yet been signed, UNLESS THE PAYMENTRECEIPT CONTAINS A
     // VALID, SIGNED AUTHORIZATION
     // FROM THE ACCOUNT HOLDER. *That* is why the authorizing agent must either
     // be the Party's Owner himself
     // (representing himself as an agent, which most will do) in which case he
     // will appear as the valid
     // owner of the account, OR he MUST be a Nym working in a Valid Role for an
     // Entity, where said Entity is
     // the valid owner on the account in question. Either OT, it will be
     // possible in OT for him to sign for
     // the paymentReceipts when they come in, and impossible for him to escape
     // liability for them.
     // (That's the idea anyway.)
     //
     // Since we know that the Authorized Agent for an account must be an ACTIVE
     // agent (one way or the other)
     // then we can error out here if he's not.  We can then pass in his Nym ID.
     //
 
     OTIdentifier theToAgentID;
     const bool bToAgentID = pToAgent->GetSignerID(theToAgentID);
 
     if (!bToAgentID) {
         otErr << "OTSmartContract::UnstashAcctFunds: Failed to find 'To' "
                  "Agent's Signer ID: " << pToAgent->GetName() << " \n";
         return false;
     }
 
     if (!pToAcct->GetAcctID().Exists()) {
         otErr << "OTSmartContract::UnstashAcctFunds: Error: ToAcct has empty "
                  "AcctID: " << to_acct_name << " \n";
         return false;
     }
 
     const OTIdentifier theToAcctID(pToAcct->GetAcctID());
     //
     // BELOW THIS POINT, theToAcctID and theToAgentID available.
 
     // WE SET THESE HERE SO THE RECEIPT SHOWS, SUCCESS OR FAIL,
     // WHO THE INTENDED SENDER / RECIPIENT ARE FOR THAT RECEIPT.
     //
     ReleaseLastSenderRecipientIDs();
 
     theToAgentID.GetString(m_strLastRecipientUser); // This is the last User ID
                                                     // of a party who RECEIVED
                                                     // money.
     theToAcctID.GetString(m_strLastRecipientAcct);  // This is the last Acct ID
                                                     // of a party who RECEIVED
                                                     // money.
     // Above: the FromAgent and FromAcct are commented out,
     // since the funds are coming from a stash.
 
     const int64_t lNegativeAmount = (lAmount * (-1));
 
     mapOfNyms map_Nyms_Already_Loaded;
     RetrieveNymPointers(map_Nyms_Already_Loaded);
 
     bool bMoved = StashFunds(map_Nyms_Already_Loaded, lNegativeAmount,
                              theToAcctID, theToAgentID, *pStash);
     if (!bMoved) {
         otOut << "OTSmartContract::UnstashAcctFunds: Failed in final call. "
                  "Values: to_acct: " << to_acct_name
               << ", from_stash: " << from_stash_name << ", lAmount: " << lAmount
               << ". \n";
         return false;
     }
 
     return true;
 }

void opentxs::OTSmartContract::UpdateContents ( )

virtual

Reimplemented from opentxs::OTTrackable.

Definition at line 5464 of file OTSmartContract.cpp.

 {
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     const OTString SERVER_ID(GetServerID()),
         ACTIVATOR_USER_ID(GetSenderUserID()),
         ACTIVATOR_ACCT_ID(GetSenderAcctID());
 
     OT_ASSERT(nullptr != m_pCancelerNymID);
 
     OTString strCanceler;
 
     if (m_bCanceled) m_pCancelerNymID->GetString(strCanceler);
 
     int64_t tCreation = OTTimeGetSecondsFromTime(
         m_bCalculatingID ? OT_TIME_ZERO : GetCreationDate());
     int64_t tValidFrom = OTTimeGetSecondsFromTime(
         m_bCalculatingID ? OT_TIME_ZERO : GetValidFrom());
     int64_t tValidTo = OTTimeGetSecondsFromTime(
         m_bCalculatingID ? OT_TIME_ZERO : GetValidTo());
     int64_t tNextProcess = OTTimeGetSecondsFromTime(
         m_bCalculatingID ? OT_TIME_ZERO : GetNextProcessDate());
 
     // OTSmartContract
     m_xmlUnsigned.Concatenate(
         "<smartContract\n version=\"%s\"\n"
         " serverID=\"%s\"\n"
         " activatorUserID=\"%s\"\n"
         " activatorAcctID=\"%s\"\n"
         " lastSenderUserID=\"%s\"\n"
         " lastSenderAcctID=\"%s\"\n"
         " lastRecipientUserID=\"%s\"\n"
         " lastRecipientAcctID=\"%s\"\n"
         " canceled=\"%s\"\n"
         " cancelerUserID=\"%s\"\n"
         " transactionNum=\"%lld\"\n"
         " creationDate=\"%" PRId64 "\"\n"
         " validFrom=\"%" PRId64 "\"\n"
         " validTo=\"%" PRId64 "\"\n"
         " nextProcessDate=\"%" PRId64 "\""
         " >\n\n",
         m_strVersion.Get(), m_bCalculatingID ? "" : SERVER_ID.Get(),
         m_bCalculatingID ? "" : ACTIVATOR_USER_ID.Get(),
         m_bCalculatingID ? "" : ACTIVATOR_ACCT_ID.Get(),
         m_bCalculatingID ? "" : m_strLastSenderUser.Get(),
         m_bCalculatingID ? "" : m_strLastSenderAcct.Get(),
         m_bCalculatingID ? "" : m_strLastRecipientUser.Get(),
         m_bCalculatingID ? "" : m_strLastRecipientAcct.Get(),
         m_bCanceled ? "true" : "false", m_bCanceled ? strCanceler.Get() : "",
         m_bCalculatingID ? 0 : m_lTransactionNum, tCreation, tValidFrom,
         tValidTo, tNextProcess);
 
     // OTCronItem
     if (!m_bCalculatingID) {
         for (int32_t i = 0; i < GetCountClosingNumbers(); i++) {
             int64_t lClosingNumber = GetClosingTransactionNoAt(i);
             OT_ASSERT(lClosingNumber > 0);
 
             m_xmlUnsigned.Concatenate(
                 "<closingTransactionNumber value=\"%lld\"/>\n\n",
                 lClosingNumber);
 
             // For OTSmartContract, this should only contain a single number,
             // from the activator Nym.
             // I preserved the loop anyway. Call me crazy. But I'm still
             // displaying an error if there's
             // more than one.
             if (i > 0)
                 otErr << "OTSmartContract::" << __FUNCTION__
                       << ": ERROR: There's only ever "
                          "supposed to be a single closing number here (for "
                          "smart contracts.)\n";
         }
     }
 
     // *** OT SCRIPTABLE ***
     //
     UpdateContentsToString(m_xmlUnsigned,
                            m_bCalculatingID); // FYI: this is: void
 
     if (!m_bCalculatingID) {
 
         // Save m_StashAccts.
         //
         // (This is an object that contains a map of OTAccountIDs, by
         // asset_type_id)
         //
         m_StashAccts.Serialize(m_xmlUnsigned);
 
         // This is a map of OTStash's, by stash_name.
         // EACH ONE contains a map of OTStashItems, by asset_type_id
 
         // These stashes are what the scripts interact with. They have names.
         // Whereas the stash accts (above) are the actual accountIDs
         for (auto& it : m_mapStashes) {
             // where the actual funds are stored for each asset type.
             OTStash* pStash = it.second;
             OT_ASSERT(nullptr != pStash);
             pStash->Serialize(m_xmlUnsigned);
         }
     }
 
     m_xmlUnsigned.Concatenate("</smartContract>\n\n");
 }

bool opentxs::OTSmartContract::VerifySmartContract	(	OTPseudonym &	theNym,
		OTAccount &	theAcct,
		OTPseudonym &	theServerNym,
		bool	bBurnTransNo = `false`
	)

Definition at line 4391 of file OTSmartContract.cpp.

 {
     OTAgent* pAuthAgent = nullptr;
     OTParty* pAuthParty = FindPartyBasedOnNymAsAuthAgent(theNym, &pAuthAgent);
 
     if (nullptr == pAuthParty) {
         OTString strNymID;
         theNym.GetIdentifier(strNymID);
         otOut << __FUNCTION__
               << ": Unable to find a party in this smart contract, based "
                  "on theNym (" << strNymID << ") as authorizing agent.\n";
         return false;
     }
     OT_ASSERT(nullptr !=
               pAuthAgent); // If it found the party, then it DEFINITELY
                            // should have set the agent pointer.
     // BELOW THIS POINT, pAuthAgent and pAuthParty and both good pointers.
     // Furthermore, we know that theNym
     // really is the authorizing agent for one of the parties to the contract.
 
     const OTString strServerID(
         GetServerID()); // the serverID has already been verified by this time,
                         // in OTServer::NotarizeSmartContract()
 
     mapOfNyms map_Nyms_Already_Loaded; // The list of Nyms that were already
                                        // instantiated before this function was
                                        // called.
     RetrieveNymPointers(map_Nyms_Already_Loaded); // now theNym is on this
                                                   // map. (His party
                                                   // already has a pointer
                                                   // to him since he is
                                                   // the activator.)
 
     mapOfNyms map_Nyms_Loaded_In_This_Function; // The total list of Nyms that
                                                 // were instantiated inside this
                                                 // function (and must be
                                                 // deleted.)
 
     mapOfAccounts map_Accts_Already_Loaded; // The list of Accounts that were
                                             // already instantiated before this
                                             // function was called.
     const OTString strAcctID(theAcct.GetRealAccountID());
     map_Accts_Already_Loaded.insert(std::pair<std::string, OTAccount*>(
         strAcctID.Get(), &theAcct)); // now theAcct is on this map.
 
     mapOfAccounts map_Accts_Loaded_In_This_Function; // The total list of Accts
                                                      // that were instantiated
                                                      // inside this function
                                                      // (and must be deleted.)
 
     bool bAreAnyInvalidParties = false;
     std::set<OTParty*> theFailedParties; // A set of pointers to parties who
                                          // failed verification.
 
     // LOOP THROUGH ALL PARTIES AND VERIFY THEM.
     for (auto& it_party : m_mapParties) {
         const std::string str_party_name = it_party.first;
         OTParty* pParty = it_party.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "OTSmartContract::VerifySmartContract: "
                       "Unexpected nullptr pointer in party "
                       "map.\n");
 
         /*
          -- Load up the authorizing agent's Nym, if not already loaded. (Why? To
          verifySignature. Also, just to have
             it loaded so I don't have to load it twice in case it's needed for
          verifying one/some of the accts.) So really:
          -- Verify each party, that the authorizing agent and signature are all
          good. (I think I have this already...)
          -- Definitely during this, need to make sure that the contents of the
          signed version match the contents of the main version, for each signer.
          -- Verify that the authorizing agent actually has the opening
          transaction # for the party issued to him. (Do I have this?....)
 
          -- REMOVE the Opening transaction # for each agent.
          (leaving it as issued, but no longer as "available to be used on
          another transaction".)
 
          THE ABOVE is all accomplished via VerifyPartyAuthorization()..
 
          Next:
 
          -- Loop through all the asset accounts
          -- For each, get a pointer to the authorized agent and verify the
          CLOSING number for that asset acct. (I have something like this?...)
 
          -- Since we're looping through all the agents, and looping through all
          the asset accounts, and checking the agent for each asset account,
          then we might as well make sure that each agent is a legit agent for
          the party, and that each account has a legit agent lording over it.
          (Don't I do something like that already?)
          */
 
         bool bToBurnOrNotToBurn = bBurnTransNo;
 
         // If we're burning a number, but THIS party has the same opening # as
         // the smart contract itself, then don't bother verifying / burning this
         // specific number (since it's been done already, higher-up.)
         //
         if (bBurnTransNo && // If this party's opening number is the SMART
                             // CONTRACT's opening number, then this party
             (GetTransactionNum() ==
              pParty->GetOpeningTransNo())) // MUST be the ACTIVATOR. (No need to
                                            // mark his trans# as IN USE since
                                            // already done earlier.)
         {
             // In cases where we're supposed to burn the transaction number, we
             // do that
             // for ALL parties EXCEPT the one who has the same Opening# as the
             // SmartContract
             // has for its GetTransactionNum().  Why? Because that one was
             // already burned, when
             // the activating party (pParty) activated the smart contract. At
             // that time, the normal
             // transaction system inside OTServer burned the # as part of its
             // process before even
             // calling NotarizeSmartContract().  Therefore, by this point, we
             // ASSUME that party's
             // opening num has already JUST been verified, and we skip it,
             // (continuing to verify
             // all the others.)
 
             bToBurnOrNotToBurn = false;
         }
 
         mapOfNyms map_Nyms_NewlyLoaded, map_Nyms_Already_Loaded_AS_OF_NOW;
 
         map_Nyms_Already_Loaded_AS_OF_NOW.insert(
             map_Nyms_Already_Loaded.begin(), map_Nyms_Already_Loaded.end());
         map_Nyms_Already_Loaded_AS_OF_NOW.insert(
             map_Nyms_Loaded_In_This_Function.begin(),
             map_Nyms_Loaded_In_This_Function.end());
 
         const bool bIsPartyAuthorized = VerifyPartyAuthorization(
             *pParty,      // The party that supposedly is authorized for this
                           // supposedly executed agreement.
             theServerNym, // For verifying signature on the authorizing Nym,
                           // when loading it
             strServerID,  // For verifying issued num, need the serverID the #
                           // goes with.
             &map_Nyms_Already_Loaded_AS_OF_NOW, &map_Nyms_NewlyLoaded,
             bToBurnOrNotToBurn); // bBurnTransNo = true  (default is false)
 
         map_Nyms_Loaded_In_This_Function.insert(map_Nyms_NewlyLoaded.begin(),
                                                 map_Nyms_NewlyLoaded.end());
 
         // By this point, we've verified that pParty->GetOpeningTransNo() really
         // is ISSUED to pParty.
         // After all, you can Verify a Party's Authorization even after the
         // smart contract has been activated.
         // But in THIS function we also want to verify TRANSACTION num (not just
         // VerifyIssuedNum()) because
         // this is where that number is actually being BURNED for each one.
         // Since VerifyPartyAuthorization() ALREADY has the Nym loaded up for
         // verification, I'm going
         // to pass in a boolean arg to verify the Transaction Num as well, and
         // burn it. (for this very purpose.)
         //
         // Due to this, We don't want to stop this loop just because one of the
         // parties failed. We want to go ahead
         // and burn ALL the opening numbers for the remainder of the parties, so
         // that they have a consistent rule (the
         // opening number is considered burned and gone after a failed
         // activation attempt, though the closing numbers
         // are salvageable.)  Otherwise they would never know, upon receiving a
         // server failure reply, whether their
         // opening number was to still be considered valid -- or not.
         //
         if (!bIsPartyAuthorized) {
             otOut << __FUNCTION__ << ": Party " << str_party_name
                   << " does NOT verify as authorized! \n";
             bAreAnyInvalidParties = true; // We let them all go through, but we
                                           // still take notice that at least one
                                           // failed.
 
             theFailedParties.insert(pParty); // (So we can skip them in the loop
                                              // below. Meaning THEIR closing #s
                                              // also don't get marked as "used",
                                              // which is another reason for
                                              // clients to just harvest the
                                              // number in that case and consider
                                              // it as clean, since the server
                                              // is.)
             //            return false; // see above comment. We still allow all
             // parties to burn their opening #s, to keep things consistent for
             // the client GUI code.
         }
     }
 
     // NEXT: THE ACCOUNTS
     //
     // We loop through the parties again, now knowing they are all authorized.
     // For each party, we call pParty->LoadAndVerifyAgentNyms(). This way, they
     // will
     // all be loaded up already for when we verify the accounts. Similarly we
     // call
     // pParty->LoadAndVerifyAssetAccounts(), so that all the accounts are loaded
     // up
     // as well. (We at least need to check their signatures...) At that point,
     // all
     // of the agent nyms AND accounts have been loaded! (And verified internally
     // against
     // themselves, such as their signature, etc.)
     //
     // From there, I need to verify the Party's Ownership over the account, as
     // well as
     // verify that the authorized agent listed for each account actually has
     // signer rights
     // over that account, and verify the closing transaction #s for each account
     // against its
     // authorized agent.
     //
     bool bAreAnyInvalidAccounts = false;
 
     /*
      NOTE on syncronicity...
 
      Above, we burned all the opening numbers for ALL the various nyms, even if
      there was some failure halfway through
      the verification process. This in order to make it easy to tell whether,
      for you, that number is still good or not.
 
      Similarly, what about the closing numbers (below) ? They are not instantly
      BURNED just for the ATTEMPT (as the
      opening numbers were) but they are still marked below as "USED BUT STILL
      ISSUED."
 
      if (bAreAnyInvalidParties) just above insures that the below code will not
      run if there are any invalid parties.
      That means that if "the message succeeded but transaction failed" due to
      invalid parties, then the closing numbers
      will never be seen by the server and thus never marked as "USED BUT STILL
      ISSUED." Instead, they would still be
      considered "ISSUED AND AVAILABLE."
 
      Based on that:
      If some FAILURE occurs below, as above, it still completes the loop in
      order to have consistent results for the
      closing transaction numbers, for all parties. So we know that success or
      fail, if the below code runs, the closing
      number is DEFINITELY marked as "USED BUT STILL ISSUED" for ALL parties,
      whereas if the below code does not run, the
      closing number for all parties is definitely still marked as "ISSUED AND
      AVAILABLE" (as far as this message is
      concerned.)
 
      Thus, there is still an inconsistency. When a client is later trying to
      interpret which transaction numbers to "claw
      back", he will have to harvest back the closing numbers SOMETIMES, based on
      WHY the transaction failed verification,
      and thus he cannot rely on a "transaction failed" state to give him a
      reliable answer to that question.
 
      However, we must keep in mind that these CLOSING numbers have NOT been
      burned -- they ARE still on the client's local
      list for his nym as "USED BUT STILL ISSUED." If the client harvests them
      back each time consistently, what will happen?
      The client will look at each closing number, see if it's on his local
      "issued" list (which it is) and then will re-add
      it to his "available" list as well. So is it really available on the server
      side? The answer is: sometimes.
 
      SOLUTION?
      1. Above, cache a list of all the parties who failed verification.
      2. Allow the code below to run, even if some parties have failed.
      3. Change the code below to skip failed parties while verifying accounts.
      (Using afore-mentioned list to make this possible.)
      4. Move the "if failed parties, return false" block BELOW this loop, in
      conjunction with the invalid accounts block.
 
      This will guarantee that closing numbers are consistently marked as "USED
      BUT STILL ISSUED" on the server side, no matter
      HOW the transaction has failed. (At least it will then be consistent.)
 
      However, if the transaction HAS failed, then all those closing numbers, if
      the clients are to claw them back, must be
      marked as available once again on the server side, as well! And if the
      clients are NOT to claw them back for future use,
      then how will they ever close them out? The server already won't allow the
      numbers to be used again, since they were
      marked as "used but still issued". But the transaction is ALREADY closed
      (it failed.)
 
      SOLUTIONS?
      -- Server could burn the closing numbers for failed transactions, vs
      marking them as "used but issued" when the transaction
         is successful. That way any client getting notice of the failure would
      DEFINITELY know that those numbers were burned, and
         could sync himself accordingly. (We definitely need to notice all
      parties as well, in this case, since they will need
         to discard the burned numbers after that point, in order to avoid going
      out-of-sync.)
 
      -- Server could also, in the event of transaction failure, mark the closing
      numbers as "available again, like new!"
         This way clients could clearly determine whether to burn their numbers
      or mark them as available again, purely based
         on the transaction's failure state. (State meaning the message itself is
      successful, and transaction could be success or fail.)
         Clients will not go out of sync in this case, if they fail to adjust to
      match the server. Well, they would be out of
         sync, but not the kind that prevents you from doing new transactions.
      (Rather, it's the kind where you have certain numbers
         signed out forever and you can never get rid of them.) Therefore, a
      notice is ALSO needed for this case.
 
      -- I know notices are already being sent upon activation, but I need to
      research that more closely now and determine the
         exact circumstances of these notices. Clearly a notice is REQUIRED, no
      matter which above option I choose!
 
      Thought: If notice is REQUIRED either way, perhaps the clients can just
      assume X unless a notice is received? For example,
      a client could just ASSUME the closing number is "used but still issued"
      unless notice is received to the contrary. This IS
      how the state would be if the transaction were successful, yet if it had
      failed, or hadn't been activated yet, the client
      also wouldn't experience any syncing issues by making this assumption.
 
      Clearly the server HAS to, in the event of transaction failure, mark the
      closing numbers either as "available again, like new!"
      or it has to mark them as BURNED, but either way, it's an additional piece
      the server has to do (up until now it has only
      marked them as "used but still issued.") What I can see is the server HAS
      to do something about those numbers, and it HAS
      to notify all the parties whether that transaction succeeded or failed, and
      then those parties HAVE to fix their client-side
      transaction count BASED on whether that transaciton succeeded or failed.
 
      Therefore:
 
      1. Implement the above 4-step solution.
      2. Do something about all the closing numbers, if activation fails.
         (Keep the nyms loaded until that is done, so as not to have to load them
      twice.)
      3. Make sure the parties are consistently noticed either way.
      4. Make sure the parties are syncing their numbers properly based on these
      notices.
 
 
      WOW, eh?  But I believe that smart contracts are the most complicated case,
      so this has got to be the worst of it, now handled :-)
 
      Another note: If we assume the server burns the closing numbers, then the
      clients will suddenly be out-of-sync and unable
      to process transactions until they receive and process the notice of this
      failure. But if we instead assume that the server
      "makes new" those closing numbers, then the clients will remain in sync
      regardless of notice, and they only need to harvest
      the numbers upon notice, just so they can use them again, and they will not
      experience any "out of sync failures" along the
      way. Thus, it is preferable for the server to "make those numbers new
      again!" in the event of activation failure, AND to notice
      the parties of this so that they can do likewise.
      One way to notice them is to drop the "message succeeded but transaction
      failed" server reply into ALL of their Nymboxes,
      and not just the activator's. But not sure if that's safe... hm.
 
      */
 
     for (auto& it_party : m_mapParties) {
         const std::string str_party_name = it_party.first;
         OTParty* pParty = it_party.second;
         OT_ASSERT_MSG(nullptr != pParty,
                       "Unexpected nullptr pointer in party map.");
 
         // SKIP FAILED PARTIES...
         //
         auto it_failed = theFailedParties.find(pParty);
 
         if (theFailedParties.end() != it_failed) // this means pParty was found
                                                  // on the FAILED list. (So we
                                                  // can skip it here.)
         {
             otOut << __FUNCTION__ << ": FYI, at least one party ("
                   << str_party_name
                   << ") has failed, and right now I'm skipping verification of "
                      "his asset accounts.\n";
             continue;
         }
 
         mapOfNyms map_Nyms_NewlyLoaded, map_Nyms_Already_Loaded_AS_OF_NOW;
 
         map_Nyms_Already_Loaded_AS_OF_NOW.insert(
             map_Nyms_Already_Loaded.begin(), map_Nyms_Already_Loaded.end());
         map_Nyms_Already_Loaded_AS_OF_NOW.insert(
             map_Nyms_Loaded_In_This_Function.begin(),
             map_Nyms_Loaded_In_This_Function.end());
 
         // After calling this, map_Nyms_NewlyLoaded will contain pointers to
         // Nyms that MUST BE CLEANED UP.
         // LoadAndVerifyAgentNyms will not bother loading any Nyms which appear
         // on map_Nyms_Already_Loaded.
         //
         const bool bAgentsLoaded = pParty->LoadAndVerifyAgentNyms(
             theServerNym, map_Nyms_Already_Loaded_AS_OF_NOW, // Nyms it won't
                                                              // bother loading
                                                              // 'cause they are
                                                              // loaded already.
             map_Nyms_NewlyLoaded); // Nyms it had to load itself, and thus that
                                    // YOU must clean up afterwards.
         map_Nyms_Loaded_In_This_Function.insert(map_Nyms_NewlyLoaded.begin(),
                                                 map_Nyms_NewlyLoaded.end());
         if (!bAgentsLoaded) {
             otOut << __FUNCTION__
                   << ": Failed trying to Load and Verify Agent Nyms for party: "
                   << str_party_name << "\n";
             bAreAnyInvalidAccounts = true; // We let them all go through, so
                                            // there is consistent output, but we
                                            // still take notice that at least
                                            // one failed.
         }
 
         mapOfAccounts map_Accts_NewlyLoaded, map_Accts_Already_Loaded_AS_OF_NOW;
 
         map_Accts_Already_Loaded_AS_OF_NOW.insert(
             map_Accts_Already_Loaded.begin(), map_Accts_Already_Loaded.end());
         map_Accts_Already_Loaded_AS_OF_NOW.insert(
             map_Accts_Loaded_In_This_Function.begin(),
             map_Accts_Loaded_In_This_Function.end());
 
         // After calling this, map_Accts_NewlyLoaded will contain pointers to
         // Accts that MUST BE CLEANED UP.
         // LoadAndVerifyAssetAccounts will not bother loading any Accts which
         // appear on map_Accts_Already_Loaded.
         //
         const bool bAcctsLoaded = pParty->LoadAndVerifyAssetAccounts(
             theServerNym, strServerID,
             map_Accts_Already_Loaded_AS_OF_NOW, // Accts it won't bother loading
                                                 // 'cause they are loaded
                                                 // already.
             map_Accts_NewlyLoaded); // Accts it had to load itself, and thus
                                     // that YOU must clean up afterwards.
 
         map_Accts_Loaded_In_This_Function.insert(map_Accts_NewlyLoaded.begin(),
                                                  map_Accts_NewlyLoaded.end());
         if (!bAcctsLoaded) {
             otOut
                 << __FUNCTION__
                 << ": Failed trying to Load and Verify Asset Accts for party: "
                 << str_party_name << "\n";
             bAreAnyInvalidAccounts = true; // We let them all go through, so
                                            // there is consistent output, but we
                                            // still take notice that at least
                                            // one failed.
         }
 
         // BY THIS POINT, FOR THIS PARTY, we have successfully loaded and
         // verified ALL of the Nyms,
         // for ALL of the party's agents, and ALL of the asset accounts, for
         // this party. We know the
         // Party has pointers internally to all of those objects as well.
         // Therefore if we erase any of those objects, we must also clear the
         // pointers!
         //
         const bool bAreAcctsVerified = pParty->VerifyAccountsWithTheirAgents(
             theServerNym, strServerID,
             bBurnTransNo); // bBurnTransNo=false by default.
         if (!bAreAcctsVerified) {
             otOut << __FUNCTION__
                   << ": Failed trying to Verify Asset Accts with their Agents, "
                      "for party: " << str_party_name << "\n";
             bAreAnyInvalidAccounts = true; // We let them all go through, so
                                            // there is consistent output, but we
                                            // still take notice that at least
                                            // one failed.
         }
 
         // Now we don't delete these until AFTER the loop, until after we know
         // if it was a success.
         // If it failed, then we can fix their closing transaction numbers from
         // "used but still issued" back to
         // "issued and available for use." (If it was a success, then we don't
         // do anything, since the numbers are
         // already marked appropriately. And we still clean up all the nyms /
         // accounts--just AFTER this loop.)
         //
         //        pParty->ClearTemporaryPointers(); // Don't want any bad
         // pointers floating around after cleanup. (Pointers must be cleared in
         // same scope as whatever they point to...)
         //      OTSmartContract::CleanupNyms (map_Nyms_NewlyLoaded);  // HAVE to
         // do this, or we'll leak. Even if something returned
         //      OTSmartContract::CleanupAccts(map_Accts_NewlyLoaded); // false,
         // some objects may have been loaded before it failed.
     }
 
     const bool bSuccess = (!bAreAnyInvalidParties &&
                            !bAreAnyInvalidAccounts); // <=== THE RETURN VALUE
 
     if (bAreAnyInvalidParties)
         otOut << __FUNCTION__ << ": Failure: There are invalid party(s) on "
                                  "this smart contract.\n";
 
     if (bAreAnyInvalidAccounts)
         otOut << __FUNCTION__ << ": Failure: there are invalid account(s) or "
                                  "authorized agent(s) on this smart "
                                  "contract.\n";
 
     // IF we marked the numbers as IN USE (bBurnTransNo) but then FAILURE
     // occurred,
     // then we need to CLOSE the opening numbers (RemoveIssuedNum) meaning they
     // are done
     // and over, and can never be used again, and we also need to HARVEST the
     // CLOSING
     // numbers, meaning they are available again for use in the future.
     // (If failure occurred in a case where we did NOT burn the numbers, then we
     // wouldn't
     // be worried about putting them back, now would we?)
     //
     //
     if (!bSuccess &&  // If this function was not a success, overall, and
         bBurnTransNo) // if we DID burn (mark as 'in use') the numbers during
                       // this function...
     {
         // CloseoutOpeningNumbers...
         // This closes the opening numbers for all parties except the activator
         // Nym.
         // Why not him? Because his is already closed out in
         // NotarizeTransaction, if
         // the transaction has failed.
         //
         // Also, where that happens, his set of open cron items is also updated
         // to
         // remove the number from that list. (As the below function also does
         // for the rest
         // of the nyms involved.)
         //
         CloseoutOpeningNumbers(&theServerNym);
 
         // Then harvest those closing numbers back again (for ALL Nyms.)
         // (Not the opening numbers, which are already burned for good by this
         // point.)
         //
         HarvestClosingNumbers(
             &theServerNym, // theServerNym is the signer, here on the server
                            // side.
             &theFailedParties); // Since we skipped marking the closing numbers
                                 // for these failed parties, then we skip adding
                                 // those same numbers back again, too.
     }
 
     // Now that all potentially-needed harvesting is done, we can clean up.
     //
     ClearTemporaryPointers(); // Don't want any bad pointers floating
                               // around after cleanup.
 
     OTSmartContract::CleanupNyms(
         map_Nyms_Loaded_In_This_Function); // HAVE to do this, or we'll leak.
                                            // Even if something returned
     OTSmartContract::CleanupAccts(
         map_Accts_Loaded_In_This_Function); // false, some objects may have been
                                             // loaded before it failed.
 
     // DONE: if the above loop fails halfway through, then we should really PUT
     // BACK the closing
     // transaction #s that we removed. After all, we have a list of them.
     // Otherwise the only way
     // to know which parties have their numbers still, and which ones don't,
     // would be to stick a notice
     // in their nymbox, like we do for finalReceipt.  Perhaps such a notice
     // should ALWAYS go into the
     // Nymbox in these cases... *shrug*
 
     return bSuccess;
 }

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

/usr/local/src/opentxs/include/opentxs/core/script/OTSmartContract.hpp
/usr/local/src/opentxs/src/core/script/OTSmartContract.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation