#include <OTScriptable.hpp>

Inheritance diagram for opentxs::OTScriptable:

Collaboration diagram for opentxs::OTScriptable:

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

int32_t	GetPartyCount () const

int32_t	GetBylawCount () const

virtual EXPORT bool	AddParty (OTParty &theParty)

virtual EXPORT bool	AddBylaw (OTBylaw &theBylaw)

virtual EXPORT bool	ConfirmParty (OTParty &theParty)

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

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

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

EXPORT OTParty *	GetPartyByIndex (int32_t nIndex) const

EXPORT OTBylaw *	GetBylawByIndex (int32_t nIndex) const

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

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

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

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

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

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

OTAgent *	GetAgent (std::string str_agent_name) const

OTPartyAccount *	GetPartyAccount (std::string str_acct_name) const

OTPartyAccount *	GetPartyAccountByID (const OTIdentifier &theAcctID) const

EXPORT int32_t	GetCountTransNumsNeededForAgent (std::string str_agent_name) const

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

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

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

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

EXPORT bool	VerifyThisAgainstAllPartiesSignedCopies ()

EXPORT bool	AllPartiesHaveSupposedlyConfirmed ()

void	RetrieveNymPointers (mapOfNyms &map_Nyms_Already_Loaded)

void	ClearTemporaryPointers ()

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

OTClause *	GetCallback (std::string str_CallbackName)

OTVariable *	GetVariable (std::string str_VarName)

bool	IsDirty () const

bool	IsDirtyImportant () const

void	SetAsClean ()

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

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

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

virtual EXPORT void	RegisterOTNativeCallsWithScript (OTScript &theScript)

virtual EXPORT bool	Compare (OTScriptable &rhs) const

	OTScriptable ()

virtual	~OTScriptable ()

void	UpdateContentsToString (OTString &strAppend, bool bCalculatingID) const

virtual EXPORT void	CalculateContractID (OTIdentifier &newID) const

virtual void	Release ()

void	Release_Scriptable ()

virtual void	UpdateContents ()

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

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

void	SetIdentifier (const OTIdentifier &theID)

EXPORT	OTContract ()

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

EXPORT	OTContract (const OTString &strID)

EXPORT	OTContract (const OTIdentifier &theID)

void	Initialize ()

virtual EXPORT	~OTContract ()

EXPORT void	Release_Contract ()

EXPORT void	ReleaseSignatures ()

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

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

EXPORT void	GetName (OTString &strName) const

EXPORT void	SetName (const OTString &strName)

virtual EXPORT bool	VerifyContract ()

virtual EXPORT void	GetIdentifier (OTIdentifier &theIdentifier) const

virtual EXPORT void	GetIdentifier (OTString &theIdentifier) const

EXPORT void	GetFilename (OTString &strFilename) const

EXPORT void	GetFoldername (OTString &strFoldername) const

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 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 int32_t	ProcessXMLNode (irr::io::IrrXMLReader *&xml)

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

Protected Attributes
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 155 of file OTScriptable.hpp.

Constructor & Destructor Documentation

opentxs::OTScriptable::OTScriptable ( )

Definition at line 3387 of file OTScriptable.cpp.

     : ot_super()
     , m_bCalculatingID(false)
     , // This is not serialized.
     m_bSpecifyAssetID(false)
     , m_bSpecifyParties(false) // These are.
 {
 }

opentxs::OTScriptable::~OTScriptable ( )

virtual

Definition at line 3396 of file OTScriptable.cpp.

 {
     Release_Scriptable();
 }

Member Function Documentation

bool opentxs::OTScriptable::AddBylaw ( OTBylaw & theBylaw )

virtual

Definition at line 2162 of file OTScriptable.cpp.

 {
     const std::string str_name = theBylaw.GetName().Get();
 
     if (!OTScriptable::ValidateName(str_name)) // this logs, FYI.
     {
         otErr << "OTScriptable::AddBylaw:  Error: invalid name.\n";
         return false;
     }
 
     if (m_mapBylaws.find(str_name) == m_mapBylaws.end()) {
         // Careful:  This ** DOES ** TAKE OWNERSHIP!  theBylaw will get deleted
         // when this OTScriptable is.
         m_mapBylaws.insert(
             std::pair<std::string, OTBylaw*>(str_name, &theBylaw));
 
         theBylaw.SetOwnerAgreement(*this);
 
         return true;
     }
     else
         otOut << "OTScriptable::AddBylaw: Failed attempt: bylaw already exists "
                  "on contract.\n ";
 
     return false;
 }

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

virtual

Reimplemented in opentxs::OTSmartContract.

Definition at line 2135 of file OTScriptable.cpp.

 {
     const std::string str_party_name = theParty.GetPartyName();
 
     if (!OTScriptable::ValidateName(str_party_name)) // this logs, FYI.
     {
         otErr << "OTScriptable::AddParty:  Error: invalid name.\n";
         return false;
     }
 
     if (m_mapParties.find(str_party_name) == m_mapParties.end()) {
         // Careful:  This ** DOES ** TAKE OWNERSHIP!  theParty will get deleted
         // when this OTScriptable is.
         m_mapParties.insert(
             std::pair<std::string, OTParty*>(str_party_name, &theParty));
 
         theParty.SetOwnerAgreement(*this);
 
         return true;
     }
     else
         otOut << "OTScriptable::AddParty: Failed attempt: party already exists "
                  "on contract.\n ";
 
     return false;
 }

bool opentxs::OTScriptable::AllPartiesHaveSupposedlyConfirmed ( )

Definition at line 501 of file OTScriptable.cpp.

 {
     bool bReturnVal = !m_mapParties.empty();
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (!(pParty->GetMySignedCopy().Exists())) return false;
     }
 
     return bReturnVal;
 }

void opentxs::OTScriptable::CalculateContractID ( OTIdentifier & newID ) const

virtual

Reimplemented from opentxs::OTContract.

Definition at line 2276 of file OTScriptable.cpp.

 {
     // Produce a template version of the scriptable.
     OTStringXML xmlUnsigned;
     UpdateContentsToString(xmlUnsigned, true);
 
     newID.CalculateDigest(xmlUnsigned);
 }

bool opentxs::OTScriptable::CanExecuteClause	(	std::string	str_party_name,
		std::string	str_clause_name
	)

Definition at line 322 of file OTScriptable.cpp.

 {
     OTParty* pParty = GetParty(str_party_name);
     OTClause* pClause = GetClause(str_clause_name);
 
     if (nullptr == pParty) {
         otOut << "OTScriptable::CanExecuteClause: Unable to find this party: "
               << (str_party_name.size() > 0 ? str_party_name.c_str() : "")
               << "\n";
         return false;
     }
 
     if (nullptr == pClause) {
         otOut << "OTScriptable::CanExecuteClause: Unable to find this clause: "
               << (str_clause_name.size() > 0 ? str_clause_name.c_str() : "")
               << "\n";
         return false;
     }
     // Below this point, pParty and pClause are both 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.
     //
     // Todo: 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!
     //
     // NOTE (Above):  When it came time to compile, I realized that OTScriptable
     // has no pointer to Cron,
     // nor access to any ServerNym (unless you pass it in).  But I want this
     // function to work by merely
     // passing in 2 strings.
     //
     // SINCE THE PARTY IS VERIFIED ALREADY (WHEN THE SMART CONTRACT IS FIRST
     // ACTIVATED) THEN THIS IS
     // REDUNDANT ANYWAY.
     //
     // IF you ever need to use CanExecuteClause() in some circumstance where the
     // party has NOT been verified
     // anyway (it won't be from within some script...) then just call
     // VerifyPartyAuthorization() yourself in
     // that code, wherever you need to.
 
     //
     // DISALLOW parties to directly execute any clauses named similarly to
     // callbacks, hooks, or cron hooks!
     // Only allow this for normal clauses.
     //
     if (str_clause_name.compare(0, 5, "cron_") == 0) // todo stop hardcoding
     {
         otOut << "OTScriptable::CanExecuteClause: Parties may not directly "
                  "trigger clauses beginning in cron_\n";
         return false;
     }
 
     if (str_clause_name.compare(0, 5, "hook_") == 0) // todo stop hardcoding
     {
         otOut << "OTScriptable::CanExecuteClause: Parties may not directly "
                  "trigger clauses beginning in hook_\n";
         return false;
     }
 
     if (str_clause_name.compare(0, 9, "callback_") == 0) // todo stop hardcoding
     {
         otOut << "OTScriptable::CanExecuteClause: Parties may not directly "
                  "trigger clauses beginning in callback_\n";
         return false;
     }
 
     // IF NO CALLBACK IS PROVIDED, The default answer to this function is:
     //     YES, this party MAY run this clause!
     //
     // But... first we check to see if this OTScriptable has a clause named:
     //          "callback_party_may_execute_clause"
     // ...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 execute
     // which clauses.
 
     //
     const std::string str_CallbackName(SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE);
 
     OTClause* pCallbackClause =
         GetCallback(str_CallbackName); // See if there is a script clause
                                        // registered for this callback.
 
     if (nullptr != pCallbackClause) // Found it!
     {
         otOut << "OTScriptable::CanExecuteClause: Found script for: "
               << SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE << ". 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 param1("param_party_name", str_party_name,
                           OTVariable::Var_Constant);
         OTVariable param2("param_clause_name", str_clause_name,
                           OTVariable::Var_Constant);
 
         OTVariable theReturnVal("return_val", false);
 
         mapOfVariables theParameters;
         theParameters.insert(
             std::pair<std::string, OTVariable*>("param_party_name", &param1));
         theParameters.insert(
             std::pair<std::string, OTVariable*>("param_clause_name", &param2));
 
         if (false ==
             ExecuteCallback(
                 *pCallbackClause, theParameters,
                 theReturnVal)) // <============================================
         {
             otErr << "OTScriptable::CanExecuteClause: Error while running "
                      "callback script " << SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE
                   << ", clause " << str_clause_name << " \n";
             return false;
         }
         else {
             otOut << "OTScriptable::CanExecuteClause: Success executing "
                      "callback script " << SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE
                   << ", clause: " << str_clause_name << ".\n\n";
 
             return theReturnVal.CopyValueBool();
         }
 
     }
     else {
         otOut << "OTScriptable::CanExecuteClause: Unable to find script for: "
               << SCRIPTABLE_CALLBACK_PARTY_MAY_EXECUTE
               << ". Therefore, default return value is: TRUE.\n";
     }
 
     return true;
 }

void opentxs::OTScriptable::ClearTemporaryPointers ( )

Definition at line 515 of file OTScriptable.cpp.

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

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

virtual

Reimplemented in opentxs::OTSmartContract.

Definition at line 2206 of file OTScriptable.cpp.

 {
     const char* szFunc = "OTScriptable::Compare";
     //
     // UPDATE: ALL of the parties should be there, in terms of their
     // names and account names --- but the actual IDs can remain blank,
     // and the signed copies can be blank. (Those things are all verified
     // elsewhere. That's about verifying the signature and authorization,
     // versus verifying the content.)
     //
     if (GetPartyCount() != rhs.GetPartyCount()) {
         otOut << szFunc << ": The number of parties does not match.\n";
         return false;
     }
     if (GetBylawCount() != rhs.GetBylawCount()) {
         otOut << szFunc << ": The number of bylaws does not match.\n";
         return false;
     }
 
     for (const auto& it : m_mapBylaws) {
         const std::string str_bylaw_name = it.first;
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         OTBylaw* p2 = rhs.GetBylaw(str_bylaw_name);
 
         if (nullptr == p2) {
             otOut << szFunc << ": Unable to find bylaw " << str_bylaw_name
                   << " on rhs.\n";
             return false;
         }
         else if (!pBylaw->Compare(*p2)) {
             otOut << szFunc << ": Bylaws don't match: " << str_bylaw_name
                   << ".\n";
             return false;
         }
     }
 
     for (const auto& it : m_mapParties) {
         const std::string str_party_name = it.first;
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         OTParty* p2 = rhs.GetParty(str_party_name);
 
         if (nullptr == p2) {
             otOut << szFunc << ": Unable to find party " << str_party_name
                   << " on rhs.\n";
             return false;
         }
         else if (!pParty->Compare(*p2)) {
             otOut << szFunc << ": Parties don't match: " << str_party_name
                   << ".\n";
             return false;
         }
     }
 
     return true;
 }

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

virtual

Reimplemented in opentxs::OTSmartContract.

Definition at line 2033 of file OTScriptable.cpp.

 {
     const std::string str_party_name = theParty.GetPartyName();
 
     if (!OTScriptable::ValidateName(str_party_name)) // this logs, FYI.
     {
         otErr << "OTScriptable::ConfirmParty:  Error: invalid name.\n";
         return false;
     }
 
     // MAKE SURE ALL SIGNED COPIES ARE OF THE SAME CONTRACT.
     // Loop through ALL the parties. For whichever ones are already signed,
     // load up the signed copy and make sure it compares to the main one.
     // This is in order to make sure that I am signing the same thing that
     // everyone else signed, before I actually sign it.
     //
     if (!VerifyThisAgainstAllPartiesSignedCopies())
         return false; // This already logs on failure.
 
     // BY THIS POINT, we know that, of all the parties who have already signed,
     // their signed copies DO match this smart contract.
     //
 
     //
     // Next, find the theoretical Party on this scriptable that matches the
     // actual Party that
     // was passed in. (It should already be there.) If found, replace it with
     // the one passed in.
     // Then sign the contract, save the signed version in the new party, and
     // then sign again.
     //
     // If NOT found, then we failed. (For trying to confirm a non-existent
     // party.)
     //
     auto it_delete = m_mapParties.find(str_party_name);
 
     if (it_delete != m_mapParties.end()) // It was already there. (Good.)
     {
         OTParty* pParty = it_delete->second;
         OT_ASSERT(nullptr != pParty);
 
         if (!pParty->Compare(theParty)) // Make sure my party compares to the
                                         // one it's replacing...
         {
             otOut << "OTScriptable::ConfirmParty: Party (" << str_party_name
                   << ") doesn't match the one it's confirming.\n";
             return false;
         }
         // else...
         m_mapParties.erase(it_delete); // Remove the theoretical party from the
                                        // map, so we can replace it with the
                                        // real one.
         delete pParty;
         pParty = nullptr; // Delete it, since I own it.
 
         // Careful:  This ** DOES ** TAKE OWNERSHIP!  theParty will get deleted
         // when
         // this OTScriptable instance is.
         //
         m_mapParties.insert(
             std::pair<std::string, OTParty*>(str_party_name, &theParty));
         theParty.SetOwnerAgreement(*this); // Now the actual party is in place,
                                            // instead of a placekeeper version
                                            // of it. There are actual Acct/Nym
                                            // IDs now, etc.
 
         // Sign it and save it,
         OTString strNewSignedCopy;
         ReleaseSignatures();
         bool bSuccess = theParty.SignContract(*this);
         if (bSuccess) {
             SaveContract();
             SaveContractRaw(strNewSignedCopy);
 
             // then save a copy of it inside theParty,
             //
             theParty.SetMySignedCopy(strNewSignedCopy);
 
             // then sign the overall thing again, so that signed copy (now
             // inside theParty) will be properly saved.
             // That way when other people verify my signature, it will be there
             // for them to verify.
             //
             ReleaseSignatures();
             theParty.SignContract(*this);
             SaveContract();
 
             return true;
         }
 
         return false;
     }
     else
         otOut << "OTScriptable::ConfirmParty: Failed attempt to confirm "
                  "non-existent party: " << str_party_name << " \n ";
 
     return false;
 }

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

Definition at line 525 of file OTScriptable.cpp.

 {
     const std::string str_clause_name = theCallbackClause.GetName().Exists()
                                             ? theCallbackClause.GetName().Get()
                                             : "";
     OT_ASSERT(OTScriptable::ValidateName(str_clause_name));
 
     OTBylaw* pBylaw = theCallbackClause.GetBylaw();
     OT_ASSERT(nullptr != pBylaw);
 
     // By this point, we have the clause we are executing as theCallbackClause,
     // and we have the Bylaw it belongs to, as pBylaw.
 
     const std::string str_code =
         theCallbackClause.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);
 
     //
     // 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);
         }
 
         // Add the parameters...
         for (auto& it : theParameters) {
             const std::string str_var_name = it.first;
             OTVariable* pVar = it.second;
             OT_ASSERT((nullptr != pVar) && (str_var_name.size() > 0));
 
             pVar->RegisterForExecution(*pScript);
         }
 
         // Also need to loop through the Variables on pBylaw and register those
         // as well.
         //
         pBylaw->RegisterVariablesForExecution(*pScript); // This sets all the
                                                          // variables as CLEAN
                                                          // so we can check for
                                                          // dirtiness after
                                                          // execution.
         //
 
         SetDisplayLabel(&str_clause_name);
 
         pScript->SetDisplayFilename(m_strLabel.Get());
 
         if (!pScript->ExecuteScript(&varReturnVal)) {
             otErr << "OTScriptable::ExecuteCallback: Error while running "
                      "callback on scriptable: " << m_strLabel << "\n";
         }
         else {
             otOut << "OTScriptable::ExecuteCallback: Successfully executed "
                      "callback on scriptable: " << m_strLabel << "\n\n";
             return true;
         }
     }
     else {
         otErr << "OTScriptable::ExecuteCallback: Error instantiating script!\n";
     }
 
     // NOTE: Normally after calling a script, you want to check to see if any of
     // the persistent variables
     // are dirty, and if important, send a notice to the parties, save an
     // updated copy of the contract, etc.
     // WE DON'T DO THAT FOR CALLBACKS!  Why not?
     //
     // 1) It only matters if the variables change, if you are actually saving an
     // updated version of the contract.
     //    (Which is more OTCronItem / OTSmartContract, which saves an updated
     // copy of itself.) Whereas if you are
     //    NOT saving the contract with those variables in it, then why the hell
     // would you care to notify people?
     // 2) Since only OTCronItem / OTSmartContract actually save updated copies
     // of themselves, they are the only ones
     //    who will ever need to notify anyone. Not EVERY OTScriptable-derived
     // class will send notifications, but if they
     //    need to, SendNoticeToAllParties() is already available on
     // OTScriptable.
     //
     // 3) MOST IMPORTANTLY: the only time a callback is currently triggered is
     // when the script has already been activated
     //    somehow, and the only places that do that ALREADY SEND NOTICES WHEN
     // DIRTY. In fact, if a callback actually makes
     //    the scriptable dirty, IT WILL SEND NOTICES ANYWAY, since the
     // "ExecuteClauses()" function that CALLED the callback
     //    is also smart enough to send the notices already.
     //
 
     return false;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnAccount	(	OTAccount &	theAccount,
		OTPartyAccount **	ppPartyAccount = `nullptr`
	)		const

Definition at line 894 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAccount(theAccount, ppPartyAccount)) {
             return pParty;
         }
     }
     return nullptr;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnAccountID	(	const OTIdentifier &	theAcctID,
		OTPartyAccount **	ppPartyAccount = `nullptr`
	)		const

Definition at line 856 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAccountByID(theAcctID, ppPartyAccount)) {
             return pParty;
         }
     }
     return nullptr;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnNymAsAgent	(	OTPseudonym &	theNym,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 870 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAgent(theNym, ppAgent)) return pParty;
     }
     return nullptr;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnNymAsAuthAgent	(	OTPseudonym &	theNym,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 882 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAuthorizingAgent(theNym, ppAgent)) return pParty;
     }
     return nullptr;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnNymIDAsAgent	(	const OTIdentifier &	theNymID,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 831 of file OTScriptable.cpp.

 {
     for (const auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAgentByNymID(theNymID, ppAgent)) return pParty;
     }
     return nullptr;
 }

OTParty * opentxs::OTScriptable::FindPartyBasedOnNymIDAsAuthAgent	(	const OTIdentifier &	theNymID,
		OTAgent **	ppAgent = `nullptr`
	)		const

Definition at line 843 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->HasAuthorizingAgentByNymID(theNymID, ppAgent))
             return pParty;
     }
     return nullptr;
 }

OTAgent * opentxs::OTScriptable::GetAgent ( std::string str_agent_name ) const

Definition at line 1867 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_agent_name)) // this logs, FYI.
     {
         otErr << __FUNCTION__ << ": Error: invalid name.\n";
         return nullptr;
     }
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         OTAgent* pAgent = pParty->GetAgent(str_agent_name);
 
         if (nullptr != pAgent) // found it.
             return pAgent;
     }
 
     return nullptr;
 }

OTBylaw * opentxs::OTScriptable::GetBylaw ( std::string str_bylaw_name ) const

Definition at line 1888 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_bylaw_name)) // this logs, FYI.
     {
         otErr << __FUNCTION__ << ": Error: invalid name.\n";
         return nullptr;
     }
 
     auto it = m_mapBylaws.find(str_bylaw_name);
 
     if (m_mapBylaws.end() == it) // Did NOT find it.
     {
         return nullptr;
     }
 
     OTBylaw* pBylaw = it->second;
     OT_ASSERT(nullptr != pBylaw);
 
     return pBylaw;
 }

OTBylaw * opentxs::OTScriptable::GetBylawByIndex ( int32_t nIndex ) const

Definition at line 1951 of file OTScriptable.cpp.

 {
     if ((nIndex < 0) || (nIndex >= static_cast<int64_t>(m_mapBylaws.size()))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
 
         int32_t nLoopIndex = -1; // will be 0 on first iteration.
 
         for (auto& it : m_mapBylaws) {
             OTBylaw* pBylaw = it.second;
             OT_ASSERT(nullptr != pBylaw);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pBylaw;
         }
     }
     return nullptr;
 }

int32_t opentxs::OTScriptable::GetBylawCount ( ) const

inline

Definition at line 252 of file OTScriptable.hpp.

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

OTClause * opentxs::OTScriptable::GetCallback ( std::string str_CallbackName )

Definition at line 3302 of file OTScriptable.cpp.

 {
     if ((false == OTScriptable::ValidateName(str_CallbackName)) ||
         (str_CallbackName.compare(0, 9, "callback_") != 0)) // this logs, FYI.
     {
         otErr << "OTScriptable::GetCallback:  Error: invalid name: "
               << str_CallbackName << "\n";
         return nullptr;
     }
 
     for (auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         OTClause* pClause = pBylaw->GetCallback(str_CallbackName);
 
         if (nullptr != pClause) // found it.
             return pClause;
     }
 
     return nullptr;
 }

OTClause * opentxs::OTScriptable::GetClause ( std::string str_clause_name ) const

Definition at line 1846 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_clause_name)) // this logs, FYI.
     {
         otErr << __FUNCTION__ << ": Error: invalid name.\n";
         return nullptr;
     }
 
     for (auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         OTClause* pClause = pBylaw->GetClause(str_clause_name);
 
         if (nullptr != pClause) // found it.
             return pClause;
     }
 
     return nullptr;
 }

int32_t opentxs::OTScriptable::GetCountTransNumsNeededForAgent ( std::string str_agent_name ) const

Definition at line 768 of file OTScriptable.cpp.

 {
     int32_t nReturnVal = 0;
 
     OTAgent* pAgent = GetAgent(str_agent_name);
     if (nullptr == pAgent)
         return nReturnVal; // (Looks like there is no agent with that name.)
 
     // Below this point, pAgent is good, meaning str_agent_name really IS
     // a legit agent for this party. But that doesn't necessarily mean the
     // agent has to supply any opening or closing transaction #s for this
     // smart contract. That's only true if he's the AUTHORIZING agent for
     // the party (for the opening num) or the authorized agent for any of
     // party's accounts (for the closing number).  So let's add it up...
     //
     if (pAgent->IsAuthorizingAgentForParty()) // true/false whether THIS agent
                                               // is the authorizing agent for
                                               // his party.
         nReturnVal++;
 
     // Add the number of accounts, owned by this agent's party, that this agent
     // is the authorized agent FOR.
     //
     nReturnVal += pAgent->GetCountAuthorizedAccts();
 
     return nReturnVal;
 }

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

Definition at line 3327 of file OTScriptable.cpp.

 {
     if ((false == OTScriptable::ValidateName(str_HookName)) ||
         ((str_HookName.compare(0, 5, "cron_") != 0) &&
          (str_HookName.compare(0, 5, "hook_") != 0))) // this logs, FYI.
     {
         otErr << "OTScriptable::GetHooks:  Error: invalid name.\n";
         return false;
     }
 
     bool bReturnVal = false;
 
     for (auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         // Look up all clauses matching a specific hook.
         //
         if (pBylaw->GetHooks(str_HookName, theResults)) bReturnVal = true;
     }
 
     return bReturnVal;
 }

OTParty * opentxs::OTScriptable::GetParty ( std::string str_party_name ) const

Definition at line 1909 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_party_name)) // this logs, FYI.
     {
         otErr << __FUNCTION__ << ": Error: invalid name.\n";
         return nullptr;
     }
 
     auto it = m_mapParties.find(str_party_name);
 
     if (m_mapParties.end() == it) // Did NOT find it.
     {
         return nullptr;
     }
 
     OTParty* pParty = it->second;
     OT_ASSERT(nullptr != pParty);
 
     return pParty;
 }

OTPartyAccount * opentxs::OTScriptable::GetPartyAccount ( std::string str_acct_name ) const

Definition at line 797 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_acct_name)) // this logs, FYI.
     {
         otErr << "OTScriptable::GetPartyAccount:  Error: invalid name.\n";
         return nullptr;
     }
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
         OTPartyAccount* pAcct = pParty->GetAccount(str_acct_name);
         if (nullptr != pAcct) // found it.
             return pAcct;
     }
     return nullptr;
 }

OTPartyAccount * opentxs::OTScriptable::GetPartyAccountByID ( const OTIdentifier & theAcctID ) const

Definition at line 815 of file OTScriptable.cpp.

 {
     for (const auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         OTPartyAccount* pAcct = pParty->GetAccountByID(theAcctID);
 
         if (nullptr != pAcct) // found it.
             return pAcct;
     }
 
     return nullptr;
 }

OTParty * opentxs::OTScriptable::GetPartyByIndex ( int32_t nIndex ) const

Definition at line 1930 of file OTScriptable.cpp.

 {
     if ((nIndex < 0) || (nIndex >= static_cast<int64_t>(m_mapParties.size()))) {
         otErr << __FUNCTION__ << ": Index out of bounds: " << nIndex << "\n";
     }
     else {
 
         int32_t nLoopIndex = -1; // will be 0 on first iteration.
 
         for (auto& it : m_mapParties) {
             OTParty* pParty = it.second;
             OT_ASSERT(nullptr != pParty);
 
             ++nLoopIndex; // 0 on first iteration.
 
             if (nLoopIndex == nIndex) return pParty;
         }
     }
     return nullptr;
 }

int32_t opentxs::OTScriptable::GetPartyCount ( ) const

inline

Definition at line 248 of file OTScriptable.hpp.

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

std::string opentxs::OTScriptable::GetTime ( void )

static

Definition at line 301 of file OTScriptable.cpp.

 {
     const time64_t CURRENT_TIME = OTTimeGetCurrentTime();
     const int64_t lTime = OTTimeGetSecondsFromTime(CURRENT_TIME);
 
     OTString strTime;
     strTime.Format("%lld", lTime);
     return strTime.Get();
 }

OTVariable * opentxs::OTScriptable::GetVariable ( std::string str_VarName )

Definition at line 3278 of file OTScriptable.cpp.

 {
     if (!OTScriptable::ValidateName(str_VarName)) // this logs, FYI.
     {
         otErr << "OTScriptable::GetVariable:  Error: invalid name.\n";
         return nullptr;
     }
 
     for (auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         OTVariable* pVar = pBylaw->GetVariable(str_VarName);
 
         if (nullptr != pVar) // found it.
             return pVar;
     }
 
     return nullptr;
 }

OTScriptable * opentxs::OTScriptable::InstantiateScriptable ( const OTString & strInput )

static

Definition at line 173 of file OTScriptable.cpp.

 {
     static char buf[45] = "";
 
     if (!strInput.Exists()) {
         otErr << __FUNCTION__ << ": Failure: Input string is empty.\n";
         return nullptr;
     }
 
     OTString strContract(strInput);
 
     if (!strContract.DecodeIfArmored(false)) // bEscapedIsAllowed=true
                                              // by default.
     {
         otErr << __FUNCTION__ << ": Input string apparently was encoded and "
                                  "then failed decoding. Contents: \n"
               << strInput << "\n";
         return nullptr;
     }
 
     // At this point, strContract contains the actual contents, whether they
     // were originally ascii-armored OR NOT. (And they are also now trimmed,
     // either way.)
     //
     strContract.reset(); // for sgets
     buf[0] = 0;          // probably unnecessary.
     bool bGotLine = strContract.sgets(buf, 40);
 
     if (!bGotLine) return nullptr;
 
     OTCronItem* pItem = nullptr;
 
     OTString strFirstLine(buf);
     strContract.reset(); // set the "file" pointer within this string back to
                          // index 0.
 
     // Now I feel pretty safe -- the string I'm examining is within
     // the first 45 characters of the beginning of the contract, and
     // it will NOT contain the escape "- " sequence. From there, if
     // it contains the proper sequence, I will instantiate that type.
     if (!strFirstLine.Exists() || strFirstLine.Contains("- -")) return nullptr;
 
     // There are actually two factories that load smart contracts. See
     // OTCronItem.
     //
     else if (strFirstLine.Contains(
                  "-----BEGIN SIGNED SMARTCONTRACT-----")) // this string is 36
                                                           // chars long.
     {
         pItem = new OTSmartContract();
         OT_ASSERT(nullptr != pItem);
     }
 
     // The string didn't match any of the options in the factory.
     if (nullptr == pItem) return nullptr;
 
     // Does the contract successfully load from the string passed in?
     if (pItem->LoadContractFromString(strContract))
         return pItem;
     else
         delete pItem;
 
     return nullptr;
 }

bool opentxs::OTScriptable::IsDirty ( ) const

Definition at line 706 of file OTScriptable.cpp.

 {
     bool bIsDirty = false;
 
     for (const auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         if (pBylaw->IsDirty()) {
             bIsDirty = true;
             break;
         }
     }
 
     return bIsDirty;
 }

bool opentxs::OTScriptable::IsDirtyImportant ( ) const

Definition at line 726 of file OTScriptable.cpp.

 {
     bool bIsDirty = false;
 
     for (const auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
 
         if (pBylaw->IsDirtyImportant()) {
             bIsDirty = true;
             break;
         }
     }
 
     return bIsDirty;
 }

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

protectedvirtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::OTPaymentPlan, opentxs::OTAgreement, opentxs::OTSmartContract, opentxs::OTOffer, opentxs::OTCronItem, opentxs::OTTrade, opentxs::Token, opentxs::OTInstrument, and opentxs::OTCheque.

Definition at line 2332 of file OTScriptable.cpp.

 {
     int32_t nReturnVal = 0; // Unless/until I want to add OTContract::Compare(),
                             // then people would be able to surreptitiously
                             // insert keys and
     //    int32_t nReturnVal = ot_super::ProcessXMLNode(xml); // conditions, and
     // entities, that passed OTScriptable::Compare() with flying colors
     //  even though they didn't really match. Therefore, here I explicitly
     // disallow loading those things.
 
     // Here we call the parent class first.
     // If the node is found there, or there is some error,
     // then we just return either way.  But if it comes back
     // as '0', then nothing happened, and we'll continue executing.
     //
     // -- Note: you can choose not to call the parent, if
     // you don't want to use any of those xml tags.
 
     //    if (nReturnVal == 1 || nReturnVal == (-1))
     //        return nReturnVal;
 
     const OTString strNodeName(xml->getNodeName());
 
     //    otErr << "OTScriptable::ProcessXMLNode:  strNodeName: %s \n",
     // strNodeName.Get());
 
     if (strNodeName.Compare("scriptableContract")) {
         const char* szFunc = "OTScriptable::ProcessXMLNode";
         const OTString strSpecify1 = xml->getAttributeValue("specifyAssetID");
         const OTString strSpecify2 = xml->getAttributeValue("specifyParties");
 
         OTString strNumParties = xml->getAttributeValue("numParties");
         OTString strNumBylaws = xml->getAttributeValue("numBylaws");
 
         // These determine whether asset IDs and/or party owner IDs
         // are used on the template for any given smart contract.
         // (Some templates are specific to certain asset types, while
         // other smart contract types allow you to leave asset ID blank
         // until the confirmation phase.)
         //
         if (strSpecify1.Compare("true")) m_bSpecifyAssetID = true;
         if (strSpecify2.Compare("true")) m_bSpecifyParties = true;
 
         // Load up the Parties.
         //
         int32_t nPartyCount =
             strNumParties.Exists() ? atoi(strNumParties.Get()) : 0;
         if (nPartyCount > 0) {
             while (nPartyCount-- > 0) {
                 //                xml->read(); // <==================
                 if (!SkipToElement(xml)) {
                     otOut << szFunc << ": Failure: Unable to find expected "
                                        "element for party. \n";
                     return (-1);
                 }
 
                 //                otOut << "%s: Looping to load parties:
                 // currently on: %s \n", szFunc, xml->getNodeName());
 
                 if ((!strcmp("party", xml->getNodeName()))) {
                     OTString strName = xml->getAttributeValue(
                         "name"); // Party name (in script code)
                     OTString strOwnerType = xml->getAttributeValue(
                         "ownerType"); // "nym" or "entity"
                     OTString strOwnerID = xml->getAttributeValue(
                         "ownerID"); // Nym or Entity ID. todo security probably
                                     // make these separate variables.
 
                     OTString strOpeningTransNo = xml->getAttributeValue(
                         "openingTransNo"); // the closing #s are on the asset
                                            // accounts.
 
                     OTString strAuthAgent = xml->getAttributeValue(
                         "authorizingAgent"); // When an agent activates this
                                              // contract, it's HIS opening
                                              // trans# that's used.
 
                     OTString strNumAgents = xml->getAttributeValue(
                         "numAgents"); // number of agents on this party.
                     OTString strNumAccounts = xml->getAttributeValue(
                         "numAccounts"); // number of accounts for this party.
 
                     OTString strIsCopyProvided =
                         xml->getAttributeValue("signedCopyProvided");
 
                     bool bIsCopyProvided = false; // default
 
                     if (strIsCopyProvided.Compare("true"))
                         bIsCopyProvided = true;
 
                     int64_t lOpeningTransNo = 0;
 
                     if (strOpeningTransNo.Exists())
                         lOpeningTransNo = atol(strOpeningTransNo.Get());
                     else
                         otErr << szFunc
                               << "s: Expected openingTransNo in party.\n";
 
                     OTParty* pParty = new OTParty(
                         strName.Exists() ? strName.Get() : "PARTY_ERROR_NAME",
                         strOwnerType.Compare("nym") ? true : false,
                         strOwnerID.Get(), strAuthAgent.Get());
                     OT_ASSERT(nullptr != pParty);
 
                     pParty->SetOpeningTransNo(
                         lOpeningTransNo); // WARNING:  NEED TO MAKE SURE pParty
                                           // IS CLEANED UP BELOW THIS POINT, IF
                                           // FAILURE!!
 
                     // Load up the agents.
                     //
                     int32_t nAgentCount =
                         strNumAgents.Exists() ? atoi(strNumAgents.Get()) : 0;
                     if (nAgentCount > 0) {
                         while (nAgentCount-- > 0) {
                             //                          xml->read(); //
                             // <==================
                             if (!SkipToElement(xml)) {
                                 otOut << szFunc << ": Failure: Unable to find "
                                                    "expected element for "
                                                    "agent. \n";
                                 delete pParty;
                                 pParty = nullptr;
                                 return (-1);
                             }
 
                             if ((xml->getNodeType() == irr::io::EXN_ELEMENT) &&
                                 (!strcmp("agent", xml->getNodeName()))) {
                                 OTString strAgentName = xml->getAttributeValue(
                                     "name"); // Agent name (if needed in script
                                              // code)
                                 OTString strAgentRepSelf =
                                     xml->getAttributeValue(
                                         "doesAgentRepresentHimself"); // Agent
                                                                       // might
                                 // also BE the
                                 // party, and
                                 // not just
                                 // party's
                                 // employee.
                                 OTString strAgentIndividual =
                                     xml->getAttributeValue(
                                         "isAgentAnIndividual"); // Is the agent
                                                                 // a voting
                                                                 // group, or an
                                                                 // individual
                                                                 // nym? (whether
                                                                 // employee or
                                                                 // not)
                                 OTString strNymID = xml->getAttributeValue(
                                     "nymID"); // Nym ID if Nym in role for
                                               // entity, or if representing
                                               // himself.
                                 OTString strRoleID = xml->getAttributeValue(
                                     "roleID"); // Role ID if Nym in Role.
                                 OTString strGroupName = xml->getAttributeValue(
                                     "groupName"); // Group name if voting group.
                                                   // (Relative to entity.)
 
                                 if (!strAgentName.Exists() ||
                                     !strAgentRepSelf.Exists() ||
                                     !strAgentIndividual.Exists()) {
                                     otErr << szFunc << ": Error loading agent: "
                                                        "Either the name, or "
                                                        "one of the bool "
                                                        "variables was EMPTY.\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
 
                                 if (!OTScriptable::ValidateName(
                                         strAgentName.Get())) {
                                     otErr << szFunc
                                           << ": Failed loading agent due to "
                                              "Invalid name: " << strAgentName
                                           << "\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
 
                                 bool bRepsHimself = true; // default
 
                                 if (strAgentRepSelf.Compare("false"))
                                     bRepsHimself = false;
 
                                 bool bIsIndividual = true; // default
 
                                 if (strAgentIndividual.Compare("false"))
                                     bIsIndividual = false;
 
                                 // See if the same-named agent already exists on
                                 // ANY of the OTHER PARTIES
                                 // (There can only be one agent on an
                                 // OTScriptable with a given name.)
                                 //
                                 OTAgent* pExistingAgent =
                                     GetAgent(strAgentName.Get());
 
                                 if (nullptr != pExistingAgent) // Uh-oh, it's
                                                                // already there!
                                 {
                                     otOut << szFunc
                                           << ": Error loading agent named "
                                           << strAgentName
                                           << ", since one was "
                                              "already there on party "
                                           << strName << ".\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
                                 // The AddAgent call below checks to see if it's
                                 // already there, but only for the
                                 // currently-loading party.
                                 // Whereas the above GetAgent() call checks this
                                 // OTScriptable for ALL the agents on the
                                 // already-loaded parties.
 
                                 OTAgent* pAgent = new OTAgent(
                                     bRepsHimself, bIsIndividual, strAgentName,
                                     strNymID, strRoleID, strGroupName);
                                 OT_ASSERT(nullptr != pAgent);
 
                                 if (!pParty->AddAgent(*pAgent)) {
                                     delete pAgent;
                                     pAgent = nullptr;
                                     delete pParty;
                                     pParty = nullptr;
                                     otErr
                                         << szFunc
                                         << ": Failed adding agent to party.\n";
                                     return (-1);
                                 }
 
                                 //                    xml->read(); //
                                 // <==================
 
                                 // MIGHT need to add "skip after element" here.
 
                                 // Update: Nope.
                             }
                             else {
                                 otErr << szFunc
                                       << ": Expected agent element in party.\n";
                                 delete pParty;
                                 pParty = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }
 
                     // LOAD PARTY ACCOUNTS.
                     //
                     int32_t nAcctCount = strNumAccounts.Exists()
                                              ? atoi(strNumAccounts.Get())
                                              : 0;
                     if (nAcctCount > 0) {
                         while (nAcctCount-- > 0) {
                             if (!OTContract::SkipToElement(xml)) {
                                 otErr << szFunc << ": Error finding expected "
                                                    "next element for party "
                                                    "account.\n";
                                 delete pParty;
                                 pParty = nullptr;
                                 return (-1);
                             }
 
                             if ((xml->getNodeType() == irr::io::EXN_ELEMENT) &&
                                 (!strcmp("assetAccount", xml->getNodeName()))) {
                                 OTString strAcctName = xml->getAttributeValue(
                                     "name"); // Acct name (if needed in script
                                              // code)
                                 OTString strAcctID = xml->getAttributeValue(
                                     "acctID"); // Asset Acct ID
                                 OTString strAssetTypeID =
                                     xml->getAttributeValue(
                                         "assetTypeID"); // Asset Type ID
                                 OTString strAgentName = xml->getAttributeValue(
                                     "agentName"); // Name of agent who controls
                                                   // this account.
                                 OTString strClosingTransNo =
                                     xml->getAttributeValue(
                                         "closingTransNo"); // the closing #s are
                                                            // on the asset
                                                            // accounts.
 
                                 int64_t lClosingTransNo = 0;
 
                                 if (strClosingTransNo.Exists())
                                     lClosingTransNo =
                                         atol(strClosingTransNo.Get());
                                 else {
                                     otErr << szFunc << ": Expected "
                                                        "closingTransNo in "
                                                        "partyaccount.\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
 
                                 // Missing Account ID is allowed, as well as
                                 // agent name, since those things may not be
                                 // decided yet.
                                 //
                                 if (!strAcctName.Exists() ||
                                     (m_bSpecifyAssetID &&
                                      !strAssetTypeID.Exists())) {
                                     otErr << szFunc << ": Expected missing "
                                                        "AcctID or AssetTypeID "
                                                        "or Name or AgentName "
                                                        "in partyaccount.\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
 
                                 // See if the same-named partyacct already
                                 // exists on ANY of the OTHER PARTIES
                                 // (There can only be one partyacct on an
                                 // OTScriptable with a given name.)
                                 //
                                 OTPartyAccount* pAcct =
                                     GetPartyAccount(strAcctName.Get());
 
                                 if (nullptr !=
                                     pAcct) // Uh-oh, it's already there!
                                 {
                                     otOut << szFunc
                                           << ": Error loading partyacct named "
                                           << strAcctName
                                           << ", since one was "
                                              "already there on party "
                                           << strName << ".\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
                                 // The AddAccount call below checks to see if
                                 // it's already there, but only for the
                                 // currently-loading party.
                                 // Whereas the above call checks this
                                 // OTScriptable for all the accounts on the
                                 // already-loaded parties.
 
                                 if (false ==
                                     pParty->AddAccount(
                                         strAgentName, strAcctName, strAcctID,
                                         strAssetTypeID, lClosingTransNo)) {
                                     otErr << szFunc << ": Failed adding "
                                                        "account to party.\n";
                                     delete pParty;
                                     pParty = nullptr;
                                     return (-1);
                                 }
 
                                 // MIGHT need to add "skip after field" call
                                 // here.
 
                                 // UPdate: Nope. Not here.
 
                             }
                             else {
                                 otErr << szFunc << ": Expected assetAccount "
                                                    "element in party.\n";
                                 delete pParty;
                                 pParty = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }
 
                     if (bIsCopyProvided) {
                         const char* pElementExpected = "mySignedCopy";
                         OTString strTextExpected; // signed copy will go here.
 
                         if (false ==
                             OTContract::LoadEncodedTextFieldByName(
                                 xml, strTextExpected, pElementExpected)) {
                             otErr << szFunc << ": Expected " << pElementExpected
                                   << " element with text field.\n";
                             delete pParty;
                             pParty = nullptr;
                             return (-1); // error condition
                         }
                         // else ...
 
                         pParty->SetMySignedCopy(strTextExpected);
                     }
 
                     if (AddParty(*pParty))
                         otInfo << szFunc
                                << ": Loaded Party: " << pParty->GetPartyName()
                                << "\n";
                     else {
                         otErr << szFunc << ": Failed loading Party: "
                               << pParty->GetPartyName() << "\n";
                         delete pParty;
                         pParty = nullptr;
                         return (-1); // error condition
                     }
                 }
                 else {
                     otErr << szFunc << ": Expected party element.\n";
                     return (-1); // error condition
                 }
             } // while
         }
 
         // Load up the Bylaws.
         //
         int32_t nBylawCount =
             strNumBylaws.Exists() ? atoi(strNumBylaws.Get()) : 0;
         if (nBylawCount > 0) {
             while (nBylawCount-- > 0) {
                 if (!SkipToElement(xml)) {
                     otOut << szFunc << ": Failure: Unable to find expected "
                                        "element for bylaw. \n";
                     return (-1);
                 }
 
                 if (!strcmp("bylaw", xml->getNodeName())) {
                     OTString strName =
                         xml->getAttributeValue("name"); // bylaw name
                     OTString strLanguage = xml->getAttributeValue(
                         "language"); // The script language used in this bylaw.
 
                     OTString strNumVariable = xml->getAttributeValue(
                         "numVariables"); // number of variables on this bylaw.
                     OTString strNumClauses = xml->getAttributeValue(
                         "numClauses"); // number of clauses on this bylaw.
                     OTString strNumHooks = xml->getAttributeValue(
                         "numHooks"); // hooks to server events.
                     OTString strNumCallbacks = xml->getAttributeValue(
                         "numCallbacks"); // Callbacks the server may initiate,
                                          // when it needs answers.
 
                     OTBylaw* pBylaw =
                         new OTBylaw(strName.Get(), strLanguage.Get());
 
                     OT_ASSERT(nullptr != pBylaw);
 
                     // LOAD VARIABLES AND CONSTANTS.
                     //
                     int32_t nCount = strNumVariable.Exists()
                                          ? atoi(strNumVariable.Get())
                                          : 0;
                     if (nCount > 0) {
                         while (nCount-- > 0) {
                             if (!OTContract::SkipToElement(xml)) {
                                 otErr << szFunc << ": Error finding expected "
                                                    "next element for "
                                                    "variable.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1);
                             }
 
                             if ((xml->getNodeType() == irr::io::EXN_ELEMENT) &&
                                 (!strcmp("variable", xml->getNodeName()))) {
                                 OTString strVarName = xml->getAttributeValue(
                                     "name"); // Variable name (if needed in
                                              // script code)
                                 OTString strVarValue = xml->getAttributeValue(
                                     "value"); // Value stored in variable (If
                                               // this is "true" then a real
                                               // value is expected in a text
                                               // field below. Otherwise, it's
                                               // assumed to be a BLANK STRING.)
                                 OTString strVarType = xml->getAttributeValue(
                                     "type"); // string or int64_t
                                 OTString strVarAccess = xml->getAttributeValue(
                                     "access"); // constant, persistent, or
                                                // important.
 
                                 if (!strVarName.Exists() ||
                                     !strVarType.Exists() ||
                                     !strVarAccess.Exists()) {
                                     otErr << szFunc << ": Expected missing "
                                                        "name, type, or access "
                                                        "type in variable.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                                 // See if the same-named variable already exists
                                 // on ANY of the OTHER BYLAWS
                                 // (There can only be one variable on an
                                 // OTScriptable with a given name.)
                                 //
                                 OTVariable* pVar =
                                     GetVariable(strVarName.Get());
 
                                 if (nullptr !=
                                     pVar) // Uh-oh, it's already there!
                                 {
                                     otOut << szFunc
                                           << ": Error loading variable named "
                                           << strVarName
                                           << ", since one was "
                                              "already there on one of the "
                                              "bylaws.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
                                 // The AddVariable call below checks to see if
                                 // it's already there, but only for the
                                 // currently-loading bylaw.
                                 // Whereas the above call checks this
                                 // OTScriptable for all the variables on the
                                 // already-loaded bylaws.
 
                                 // VARIABLE TYPE AND ACCESS TYPE
                                 //
                                 OTVariable::OTVariable_Type theVarType =
                                     OTVariable::Var_Error_Type;
 
                                 if (strVarType.Compare("integer"))
                                     theVarType = OTVariable::Var_Integer;
                                 else if (strVarType.Compare("string"))
                                     theVarType = OTVariable::Var_String;
                                 else if (strVarType.Compare("bool"))
                                     theVarType = OTVariable::Var_Bool;
                                 else
                                     otErr << szFunc << ": Bad variable type: "
                                           << strVarType << ".\n";
 
                                 OTVariable::OTVariable_Access theVarAccess =
                                     OTVariable::Var_Error_Access;
 
                                 if (strVarAccess.Compare("constant"))
                                     theVarAccess = OTVariable::Var_Constant;
                                 else if (strVarAccess.Compare("persistent"))
                                     theVarAccess = OTVariable::Var_Persistent;
                                 else if (strVarAccess.Compare("important"))
                                     theVarAccess = OTVariable::Var_Important;
                                 else
                                     otErr << szFunc
                                           << ": Bad variable access type: "
                                           << strVarAccess << ".\n";
 
                                 if ((OTVariable::Var_Error_Access ==
                                      theVarAccess) ||
                                     (OTVariable::Var_Error_Type ==
                                      theVarType)) {
                                     otErr << szFunc
                                           << ": Error loading variable to "
                                              "bylaw: bad type (" << strVarType
                                           << ") or access type ("
                                           << strVarAccess << ").\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                                 bool bAddedVar = false;
                                 const std::string str_var_name =
                                     strVarName.Get();
 
                                 switch (theVarType) {
                                 case OTVariable::Var_Integer:
                                     if (strVarValue.Exists()) {
                                         const int32_t nVarValue =
                                             atoi(strVarValue.Get());
                                         bAddedVar = pBylaw->AddVariable(
                                             str_var_name, nVarValue,
                                             theVarAccess);
                                     }
                                     else {
                                         otErr << szFunc
                                               << ": No value found for integer "
                                                  "variable: " << strVarName
                                               << "\n";
                                         delete pBylaw;
                                         pBylaw = nullptr;
                                         return (-1);
                                     }
                                     break;
 
                                 case OTVariable::Var_Bool:
                                     if (strVarValue.Exists()) {
                                         const bool bVarValue =
                                             strVarValue.Compare("true") ? true
                                                                         : false;
                                         bAddedVar = pBylaw->AddVariable(
                                             str_var_name, bVarValue,
                                             theVarAccess);
                                     }
                                     else {
                                         otErr << szFunc
                                               << ": No value found for bool "
                                                  "variable: " << strVarName
                                               << "\n";
                                         delete pBylaw;
                                         pBylaw = nullptr;
                                         return (-1);
                                     }
                                     break;
 
                                 case OTVariable::Var_String: {
                                     // I realized I should probably allow empty
                                     // strings.  :-P
                                     if (strVarValue.Exists() &&
                                         strVarValue.Compare("exists")) {
                                         strVarValue.Release(); // probably
                                                                // unnecessary.
                                         if (false ==
                                             OTContract::LoadEncodedTextField(
                                                 xml, strVarValue)) {
                                             otErr << szFunc
                                                   << ": No value found for "
                                                      "string variable: "
                                                   << strVarName << "\n";
                                             delete pBylaw;
                                             pBylaw = nullptr;
                                             return (-1);
                                         }
                                         // (else success)
                                     }
                                     else
                                         strVarValue.Release(); // Necessary. If
                                                                // it's going to
                                                                // be a blank
                                                                // string, then
                                                                // let's make
                                                                // sure.
 
                                     const std::string str_var_value =
                                         strVarValue.Get();
                                     bAddedVar = pBylaw->AddVariable(
                                         str_var_name, str_var_value,
                                         theVarAccess);
                                 } break;
                                 default:
                                     otErr << szFunc
                                           << ": Wrong variable type... "
                                              "somehow AFTER I should have "
                                              "already detected it...\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                                 if (!bAddedVar) {
                                     otErr << szFunc << ": Failed adding "
                                                        "variable to bylaw.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                             }
                             else {
                                 otErr << szFunc << ": Expected variable "
                                                    "element in bylaw.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }
 
                     // LOAD CLAUSES
                     //
                     nCount =
                         strNumClauses.Exists() ? atoi(strNumClauses.Get()) : 0;
                     if (nCount > 0) {
                         while (nCount-- > 0) {
                             const char* pElementExpected = "clause";
                             OTString strTextExpected; // clause's script code
                                                       // will go here.
 
                             OTString::Map temp_MapAttributes;
                             //
                             // This map contains values we will also want, when
                             // we read the clause...
                             // (The OTContract::LoadEncodedTextField call below
                             // will read all the values
                             // as specified in this map.)
                             //
                             //
                             temp_MapAttributes.insert(
                                 std::pair<std::string, std::string>("name",
                                                                     ""));
                             if (!OTContract::LoadEncodedTextFieldByName(
                                     xml, strTextExpected, pElementExpected,
                                     &temp_MapAttributes)) // </clause>
                             {
                                 otErr << szFunc << ": Error: Expected "
                                       << pElementExpected
                                       << " element with text field.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1); // error condition
                             }
 
                             // Okay we now have the script code in
                             // strTextExpected. Next, let's read the clause's
                             // NAME
                             // from the map. If it's there, and presumably some
                             // kind of harsh validation for both, then
                             // create a clause object and add to my list here.
 
                             auto it = temp_MapAttributes.find("name");
 
                             if ((it != temp_MapAttributes.end())) // We expected
                                                                   // this much.
                             {
                                 std::string& str_name = it->second;
 
                                 if (str_name.size() > 0) // SUCCESS
                                 {
 
                                     // See if the same-named clause already
                                     // exists on ANY of the OTHER BYLAWS
                                     // (There can only be one clause on an
                                     // OTScriptable with a given name.)
                                     //
                                     OTClause* pClause =
                                         GetClause(str_name.c_str());
 
                                     if (nullptr !=
                                         pClause) // Uh-oh, it's already there!
                                     {
                                         otOut
                                             << szFunc
                                             << ": Error loading clause named "
                                             << str_name
                                             << ", since one was already "
                                                "there on one of the bylaws.\n";
                                         delete pBylaw;
                                         pBylaw = nullptr;
                                         return (-1);
                                     }
                                     else if (false ==
                                                pBylaw->AddClause(
                                                    str_name.c_str(),
                                                    strTextExpected.Get())) {
                                         otErr << szFunc << ": Failed adding "
                                                            "clause to bylaw.\n";
                                         delete pBylaw;
                                         pBylaw = nullptr;
                                         return (-1); // error condition
                                     }
                                 }
                                 // else it's empty, which is expected if nothing
                                 // was there, since that's the default value
                                 // that we set above for "name" in
                                 // temp_MapAttributes.
                                 else {
                                     otErr << szFunc
                                           << ": Expected clause name.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1); // error condition
                                 }
                             }
                             else {
                                 otErr << szFunc << ": Strange error: couldn't "
                                                    "find name AT ALL.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }     // if strNumClauses.Exists() && nCount > 0
 
                     // LOAD HOOKS.
                     //
                     nCount = strNumHooks.Exists() ? atoi(strNumHooks.Get()) : 0;
                     if (nCount > 0) {
                         while (nCount-- > 0) {
                             //                          xml->read();
                             if (!SkipToElement(xml)) {
                                 otOut << szFunc << ": Failure: Unable to find "
                                                    "expected element.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1);
                             }
 
                             if ((xml->getNodeType() == irr::io::EXN_ELEMENT) &&
                                 (!strcmp("hook", xml->getNodeName()))) {
                                 OTString strHookName = xml->getAttributeValue(
                                     "name"); // Name of standard hook such as
                                              // hook_activate or cron_process,
                                              // etc
                                 OTString strClause = xml->getAttributeValue(
                                     "clause"); // Name of clause on this Bylaw
                                                // that should trigger when that
                                                // callback occurs.
 
                                 if (!strHookName.Exists() ||
                                     !strClause.Exists()) {
                                     otErr << szFunc << ": Expected missing "
                                                        "name or clause while "
                                                        "loading hook.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                                 if (false ==
                                     pBylaw->AddHook(strHookName.Get(),
                                                     strClause.Get())) {
                                     otErr << szFunc
                                           << ": Failed adding hook to bylaw.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
                             }
                             else {
                                 otErr << szFunc
                                       << ": Expected hook element in bylaw.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }
 
                     // LOAD CALLBACKS.
                     //
                     nCount = strNumCallbacks.Exists()
                                  ? atoi(strNumCallbacks.Get())
                                  : 0;
                     if (nCount > 0) {
                         while (nCount-- > 0) {
                             //                          xml->read();
                             if (!SkipToElement(xml)) {
                                 otOut << szFunc << ": Failure: Unable to find "
                                                    "expected element.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1);
                             }
 
                             if ((xml->getNodeType() == irr::io::EXN_ELEMENT) &&
                                 (!strcmp("callback", xml->getNodeName()))) {
                                 OTString strCallbackName =
                                     xml->getAttributeValue(
                                         "name"); // Name of standard callback
                                                  // such as OnActivate,
                                                  // OnDeactivate, etc
                                 OTString strClause = xml->getAttributeValue(
                                     "clause"); // Name of clause on this Bylaw
                                                // that should trigger when that
                                                // hook occurs.
 
                                 if (!strCallbackName.Exists() ||
                                     !strClause.Exists()) {
                                     otErr << szFunc
                                           << ": Expected, yet nevertheless "
                                              "missing, name or clause while "
                                              "loading "
                                              "callback for bylaw " << strName
                                           << ".\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
 
                                 // See if the same-named callback already exists
                                 // on ANY of the OTHER BYLAWS
                                 // (There can only be one clause to handle any
                                 // given callback.)
                                 //
                                 OTClause* pClause =
                                     GetCallback(strCallbackName.Get());
 
                                 if (nullptr !=
                                     pClause) // Uh-oh, it's already there!
                                 {
                                     otOut << szFunc
                                           << ": Error loading callback "
                                           << strCallbackName
                                           << ", since one was already there on "
                                              "one of the other bylaws.\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
                                 // The below call checks to see if it's already
                                 // there, but only for the currently-loading
                                 // bylaw.
                                 // Whereas the above call checks this
                                 // OTScriptable for all the already-loaded
                                 // bylaws.
 
                                 if (false ==
                                     pBylaw->AddCallback(strCallbackName.Get(),
                                                         strClause.Get())) {
                                     otErr << szFunc
                                           << ": Failed adding callback ("
                                           << strCallbackName << ") to bylaw ("
                                           << strName << ").\n";
                                     delete pBylaw;
                                     pBylaw = nullptr;
                                     return (-1);
                                 }
                             }
                             else {
                                 otErr << szFunc << ": Expected callback "
                                                    "element in bylaw.\n";
                                 delete pBylaw;
                                 pBylaw = nullptr;
                                 return (-1); // error condition
                             }
                         } // while
                     }
 
                     if (AddBylaw(*pBylaw)) {
                         otInfo << szFunc
                                << ": Loaded Bylaw: " << pBylaw->GetName()
                                << "\n";
                     }
                     else {
                         otErr << szFunc
                               << ": Failed loading Bylaw: " << pBylaw->GetName()
                               << "\n";
                         delete pBylaw;
                         pBylaw = nullptr;
                         return (-1); // error condition
                     }
                 }
                 else {
                     otErr << szFunc << ": Expected bylaw element.\n";
                     return (-1); // error condition
                 }
 
             } // while
         }
 
         nReturnVal = 1;
     }
 
     return nReturnVal;
 }

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

virtual

Reimplemented in opentxs::OTSmartContract.

Definition at line 274 of file OTScriptable.cpp.

 {
 #ifdef OT_USE_SCRIPT_CHAI
     using namespace chaiscript;
 
     // In the future, this will be polymorphic.
     // But for now, I'm forcing things...
 
     OTScriptChai* pScript = dynamic_cast<OTScriptChai*>(&theScript);
 
     if (nullptr != pScript) {
         OT_ASSERT(nullptr != pScript->chai)
 
         pScript->chai->add(fun(&OTScriptable::GetTime), "get_time");
 
         pScript->chai->add(fun(&OTScriptable::CanExecuteClause, this),
                            "party_may_execute_clause");
     }
     else
 #endif // OT_USE_SCRIPT_CHAI
     {
         otErr << "OTScriptable::RegisterOTNativeCallsWithScript: Failed "
                  "dynamic casting OTScript to OTScriptChai \n";
     }
 }

void opentxs::OTScriptable::Release ( void )

virtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::OTPaymentPlan, opentxs::OTAgreement, opentxs::OTSmartContract, opentxs::OTOffer, opentxs::OTCronItem, opentxs::OTTrade, opentxs::Token, opentxs::OTCheque, opentxs::OTTrackable, and opentxs::OTInstrument.

Definition at line 3377 of file OTScriptable.cpp.

 {
     Release_Scriptable();
 
     // If there were any dynamically allocated objects, clean them up here.
 
     ot_super::Release(); // since I've overridden the base class, I call it
                          // now...
 }

void opentxs::OTScriptable::Release_Scriptable ( )

Definition at line 3351 of file OTScriptable.cpp.

 {
     // Go through the existing list of parties and bylaws at this point, and
     // delete them all.
     // (After all, I own them.)
     //
     while (!m_mapParties.empty()) {
         OTParty* pParty = m_mapParties.begin()->second;
         OT_ASSERT(nullptr != pParty);
 
         m_mapParties.erase(m_mapParties.begin());
 
         delete pParty;
         pParty = nullptr;
     }
     while (!m_mapBylaws.empty()) {
         OTBylaw* pBylaw = m_mapBylaws.begin()->second;
         OT_ASSERT(nullptr != pBylaw);
 
         m_mapBylaws.erase(m_mapBylaws.begin());
 
         delete pBylaw;
         pBylaw = nullptr;
     }
 }

void opentxs::OTScriptable::RetrieveNymPointers ( mapOfNyms & map_Nyms_Already_Loaded )

Definition at line 908 of file OTScriptable.cpp.

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

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

virtual

Implements opentxs::OTContract.

Reimplemented in opentxs::OTPaymentPlan, opentxs::OTAgreement, opentxs::OTSmartContract, opentxs::Token, opentxs::OTOffer, opentxs::OTTrade, opentxs::OTCheque, and opentxs::OTInstrument.

Definition at line 3401 of file OTScriptable.cpp.

 {
     return true;
 }

bool opentxs::OTScriptable::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

Definition at line 657 of file OTScriptable.cpp.

 {
     bool bSuccess =
         true; // Success is defined as ALL parties receiving a notice
 
     for (auto& it : m_mapParties) {
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         // If a smart contract is being canceled, it may not have been confirmed
         // by
         // all parties. There may be some unconfirmed parties. (Meaning there is
         // no
         // NymID available for those parties.) So here, we make sure we are only
         // sending
         // the notice to parties which have been confirmed. Those parties will
         // have an
         // opening transaction number that is non-zero. So for parties with a 0
         // opening
         // number, we skip the notice (since there won't be any NymID anyway --
         // nowhere
         // to send the notice even if we tried.)
         //
         if (0 != pParty->GetOpeningTransNo()) {
             if (false ==
                 pParty->SendNoticeToParty(
                     bSuccessMsg, // "success" notice? or "failure" notice?
                     theServerNym, theServerID, lNewTransactionNumber,
                     //                                                 lInReferenceTo,
                     // // each party has its own opening trans #.
                     strReference, pstrNote, pstrAttachment, pActualNym))
                 bSuccess = false; // Notice I don't break here -- I still allow
                                   // it to try to notice ALL parties, even if
                                   // one fails.
         }
     }
 
     return bSuccess;
 }

void opentxs::OTScriptable::SetAsClean ( )

Definition at line 746 of file OTScriptable.cpp.

 {
     for (auto& it : m_mapBylaws) {
         OTBylaw* pBylaw = it.second;
         OT_ASSERT(nullptr != pBylaw);
         // so we can check for dirtiness later, if it's changed.
         pBylaw->SetAsClean();
     }
 }

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

virtual

Reimplemented in opentxs::OTSmartContract.

Definition at line 239 of file OTScriptable.cpp.

 {
     m_strLabel = (nullptr != pstrLabel) ? pstrLabel->c_str() : "";
 }

void opentxs::OTScriptable::UpdateContents ( )

virtual

Reimplemented from opentxs::OTContract.

Reimplemented in opentxs::OTPaymentPlan, opentxs::OTAgreement, opentxs::OTSmartContract, opentxs::OTOffer, opentxs::OTTrade, opentxs::Token, opentxs::OTCheque, and opentxs::OTTrackable.

Definition at line 2321 of file OTScriptable.cpp.

 {
     // I release this because I'm about to repopulate it.
     m_xmlUnsigned.Release();
 
     UpdateContentsToString(m_xmlUnsigned, m_bCalculatingID);
 }

void opentxs::OTScriptable::UpdateContentsToString	(	OTString &	strAppend,
		bool	bCalculatingID
	)		const

Definition at line 2285 of file OTScriptable.cpp.

 {
     if ((!m_mapParties.empty()) || (!m_mapBylaws.empty())) {
         strAppend.Concatenate("<scriptableContract\n specifyAssetID=\"%s\"\n "
                               "specifyParties=\"%s\"\n"
                               " numParties=\"%d\"\n numBylaws=\"%d\" >\n\n",
                               m_bSpecifyAssetID ? "true" : "false",
                               m_bSpecifyParties ? "true" : "false",
                               m_mapParties.size(), m_mapBylaws.size());
 
         for (auto& it : m_mapParties) {
             OTParty* pParty = it.second;
             OT_ASSERT(nullptr != pParty);
 
             // Serialization is slightly different depending on whether we are
             // saving
             // for real, or just generating a template version of the contract
             // in order
             // to generate its ID.
             //
             pParty->Serialize(strAppend, bCalculatingID, m_bSpecifyAssetID,
                               m_bSpecifyParties);
         }
 
         for (auto& it : m_mapBylaws) {
             OTBylaw* pBylaw = it.second;
             OT_ASSERT(nullptr != pBylaw);
 
             pBylaw->Serialize(strAppend, bCalculatingID);
         }
 
         strAppend.Concatenate("</scriptableContract>\n\n");
     }
 }

bool opentxs::OTScriptable::ValidateName ( std::string str_name )

static

Definition at line 255 of file OTScriptable.cpp.

 {
     if (str_name.size() <= 0) {
         otErr << "OTScriptable::ValidateName: Name has zero size.\n";
         return false;
     }
     else if (find_if(str_name.begin(), str_name.end(),
                        is_ot_namechar_invalid) != str_name.end()) {
         otErr << "OTScriptable::ValidateName: Name fails validation testing: "
               << str_name << "\n";
         return false;
     }
 
     return true;
 }

bool opentxs::OTScriptable::VerifyNymAsAgent	(	OTPseudonym &	theNym,
		OTPseudonym &	theSignerNym,
		mapOfNyms *	pmap_ALREADY_LOADED = `nullptr`
	)		const

virtual

Reimplemented in opentxs::OTAgreement, and opentxs::OTTrade.

Definition at line 1271 of file OTScriptable.cpp.

 {
     // (COmmented out) existing trades / payment plans on OT basically just have
     // this one line:
     //
     // VerifySignature(theNym)
 
     // NEW VERSION:
     /*
      Proves the original party DOES approve of Nym:
 
      1) Lookup the party for this Nym, (loop to see if Nym is listed as an agent
      by any party.)
      2) If party found, lookup authorizing agent for party, loading him if
      necessary.
      3) Use authorizing agent to verify signature on original copy of this
      contract. Each party stores their
         own copy of the agreement, therefore use that copy to verify signature,
      instead of the current version.
 
      This proves that the original authorizing agent for the party that lists
      Nym as an agent HAS signed the smart contract.
      (As long as that same party OWNS the account, that should be fine.)
      Obviously the best proof is to verify the ORIGINAL version of the contract
      against the PARTY'S ORIGINAL SIGNED COPY,
      and also to verify them AGAINST EACH OTHER.  The calling function should do
      this. Otherwise what if the "authorized signer"
      has been changed, and some new guy and signature are substituted? Well, I
      guess as long as he really is authorized... but
      you simply don't know what the original agreement really says unless you
      look at it.  So load it and use it to call THIS METHOD.
      */
 
     // (1)
     // This step verifies that theNym is at least REGISTERED as a valid agent
     // for the party. (According to the party.)
     //
     OTParty* pParty = FindPartyBasedOnNymAsAgent(theNym);
 
     if (nullptr == pParty) {
         otOut << "OTScriptable::VerifyNymAsAgent: Unable to find party based "
                  "on Nym as agent.\n";
         return false;
     }
     // Below this point, pParty is good.
 
     // This party hasn't signed the contract??
     //
     if (!pParty->GetMySignedCopy().Exists()) {
         otOut << "OTScriptable::VerifyNymAsAgent: Unable to find party's ("
               << pParty->GetPartyName()
               << ") signed copy of this contract. Has it been executed?\n";
         return false;
     }
 
     // By this point, we know that pParty has a signed copy of the agreement (or
     // of SOMETHING anyway) and we know that
     // we were able to find the party based on theNym as one of its agents. But
     // the signature still needs to be verified...
 
     // (2)
     // This step verifies that the party has been signed by its authorizing
     // agent. (Who may not be the Nym, yet might be.)
     //
     OTAgent* pAuthorizingAgent = nullptr;
     OTPseudonym* pAuthAgentsNym = nullptr;
     std::unique_ptr<OTPseudonym> theAgentNymAngel;
 
     // See if theNym is the authorizing agent.
     //
     if ((false == pParty->HasAuthorizingAgent(theNym, &pAuthorizingAgent)) &&
         (nullptr != pmap_ALREADY_LOADED)) {
         // No? Okay then, let's see if the authorizing agent is one of these
         // already loaded.
         // (So we don't load it twice.)
         //
         mapOfNyms& map_Nyms_Already_Loaded = (*pmap_ALREADY_LOADED);
         for (auto& it : map_Nyms_Already_Loaded) {
             OTPseudonym* pNym = it.second;
             OT_ASSERT(nullptr != pNym);
 
             if (pParty->HasAuthorizingAgent(*pNym, &pAuthorizingAgent)) {
                 pAuthAgentsNym = pNym; // Just in case.
                 break;
             }
         }
         // if pAuthorizingAgent != nullptr, that means the authorizing agent was
         // found among the map of nyms that were already loaded.
     }
 
     // Still not found?
     if (nullptr == pAuthorizingAgent) {
         // 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#.) Since
         // we need to verify his
         // signature, we have to load him up.
         //
         pAuthAgentsNym =
             pParty->LoadAuthorizingAgentNym(theSignerNym, &pAuthorizingAgent);
 
         if (nullptr != pAuthAgentsNym) // success
         {
             OT_ASSERT(nullptr !=
                       pAuthorizingAgent); // This HAS to be set now. I
                                           // assume it henceforth.
             otLog3 << "OTScriptable::VerifyNymAsAgent: I just had to load the "
                       "authorizing agent's Nym for a party ("
                    << pParty->GetPartyName()
                    << "), so I guess it wasn't already available "
                       "on the list of Nyms that were already loaded.\n";
             theAgentNymAngel.reset(pAuthAgentsNym); // CLEANUP!!
         }
         else {
             otErr << "OTScriptable::VerifyNymAsAgent: Error: Strange, unable "
                      "to load authorizing "
                      "agent's Nym for party " << pParty->GetPartyName()
                   << " (to verify his signature.)\n";
             pParty->ClearTemporaryPointers();
             return false;
         }
     }
 
     // Below this point, we KNOW that pAuthorizingAgent is a good pointer and
     // will be cleaned up properly/automatically.
     // I'm not using pAuthAgentsNym directly, but pAuthorizingAgent WILL use it
     // before this function is done.
 
     // TODO: Verify the opening transaction # here, like I do in
     // VerifyPartyAuthorization() ??  Research first.
 
     // (3)
     // Here, we use the Authorizing Agent to verify the signature on his party's
     // version of the contract.
     // Notice: Even if the authorizing agent gets fired, we can still load his
     // Nym to verify the original signature on the
     // original contract! We should ALWAYS be able to verify our signatures!
     // Therefore, TODO: When a Nym is DELETED, it's necessary
     // to KEEP the public key on file. We may not have a Nymfile with any
     // request #s or trans# signed out, and there are may be no
     // accounts for him, but we still need that public key, for later
     // verification of the signature.
     // UNLESS... the public key ITSELF is stashed into the contract... Notice
     // that normal asset contracts already keep the keys inside,
     // so why shouldn't these? In fact I can pop the "key" value onto the
     // contract as part of the "Party-Signing" API call. Just grab the
     // public key from each one. Meanwhile the server can verify that it's
     // actually there, and refuse to process without it!!  Nice.
     // This also shows why we need to store the NymID, even if it can be
     // overridden by a Role: because you want to be able to verify
     // the original signature, no matter WHO is authorized now. Otherwise your
     // entire contract falls apart.
 
     OTScriptable* pPartySignedCopy =
         OTScriptable::InstantiateScriptable(pParty->GetMySignedCopy());
     std::unique_ptr<OTScriptable> theCopyAngel;
 
     if (nullptr == pPartySignedCopy) {
         otErr << "OTScriptable::VerifyNymAsAgent: Error loading party's ("
               << pParty->GetPartyName()
               << ") signed copy of agreement. Has it been executed?\n";
         pParty->ClearTemporaryPointers();
         return false;
     }
     else
         theCopyAngel.reset(pPartySignedCopy);
 
     const bool bSigVerified =
         pAuthorizingAgent->VerifySignature(*pPartySignedCopy);
     bool bContentsVerified = false;
 
     if (bSigVerified) {
         // Todo OPTIMIZE: Might move this call to a higher layer, so it gets
         // called MUCH less often but retains the same security.
         // There are several places currently in smart contracts like this.
         // Need to analyze security aspects before doing it.
         //
         bContentsVerified = Compare(*pPartySignedCopy);
 
         if (!bContentsVerified)
             otOut << "OTScriptable::VerifyNymAsAgent: Though the signature "
                      "verifies, the contract "
                      "signed by the party (" << pParty->GetPartyName()
                   << ") doesn't match this contract. (Failed comparison.)\n";
     }
     else
         otOut << "OTScriptable::VerifyNymAsAgent: Signature failed to verify "
                  "for party: " << pParty->GetPartyName() << " \n";
 
     // Todo: possibly call Compare(*pPartySignedCopy); to make sure
     // there's no funny business.
     // Well actually that HAS to happen anyway, it's just a question of whether
     // it goes here too, or only somewhere else.
 
     pParty->ClearTemporaryPointers(); // We loaded a Nym ourselves, which goes
                                       // out of scope after this function. The
                                       // party is done
     // with it now, and we don't want it to keep pointing to something that is
     // now going out of scope.
 
     return bContentsVerified;
 }

bool opentxs::OTScriptable::VerifyNymAsAgentForAccount	(	OTPseudonym &	theNym,
		OTAccount &	theAccount
	)		const

virtual

Reimplemented in opentxs::OTAgreement, and opentxs::OTTrade.

Definition at line 1639 of file OTScriptable.cpp.

 {
 
     // Lookup the party via the ACCOUNT.
     //
     OTPartyAccount* pPartyAcct = nullptr;
     OTParty* pParty = FindPartyBasedOnAccount(theAccount, &pPartyAcct);
 
     if (nullptr == pParty) {
         OT_ASSERT(nullptr != pPartyAcct);
         otOut << "OTScriptable::VerifyNymAsAgentForAccount: Unable to find "
                  "party based on account.\n";
         return false;
     }
     // pPartyAcct is a good pointer below this point.
 
     // Verify ownership.
     //
     if (!pParty->VerifyOwnershipOfAccount(theAccount)) {
         otOut << "OTScriptable::VerifyNymAsAgentForAccount: pParty is not the "
                  "owner of theAccount.\n";
         pParty->ClearTemporaryPointers(); // Just in case.
         return false;
     }
 
     const std::string str_acct_agent_name = pPartyAcct->GetAgentName().Get();
     OTAgent* pAgent = pParty->GetAgent(str_acct_agent_name);
 
     // Make sure they are from the SAME PARTY.
     //
     if (nullptr == pAgent) {
         otOut << "OTScriptable::VerifyNymAsAgentForAccount: Unable to find the "
                  "right agent for this account.\n";
         pParty->ClearTemporaryPointers(); // Just in case.
         return false;
     }
     // Below this point, pPartyAcct is a good pointer, and so is pParty, as well
     // as pAgent
     // We also know that the agent's name is the same one that was listed on the
     // account as authorized.
     // (Because we used the account's agent_name to look up pAgent in the first
     // place.)
 
     // Make sure theNym is a valid signer for pAgent, whether representing
     // himself as in individual, or in a role for an entity.
     // This means that pAgent (looked up based on partyAcct's agent name) will
     // return true to IsValidSigner when passed theNym,
     // assuming theNym really is the agent that partyAcct was talking about.
     //
     if (!pAgent->IsValidSigner(theNym)) {
         otOut << "OTScriptable::VerifyNymAsAgentForAccount: theNym is not a "
                  "valid signer for pAgent.\n";
         pParty->ClearTemporaryPointers(); // Just in case.
         return false;
     }
     if (!pAgent->VerifyAgencyOfAccount(theAccount)) {
         otOut << "OTScriptable::VerifyNymAsAgentForAccount: theNym is not a "
                  "valid agent for theAccount.\n";
         pParty->ClearTemporaryPointers(); // Just in case.
         return false;
     }
 
     //    Now we know:
     // (1) theNym is agent for pParty,     (according to the party)
     // (2) theAccount is owned by pParty   (according to the party)
     // (3) theNym is agent for theAccount  (according to the party)
     // (4) theNym is valid signer for pAgent
     // (5) pParty is the actual OWNER of the account. (According to theAccount.)
 
     pParty->ClearTemporaryPointers(); // Just in case.
 
     return true;
 }

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

Definition at line 1490 of file OTScriptable.cpp.

 {
     OTParty* pParty = thePartyAcct.GetParty();
 
     if (nullptr == pParty) {
         otErr << "OTScriptable::" << __FUNCTION__
               << ": Unable to find party for acct: " << thePartyAcct.GetName()
               << " \n";
         return false;
     }
 
     OTAgent* pAuthorizedAgent = thePartyAcct.GetAuthorizedAgent();
 
     if (nullptr == pAuthorizedAgent) {
         otOut << "OTScriptable::" << __FUNCTION__
               << ": Unable to find authorized agent ("
               << thePartyAcct.GetAgentName()
               << ") for acct: " << thePartyAcct.GetName() << " \n";
         return false;
     }
 
     // BELOW THIS POINT, pParty and pAuthorizedAgent are both good pointers.
     //
     // Next, we need to verify that pParty is the proper OWNER of thePartyAcct..
     //
     // AND that pAuthorizedAgent really IS authorized to manipulate the actual
     // account itself. (Either he is listed as its actual owner, or he is an
     // agent for an entity, authorized based on a specific role, and the account
     // is owned by that entity / controlled by that role.)
     //
 
     // VERIFY ACCOUNT's OWNERSHIP BY PARTY
     //
     if (!thePartyAcct.VerifyOwnership()) // This will use pParty internally.
     {
         otOut << "OTScriptable::" << __FUNCTION__
               << ": Unable to verify party's (" << pParty->GetPartyName()
               << ") ownership of acct: " << thePartyAcct.GetName() << " \n";
         return false;
     }
 
     // VERIFY ACCOUNT's AUTHORIZED AGENT (that he has rights to manipulate the
     // account itself)
     //
     if (!thePartyAcct.VerifyAgency()) // This will use pAuthorizedAgent
                                       // internally.
     {
         otOut << "OTScriptable::" << __FUNCTION__
               << ": Unable to verify agent's ("
               << pAuthorizedAgent->GetName().Get()
               << ") rights re: acct: " << thePartyAcct.GetName() << " \n";
         return false;
     }
 
     //     Verify the closing number, if he has one. (If this instance is
     // OTScriptable-derived, but NOT OTCronItem-derived,
     //     then that means there IS NO closing number, since we're not even on
     // Cron.) The PartyAccts just happen
     //     to store their closing number for the cases where we ARE on Cron,
     // which will probably be most cases.
     //     Therefore we CHECK TO SEE if the closing number is NONZERO -- and if
     // so, we VERIFY ISSUED on that #. That way,
     //     for cases where this IS a cron item, it will still verify the number
     // (as it should) and in other cases, it will
     //     just skip this step.
     //
     //     Also: If bBurnTransNo is set to true, then it will force this issue,
     // since the code then DEMANDS a number
     //     be available for use.
 
     const int64_t lClosingNo = thePartyAcct.GetClosingTransNo();
 
     if (lClosingNo > 0) // If one exists, then verify it.
     {
         if (false ==
             pAuthorizedAgent->VerifyIssuedNumber(lClosingNo, strServerID)) {
             otOut << "OTScriptable::" << __FUNCTION__
                   << ": Closing trans number " << lClosingNo
                   << " doesn't "
                      "verify for the nym listed as the authorized agent for "
                      "account " << thePartyAcct.GetName() << ".\n";
             return false;
         }
 
         // The caller wants the additional verification that the number hasn't
         // been USED
         // yet -- AND the caller wants you to BURN IT HERE.
         //
         else if (bBurnTransNo) {
             if (false ==
                 pAuthorizedAgent->VerifyTransactionNumber(lClosingNo,
                                                           strServerID)) {
                 otOut << "OTScriptable::" << __FUNCTION__
                       << ": Closing trans number " << lClosingNo
                       << " doesn't "
                          "verify as available for use, for the "
                          "nym listed as the authorized agent for "
                          "acct: " << thePartyAcct.GetName() << ".\n";
                 return false;
             }
             else // SUCCESS -- It verified as available, so let's burn it
                    // here. (So he can't use it twice. It remains
             { // issued and open until the cron item is eventually closed out
                 // for good.)
                 //
                 // NOTE: This also adds lClosingNo to the agent's nym's
                 // GetSetOpenCronItems.
                 //
                 pAuthorizedAgent->RemoveTransactionNumber(
                     lClosingNo, strServerID, theSignerNym, true); // bSave=true
             }
         }
 
     }                      // if lClosingNo>0
     else if (bBurnTransNo) // In this case, bBurnTransNo=true, then the caller
                            // EXPECTED to burn a transaction
     {                      // num. But the number was 0! Therefore, FAILURE!
         otOut << "OTScriptable::" << __FUNCTION__ << ": FAILURE. On Acct "
               << thePartyAcct.GetName()
               << ", expected to burn a legitimate closing transaction "
                  "number, but got this instead: " << lClosingNo << "\n";
         return false;
     }
 
     return true;
 }

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

Definition at line 959 of file OTScriptable.cpp.

 {
     // This function DOES assume that theParty was initially FOUND on
     // OTScriptable.
     // Meaning I don't have to verify that much if I got this far.
 
     const bool bNeedToCleanup = (nullptr == pmap_NEWLY_LOADED) ? true : false;
 
     // This party hasn't signed the contract??
     //
     if (!theParty.GetMySignedCopy().Exists()) {
         otOut << __FUNCTION__ << ": Unable to find party's signed copy of this "
                                  "contract. Has it been executed?\n";
         return false;
     }
 
     // By this point, we know that theParty has a signed copy of the agreement
     // (or of SOMETHING anyway) and we know that
     // we were able to find the party based on theNym as one of its agents. But
     // the signature still needs to be verified...
 
     // (2)
     // This step verifies that the party has been signed by its authorizing
     // agent. (Who may not be the Nym, yet might be.)
     //
     OTAgent* pAuthorizingAgent = nullptr;
     OTPseudonym* pAuthAgentsNym = nullptr;
     // In case I have to load it myself, I want it cleaned up properly.
     std::unique_ptr<OTPseudonym> theAgentNymAngel;
 
     // Some nyms are *already* loaded. If any were passed in, let's see if any
     // of them are
     // the authorizing agent for the contract (for this party)...
     //
     if (nullptr != pmap_ALREADY_LOADED) {
         // (So we don't load it twice, if it's there.)
         //
         mapOfNyms& map_Nyms_Already_Loaded = (*pmap_ALREADY_LOADED);
 
         for (auto& it : map_Nyms_Already_Loaded) {
             OTPseudonym* pNym = it.second;
             OT_ASSERT(nullptr != pNym);
 
             if (theParty.HasAuthorizingAgent(*pNym, &pAuthorizingAgent)) {
                 pAuthAgentsNym = pNym; // Just in case
                 break;
             }
         }
         // if pAuthorizingAgent != nullptr, that means the authorizing agent was
         // found among the map of nyms that were already loaded.
     }
 
     // Only if I had to load the authorizing agent myself, do I clear its
     // temporary pointer.
     // (Because it's going out of scope at the bottom of this function.)
     // Any other temporary pointers, I do NOT clear, but I leave them because a
     // script is
     // probably executing and may still need them.
     // (This function that we're in was expressly called by someone who didn't
     // want the
     // temporary nym pointers cleared just yet, for whatever reason.)
     //
     bool bHadToLoadItMyself = (nullptr == pAuthorizingAgent) ? true : false;
 
     // Still not found? Okay, let's LOAD IT UP then...
     //
     if (bHadToLoadItMyself) {
         // 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#.) Since
         // we need to verify his
         // signature, we have to load him up.
         //
         pAuthAgentsNym =
             theParty.LoadAuthorizingAgentNym(theSignerNym, &pAuthorizingAgent);
 
         if (nullptr != pAuthAgentsNym) // success
         {
             OT_ASSERT(nullptr !=
                       pAuthorizingAgent); // This HAS to be set now. I
                                           // assume it henceforth.
             otLog3 << __FUNCTION__
                    << ": I just had to load "
                       "the authorizing agent's Nym for a party ("
                    << theParty.GetPartyName()
                    << "), "
                       "so I guess it wasn't already available on the list of "
                       "Nyms that were already loaded.\n";
 
             // Either I'm DEFINITELY cleaning it up myself, OR I'm adding it to
             // a list
             // where the CALLER can clean it up.
             //
             if (bNeedToCleanup)
                 theAgentNymAngel.reset(pAuthAgentsNym); // CLEANUP!!
             else {
                 const std::string str_agent_name =
                     pAuthorizingAgent->GetName().Get();
 
                 mapOfNyms& map_Nyms_Newly_Loaded = (*pmap_NEWLY_LOADED);
                 map_Nyms_Newly_Loaded.insert(
                     map_Nyms_Newly_Loaded.begin(),
                     std::pair<std::string, OTPseudonym*>(
                         str_agent_name,
                         pAuthAgentsNym)); // (Caller must clean these up.)
             }
         }
         else {
             otErr << __FUNCTION__ << ": Error: Strange, unable to load "
                                      "authorizing agent's Nym (to verify his "
                                      "signature.)\n";
             return false;
         }
     }
 
     // Below this point, we KNOW that pAuthorizingAgent is a good pointer and
     // will be cleaned up properly/automatically.
     // I'm not using pAuthAgentsNym directly, but pAuthorizingAgent WILL use it
     // before this function is done.
 
     // (3) Verify the issued number, if he has one. If this instance is
     // OTScriptable-derived, but NOT OTCronItem-derived,
     //     then that means there IS NO opening number (or closing number) since
     // we're not even on Cron. The parties just
     //     happen to store their opening number for the cases where we ARE on
     // Cron, which will probably be most cases.
     //     Therefore we CHECK TO SEE if the opening number is NONZERO -- and if
     // so, we VERIFY ISSUED on that #. That way,
     //     for cases where this IS a cron item, it will still verify the number
     // (as it should) and in other cases, it will
     //     just skip this step.
     //
 
     const int64_t lOpeningNo = theParty.GetOpeningTransNo();
 
     if (lOpeningNo > 0) // If one exists, then verify it.
     {
         if (false ==
             pAuthorizingAgent->VerifyIssuedNumber(lOpeningNo, strServerID)) {
             otErr << __FUNCTION__ << ": Opening trans number " << lOpeningNo
                   << " doesn't "
                      "verify for the nym listed as the authorizing agent for "
                      "party " << theParty.GetPartyName() << ".\n";
             if (bHadToLoadItMyself && bNeedToCleanup)
                 pAuthorizingAgent->ClearTemporaryPointers(); // We loaded the
                                                              // Nym ourselves,
                                                              // which goes out
                                                              // of scope after
                                                              // this function.
             return false;
         }
 
         // The caller wants the additional verification that the number hasn't
         // been USED
         // yet -- AND the caller wants you to BURN IT HERE.
         else if (bBurnTransNo) {
             if (false ==
                 pAuthorizingAgent->VerifyTransactionNumber(lOpeningNo,
                                                            strServerID)) {
                 otErr << __FUNCTION__ << ": Opening trans number " << lOpeningNo
                       << " doesn't "
                          "verify as available for use, for the "
                          "nym listed as the authorizing agent "
                          "for party: " << theParty.GetPartyName() << ".\n";
                 if (bHadToLoadItMyself && bNeedToCleanup)
                     pAuthorizingAgent->ClearTemporaryPointers(); // We loaded
                                                                  // the Nym
                                                                  // ourselves,
                                                                  // which goes
                                                                  // out of scope
                                                                  // after this
                                                                  // function.
                 return false;
             }
             else // SUCCESS -- It verified as available, so let's burn it
                    // here. (So he can't use it twice. It remains issued and
                    // open until the cron item is eventually closed out for
                    // good.)
             {
                 // This function also adds lOpeningNo to the agent's nym's list
                 // of open cron items.
                 // (OTPseudonym::GetSetOpenCronItems)
                 //
                 pAuthorizingAgent->RemoveTransactionNumber(
                     lOpeningNo, strServerID, theSignerNym, true); // bSave=true
             }
         }
 
     }                      // if lOpeningNo>0
     else if (bBurnTransNo) // In this case, bBurnTransNo=true, then the caller
                            // EXPECTED to burn a transaction
     {                      // num. But the number was 0! Therefore, FAILURE!
         otOut << __FUNCTION__ << ": FAILURE. On Party "
               << theParty.GetPartyName().c_str()
               << ", expected to burn a legitimate opening transaction "
                  "number, but got this instead: " << lOpeningNo << "\n";
         if (bHadToLoadItMyself && bNeedToCleanup)
             pAuthorizingAgent->ClearTemporaryPointers(); // We loaded the Nym
                                                          // ourselves, which
                                                          // goes out of scope
                                                          // after this function.
         return false;
     }
 
     // (4)
     // Here, we use the Authorizing Agent to verify the signature on his party's
     // version of the contract.
     // Notice: Even if the authorizing agent gets fired, we can still load his
     // Nym to verify the original signature on the
     // original contract! We should ALWAYS be able to verify our signatures!
     // Therefore, TODO: When a Nym is DELETED, it's necessary
     // to KEEP the public key on file. We may not have a Nymfile with any
     // request #s or trans# signed out, and there are may be no
     // accounts for him, but we still need that public key, for later
     // verification of the signature.
     // UNLESS... the public key ITSELF is stashed into the contract... Notice
     // that normal asset contracts already keep the keys inside,
     // so why shouldn't these? In fact I can pop the "key" value onto the
     // contract as part of the "Party-Signing" API call. Just grab the
     // public key from each one. Meanwhile the server can verify that it's
     // actually there, and refuse to process without it!!  Nice.
     // This also shows why we need to store the NymID, even if it can be
     // overridden by a Role: because you want to be able to verify
     // the original signature, no matter WHO is authorized now. Otherwise your
     // entire contract falls apart.
 
     OTScriptable* pPartySignedCopy =
         OTScriptable::InstantiateScriptable(theParty.GetMySignedCopy());
     std::unique_ptr<OTScriptable> theCopyAngel;
 
     if (nullptr == pPartySignedCopy) {
         otErr << __FUNCTION__ << ": Error loading party's signed copy of "
                                  "agreement. Has it been executed?\n";
         if (bHadToLoadItMyself && bNeedToCleanup)
             pAuthorizingAgent->ClearTemporaryPointers();
         return false;
     }
     else {
         theCopyAngel.reset(pPartySignedCopy);
     }
 
     const bool bSigVerified =
         pAuthorizingAgent->VerifySignature(*pPartySignedCopy);
     bool bContentsVerified = false;
 
     if (bSigVerified) {
         // Todo OPTIMIZE: Might move this call to a higher layer, so it gets
         // called MUCH less often but retains the same security.
         // There are several places currently in smart contracts like this.
         // Need to analyze security aspects before doing it.
         //
         bContentsVerified =
             Compare(*pPartySignedCopy); // This also compares the opening
                                         // / closing numbers, if they are
                                         // non-zero.
 
         if (!bContentsVerified)
             otOut << __FUNCTION__
                   << ": Though the signature verifies, the contract "
                      "signed by the party (" << theParty.GetPartyName()
                   << ") doesn't match this contract. (Failed comparison.)\n";
     }
     else
         otOut << __FUNCTION__ << ": Signature failed to verify for party: "
               << theParty.GetPartyName() << " \n";
 
     if (bHadToLoadItMyself && bNeedToCleanup)
         pAuthorizingAgent->ClearTemporaryPointers(); // We loaded the Nym
                                                      // ourselves, which goes
                                                      // out of scope after this
                                                      // function.
     // The party is done with it now, and we don't want it to keep pointing to
     // something that is now going out of scope.
 
     return bContentsVerified;
 }

bool opentxs::OTScriptable::VerifyThisAgainstAllPartiesSignedCopies ( )

Definition at line 1975 of file OTScriptable.cpp.

 {
     bool bReturnVal = !m_mapParties.empty();
 
     // MAKE SURE ALL SIGNED COPIES ARE OF THE SAME CONTRACT.
     // Loop through ALL the parties. For whichever ones are already signed,
     // load up the signed copy and make sure it compares to the main one.
     // This is in order to make sure that I am signing the same thing that
     // everyone else signed, before I actually sign it.
     //
     for (auto& it : m_mapParties) {
         const std::string current_party_name = it.first;
         OTParty* pParty = it.second;
         OT_ASSERT(nullptr != pParty);
 
         if (pParty->GetMySignedCopy().Exists()) {
             OTScriptable* pPartySignedCopy =
                 OTScriptable::InstantiateScriptable(pParty->GetMySignedCopy());
             std::unique_ptr<OTScriptable> theCopyAngel;
 
             if (nullptr == pPartySignedCopy) {
                 otErr << __FUNCTION__ << ": Error loading party's ("
                       << current_party_name
                       << ") signed copy of agreement. Has it been executed?\n";
                 return false;
             }
             else
                 theCopyAngel.reset(pPartySignedCopy);
 
             if (!Compare(*pPartySignedCopy)) // <==== For all signed
                                              // copies, we compare them to
                                              // *this.
             {
                 otErr << __FUNCTION__ << ": Party's (" << current_party_name
                       << ") signed copy of agreement doesn't match *this.\n";
                 return false;
             }
         }
         // else nothing. (We only verify against the ones that are signed.)
     }
 
     return bReturnVal;
 }

Member Data Documentation

bool opentxs::OTScriptable::m_bCalculatingID

protected

Definition at line 234 of file OTScriptable.hpp.

bool opentxs::OTScriptable::m_bSpecifyAssetID

protected

Definition at line 236 of file OTScriptable.hpp.

bool opentxs::OTScriptable::m_bSpecifyParties

protected

Definition at line 237 of file OTScriptable.hpp.

mapOfBylaws opentxs::OTScriptable::m_mapBylaws

protected

Definition at line 163 of file OTScriptable.hpp.

mapOfParties opentxs::OTScriptable::m_mapParties

protected

Definition at line 161 of file OTScriptable.hpp.

OTString opentxs::OTScriptable::m_strLabel

protected

Definition at line 242 of file OTScriptable.hpp.

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation