OTAPI_Func Class Reference

#include <ot_otapi_ot.hpp>

Collaboration diagram for OTAPI_Func:

Public Member Functions
	OTAPI_Func ()
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_strParam)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_strParam, int64_t p_lData)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_strParam, const std::string &p_strData)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_nymID2, const std::string &p_strData, const std::string &p_strData2)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_accountID, const std::string &p_strParam, int64_t p_lData, const std::string &p_strData2)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_accountID, const std::string &p_strParam, const std::string &p_strData, int64_t p_lData2)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_accountID, const std::string &p_strParam, const std::string &p_strData, const std::string &p_strData2)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &p_assetID, const std::string &p_basket, const std::string &p_accountID, bool p_bBool, int32_t p_nTransNumsNeeded)
	OTAPI_Func (OTAPI_Func_Type theType, const std::string &p_serverID, const std::string &p_nymID, const std::string &assetAccountID, const std::string &currencyAcctID, const std::string &scale, const std::string &minIncrement, const std::string &quantity, const std::string &price, bool bSelling)
	~OTAPI_Func ()
OT_OTAPI_OT void	InitCustom ()
OT_OTAPI_OT int32_t	Run () const
OT_OTAPI_OT std::string	SendRequest (OTAPI_Func &theFunction, const std::string &IN_FUNCTION) const
OT_OTAPI_OT int32_t	SendRequestLowLevel (OTAPI_Func &theFunction, const std::string &IN_FUNCTION) const
OT_OTAPI_OT std::string	SendRequestOnce (OTAPI_Func &theFunction, const std::string &IN_FUNCTION, bool bIsTransaction, bool bWillRetryAfterThis, bool &bCanRetryAfterThis) const
OT_OTAPI_OT std::string	SendTransaction (OTAPI_Func &theFunction, const std::string &IN_FUNCTION)
OT_OTAPI_OT std::string	SendTransaction (OTAPI_Func &theFunction, const std::string &IN_FUNCTION, int32_t nTotalRetries) const

Static Public Member Functions
EXPORT static OT_OTAPI_OT void	CopyVariables ()

Public Attributes
OTAPI_Func_Type	funcType
std::string	serverID
std::string	nymID
std::string	nymID2
std::string	assetID
std::string	assetID2
std::string	accountID
std::string	accountID2
std::string	basket
std::string	strData
std::string	strData2
std::string	strData3
std::string	strData4
std::string	strData5
bool	bBool
int32_t	nData
int64_t	lData
time64_t	tData
int32_t	nTransNumsNeeded
int32_t	nRequestNum

Detailed Description

Definition at line 257 of file ot_otapi_ot.hpp.

Constructor & Destructor Documentation

OTAPI_Func::OTAPI_Func

(

)

Definition at line 190 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 0 arguments.)\n";

    InitCustom();
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID
	)

Definition at line 201 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 3 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_strParam
	)

Definition at line 224 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 4 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;

    if (theType == ISSUE_BASKET) {
        basket = p_strParam;
    }
    else if ((theType == GET_MINT) || (theType == GET_CONTRACT) ||
               (theType == CREATE_ASSET_ACCT)) {
        assetID = p_strParam;
    }
    else if (theType == CHECK_USER) {
        nymID2 = p_strParam;
    }
    else if (theType == DELETE_ASSET_ACCT) {
        accountID = p_strParam;
    }
    else if ((theType == ISSUE_ASSET_TYPE) ||
               (theType == GET_MARKET_RECENT_TRADES) ||
               (theType == QUERY_ASSET_TYPES)) {
        strData = p_strParam;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func()\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_strParam,
		int64_t	p_lData
	)

Definition at line 322 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 5 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID \n";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID \n";
    }

    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam \n";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;

    if (theType == WITHDRAW_CASH) {
        accountID = p_strParam;
        lData = p_lData;
    }
    else if (theType == GET_MARKET_OFFERS) {
        strData = p_strParam;
        lData = p_lData;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func()\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_strParam,
		const std::string &	p_strData
	)

Definition at line 272 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 5 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID \n";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID \n";
    }

    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam \n";
    }

    if (!VerifyStringVal(p_strData)) {
        otOut << strError << "p_strData \n";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;

    if ((theType == KILL_MARKET_OFFER) || (theType == KILL_PAYMENT_PLAN) ||
        (theType == PROCESS_INBOX) || (theType == DEPOSIT_CASH) ||
        (theType == DEPOSIT_CHEQUE) || (theType == DEPOSIT_PAYMENT_PLAN)) {
        accountID = p_strParam;
        strData = p_strData;
    }
    else if (theType == ADJUST_USAGE_CREDITS) {
        nymID2 = p_strParam; // target nym ID
        strData = p_strData; // adjustment (up or down.)
    }
    else if (theType == EXCHANGE_CASH) {
        assetID = p_strParam;
        strData = p_strData;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func()\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_nymID2,
		const std::string &	p_strData,
		const std::string &	p_strData2
	)

Definition at line 362 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 6 arguments.)\n";
    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_nymID2)) {
        otOut << strError << "p_nymID2";
    }
    if (!VerifyStringVal(p_strData)) {
        otOut << strError << "p_strData";
    }
    if (!VerifyStringVal(p_strData2)) {
        otOut << strError << "p_strData2";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;

    if ((theType == SEND_USER_MESSAGE) || (theType == SEND_USER_INSTRUMENT)) {
        nymID2 = p_nymID2;
        strData = p_strData;
        strData2 = p_strData2;
    }
    else if (theType == TRIGGER_CLAUSE) {
        strData = p_nymID2;
        strData2 = p_strData;
        strData3 = p_strData2;
    }
    else if (theType == ACTIVATE_SMART_CONTRACT) {

        accountID = p_nymID2;  // the "official" asset account of the party
                               // activating the contract.;
        strData = p_strData;   // the agent's name for that party, as listed on
                               // the contract.;
        strData2 = p_strData2; // the smart contract itself.;

        int32_t nNumsNeeded =
            OTAPI_Wrap::SmartContract_CountNumsNeeded(p_strData2, p_strData);

        if (nNumsNeeded > 0) {
            nTransNumsNeeded = nNumsNeeded;
        }
    }
    else if (theType == GET_BOX_RECEIPT) {
        accountID = p_nymID2; // accountID (inbox/outbox) or NymID (nymbox) is
                              // passed here.;
        nData = stol(p_strData);
        strData = p_strData2; // transaction number passed here as string;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func() "
                 "ERROR!!!!!!\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_accountID,
		const std::string &	p_strParam,
		int64_t	p_lData,
		const std::string &	p_strData2
	)

Definition at line 430 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 7 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_accountID)) {
        otOut << strError << "p_accountID";
    }
    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;
    accountID = p_accountID;

    if (theType == SEND_TRANSFER) {
        if (!VerifyStringVal(p_strData2)) {
            otOut << strError << "p_strData2";
        }
        accountID2 = p_strParam;
        lData = p_lData;      // int64_t Amount;
        strData = p_strData2; // str  Note;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func() "
                 "ERROR!!!!!!\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_accountID,
		const std::string &	p_strParam,
		const std::string &	p_strData,
		int64_t	p_lData2
	)

Definition at line 475 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 7 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_accountID)) {
        otOut << strError << "p_accountID";
    }
    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;
    accountID = p_accountID;

    if (theType == WITHDRAW_VOUCHER) {
        if (!VerifyStringVal(p_strData)) {
            otOut << strError << "p_strData";
        }
        nymID2 = p_strParam; // str  Recipient Nym ID;
        strData = p_strData; // str  Memo;
        lData = p_lData2;    // int64_t Amount;
    }
    else if (theType == PAY_DIVIDEND) {
        if (!VerifyStringVal(p_strData)) {
            otOut << strError << "p_strData";
        }
        assetID = p_strParam; // str  Shares Asset ID;
        strData = p_strData;  // str  Memo;
        lData = p_lData2;     // int64_t Amount Per Share;
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func() "
                 "ERROR!!!!!!\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_accountID,
		const std::string &	p_strParam,
		const std::string &	p_strData,
		const std::string &	p_strData2
	)

Definition at line 528 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 7 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_accountID)) {
        otOut << strError << "p_accountID";
    }
    if (!VerifyStringVal(p_strParam)) {
        otOut << strError << "p_strParam";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = 1;
    bBool = false;
    accountID = p_accountID;

    if (theType == SEND_USER_INSTRUMENT) {
        if (!VerifyStringVal(p_accountID)) {
            otOut << strError << "p_accountID";
        }
        if (!VerifyStringVal(p_strParam)) {
            otOut << strError << "p_strParam";
        }
        if (!VerifyStringVal(p_strData)) {
            otOut << strError << "p_strData";
        }
        nymID2 = p_accountID; // Recipient Nym;
        strData = p_strParam; // Recipient pubkey;
        strData2 = p_strData; // Instrument for recipient.;
        accountID =
            p_strData2; // sender_instrument is attached here. (Optional.);
    }
    else {
        otOut << "ERROR! WRONG TYPE passed to OTAPI_Func.OTAPI_Func() "
                 "ERROR!!!!!!\n";
    }
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	p_assetID,
		const std::string &	p_basket,
		const std::string &	p_accountID,
		bool	p_bBool,
		int32_t	p_nTransNumsNeeded
	)

Definition at line 581 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 8 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(p_assetID)) {
        otOut << strError << "p_assetID";
    }
    if (!VerifyStringVal(p_accountID)) {
        otOut << strError << "p_accountID";
    }
    if (!VerifyStringVal(p_basket)) {
        otOut << strError << "p_basket";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    nTransNumsNeeded = p_nTransNumsNeeded;
    bBool = p_bBool;
    assetID = p_assetID;
    basket = p_basket;
    accountID = p_accountID;
}

OTAPI_Func::OTAPI_Func	(	OTAPI_Func_Type	theType,
		const std::string &	p_serverID,
		const std::string &	p_nymID,
		const std::string &	assetAccountID,
		const std::string &	currencyAcctID,
		const std::string &	scale,
		const std::string &	minIncrement,
		const std::string &	quantity,
		const std::string &	price,
		bool	bSelling
	)

Definition at line 618 of file ot_otapi_ot.cpp.

{
    // otOut << "(Version of OTAPI_Func with 10 arguments.)\n";

    InitCustom();

    string strError =
        "ERROR! Empty string passed to OTAPI_Func.OTAPI_Func() as: ";
    if (!VerifyStringVal(p_serverID)) {
        otOut << strError << "p_serverID";
    }
    if (!VerifyStringVal(p_nymID)) {
        otOut << strError << "p_nymID";
    }
    if (!VerifyStringVal(assetAccountID)) {
        otOut << strError << "assetAccountID";
    }
    if (!VerifyStringVal(currencyAcctID)) {
        otOut << strError << "currencyAcctID";
    }
    if (!VerifyStringVal(scale)) {
        otOut << strError << "scale";
    }
    if (!VerifyStringVal(minIncrement)) {
        otOut << strError << "minIncrement";
    }
    if (!VerifyStringVal(quantity)) {
        otOut << strError << "quantity";
    }
    if (!VerifyStringVal(price)) {
        otOut << strError << "price";
    }

    funcType = theType;
    serverID = p_serverID;
    nymID = p_nymID;
    accountID = assetAccountID;
    accountID2 = currencyAcctID;

    strData = scale;
    strData2 = minIncrement;
    strData3 = quantity;
    strData4 = price;

    strData5 = ""; // Will be set after this function is called, since there
                   // were too many arguments.

    bBool = bSelling;

    nTransNumsNeeded = 3; // An opening transaction number, plus another for
                          // each asset account, total of 3.
}

OTAPI_Func::~OTAPI_Func

(

)

Definition at line 197 of file ot_otapi_ot.cpp.

{
}

Member Function Documentation

OT_OTAPI_OT void OTAPI_Func::CopyVariables ( )

static

Definition at line 167 of file ot_otapi_ot.cpp.

{
    Args = GetVariable("Args");
    HisAcct = GetVariable("HisAcct");
    HisNym = GetVariable("HisNym");
    HisPurse = GetVariable("HisPurse");
    MyAcct = GetVariable("MyAcct");
    MyNym = GetVariable("MyNym");
    MyPurse = GetVariable("MyPurse");
    Server = GetVariable("Server");
}

OT_OTAPI_OT void OTAPI_Func::InitCustom

(

)

Definition at line 179 of file ot_otapi_ot.cpp.

{
    bBool = false;
    nData = 0;
    lData = 0;
    tData = OT_TIME_ZERO;
    nTransNumsNeeded = 0;
    nRequestNum = -1;
    funcType = NO_FUNC;
}

OT_OTAPI_OT int32_t OTAPI_Func::Run

(

)

const

Definition at line 675 of file ot_otapi_ot.cpp.

{
    // -1 means error, no message was sent.
    //  0 means NO error, yet still no message was sent.
    // >0 means (usually) the request number is being returned.
    //
    switch (funcType) {
    case CHECK_USER:
        return OTAPI_Wrap::checkUser(serverID, nymID, nymID2);
    case CREATE_USER_ACCT:
        return OTAPI_Wrap::createUserAccount(serverID, nymID);
    case DELETE_USER_ACCT:
        return OTAPI_Wrap::deleteUserAccount(serverID, nymID);
    case SEND_USER_MESSAGE:
        return OTAPI_Wrap::sendUserMessage(serverID, nymID, nymID2, strData,
                                           strData2);
    case SEND_USER_INSTRUMENT:
        // accountID stores here the sender's copy of the instrument, which is
        // used only in the case of a cash purse.
        return OTAPI_Wrap::sendUserInstrument(serverID, nymID, nymID2, strData,
                                              strData2, accountID);
    case GET_NYM_MARKET_OFFERS:
        return OTAPI_Wrap::getNym_MarketOffers(serverID, nymID);
    case CREATE_ASSET_ACCT:
        return OTAPI_Wrap::createAssetAccount(serverID, nymID, assetID);
    case DELETE_ASSET_ACCT:
        return OTAPI_Wrap::deleteAssetAccount(serverID, nymID, accountID);
    case ACTIVATE_SMART_CONTRACT:
        return OTAPI_Wrap::activateSmartContract(serverID, nymID, strData2);
    case TRIGGER_CLAUSE:
        return OTAPI_Wrap::triggerClause(serverID, nymID, stoll(strData),
                                         strData2, strData3);
    case EXCHANGE_BASKET:
        return OTAPI_Wrap::exchangeBasket(serverID, nymID, assetID, basket,
                                          bBool);
    case GET_CONTRACT:
        return OTAPI_Wrap::getContract(serverID, nymID, assetID);
    case GET_MINT:
        return OTAPI_Wrap::getMint(serverID, nymID, assetID);
    case QUERY_ASSET_TYPES:
        return OTAPI_Wrap::queryAssetTypes(serverID, nymID, strData);
    case ISSUE_ASSET_TYPE:
        return OTAPI_Wrap::issueAssetType(serverID, nymID, strData);
    case ISSUE_BASKET:
        return OTAPI_Wrap::issueBasket(serverID, nymID, basket);
    case EXCHANGE_CASH:
        return OTAPI_Wrap::exchangePurse(serverID, assetID, nymID, strData);
    case KILL_MARKET_OFFER:
        return OTAPI_Wrap::killMarketOffer(serverID, nymID, accountID,
                                           stoll(strData));
    case KILL_PAYMENT_PLAN:
        return OTAPI_Wrap::killPaymentPlan(serverID, nymID, accountID,
                                           stoll(strData));
    case GET_BOX_RECEIPT:
        return OTAPI_Wrap::getBoxReceipt(serverID, nymID, accountID, nData,
                                         stoll(strData));
    case PROCESS_INBOX:
        return OTAPI_Wrap::processInbox(serverID, nymID, accountID, strData);
    case DEPOSIT_CASH:
        return OTAPI_Wrap::notarizeDeposit(serverID, nymID, accountID, strData);
    case DEPOSIT_CHEQUE:
        return OTAPI_Wrap::depositCheque(serverID, nymID, accountID, strData);
    case DEPOSIT_PAYMENT_PLAN:
        return OTAPI_Wrap::depositPaymentPlan(serverID, nymID, strData);
    case WITHDRAW_CASH:
        return OTAPI_Wrap::notarizeWithdrawal(serverID, nymID, accountID,
                                              lData);
    case WITHDRAW_VOUCHER:
        return OTAPI_Wrap::withdrawVoucher(serverID, nymID, accountID, nymID2,
                                           strData, lData);
    case PAY_DIVIDEND:
        return OTAPI_Wrap::payDividend(serverID, nymID, accountID, assetID,
                                       strData, lData);
    case SEND_TRANSFER:
        return OTAPI_Wrap::notarizeTransfer(serverID, nymID, accountID,
                                            accountID2, lData, strData);
    case GET_MARKET_LIST:
        return OTAPI_Wrap::getMarketList(serverID, nymID);
    case GET_MARKET_OFFERS:
        return OTAPI_Wrap::getMarketOffers(serverID, nymID, strData, lData);
    case GET_MARKET_RECENT_TRADES:
        return OTAPI_Wrap::getMarketRecentTrades(serverID, nymID, strData);
    case CREATE_MARKET_OFFER:
        return OTAPI_Wrap::issueMarketOffer(
            accountID, accountID2, stoll(strData), stoll(strData2),
            stoll(strData3), stoll(strData4), bBool, tData, strData5, lData);
    case ADJUST_USAGE_CREDITS:
        return OTAPI_Wrap::usageCredits(serverID, nymID, nymID2,
                                        stoll(strData));
    default:
        break;
    }

    otOut << "ERROR! OTAPI_Func.Send() activated, with bad function type: "
          << funcType << "\n";

    return -1;
}

OT_OTAPI_OT string OTAPI_Func::SendRequest	(	OTAPI_Func &	theFunction,
		const std::string &	IN_FUNCTION
	)		const

Definition at line 996 of file ot_otapi_ot.cpp.

{
    Utility MsgUtil;

    bool bCanRetryAfterThis = false;

    string strResult = SendRequestOnce(theFunction, IN_FUNCTION, false, true,
                                       bCanRetryAfterThis);

    if (!VerifyStringVal(strResult) && bCanRetryAfterThis) {
        strResult = SendRequestOnce(theFunction, IN_FUNCTION, false, false,
                                    bCanRetryAfterThis);
    }
    return strResult;
}

OT_OTAPI_OT int32_t OTAPI_Func::SendRequestLowLevel	(	OTAPI_Func &	theFunction,
		const std::string &	IN_FUNCTION
	)		const

Definition at line 775 of file ot_otapi_ot.cpp.

{
    Utility MsgUtil;
    string strLocation = "OTAPI_Func::SendRequestLowLevel: " + IN_FUNCTION;

    OTAPI_Wrap::FlushMessageBuffer();

    int32_t nRun =
        theFunction.Run(); // <===== ATTEMPT TO SEND THE MESSAGE HERE...;

    if (nRun == -1) // if the requestNumber returned by the send-attempt is -1,
                    // that means it DIDN'T SEND (error)
    {
        otOut << strLocation << ": Failed to send message due to error.\n";

        theFunction.nRequestNum = -1;
    }
    else if (nRun == 0) // if the requestNumber returned by the send-attempt
                          // is 0, it means no error, but nothing was sent.
                          // (Like processing an empty box.)
    {
        otOut << strLocation << ": Didn't send this message, but NO error "
                                "occurred, either. (For example, a request to "
                                "process an empty Nymbox will return 0, "
                                "meaning, nothing was sent, but also no error "
                                "occurred.)\n";

        theFunction.nRequestNum = 0;
    }
    else if (nRun == (-2)) // -2 is also possible at some future date. (If the
                             // request number won't fit in an int32_t, this is
                             // returned and then you can retrieve the actual
                             // number via a separate call.)
    {
        otOut << strLocation << ": ERROR, not supported. (-2 was returned.)\n";

        // TODO: Have an OT API call here, which retrieves the request number
        // (It must be too large to fit into an integer, which is why this
        // happened.)

        theFunction.nRequestNum = -1;
    }
    else {
        theFunction.nRequestNum = nRun;
    }

    // BY this point, we definitely have the request number, which means the
    // message was actually SENT. (At least.) This also means we can use nRun
    // later to query for a copy of that sent message (like if we need to
    // clawback
    // the transaction numbers from it later, once we confirm whether the server
    // actually never got it.)
    //
    return theFunction.nRequestNum;
}

OT_OTAPI_OT string OTAPI_Func::SendRequestOnce	(	OTAPI_Func &	theFunction,
		const std::string &	IN_FUNCTION,
		bool	bIsTransaction,
		bool	bWillRetryAfterThis,
		bool &	bCanRetryAfterThis
	)		const

Definition at line 1013 of file ot_otapi_ot.cpp.

{
    Utility MsgUtil;
    string strLocation = "OTAPI_Func::SendRequestOnce: " + IN_FUNCTION;

    bCanRetryAfterThis = false;

    string strReply = "";
    int32_t nlocalRequestNum = SendRequestLowLevel(
        theFunction, IN_FUNCTION); // <========   FIRST ATTEMPT!!!!!!;

    if ((nlocalRequestNum == -1) || (nlocalRequestNum == 0)) {
        return "";
    }
    else // 1 and default.
    {
        if (nlocalRequestNum < -1) {
            return "";
        }

        strReply = MsgUtil.ReceiveReplyLowLevel(
            theFunction.serverID, theFunction.nymID, nlocalRequestNum,
            IN_FUNCTION); // <==== Here we RECEIVE the REPLY...;
    }

    // Below this point, we definitely have a request number.
    // (But not yet necessarily a reply...)
    //

    // nlocalRequestNum is positive and contains the request number from
    // sending.
    //
    // nReplySuccess contains status of the REPLY to that sent message.
    // nReplySuccess contains:
    //   0 == FAILURE reply msg from server,
    //   1 == SUCCESS reply msg from server (transaction could be success or
    // fail.)
    //  -1 == (ERROR)
    //
    // strReply contains the reply itself (or null.)
    //
    int32_t nReplySuccess = VerifyMessageSuccess(strReply);

    bool bMsgReplyError = (!VerifyStringVal(strReply) || (nReplySuccess < 0));

    bool bMsgReplySuccess = (!bMsgReplyError && (nReplySuccess > 0));
    bool bMsgReplyFailure = (!bMsgReplyError && (nReplySuccess == 0));

    bool bMsgTransSuccess;
    bool bMsgTransFailure;

    bool bMsgAnyError;
    bool bMsgAnyFailure;

    bool bMsgAllSuccess;

    // If you EVER are in a situation where you have to harvest numbers
    // back, it will ONLY be for transactions, not normal messages. (Those
    // are the only ones that USE transaction numbers.)
    //
    if (bIsTransaction) // This request contains a TRANSACTION...
    {
        int32_t nTransSuccess;
        int32_t nBalanceSuccess;
        if (bMsgReplySuccess) // If message was success, then let's see if the
                              // transaction was, too.
        {
            nBalanceSuccess = OTAPI_Wrap::Message_GetBalanceAgreementSuccess(
                theFunction.serverID, theFunction.nymID, theFunction.accountID,
                strReply);

            if (nBalanceSuccess > 0) {
                // Sometimes a transaction is sent that is meant to "fail" in
                // order to cancel itself from ever being run in the future.
                // It's being cancelled. In that case, whether the server reply
                // itself is acknowledged or rejection, either way,
                // IsCancelled() will be set to TRUE.
                // This is used when cancelling a cheque, or a payment plan, or
                // a smart contract, so that it can never be activated at some
                // future time.
                //
                // Therefore when we see that IsCancelled is set to TRUE, we
                // interpret it as a "success" as far as the UI is concerned,
                // even though behind the scenes, it is still "rejected" and
                // transaction numbers were harvested from it.
                //
                int32_t nTransCancelled =
                    OTAPI_Wrap::Message_IsTransactionCanceled(
                        theFunction.serverID, theFunction.nymID,
                        theFunction.accountID, strReply);

                // If it's not cancelled, then we assume it's a normal
                // transaction (versus a cancellation)
                // and we check for success/failure as normal...
                //
                if (1 != nTransCancelled) {
                    nTransSuccess = OTAPI_Wrap::Message_GetTransactionSuccess(
                        theFunction.serverID, theFunction.nymID,
                        theFunction.accountID, strReply);
                }
                else // If it WAS cancelled, then for the UI we say "Success"
                       // even though OT behind the scenes is harvesting as
                       // though it failed.
                {      // (Which is what we want to happen, in the case that a
                       // cancellation was performed.)
                    // This way, the UI won't go off doing a bunch of
                    // unnecessary retries for a "failed" transaction.
                    // (After all, if it was cancelled, then we know for a fact
                    // that all future retries will fail anyway.)
                    //
                    nTransSuccess = 1;
                }
            }
            else {
                nTransSuccess = -1;
            }
        }
        else {
            nBalanceSuccess = -1;
            nTransSuccess = -1;
        }
        // All of these booleans (except "error") represent RECEIVED ANSWERS
        // from the server.
        // In other words, "failure" does not mean "failed to find message."
        // Rather, it means "DEFINITELY got a reply, and that reply says
        // status==failure."
        //

        bool bMsgBalanceError =
            (!VerifyStringVal(strReply) || (nBalanceSuccess < 0));
        bool bMsgBalanceSuccess =
            (!bMsgReplyError && !bMsgBalanceError && (nBalanceSuccess > 0));
        bool bMsgBalanceFailure =
            (!bMsgReplyError && !bMsgBalanceError && (nBalanceSuccess == 0));

        bool bMsgTransError =
            (!VerifyStringVal(strReply) || (nTransSuccess < 0));
        bMsgTransSuccess = (!bMsgReplyError && !bMsgBalanceError &&
                            !bMsgTransError && (nTransSuccess > 0));
        bMsgTransFailure = (!bMsgReplyError && !bMsgBalanceError &&
                            !bMsgTransError && (nTransSuccess == 0));

        bMsgAnyError = (bMsgReplyError || bMsgBalanceError || bMsgTransError);
        bMsgAnyFailure =
            (bMsgReplyFailure || bMsgBalanceFailure || bMsgTransFailure);

        bMsgAllSuccess =
            (bMsgReplySuccess && bMsgBalanceSuccess && bMsgTransSuccess);

    }
    else // it's NOT a transaction, but a normal message..
    {
        bMsgTransSuccess = false;
        bMsgTransFailure = false;

        bMsgAnyError = (bMsgReplyError);
        bMsgAnyFailure = (bMsgReplyFailure);

        bMsgAllSuccess = (bMsgReplySuccess);
    }

    // We know the message SENT. The above logic is about figuring out whether
    // the reply message,
    // the transaction inside it, and the balance agreement inside that
    // transaction, whether
    // any of those three things is a definite error, a definite failure, or a
    // definite success.
    // (Any one of those things could be true, OR NOT, and we can only act as if
    // they are, if we
    // have definitive proof in any of those cases.)
    //
    // The below logic is about what sort of REPLY we may have gotten (if
    // anything.)
    // Without a definite reply we cannot claw back. But the Nymbox can show us
    // this answer,
    // either now, or later...
    //
    if (bMsgAllSuccess) {
        // the Msg was a complete success, including the message
        // AND the transaction AND the balance agreement.
        // Therefore, there's DEFINITELY nothing to clawback.
        //
        // (Thus I RemoveSentMessage for the message, since
        // I'm totally done with it now. NO NEED TO HARVEST anything, either.)
        //
        //          var nRemoved =
        // OTAPI_Wrap::RemoveSentMessage(Integer.toString(nlocalRequestNum),
        // theFunction.serverID, theFunction.nymID);
        //
        // NOTE: The above call is unnecessary, since a successful reply means
        // we already received the successful server reply, and OT's
        // "ProcessServerReply"
        // already removed the sent message from the sent buffer (so no need to
        // do that here.)

        //          otOut << strLocation << ", SendRequestOnce():
        // OT_API_RemoveSentMessage: " + nRemoved);

        return strReply;

    }
    // In this case we want to grab the Nymbox and see if the replyNotice is
    // there.
    // If it IS, then OT server DEFINITELY replied to it (the MESSAGE was a
    // success,
    // whether the transaction inside of it was success or fail.) So we know
    // bMsgReplySuccess
    // is true, if we find a replyNotice.
    // From there, we can also check for transaction success.
    //
    else if (bMsgAnyError || bMsgAnyFailure) // let's resync, and clawback
                                             // whatever transaction numbers we
                                             // might have used on the
                                             // Request...
    {
        bool bWasGetReqSent = false;
        int32_t nGetRequest = MsgUtil.getRequestNumber(
            theFunction.serverID, theFunction.nymID,
            bWasGetReqSent); // <==== RE-SYNC ATTEMPT...;

        // GET REQUEST WAS A SUCCESS.
        //
        if (bWasGetReqSent && (nGetRequest > 0)) {
            bCanRetryAfterThis = true;

            // But--if it was a TRANSACTION, then we're not done syncing yet!
            //
            if (bIsTransaction) {
                bCanRetryAfterThis = false;

                //
                // Maybe we have an old Inbox or something.
                // NEW CODE HERE FOR DEBUGGING (THIS BLOCK)
                //
                bool bForceDownload = true;
                if (!MsgUtil.getIntermediaryFiles(
                        theFunction.serverID, theFunction.nymID,
                        theFunction.accountID, bForceDownload)) {
                    otOut << strLocation << ", getIntermediaryFiles returned "
                                            "false. (After a failure to send "
                                            "the transaction. Thus, I give "
                                            "up.)\n";
                    return "";
                }

                bool bWasFound = false;
                bool bWasSent = false;

                OTfourbool the_foursome = {bMsgReplySuccess, bMsgReplyFailure,
                                           bMsgTransSuccess, bMsgTransFailure};

                bForceDownload = false;

                int32_t nProcessNymboxResult = MsgUtil.getAndProcessNymbox_8(
                    theFunction.serverID, theFunction.nymID, bWasSent,
                    bForceDownload, nlocalRequestNum, bWasFound,
                    bWillRetryAfterThis, the_foursome);

                // bHarvestingForRetry,// bHarvestingForRetry is INPUT, in the
                // case nlocalRequestNum needs to be harvested before a flush
                // occurs.

                //  bMsgReplySuccess,    // bMsgReplySuccess is INPUT, and is in
                // case nlocalRequestNum needs to be HARVESTED before a FLUSH
                // happens.
                //  bMsgReplyFailure,    // bMsgReplyFailure is INPUT, and is in
                // case nlocalRequestNum needs to be HARVESTED before a FLUSH
                // happens.
                //  bMsgTransSuccess,    // bMsgTransSuccess is INPUT, and is in
                // case nlocalRequestNum needs to be HARVESTED before a FLUSH
                // happens.
                //  bMsgTransFailure)    // Etc.

                // FIX: Add '(' and ')' here to silence warning. But where?
                if ((bWasSent && (1 == nProcessNymboxResult)) ||
                    (!bWasSent &&
                     (0 == nProcessNymboxResult))) // success processing Nymbox.
                {
                    bCanRetryAfterThis = true;
                }

                // This means a request number was returned, since the
                // processNymbox failed,
                // and hasn't been properly harvested, so we either need to
                // harvest it for a re-try,
                // or flush it.
                //
                else if (bWasSent && (nProcessNymboxResult > 1)) {
                    string strNymbox = OTAPI_Wrap::LoadNymboxNoVerify(
                        theFunction.serverID,
                        theFunction.nymID); // FLUSH SENT MESSAGES!!!!  (AND
                                            // HARVEST.);

                    if (VerifyStringVal(strNymbox)) {
                        OTAPI_Wrap::FlushSentMessages(
                            false, theFunction.serverID, theFunction.nymID,
                            strNymbox);
                    }
                }
            } // if (bIsTransaction)

        } // if getRequest was success.
        else {
            otOut << strLocation << ", Failure: Never got reply from server, "
                                    "so tried getRequest, and that failed too. "
                                    "(I give up.)\n";

            // Note: cannot harvest transaction nums here because I do NOT know
            // for sure
            // whether the server has replied to the message or not! (Not until
            // I successfully
            // download my Nymbox.) Therefore, do NOT harvest or flush, but hold
            // back and wait
            // until the next attempt does a successful getNymbox and THEN do a
            // "flush sent" after
            // that. (That's the time we'll know for SURE what happened to the
            // original reply.)
            //
            // (Therefore LEAVE the sent message in the sent queue.)

            return "";
        }
    } // else if (bMsgAnyError || bMsgAnyFailure)

    // Returning an empty string.

    return "";
}

OT_OTAPI_OT string OTAPI_Func::SendTransaction	(	OTAPI_Func &	theFunction,
		const std::string &	IN_FUNCTION
	)

Definition at line 832 of file ot_otapi_ot.cpp.

{
    int32_t nTotalRetries = 2;
    return SendTransaction(theFunction, IN_FUNCTION, nTotalRetries);
}

OT_OTAPI_OT string OTAPI_Func::SendTransaction	(	OTAPI_Func &	theFunction,
		const std::string &	IN_FUNCTION,
		int32_t	nTotalRetries
	)		const

Definition at line 839 of file ot_otapi_ot.cpp.

{
    Utility MsgUtil;
    string strLocation = "OTAPI_Func::SendTransaction: " + IN_FUNCTION;

    if (!MsgUtil.getIntermediaryFiles(theFunction.serverID, theFunction.nymID,
                                      theFunction.accountID,
                                      false)) // bForceDownload=false))
    {
        otOut << strLocation << ", getIntermediaryFiles returned false. (It "
                                "couldn't download files that it needed.)\n";
        return "";
    }

    // GET TRANSACTION NUMBERS HERE IF NECESSARY.
    //
    int32_t getnym_trnsnum_count = OTAPI_Wrap::GetNym_TransactionNumCount(
        theFunction.serverID, theFunction.nymID);
    int32_t configTxnCount = MsgUtil.getNbrTransactionCount();
    bool b1 = (theFunction.nTransNumsNeeded > configTxnCount);
    int32_t comparative = 0;

    if (b1) {
        comparative = theFunction.nTransNumsNeeded;
    }
    else {
        comparative = configTxnCount;
    }

    if (getnym_trnsnum_count < comparative) {
        otOut << strLocation << ", I don't have enough transaction numbers to "
                                "perform this transaction. Grabbing more "
                                "now...\n";
        MsgUtil.setNbrTransactionCount(comparative);
        MsgUtil.getTransactionNumbers(theFunction.serverID, theFunction.nymID);
        MsgUtil.setNbrTransactionCount(configTxnCount);
    }

    // second try
    getnym_trnsnum_count =
        OTAPI_Wrap::GetNym_TransactionNumCount(serverID, nymID);
    if (getnym_trnsnum_count < comparative) {
        otOut
            << strLocation
            << ", failure: MsgUtil.getTransactionNumbers. (Trying again...)\n";

        // (the final parameter, the 'false' is us telling getTransNumbers that
        // it can skip the first call to getTransNumLowLevel)
        //
        MsgUtil.setNbrTransactionCount(comparative);
        MsgUtil.getTransactionNumbers(serverID, nymID, false);
        MsgUtil.setNbrTransactionCount(configTxnCount);
    }

    // third try
    getnym_trnsnum_count =
        OTAPI_Wrap::GetNym_TransactionNumCount(serverID, nymID);
    if (getnym_trnsnum_count < comparative) {
        otOut
            << strLocation
            << ", failure: MsgUtil.getTransactionNumbers. (Trying again...)\n";

        // (the final parameter, the 'false' is us telling getTransNumbers that
        // it can skip the first call to getTransNumLowLevel)
        //
        MsgUtil.setNbrTransactionCount(comparative);
        MsgUtil.getTransactionNumbers(serverID, nymID, false);
        MsgUtil.setNbrTransactionCount(configTxnCount);
    }

    // Giving up, if still a failure by this point.
    //
    getnym_trnsnum_count = OTAPI_Wrap::GetNym_TransactionNumCount(
        theFunction.serverID, theFunction.nymID);

    if (getnym_trnsnum_count < comparative) {
        otOut
            << strLocation
            << ", third failure: MsgUtil.getTransactionNumbers. (Giving up.)\n";
        return "";
    }

    bool bCanRetryAfterThis = false;

    string strResult = SendRequestOnce(theFunction, IN_FUNCTION, true, true,
                                       bCanRetryAfterThis);

    if (VerifyStringVal(strResult)) {
        otOut << " Getting Intermediary files.. \n";

        if (!MsgUtil.getIntermediaryFiles(theFunction.serverID,
                                          theFunction.nymID,
                                          theFunction.accountID, true)) {
            otOut << strLocation << ", getIntermediaryFiles returned false. "
                                    "(After a success sending the transaction. "
                                    "Strange...)\n";
            return "";
        }

        return strResult;
    }

    //
    // Maybe we have an old Inbox or something.
    //

    // TODO!!  SECURITY:  This is where a GOOD CLIENT (vs. a test client)
    // will verify these intermediary files against your LAST SIGNED RECEIPT,
    // using OTAPI_Wrap::VerifySomethingorother().
    // See verifyFiles() at the bottom of this file.
    // Add some kind of warning Modal Dialog here, since it's actually
    // normal for a NEW account (never had any receipts yet.) But for
    // any other account, this should ALWAYS VERIFY!
    //
    // Another note: this should happen INSIDE the getIntermediaryFiles call
    // itself,
    // and all similar calls.  You simply should not download those files,
    // without verifying them also. Otherwise you could end up signing
    // a future bad receipt, based on malicious, planted intermediary files.

    int32_t nRetries = nTotalRetries;

    while ((nRetries > 0) && !VerifyStringVal(strResult) &&
           bCanRetryAfterThis) {
        --nRetries;

        bool bWillRetryAfterThis = true;

        if ((nRetries == 0) || !bCanRetryAfterThis) {
            bWillRetryAfterThis = false;
        }

        strResult = SendRequestOnce(theFunction, IN_FUNCTION, true,
                                    bWillRetryAfterThis, bCanRetryAfterThis);

        // In case of failure, we want to get these before we re-try.
        // But in case of success, we also want to get these, so we can
        // see the results of our success. So we get these either way...
        //
        if (VerifyStringVal(strResult)) {
            if (!MsgUtil.getIntermediaryFiles(theFunction.serverID,
                                              theFunction.nymID,
                                              theFunction.accountID, true)) {
                otOut << strLocation
                      << ", getIntermediaryFiles (loop) returned false even "
                         "after successfully sending the transaction.\n";
                return "";
            }
            break;
        }
    }

    return strResult;
}

Member Data Documentation

std::string OTAPI_Func::accountID

Definition at line 266 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::accountID2

Definition at line 267 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::assetID

Definition at line 264 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::assetID2

Definition at line 265 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::basket

Definition at line 268 of file ot_otapi_ot.hpp.

bool OTAPI_Func::bBool

Definition at line 274 of file ot_otapi_ot.hpp.

OTAPI_Func_Type OTAPI_Func::funcType

Definition at line 260 of file ot_otapi_ot.hpp.

int64_t OTAPI_Func::lData

Definition at line 276 of file ot_otapi_ot.hpp.

int32_t OTAPI_Func::nData

Definition at line 275 of file ot_otapi_ot.hpp.

int32_t OTAPI_Func::nRequestNum

Definition at line 279 of file ot_otapi_ot.hpp.

int32_t OTAPI_Func::nTransNumsNeeded

Definition at line 278 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::nymID

Definition at line 262 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::nymID2

Definition at line 263 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::serverID

Definition at line 261 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::strData

Definition at line 269 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::strData2

Definition at line 270 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::strData3

Definition at line 271 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::strData4

Definition at line 272 of file ot_otapi_ot.hpp.

std::string OTAPI_Func::strData5

Definition at line 273 of file ot_otapi_ot.hpp.

time64_t OTAPI_Func::tData

Definition at line 277 of file ot_otapi_ot.hpp.

---

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

• /usr/local/src/opentxs/include/opentxs/client/ot_otapi_ot.hpp
• /usr/local/src/opentxs/src/client/ot_otapi_ot.cpp