OTAPI.hpp

Go to the documentation of this file.

/************************************************************
 *
 *  OTAPI.hpp
 *
 */

/************************************************************
 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA1

 *                 OPEN TRANSACTIONS
 *
 *       Financial Cryptography and Digital Cash
 *       Library, Protocol, API, Server, CLI, GUI
 *
 *       -- Anonymous Numbered Accounts.
 *       -- Untraceable Digital Cash.
 *       -- Triple-Signed Receipts.
 *       -- Cheques, Vouchers, Transfers, Inboxes.
 *       -- Basket Currencies, Markets, Payment Plans.
 *       -- Signed, XML, Ricardian-style Contracts.
 *       -- Scripted smart contracts.
 *
 *  Copyright (C) 2010-2013 by "Fellow Traveler" (A pseudonym)
 *
 *  EMAIL:
 *  [email protected]
 *
 *  BITCOIN:  1NtTPVVjDsUfDWybS4BwvHpG2pdS9RnYyQ
 *
 *  KEY FINGERPRINT (PGP Key in license file):
 *  9DD5 90EB 9292 4B48 0484  7910 0308 00ED F951 BB8E
 *
 *  OFFICIAL PROJECT WIKI(s):
 *  https://github.com/FellowTraveler/Moneychanger
 *  https://github.com/FellowTraveler/Open-Transactions/wiki
 *
 *  WEBSITE:
 *  http://www.OpenTransactions.org/
 *
 *  Components and licensing:
 *   -- Moneychanger..A Java client GUI.....LICENSE:.....GPLv3
 *   -- otlib.........A class library.......LICENSE:...LAGPLv3
 *   -- otapi.........A client API..........LICENSE:...LAGPLv3
 *   -- opentxs/ot....Command-line client...LICENSE:...LAGPLv3
 *   -- otserver......Server Application....LICENSE:....AGPLv3
 *  Github.com/FellowTraveler/Open-Transactions/wiki/Components
 *
 *  All of the above OT components were designed and written by
 *  Fellow Traveler, with the exception of Moneychanger, which
 *  was contracted out to Vicky C ([email protected]).
 *  The open-source community has since actively contributed.
 *
 *  -----------------------------------------------------
 *
 *   LICENSE:
 *   This program is free software: you can redistribute it
 *   and/or modify it under the terms of the GNU Affero
 *   General Public License as published by the Free Software
 *   Foundation, either version 3 of the License, or (at your
 *   option) any later version.
 *
 *   ADDITIONAL PERMISSION under the GNU Affero GPL version 3
 *   section 7: (This paragraph applies only to the LAGPLv3
 *   components listed above.) If you modify this Program, or
 *   any covered work, by linking or combining it with other
 *   code, such other code is not for that reason alone subject
 *   to any of the requirements of the GNU Affero GPL version 3.
 *   (==> This means if you are only using the OT API, then you
 *   don't have to open-source your code--only your changes to
 *   Open-Transactions itself must be open source. Similar to
 *   LGPLv3, except it applies to software-as-a-service, not
 *   just to distributing binaries.)
 *
 *   Extra WAIVER for OpenSSL, Lucre, and all other libraries
 *   used by Open Transactions: This program is released under
 *   the AGPL with the additional exemption that compiling,
 *   linking, and/or using OpenSSL is allowed. The same is true
 *   for any other open source libraries included in this
 *   project: complete waiver from the AGPL is hereby granted to
 *   compile, link, and/or use them with Open-Transactions,
 *   according to their own terms, as long as the rest of the
 *   Open-Transactions terms remain respected, with regard to
 *   the Open-Transactions code itself.
 *
 *   Lucre License:
 *   This code is also "dual-license", meaning that Ben Lau-
 *   rie's license must also be included and respected, since
 *   the code for Lucre is also included with Open Transactions.
 *   See Open-Transactions/src/otlib/lucre/LUCRE_LICENSE.txt
 *   The Laurie requirements are light, but if there is any
 *   problem with his license, simply remove the Lucre code.
 *   Although there are no other blind token algorithms in Open
 *   Transactions (yet. credlib is coming), the other functions
 *   will continue to operate.
 *   See Lucre on Github:  https://github.com/benlaurie/lucre
 *   -----------------------------------------------------
 *   You should have received a copy of the GNU Affero General
 *   Public License along with this program.  If not, see:
 *   http://www.gnu.org/licenses/
 *
 *   If you would like to use this software outside of the free
 *   software license, please contact FellowTraveler.
 *   (Unfortunately many will run anonymously and untraceably,
 *   so who could really stop them?)
 *
 *   DISCLAIMER:
 *   This program is distributed in the hope that it will be
 *   useful, but WITHOUT ANY WARRANTY; without even the implied
 *   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 *   PURPOSE.  See the GNU Affero General Public License for
 *   more details.

 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.9 (Darwin)

 iQIcBAEBAgAGBQJRSsfJAAoJEAMIAO35UbuOQT8P/RJbka8etf7wbxdHQNAY+2cC
 vDf8J3X8VI+pwMqv6wgTVy17venMZJa4I4ikXD/MRyWV1XbTG0mBXk/7AZk7Rexk
 KTvL/U1kWiez6+8XXLye+k2JNM6v7eej8xMrqEcO0ZArh/DsLoIn1y8p8qjBI7+m
 aE7lhstDiD0z8mwRRLKFLN2IH5rAFaZZUvj5ERJaoYUKdn4c+RcQVei2YOl4T0FU
 LWND3YLoH8naqJXkaOKEN4UfJINCwxhe5Ke9wyfLWLUO7NamRkWD2T7CJ0xocnD1
 sjAzlVGNgaFDRflfIF4QhBx1Ddl6wwhJfw+d08bjqblSq8aXDkmFA7HeunSFKkdn
 oIEOEgyj+veuOMRJC5pnBJ9vV+7qRdDKQWaCKotynt4sWJDGQ9kWGWm74SsNaduN
 TPMyr9kNmGsfR69Q2Zq/FLcLX/j8ESxU+HYUB4vaARw2xEOu2xwDDv6jt0j3Vqsg
 x7rWv4S/Eh18FDNDkVRChiNoOIilLYLL6c38uMf1pnItBuxP3uhgY6COm59kVaRh
 nyGTYCDYD2TK+fI9o89F1297uDCwEJ62U0Q7iTDp5QuXCoxkPfv8/kX6lS6T3y9G
 M9mqIoLbIQ1EDntFv7/t6fUTS2+46uCrdZWbQ5RjYXdrzjij02nDmJAm2BngnZvd
 kamH0Y/n11lCvo1oQxM+
 =uSzz
 -----END PGP SIGNATURE-----
 **************************************************************/

#ifndef OPENTXS_CLIENT_OTAPI_HPP
#define OPENTXS_CLIENT_OTAPI_HPP

#include "opentxs/core/util/Common.hpp"

namespace opentxs
{

class OT_API;
class OTAPI_Exec;

class OTAPI_Wrap
{
public:
    EXPORT static OTAPI_Exec* SetExecutor(OTAPI_Exec* exec);

    EXPORT static OTAPI_Exec* Exec();
    EXPORT static OTAPI_Exec* It();

    EXPORT static OT_API* OTAPI();

    EXPORT static int64_t StringToLong(const std::string& strNumber);
    EXPORT static std::string LongToString(const int64_t& lNumber);

    EXPORT static uint64_t StringToUlong(const std::string& strNumber);
    EXPORT static std::string UlongToString(const uint64_t& lNumber);

    EXPORT static bool AppInit();    // Call this ONLY ONCE, when your App first
                                     // starts up.
    EXPORT static bool AppCleanup(); // Call this ONLY ONCE, when your App is
                                     // shutting down.

    // SetAppBinaryFolder
    // OPTIONAL. Used in Android and Qt.
    //
    // Certain platforms use this to override the Prefix folder.
    // Basically /usr/local is the prefix folder by default, meaning
    // /usr/local/lib/opentxs will be the location of the scripts. But
    // if you override AppBinary folder to, say, "res/raw"
    // (Android does something like that) then even though the prefix remains
    // as /usr/local, the scripts folder will be res/raw
    //
    EXPORT static void SetAppBinaryFolder(const std::string& strFolder);

    // SetHomeFolder
    // OPTIONAL. Used in Android.
    //
    // The AppDataFolder, such as /Users/au/.ot, is constructed from the home
    // folder, such as /Users/au.
    //
    // Normally the home folder is auto-detected, but certain platforms, such as
    // Android, require us to explicitly set this folder from the Java code.
    // Then
    // the AppDataFolder is constructed from it. (It's the only way it can be
    // done.)
    //
    // In Android, you would SetAppBinaryFolder to the path to
    // "/data/app/packagename/res/raw",
    // and you would SetHomeFolder to "/data/data/[app package]/files/"
    //
    EXPORT static void SetHomeFolder(const std::string& strFolder);

    // Then:

    EXPORT static bool SetWallet(const std::string& strWalletFilename);

    EXPORT static bool WalletExists();

    EXPORT static bool LoadWallet();

    EXPORT static bool SwitchWallet();

    EXPORT static void Output(const int32_t& nLogLevel,
                              const std::string& strOutput);

    EXPORT static time64_t GetTime();

    // const std::string& OT_CLI_ReadLine();    // Reads from cin until
    // Newline.
    // const std::string& OT_CLI_ReadUntilEOF();    // Reads from cin until
    // EOF.

    // OTNumList is a class that encapsulates working with a comma-separated
    // list
    // of int64_t integers, stored in a std::set and easily serializable in/out
    // of a string.
    // (It's useful.)
    //
    EXPORT static std::string NumList_Add(const std::string& strNumList,
                                          const std::string& strNumbers);
    EXPORT static std::string NumList_Remove(const std::string& strNumList,
                                             const std::string& strNumbers);
    EXPORT static bool NumList_VerifyQuery(const std::string& strNumList,
                                           const std::string& strNumbers);
    EXPORT static bool NumList_VerifyAll(const std::string& strNumList,
                                         const std::string& strNumbers);
    EXPORT static int32_t NumList_Count(const std::string& strNumList);

    EXPORT static std::string Encode(const std::string& strPlaintext,
                                     const bool& bLineBreaks);

    EXPORT static std::string Decode(const std::string& strEncoded,
                                     const bool& bLineBreaks);

    EXPORT static std::string Encrypt(const std::string& RECIPIENT_NYM_ID,
                                      const std::string& strPlaintext);

    EXPORT static std::string Decrypt(const std::string& RECIPIENT_NYM_ID,
                                      const std::string& strCiphertext);

    // Generates a new symmetric key, based on a passphrase,
    // and returns it (or nullptr.)
    //
    EXPORT static std::string CreateSymmetricKey();

    EXPORT static std::string SymmetricEncrypt(const std::string& SYMMETRIC_KEY,
                                               const std::string& PLAINTEXT);
    EXPORT static std::string SymmetricDecrypt(
        const std::string& SYMMETRIC_KEY,
        const std::string& CIPHERTEXT_ENVELOPE);

    EXPORT static std::string SignContract(const std::string& SIGNER_NYM_ID,
                                           const std::string& THE_CONTRACT);

    // Instead of signing an existing contract, this is for just signing a flat
    // message.
    // Or, for example, for signing a new contract that has no signature yet.
    // Let's say you
    // have a ledger, for example, with no signatures yet. Pass "LEDGER" as the
    // CONTRACT_TYPE
    // and the resulting output will start like this: -----BEGIN OT SIGNED
    // LEDGER----- ...
    // Returns the signed output, or nullptr.
    //
    EXPORT static std::string FlatSign(const std::string& SIGNER_NYM_ID,
                                       const std::string& THE_INPUT,
                                       const std::string& CONTRACT_TYPE);

    EXPORT static std::string AddSignature(const std::string& SIGNER_NYM_ID,
                                           const std::string& THE_CONTRACT);

    EXPORT static bool VerifySignature(const std::string& SIGNER_NYM_ID,
                                       const std::string& THE_CONTRACT);

    EXPORT static std::string VerifyAndRetrieveXMLContents(
        const std::string& THE_CONTRACT, const std::string& SIGNER_ID);

    EXPORT static int32_t GetMemlogSize();

    EXPORT static std::string GetMemlogAtIndex(const int32_t& nIndex);

    EXPORT static std::string PeekMemlogFront();
    EXPORT static std::string PeekMemlogBack();

    EXPORT static bool PopMemlogFront();
    EXPORT static bool PopMemlogBack();

    EXPORT static std::string CreateNym(
        const int32_t& nKeySize, const std::string& NYM_ID_SOURCE,
        const std::string& ALT_LOCATION); // source and location can be empty.
                                          // (OT will generate a Nym with a
                                          // public key as the source.)

    EXPORT static std::string GetNym_ActiveCronItemIDs(
        const std::string& NYM_ID, const std::string& SERVER_ID);
    EXPORT static std::string GetActiveCronItem(const std::string& SERVER_ID,
                                                int64_t lTransNum);

    EXPORT static std::string GetNym_SourceForID(const std::string& NYM_ID);
    EXPORT static std::string GetNym_AltSourceLocation(
        const std::string& NYM_ID);

    EXPORT static int32_t GetNym_CredentialCount(const std::string& NYM_ID);
    EXPORT static std::string GetNym_CredentialID(const std::string& NYM_ID,
                                                  const int32_t& nIndex);
    EXPORT static std::string GetNym_CredentialContents(
        const std::string& NYM_ID, const std::string& CREDENTIAL_ID);

    EXPORT static int32_t GetNym_RevokedCredCount(const std::string& NYM_ID);
    EXPORT static std::string GetNym_RevokedCredID(const std::string& NYM_ID,
                                                   const int32_t& nIndex);
    EXPORT static std::string GetNym_RevokedCredContents(
        const std::string& NYM_ID, const std::string& CREDENTIAL_ID);

    EXPORT static int32_t GetNym_SubcredentialCount(
        const std::string& NYM_ID, const std::string& MASTER_CRED_ID);
    EXPORT static std::string GetNym_SubCredentialID(
        const std::string& NYM_ID, const std::string& MASTER_CRED_ID,
        const int32_t& nIndex);
    EXPORT static std::string GetNym_SubCredentialContents(
        const std::string& NYM_ID, const std::string& MASTER_CRED_ID,
        const std::string& SUB_CRED_ID);

    EXPORT static std::string AddSubcredential(
        const std::string& NYM_ID, const std::string& MASTER_CRED_ID,
        const int32_t& nKeySize);
    EXPORT static bool RevokeSubcredential(const std::string& NYM_ID,
                                           const std::string& MASTER_CRED_ID,
                                           const std::string& SUB_CRED_ID);

    EXPORT static std::string CreateServerContract(
        const std::string& NYM_ID, const std::string& strXMLcontents);
    EXPORT static std::string CreateAssetContract(
        const std::string& NYM_ID, const std::string& strXMLcontents);

    EXPORT static std::string CalculateAssetContractID(
        const std::string& str_Contract);
    EXPORT static std::string CalculateServerContractID(
        const std::string& str_Contract);

    // Use these below functions to get the new contract ITSELF, using its ID
    // that was returned by the above two functions:
    //
    // EXPORT std::string GetServer_Contract(const std::string& SERVER_ID); //
    // Return's Server's contract (based on server ID)
    // EXPORT std::string GetAssetType_Contract(const std::string&
    // ASSET_TYPE_ID); // Returns currency contract based on Asset Type ID

    /*
    ---------------------------------

    ASSET CONTRACTS will want to make sure they put something like this at the
    top:

    <?xml version="1.0"?>
    <digitalAssetContract version="1.0">

    <entity shortname="Just testing"
    longname="I need user feedback to help design the contract tags the server
    must support..."
    email="F3llowTraveler (at) gmail.com"/>

    <issue company="Chuck-E-Cheese, Inc"
    email="[email protected]"
    contractUrl="https://chuckecheese.com/games/contract/"
    type="currency"/>

    <currency name="game tokens" tla="TOKEN" symbol="tks" type="decimal"
    factor="1" decimal_power="0" fraction="mg"/>

    ---------------------------------

    SERVER CONTRACTS will want to make sure they put something like this at the
    top:

    <?xml version="1.0"?>
    <notaryProviderContract version="1.0">

    <entity shortname="Transactions.com"
    longname="Transactions.com, LLC"
    email="[email protected]"
    serverURL="https://transactions.com/vers/1/"/>

    <notaryServer hostname="localhost"
    port="7085"
    URL="https://transactions.com/vers/1/" />

    ---------------------------------


    NEITHER has to worry about THIS, which is added automatically:


    <key name="contract">
    - -----BEGIN CERTIFICATE-----
    MIICZjCCAc+gAwIBAgIJAO14L19TJgzcMA0GCSqGSIb3DQEBBQUAMFcxCzAJBgNV
    BAYTAlVTMREwDwYDVQQIEwhWaXJnaW5pYTEQMA4GA1UEBxMHRmFpcmZheDERMA8G
    A1UEChMIWm9yay5vcmcxEDAOBgNVBAMTB1Jvb3QgQ0EwHhcNMTAwOTI5MDUyMzAx
    WhcNMjAwOTI2MDUyMzAxWjBeMQswCQYDVQQGEwJVUzERMA8GA1UECBMIVmlyZ2lu
    aWExEDAOBgNVBAcTB0ZhaXJmYXgxETAPBgNVBAoTCFpvcmsub3JnMRcwFQYDVQQD
    Ew5zaGVsbC56b3JrLm9yZzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA3vD9
    fO4ov4854L8wXrgfv2tltDz0ieVrTNSLuy1xuQyb//+MwZ0EYwu8jMMQrqbUaYG6
    y8zJu32yBKrBNPPwJ+fJE+tfgVg860dGVbwMd4KhpkKtppJXmZaGqLqvELaXa4Uw
    9N3qg/faj0NMEDIBhv/tD/B5U65vH+U0JlRJ07kCAwEAAaMzMDEwCQYDVR0TBAIw
    ADAkBgNVHREEHTAbgg5zaGVsbC56b3JrLm9yZ4IJbG9jYWxob3N0MA0GCSqGSIb3
    DQEBBQUAA4GBALLXPa/naWsiXsw0JwlSiG7aOmvMF2romUkcr6uObhN7sghd38M0
    l2kKTiptnA8txrri8RhqmQgOgiyKFCKBkxY7/XGot62cE8Y1+lqGXlhu2UHm6NjA
    pRKvng75J2HTjmmsbCHy+nexn4t44wssfPYlGPD8sGwmO24u9tRfdzJE
    - -----END CERTIFICATE-----
    </key>

    */

    /*
    EXPORT static std::string Contract_AddTag(const std::string& NYM_ID, const
    std::string& THE_CONTRACT,
    const std::string& TAG_NAME, const std::string& SUBTAG_NAME,
    const std::string& SUBTAG_VALUE, const std::string& TAG_VALUE);
    key == TAG_NAME
    name == SUBTAG_NAME
    "contract" == SUBTAG_VALUE
    <the cert> == TAG_VALUE

    */

    EXPORT static int32_t AddServerContract(
        const std::string& strContract); // returns OT_TRUE (1) or OT_FALSE(0)

    EXPORT static int32_t AddAssetContract(
        const std::string& strContract); // returns OT_TRUE (1) or OT_FALSE(0)

    EXPORT static int32_t GetServerCount();
    EXPORT static int32_t GetAssetTypeCount();
    EXPORT static int32_t GetAccountCount();
    EXPORT static int32_t GetNymCount();

    EXPORT static std::string GetServer_ID(const int32_t& nIndex); // based on
                                                                   // Index
                                                                   // (above 4
                                                                   // functions)
                                                                   // this
                                                                   // returns
                                                                   // the
                                                                   // Server's
                                                                   // ID
    EXPORT static std::string GetServer_Name(
        const std::string& SERVER_ID); // Return's Server's name (based on
                                       // server ID)
    EXPORT static std::string GetServer_Contract(
        const std::string& SERVER_ID); // Return's Server's contract (based on
                                       // server ID)

    EXPORT static std::string FormatAmount(const std::string& ASSET_TYPE_ID,
                                           const int64_t& THE_AMOUNT);

    EXPORT static int64_t StringToAmount(const std::string& ASSET_TYPE_ID,
                                         const std::string& str_input);

    EXPORT static std::string GetAssetType_ID(
        const int32_t& nIndex); // returns Asset Type ID (based on index from
                                // GetAssetTypeCount)
    EXPORT static std::string GetAssetType_Name(
        const std::string& ASSET_TYPE_ID); // Returns asset type name based on
                                           // Asset Type ID
    EXPORT static std::string GetAssetType_TLA(
        const std::string& ASSET_TYPE_ID); // Returns asset type TLA based on
                                           // Asset Type ID
    EXPORT static std::string GetAssetType_Contract(
        const std::string& ASSET_TYPE_ID); // Returns currency contract based on
                                           // Asset Type ID

    EXPORT static std::string GetAccountWallet_ID(
        const int32_t& nIndex); // returns a string containing the account ID,
                                // based on index.
    EXPORT static std::string GetAccountWallet_Name(
        const std::string& ACCOUNT_ID); // returns the account name, based on
                                        // account ID.
    EXPORT static int64_t GetAccountWallet_Balance(
        const std::string& ACCOUNT_ID); // returns the account balance, based on
                                        // account ID.
    EXPORT static std::string GetAccountWallet_Type(
        const std::string& ACCOUNT_ID); // returns the account type (simple,
                                        // issuer, etc)
    EXPORT static std::string GetAccountWallet_AssetTypeID(
        const std::string& ACCOUNT_ID); // returns asset type ID of the account
    EXPORT static std::string GetAccountWallet_ServerID(
        const std::string& ACCOUNT_ID); // returns Server ID of the account
    EXPORT static std::string GetAccountWallet_NymID(
        const std::string& ACCOUNT_ID); // returns Nym ID of the account

    EXPORT static std::string GetAccountWallet_InboxHash(
        const std::string& ACCOUNT_ID); // returns latest InboxHash according to
                                        // the account file. (Usually more
                                        // recent than: GetNym_InboxHash)
    EXPORT static std::string GetAccountWallet_OutboxHash(
        const std::string& ACCOUNT_ID); // returns latest OutboxHash according
                                        // to the account file. (Usually more
                                        // recent than: GetNym_OutboxHash)

    EXPORT static bool VerifyAccountReceipt(const std::string& SERVER_ID,
                                            const std::string& NYM_ID,
                                            const std::string& ACCT_ID);

    EXPORT static int32_t GetNym_TransactionNumCount(
        const std::string& SERVER_ID, const std::string& NYM_ID);

    EXPORT static std::string GetNym_ID(const int32_t& nIndex); // based on
                                                                // Index (above
                                                                // 4 functions)
                                                                // this returns
                                                                // the Nym's ID
    EXPORT static std::string GetNym_Name(
        const std::string& NYM_ID); // Returns Nym Name (based on NymID)
    EXPORT static std::string GetNym_Stats(
        const std::string& NYM_ID); // Returns Nym Statistics (based on NymID)
    EXPORT static std::string GetNym_NymboxHash(
        const std::string& SERVER_ID,
        const std::string& NYM_ID); // NymboxHash for "most recently DOWNLOADED"
                                    // Nymbox (by ServerID)
    EXPORT static std::string GetNym_RecentHash(
        const std::string& SERVER_ID,
        const std::string& NYM_ID); // "Most recent NymboxHash according to the
                                    // SERVER's records" (Which is often sent as
                                    // an 'FYI' with various server replies to
                                    // my messages.)

    EXPORT static std::string GetNym_InboxHash(
        const std::string& ACCOUNT_ID,
        const std::string& NYM_ID); // InboxHash for "most recently DOWNLOADED"
                                    // Inbox (by AccountID). Often contains
                                    // older value than
                                    // GetAccountWallet_InboxHash.
    EXPORT static std::string GetNym_OutboxHash(
        const std::string& ACCOUNT_ID,
        const std::string& NYM_ID); // OutboxHash for "most recently DOWNLOADED"
                                    // Outbox (by AccountID) Often contains
                                    // older value than
                                    // GetAccountWallet_OutboxHash

    EXPORT static bool IsNym_RegisteredAtServer(const std::string& NYM_ID,
                                                const std::string& SERVER_ID);

    EXPORT static int32_t GetNym_MailCount(const std::string& NYM_ID);

    EXPORT static std::string GetNym_MailContentsByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the message itself (Subject:
                                // optionally as first line)

    EXPORT static std::string GetNym_MailSenderIDByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the NymID of the sender.
    EXPORT static std::string GetNym_MailServerIDByIndex(
        const std::string& NYM_ID, const int32_t& nIndex); // returns the
                                                           // ServerID where the
                                                           // message came from.

    EXPORT static bool Nym_RemoveMailByIndex(const std::string& NYM_ID,
                                             const int32_t& nIndex); // (1 or
                                                                     // 0.)
    EXPORT static bool Nym_VerifyMailByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // true if signature verifies. (Sender Nym MUST
                                // be in my wallet for this to work.)

    EXPORT static int32_t GetNym_OutmailCount(const std::string& NYM_ID);

    EXPORT static std::string GetNym_OutmailContentsByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the message itself (Subject:
                                // optionally as first line)

    EXPORT static std::string GetNym_OutmailRecipientIDByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the NymID of the recipient.
    EXPORT static std::string GetNym_OutmailServerIDByIndex(
        const std::string& NYM_ID, const int32_t& nIndex); // returns the
                                                           // ServerID where the
                                                           // message came from.

    EXPORT static bool Nym_RemoveOutmailByIndex(const std::string& NYM_ID,
                                                const int32_t& nIndex); // (1 or
                                                                        // 0.)
    EXPORT static bool Nym_VerifyOutmailByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // true if signature verifies. (Sender Nym MUST
                                // be in my wallet for this to work.)

    EXPORT static int32_t GetNym_OutpaymentsCount(const std::string& NYM_ID);

    EXPORT static std::string GetNym_OutpaymentsContentsByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the message itself

    EXPORT static std::string GetNym_OutpaymentsRecipientIDByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // returns the NymID of the recipient.
    EXPORT static std::string GetNym_OutpaymentsServerIDByIndex(
        const std::string& NYM_ID, const int32_t& nIndex); // returns the
                                                           // ServerID where the
                                                           // message came from.

    EXPORT static bool Nym_RemoveOutpaymentsByIndex(
        const std::string& NYM_ID, const int32_t& nIndex); // (1 or 0.)
    EXPORT static bool Nym_VerifyOutpaymentsByIndex(
        const std::string& NYM_ID,
        const int32_t& nIndex); // true if signature verifies. (Sender Nym MUST
                                // be in my wallet for this to work.)

    EXPORT static bool Wallet_CanRemoveServer(const std::string& SERVER_ID);

    EXPORT static bool Wallet_RemoveServer(const std::string& SERVER_ID);

    EXPORT static bool Wallet_CanRemoveAssetType(const std::string& ASSET_ID);

    EXPORT static bool Wallet_RemoveAssetType(const std::string& ASSET_ID);

    EXPORT static bool Wallet_CanRemoveNym(const std::string& NYM_ID);

    EXPORT static bool Wallet_RemoveNym(const std::string& NYM_ID);

    EXPORT static bool Wallet_CanRemoveAccount(const std::string& ACCOUNT_ID);

    // See deleteAssetAccount(), a server message, for deleting asset accounts.
    // (You can't just delete them out of the wallet without first deleting them
    // off of the server.)
    //

    EXPORT static bool Wallet_ChangePassphrase(); //  (true for success and
                                                  // false for error.)

    EXPORT static std::string Wallet_ExportNym(const std::string& NYM_ID);

    EXPORT static std::string Wallet_ImportNym(
        const std::string& FILE_CONTENTS);

    EXPORT static std::string Wallet_ImportCert(
        const std::string& DISPLAY_NAME, const std::string& FILE_CONTENTS);

    EXPORT static std::string Wallet_ExportCert(const std::string& NYM_ID);

    // ID.
    //
    EXPORT static std::string Wallet_GetNymIDFromPartial(
        const std::string& PARTIAL_ID);
    EXPORT static std::string Wallet_GetServerIDFromPartial(
        const std::string& PARTIAL_ID);
    EXPORT static std::string Wallet_GetAssetIDFromPartial(
        const std::string& PARTIAL_ID);
    EXPORT static std::string Wallet_GetAccountIDFromPartial(
        const std::string& PARTIAL_ID);

    EXPORT static bool SetNym_Name(const std::string& NYM_ID,
                                   const std::string& SIGNER_NYM_ID,
                                   const std::string& NYM_NEW_NAME);

    EXPORT static bool SetAccountWallet_Name(const std::string& ACCT_ID,
                                             const std::string& SIGNER_NYM_ID,
                                             const std::string& ACCT_NEW_NAME);

    EXPORT static bool SetAssetType_Name(const std::string& ASSET_ID,
                                         const std::string& STR_NEW_NAME);

    EXPORT static bool SetServer_Name(const std::string& SERVER_ID,
                                      const std::string& STR_NEW_NAME);

    EXPORT static std::string WriteCheque(
        const std::string& SERVER_ID, const int64_t& CHEQUE_AMOUNT,
        const time64_t& VALID_FROM, const time64_t& VALID_TO,
        const std::string& SENDER_ACCT_ID, const std::string& SENDER_USER_ID,
        const std::string& CHEQUE_MEMO, const std::string& RECIPIENT_USER_ID);

    EXPORT static bool DiscardCheque(const std::string& SERVER_ID,
                                     const std::string& USER_ID,
                                     const std::string& ACCT_ID,
                                     const std::string& THE_CHEQUE);

    EXPORT static std::string ProposePaymentPlan(
        const std::string& SERVER_ID,
        const time64_t& VALID_FROM, // Default (0 or nullptr) == current time
                                    // measured in seconds since Jan 1970.
        const time64_t& VALID_TO,   // Default (0 or nullptr) == no expiry /
                                    // cancel
                                    // anytime. Otherwise this is ADDED to
                                    // VALID_FROM (it's a length.)
        const std::string& SENDER_ACCT_ID,     // Mandatory parameters.
        const std::string& SENDER_USER_ID,     // Both sender and recipient must
                                               // sign before submitting.
        const std::string& PLAN_CONSIDERATION, // Like a memo.
        const std::string& RECIPIENT_ACCT_ID,  // NOT optional.
        const std::string& RECIPIENT_USER_ID,  // Both sender and recipient must
                                               // sign before submitting.
        const int64_t& INITIAL_PAYMENT_AMOUNT, // zero or nullptr == no initial
                                               // payment.
        const time64_t& INITIAL_PAYMENT_DELAY, // seconds from creation date.
                                               // Default is zero or nullptr.
        const int64_t& PAYMENT_PLAN_AMOUNT,    // Zero or nullptr == no regular
                                               // payments.
        const time64_t& PAYMENT_PLAN_DELAY,    // No. of seconds from creation
        // date. Default is zero or nullptr.
        // (Causing 30 days.)
        const time64_t& PAYMENT_PLAN_PERIOD, // No. of seconds between payments.
                                             // Default is zero or nullptr.
                                             // (Causing 30 days.)
        const time64_t& PAYMENT_PLAN_LENGTH, // In seconds. Defaults to 0 or
                                             // nullptr (no maximum length.)
        const int32_t& PAYMENT_PLAN_MAX_PAYMENTS // integer. Defaults to 0 or
        // nullptr (no maximum payments.)
        );

    // The above version has too many arguments for boost::function apparently
    // (for Chaiscript.)
    // So this is a version of it that compresses those into a fewer number of
    // arguments.
    // (Then it expands them and calls the above version.)
    // See above function for more details on parameters.
    // Basically this version has ALL the same parameters, but it stuffs two or
    // three at a time into
    // a single parameter, as a comma-separated list in string form.
    //
    EXPORT static std::string EasyProposePlan(
        const std::string& SERVER_ID,
        const std::string& DATE_RANGE, // "from,to"  Default 'from' (0 or "") ==
                                       // NOW, and default 'to' (0 or "") == no
                                       // expiry / cancel anytime
        const std::string& SENDER_ACCT_ID,     // Mandatory parameters.
        const std::string& SENDER_USER_ID,     // Both sender and recipient must
                                               // sign before submitting.
        const std::string& PLAN_CONSIDERATION, // Like a memo.
        const std::string& RECIPIENT_ACCT_ID,  // NOT optional.
        const std::string& RECIPIENT_USER_ID,  // Both sender and recipient must
                                               // sign before submitting.
        const std::string& INITIAL_PAYMENT, // "amount,delay"  Default 'amount'
                                            // (0 or "") == no initial payment.
                                            // Default 'delay' (0 or nullptr) is
                                            // seconds from creation date.
        const std::string& PAYMENT_PLAN, // "amount,delay,period" 'amount' is a
                                         // recurring payment. 'delay' and
                                         // 'period' cause 30 days if you pass 0
                                         // or "".
        const std::string& PLAN_EXPIRY   // "length,number" 'length' is maximum
                                         // lifetime in seconds. 'number' is
        // maximum number of payments in seconds.
        // 0 or "" is unlimited (for both.)
        );

    // Called by Customer. Pass in the plan obtained in the above call.
    //
    EXPORT static std::string ConfirmPaymentPlan(
        const std::string& SERVER_ID, const std::string& SENDER_USER_ID,
        const std::string& SENDER_ACCT_ID, const std::string& RECIPIENT_USER_ID,
        const std::string& PAYMENT_PLAN);

    // SMART CONTRACTS

    // RETURNS: the Smart Contract itself. (Or nullptr.)
    //
    EXPORT static std::string Create_SmartContract(
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const time64_t& VALID_FROM,       // Default (0 or nullptr) == NOW
        const time64_t& VALID_TO // Default (0 or nullptr) == no expiry / cancel
                                 // anytime
        );

    //
    // todo: Someday add a parameter here BYLAW_LANGUAGE so that people can use
    // custom languages in their scripts. For now I have a default language, so
    // I'll just make that the default. (There's only one language right now
    // anyway.)
    //
    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddBylaw(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // bylaw added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& BYLAW_NAME // The Bylaw's NAME as referenced in the
                                      // smart contract. (And the scripts...)
        );

    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddClause(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // clause added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& BYLAW_NAME,    // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& CLAUSE_NAME,   // The Clause's name as referenced in
                                          // the smart contract. (And the
                                          // scripts...)
        const std::string& SOURCE_CODE // The actual source code for the clause.
        );

    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddVariable(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // variabnle added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& BYLAW_NAME,    // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& VAR_NAME, // The Variable's name as referenced in the
                                     // smart contract. (And the scripts...)
        const std::string& VAR_ACCESS, // "constant", "persistent", or
                                       // "important".
        const std::string& VAR_TYPE,   // "string", "int64_t", or "bool"
        const std::string& VAR_VALUE   // Contains a string. If type is int64_t,
        // atol() will be used to convert value to
        // a int64_t. If type is bool, the strings
        // "true" or "false" are expected here in
        // order to convert to a bool.
        );

    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddCallback(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // callback added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& BYLAW_NAME,    // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& CALLBACK_NAME, // The Callback's name as referenced
                                          // in the smart contract. (And the
                                          // scripts...)
        const std::string& CLAUSE_NAME    // The actual clause that will be
                                          // triggered by the callback. (Must
                                          // exist.)
        );

    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddHook(
        const std::string& THE_CONTRACT, // The contract, about to have the hook
                                         // added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& BYLAW_NAME,    // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& HOOK_NAME,  // The Hook's name as referenced in the
                                       // smart contract. (And the scripts...)
        const std::string& CLAUSE_NAME // The actual clause that will be
                                       // triggered by the hook. (You can call
                                       // this multiple times, and have multiple
                                       // clauses trigger on the same hook.)
        );

    // RETURNS: Updated version of THE_CONTRACT. (Or nullptr.)
    EXPORT static std::string SmartContract_AddParty(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // party added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& PARTY_NAME, // The Party's NAME as referenced in the
                                       // smart contract. (And the scripts...)
        const std::string& AGENT_NAME  // An AGENT will be added by default for
                                       // this party. Need Agent NAME.
        );

    // (FYI, that is basically the only option, until I code Entities and Roles.
    // Until then, a party can ONLY be
    // a Nym, with himself as the agent representing that same party. Nym ID is
    // supplied on ConfirmParty() below.)

    // Used when creating a theoretical smart contract (that could be used over
    // and over again with different parties.)
    //
    // returns: the updated smart contract (or nullptr)
    EXPORT static std::string SmartContract_AddAccount(
        const std::string& THE_CONTRACT,  // The contract, about to have the
                                          // account added to it.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& PARTY_NAME, // The Party's NAME as referenced in the
                                       // smart contract. (And the scripts...)
        const std::string& ACCT_NAME, // The Account's name as referenced in the
                                      // smart contract
        const std::string& ASSET_TYPE_ID // Asset Type ID for the Account.
        );

    EXPORT static int32_t SmartContract_CountNumsNeeded(
        const std::string& THE_CONTRACT, // The smart contract, about to be
                                         // queried by this function.
        const std::string& AGENT_NAME);

    EXPORT static std::string SmartContract_ConfirmAccount(
        const std::string& THE_CONTRACT,  // The smart contract, about to be
                                          // changed by this function.
        const std::string& SIGNER_NYM_ID, // Use any Nym you wish here. (The
                                          // signing at this point is only to
                                          // cause a save.)
        const std::string& PARTY_NAME,    // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& ACCT_NAME,     // Should already be on the contract.
                                          // (This way we can find it.)
        const std::string& AGENT_NAME, // The agent name for this asset account.
        const std::string& ACCT_ID     // AcctID for the asset account. (For
                                       // acct_name).
        );

    EXPORT static std::string SmartContract_ConfirmParty(
        const std::string& THE_CONTRACT, // The smart contract, about to be
                                         // changed by this function.
        const std::string& PARTY_NAME,   // Should already be on the contract.
                                         // This way we can find it.
        const std::string& NYM_ID // Nym ID for the party, the actual owner,
        );
    // ===> AS WELL AS for the default AGENT of that party.

    /* ----------------------------------------
     Various informational functions for the Smart Contracts.
     */

    EXPORT static bool Smart_AreAllPartiesConfirmed(
        const std::string& THE_CONTRACT); // true or false?
    EXPORT static int32_t Smart_GetBylawCount(const std::string& THE_CONTRACT);
    EXPORT static std::string Smart_GetBylawByIndex(
        const std::string& THE_CONTRACT,
        const int32_t& nIndex); // returns the name of the bylaw.
    EXPORT static std::string Bylaw_GetLanguage(const std::string& THE_CONTRACT,
                                                const std::string& BYLAW_NAME);
    EXPORT static int32_t Bylaw_GetClauseCount(const std::string& THE_CONTRACT,
                                               const std::string& BYLAW_NAME);
    EXPORT static std::string Clause_GetNameByIndex(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const int32_t& nIndex); // returns the name of the clause.
    EXPORT static std::string Clause_GetContents(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& CLAUSE_NAME); // returns the contents of the clause.
    EXPORT static int32_t Bylaw_GetVariableCount(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME);
    EXPORT static std::string Variable_GetNameByIndex(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const int32_t& nIndex); // returns the name of the variable.
    EXPORT static std::string Variable_GetType(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& VARIABLE_NAME); // returns the type of the variable.
    EXPORT static std::string Variable_GetAccess(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& VARIABLE_NAME); // returns the access level of the
                                           // variable.
    EXPORT static std::string Variable_GetContents(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& VARIABLE_NAME); // returns the contents of the
                                           // variable.
    EXPORT static int32_t Bylaw_GetHookCount(const std::string& THE_CONTRACT,
                                             const std::string& BYLAW_NAME);
    EXPORT static std::string Hook_GetNameByIndex(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const int32_t& nIndex); // returns the name of the hook.
    EXPORT static int32_t Hook_GetClauseCount(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& HOOK_NAME); // for iterating clauses on a hook.
    EXPORT static std::string Hook_GetClauseAtIndex(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& HOOK_NAME, const int32_t& nIndex);
    EXPORT static int32_t Bylaw_GetCallbackCount(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME);
    EXPORT static std::string Callback_GetNameByIndex(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const int32_t& nIndex); // returns the name of the callback.
    EXPORT static std::string Callback_GetClause(
        const std::string& THE_CONTRACT, const std::string& BYLAW_NAME,
        const std::string& CALLBACK_NAME); // returns name of clause attached to
                                           // callback.
    EXPORT static int32_t Smart_GetPartyCount(const std::string& THE_CONTRACT);
    EXPORT static std::string Smart_GetPartyByIndex(
        const std::string& THE_CONTRACT,
        const int32_t& nIndex); // returns the name of the party.
    EXPORT static bool Smart_IsPartyConfirmed(
        const std::string& THE_CONTRACT,
        const std::string& PARTY_NAME); // true or false?
    EXPORT static std::string Party_GetID(
        const std::string& THE_CONTRACT,
        const std::string& PARTY_NAME); // returns either NymID or Entity ID.
    EXPORT static int32_t Party_GetAcctCount(const std::string& THE_CONTRACT,
                                             const std::string& PARTY_NAME);
    EXPORT static std::string Party_GetAcctNameByIndex(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const int32_t& nIndex); // returns the name of the clause.
    EXPORT static std::string Party_GetAcctID(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const std::string& ACCT_NAME); // returns account ID for a given acct
                                       // name.
    EXPORT static std::string Party_GetAcctAssetID(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const std::string& ACCT_NAME); // returns asset type ID for a given acct
                                       // name.
    EXPORT static std::string Party_GetAcctAgentName(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const std::string& ACCT_NAME); // returns agent name authorized to
                                       // administer a given named acct. (If
                                       // it's set...)
    EXPORT static int32_t Party_GetAgentCount(const std::string& THE_CONTRACT,
                                              const std::string& PARTY_NAME);
    EXPORT static std::string Party_GetAgentNameByIndex(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const int32_t& nIndex); // returns the name of the agent.
    EXPORT static std::string Party_GetAgentID(
        const std::string& THE_CONTRACT, const std::string& PARTY_NAME,
        const std::string& AGENT_NAME); // returns ID of the agent. (If there is
                                        // one...)

    EXPORT static int32_t activateSmartContract(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& THE_SMART_CONTRACT);
    EXPORT static int32_t triggerClause(const std::string& SERVER_ID,
                                        const std::string& USER_ID,
                                        const int64_t& TRANSACTION_NUMBER,
                                        const std::string& CLAUSE_NAME,
                                        const std::string& STR_PARAM);

    /*
    Msg_HarvestTransactionNumbers

    This function will load up the cron item (which is either a market offer, a
    payment plan,
    or a SMART CONTRACT.) UPDATE: this function operates on messages, not cron
    items.

    Then it will try to harvest all of the closing transaction numbers for
    NYM_ID that are
    available to be harvested from THE_CRON_ITEM. (There might be zero #s
    available for that
    Nym, which is still a success and will return true. False means error.)

    YOU MIGHT ASK:

    WHY WOULD I WANT to harvest ONLY the closing numbers for the Nym, and not
    the OPENING
    numbers as well? The answer is because for this Nym, the opening number
    might already
    be burned. For example, if Nym just tried to activate a smart contract, and
    the activation
    FAILED, then maybe the opening number is already gone, even though his
    closing numbers, on the
    other hand, are still valid for retrieval. (I have to double check this.)

    HOWEVER, what if the MESSAGE failed, before it even TRIED the transaction?
    In which case,
    the opening number is still good also, and should be retrieved.

    Remember, I have to keep signing for my transaction numbers until they are
    finally closed out.
    They will appear on EVERY balance agreement and transaction statement from
    here until the end
    of time, whenever I finally close out those numbers. If some of them are
    still good on a failed
    transaction, then I want to retrieve them so I can use them, and eventually
    close them out.

    ==> Whereas, what if I am the PARTY to a smart contract, but I am not the
    actual ACTIVATOR / ORIGINATOR
    (who activated the smart contract on the server). Therefore I never sent any
    transaction to the
    server, and I never burned my opening number. It's probably still a good #.
    If my wallet is not a piece
    of shit, then I should have a stored copy of any contract that I signed. If
    it turns out in the future
    that that contract wasn't activated, then I can retrieve not only my closing
    numbers, but my OPENING
    number as well! IN THAT CASE, I would call HarvestAllNumbers() instead of
    HarvestClosingNumbers().


    UPDATE: The above logic is now handled automatically in
    HarvestTransactionNumbers.
    Therefore HarvestClosingNumbers and HarvestAllNumbers have been removed.

    */

    // Returns OT_BOOL
    EXPORT static bool Msg_HarvestTransactionNumbers(
        const std::string& THE_MESSAGE, const std::string& USER_ID,
        const bool& bHarvestingForRetry, const bool& bReplyWasSuccess,
        const bool& bReplyWasFailure, const bool& bTransactionWasSuccess,
        const bool& bTransactionWasFailure);

    // Returns OT_BOOL
    // int32_t HarvestClosingNumbers(const std::string& SERVER_ID,
    //    const std::string& NYM_ID,
    //    const std::string& THE_CRON_ITEM);
    //
    //
    //
    // Returns OT_BOOL
    // int32_t HarvestAllNumbers(const std::string& SERVER_ID,
    //    const std::string& NYM_ID,
    //    const std::string& THE_CRON_ITEM);

    EXPORT static std::string LoadUserPubkey_Encryption(
        const std::string& USER_ID); // returns nullptr, or a public key.

    EXPORT static std::string LoadUserPubkey_Signing(
        const std::string& USER_ID); // returns nullptr, or a public key.

    EXPORT static std::string LoadPubkey_Encryption(
        const std::string& USER_ID); // returns nullptr, or a public key.

    EXPORT static std::string LoadPubkey_Signing(
        const std::string& USER_ID); // returns nullptr, or a public key.

    EXPORT static bool VerifyUserPrivateKey(
        const std::string& USER_ID); // returns OT_BOOL

    EXPORT static std::string LoadPurse(const std::string& SERVER_ID,
                                        const std::string& ASSET_TYPE_ID,
                                        const std::string& USER_ID); // returns
    // nullptr, or
    // a purse.

    EXPORT static std::string LoadMint(
        const std::string& SERVER_ID,
        const std::string& ASSET_TYPE_ID); // returns nullptr, or a mint

    EXPORT static std::string LoadAssetContract(
        const std::string& ASSET_TYPE_ID); // returns nullptr, or an asset
                                           // contract.

    EXPORT static std::string LoadServerContract(
        const std::string& SERVER_ID); // returns nullptr, or a server contract.

    //
    EXPORT static bool Mint_IsStillGood(const std::string& SERVER_ID,
                                        const std::string& ASSET_TYPE_ID);

    EXPORT static bool IsBasketCurrency(
        const std::string& ASSET_TYPE_ID); // returns OT_BOOL (OT_TRUE or
                                           // OT_FALSE aka 1 or 0.)

    EXPORT static int32_t Basket_GetMemberCount(
        const std::string& BASKET_ASSET_TYPE_ID);

    EXPORT static std::string Basket_GetMemberType(
        const std::string& BASKET_ASSET_TYPE_ID, const int32_t& nIndex);

    EXPORT static int64_t Basket_GetMinimumTransferAmount(
        const std::string& BASKET_ASSET_TYPE_ID);

    EXPORT static int64_t Basket_GetMemberMinimumTransferAmount(
        const std::string& BASKET_ASSET_TYPE_ID, const int32_t& nIndex);

    EXPORT static std::string LoadAssetAccount(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // Returns nullptr, or an account.

    EXPORT static std::string LoadInbox(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // Returns nullptr, or an inbox.

    EXPORT static std::string LoadOutbox(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // returns nullptr, or an outbox.

    //
    EXPORT static std::string LoadInboxNoVerify(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // Returns nullptr, or an inbox.

    EXPORT static std::string LoadOutboxNoVerify(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // returns nullptr, or an outbox.

    // from local storage.
    EXPORT static std::string LoadPaymentInbox(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Returns nullptr, or a payment inbox.

    EXPORT static std::string LoadPaymentInboxNoVerify(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Returns nullptr, or a payment inbox.

    // depending
    // from local storage.
    EXPORT static std::string LoadRecordBox(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // Returns nullptr, or a RecordBox.

    EXPORT static std::string LoadRecordBoxNoVerify(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID); // Returns nullptr, or a RecordBox.

    EXPORT static bool ClearRecord(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, // USER_ID can be passed here as well.
        const int32_t& nIndex,
        const bool& bClearAll // if true, nIndex is ignored.
        );

    // The expired box is only for incoming/outgoing payments that expired
    // before proecssing.
    //
    // (It doesn't apply to asset account inbox/outbox because those receipts
    // have already processed and thus cannot ever expire.)
    //
    // Whereas an incoming cheque can be left in the payments inbox and THEN
    // expire -- so this is where it will go when the user records the payment;
    // instead of putting it in the record box, we put it here. That way we
    // can tell which ones have actually expired, versus the ones that "expired"
    // AFTER they were put into the record box. (Meaning they never expired, but
    // they just seem that way because the "to" date passed sometime AFTER going
    // into the record box.) Whereas the expired box is for payments that
    // expired
    // BEFORE going into the record box. Basically, when you call RecordPayment,
    // if the instrument is expired BEFORE being recorded, it goes into the
    // expired
    // box -- whereas if it goes into the record box and THEN expires, then we
    // know
    // it wasn't expired at the time that it was recorded.)
    //
    EXPORT static std::string LoadExpiredBox(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Returns nullptr, or an ExpiredBox

    EXPORT static std::string LoadExpiredBoxNoVerify(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Returns nullptr, or a ExpiredBox.

    EXPORT static bool ClearExpired(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const int32_t& nIndex,
        const bool& bClearAll // if true, nIndex is ignored.
        );

    EXPORT static int32_t Ledger_GetCount(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID,
        const std::string& THE_LEDGER); // Returns number of transactions
                                        // within.

    // so you can
    // ledger
    // response.)
    //
    EXPORT static std::string Ledger_CreateResponse(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& ORIGINAL_LEDGER);

    //
    EXPORT static std::string Ledger_GetTransactionByIndex(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_LEDGER,
        const int32_t& nIndex); // returns transaction by index.

    EXPORT static std::string Ledger_GetTransactionByID(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_LEDGER,
        const int64_t& TRANSACTION_NUMBER); // returns transaction by ID.

    EXPORT static int64_t Ledger_GetTransactionIDByIndex(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_LEDGER,
        const int32_t& nIndex); // returns transaction number by index.

    //
    EXPORT static std::string Ledger_AddTransaction(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_LEDGER,
        const std::string& THE_TRANSACTION);

    //
    EXPORT static std::string Transaction_CreateResponse(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID,
        const std::string& RESPONSE_LEDGER,      // To be sent to the server...
        const std::string& ORIGINAL_TRANSACTION, // Responding to...?
        const bool& BOOL_DO_I_ACCEPT);

    EXPORT static std::string Ledger_FinalizeResponse(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID,
        const std::string& THE_LEDGER // 'Response' ledger be sent to the
                                      // server...
        );

    EXPORT static std::string Ledger_GetInstrument(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_LEDGER,
        const int32_t& nIndex); // returns financial instrument by index of the
                                // transaction it's in.

    // NOTE: If an instrument is already expired when this function is called,
    // it will be moved
    // to the expired box instead of the record box.
    EXPORT static bool RecordPayment(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const bool& bIsInbox,   // true == payments inbox. false == payments
                                // outbox.
        const int32_t& nIndex,  // removes payment instrument (from payments in
                                // or out box) and moves to record box.
        const bool& bSaveCopy); // If false, a copy will NOT be saved in the
                                // record box.

    //
    EXPORT static std::string Transaction_GetType(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    // replyNotice
    // server
    // replyNotice,
    // notice.
    //
    EXPORT static int64_t ReplyNotice_GetRequestNum(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& THE_TRANSACTION);

    EXPORT static std::string Transaction_GetVoucher(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static int32_t Transaction_GetSuccess(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static int32_t Transaction_IsCanceled(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static int32_t Transaction_GetBalanceAgreementSuccess(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static time64_t Transaction_GetDateSigned(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static int64_t Transaction_GetAmount(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static std::string Pending_GetNote(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static std::string Transaction_GetSenderUserID(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static std::string Transaction_GetSenderAcctID(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static std::string Transaction_GetRecipientUserID(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static std::string Transaction_GetRecipientAcctID(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static int64_t Transaction_GetDisplayReferenceToNum(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_TRANSACTION);

    EXPORT static bool SavePurse(const std::string& SERVER_ID,
                                 const std::string& ASSET_TYPE_ID,
                                 const std::string& USER_ID,
                                 const std::string& THE_PURSE);

    //
    EXPORT static std::string CreatePurse(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& OWNER_ID,
        const std::string& SIGNER_ID); // returns nullptr, or a purse.

    // Creates a password-protected purse, instead of nym-protected.
    //
    EXPORT static std::string CreatePurse_Passphrase(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& SIGNER_ID);

    //
    //
    EXPORT static int64_t Purse_GetTotalValue(const std::string& SERVER_ID,
                                              const std::string& ASSET_TYPE_ID,
                                              const std::string& THE_PURSE);

    //
    EXPORT static int32_t Purse_Count(const std::string& SERVER_ID,
                                      const std::string& ASSET_TYPE_ID,
                                      const std::string& THE_PURSE);

    //
    EXPORT static bool Purse_HasPassword(const std::string& SERVER_ID,
                                         const std::string& THE_PURSE);

    //
    // returns empty string if failure.
    //
    EXPORT static std::string Purse_Peek(const std::string& SERVER_ID,
                                         const std::string& ASSET_TYPE_ID,
                                         const std::string& OWNER_ID,
                                         const std::string& THE_PURSE);

    // returns nullptr if failure.
    EXPORT static std::string Purse_Pop(const std::string& SERVER_ID,
                                        const std::string& ASSET_TYPE_ID,
                                        const std::string& OWNER_OR_SIGNER_ID,
                                        const std::string& THE_PURSE);

    // Returns nullptr if failure.
    EXPORT static std::string Purse_Push(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& SIGNER_ID, // The purse, in order to be changed, must
                                      // be re-signed, which requires a private
                                      // Nym. Even if the purse is
                                      // password-protected, then there's no
                                      // owner, but you still need to pass a Nym
                                      // in here to sign it (doesn't really
                                      // matter which one, but must have private
                                      // key for signing.)
        const std::string& OWNER_ID, // If the purse is password-protected, then
                                     // there's no owner, and this owner
                                     // parameter should be nullptr. However, if
                                     // the purse DOES have a Nym owner, then
                                     // you MUST pass the owner's Nym ID here,
                                     // in order for this action to be
                                     // successful. Furthermore, the public key
                                     // for that Nym must be available, in order
                                     // to encrypt the token being pushed into
                                     // the purse. (Private key NOT necessary
                                     // for owner, in this case.)
        const std::string& THE_PURSE, const std::string& THE_TOKEN);

    EXPORT static std::string Purse_Empty(const std::string& SERVER_ID,
                                          const std::string& ASSET_TYPE_ID,
                                          const std::string& SIGNER_ID,
                                          const std::string& THE_PURSE);

    // Returns OT_BOOL
    EXPORT static bool Wallet_ImportPurse(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& USER_ID,  // you pass in the purse you're trying to
                                     // import
        const std::string& THE_PURSE // It should either have your User ID on
                                     // it, or the key should be inside so you
                                     // can import.
        );

    EXPORT static int32_t exchangePurse(const std::string& SERVER_ID,
                                        const std::string& ASSET_TYPE_ID,
                                        const std::string& USER_ID,
                                        const std::string& THE_PURSE);

    EXPORT static std::string Token_ChangeOwner(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& THE_TOKEN, const std::string& SIGNER_NYM_ID,
        const std::string& OLD_OWNER, // Pass a NymID here as a string, or a
                                      // purse. (IF symmetrically encrypted, the
                                      // relevant key is in the purse.)
        const std::string& NEW_OWNER  // Pass a NymID here as a string, or a
                                      // purse. (IF symmetrically encrypted, the
                                      // relevant key is in the purse.)
        );

    EXPORT static std::string Token_GetID(const std::string& SERVER_ID,
                                          const std::string& ASSET_TYPE_ID,
                                          const std::string& THE_TOKEN);

    //
    EXPORT static int64_t Token_GetDenomination(
        const std::string& SERVER_ID, const std::string& ASSET_TYPE_ID,
        const std::string& THE_TOKEN);

    EXPORT static int32_t Token_GetSeries(const std::string& SERVER_ID,
                                          const std::string& ASSET_TYPE_ID,
                                          const std::string& THE_TOKEN);

    //
    EXPORT static time64_t Token_GetValidFrom(const std::string& SERVER_ID,
                                              const std::string& ASSET_TYPE_ID,
                                              const std::string& THE_TOKEN);

    // the date is seconds since Jan 1970.
    //
    EXPORT static time64_t Token_GetValidTo(const std::string& SERVER_ID,
                                            const std::string& ASSET_TYPE_ID,
                                            const std::string& THE_TOKEN);

    EXPORT static std::string Token_GetAssetID(const std::string& THE_TOKEN);
    EXPORT static std::string Token_GetServerID(const std::string& THE_TOKEN);

    EXPORT static int64_t Instrmnt_GetAmount(const std::string& THE_INSTRUMENT);
    EXPORT static int64_t Instrmnt_GetTransNum(
        const std::string& THE_INSTRUMENT);
    EXPORT static time64_t Instrmnt_GetValidFrom(
        const std::string& THE_INSTRUMENT);
    EXPORT static time64_t Instrmnt_GetValidTo(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetMemo(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetType(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetServerID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetAssetID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetSenderUserID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetSenderAcctID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetRemitterUserID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetRemitterAcctID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetRecipientUserID(
        const std::string& THE_INSTRUMENT);
    EXPORT static std::string Instrmnt_GetRecipientAcctID(
        const std::string& THE_INSTRUMENT);

    // *** MESSAGES BEING SENT TO THE SERVER -- BELOW!!! ***

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t checkServerID(const std::string& SERVER_ID,
                                        const std::string& USER_ID);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t createUserAccount(const std::string& SERVER_ID,
                                            const std::string& USER_ID);

    EXPORT static int32_t deleteUserAccount(const std::string& SERVER_ID,
                                            const std::string& USER_ID);

    EXPORT static int32_t deleteAssetAccount(const std::string& SERVER_ID,
                                             const std::string& USER_ID,
                                             const std::string& ACCOUNT_ID);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t usageCredits(const std::string& SERVER_ID,
                                       const std::string& USER_ID,
                                       const std::string& USER_ID_CHECK,
                                       const int64_t& ADJUSTMENT);

    EXPORT static int64_t Message_GetUsageCredits(
        const std::string& THE_MESSAGE);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t checkUser(const std::string& SERVER_ID,
                                    const std::string& USER_ID,
                                    const std::string& USER_ID_CHECK);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t sendUserMessage(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& USER_ID_RECIPIENT,
                                          const std::string& RECIPIENT_PUBKEY,
                                          const std::string& THE_MESSAGE);
    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t sendUserInstrument(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& USER_ID_RECIPIENT,
        const std::string& RECIPIENT_PUBKEY, const std::string& THE_INSTRUMENT,
        const std::string& INSTRUMENT_FOR_SENDER // Can be empty. Optional. Only
                                                 // used in the case of cash
                                                 // purses.
        );

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getRequest(const std::string& SERVER_ID,
                                     const std::string& USER_ID);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getTransactionNumber(const std::string& SERVER_ID,
                                               const std::string& USER_ID);

    EXPORT static int32_t issueAssetType(const std::string& SERVER_ID,
                                         const std::string& USER_ID,
                                         const std::string& THE_CONTRACT);

    EXPORT static int32_t getContract(const std::string& SERVER_ID,
                                      const std::string& USER_ID,
                                      const std::string& ASSET_ID);

    EXPORT static int32_t getMint(const std::string& SERVER_ID,
                                  const std::string& USER_ID,
                                  const std::string& ASSET_ID);

    EXPORT static int32_t createAssetAccount(const std::string& SERVER_ID,
                                             const std::string& USER_ID,
                                             const std::string& ASSET_ID);

    // NOTE: Deprecated. Replaced by getAccountFiles.
    EXPORT static int32_t getAccount(const std::string& SERVER_ID,
                                     const std::string& USER_ID,
                                     const std::string& ACCT_ID);

    EXPORT static int32_t getAccountFiles(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& ACCT_ID);

    EXPORT static std::string GenerateBasketCreation(
        const std::string& USER_ID,
        const int64_t& MINIMUM_TRANSFER // If basket is X=2,3,4, then this is X.
        );

    EXPORT static std::string AddBasketCreationItem(
        const std::string& USER_ID,       // for signature.
        const std::string& THE_BASKET,    // created in above call.
        const std::string& ASSET_TYPE_ID, // Adding an asset type to the new
                                          // basket.
        const int64_t& MINIMUM_TRANSFER // If basket is 5=X,X,X then this is an
                                        // X.
        );

    EXPORT static int32_t issueBasket(const std::string& SERVER_ID,
                                      const std::string& USER_ID,
                                      const std::string& THE_BASKET);

    EXPORT static std::string GenerateBasketExchange(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& BASKET_ASSET_TYPE_ID,
        const std::string& BASKET_ASSET_ACCT_ID,
        const int32_t& TRANSFER_MULTIPLE);


    EXPORT static std::string AddBasketExchangeItem(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& THE_BASKET, const std::string& ASSET_TYPE_ID,
        const std::string& ASSET_ACCT_ID);

    EXPORT static int32_t exchangeBasket(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& BASKET_ASSET_ID, const std::string& THE_BASKET,
        const bool& BOOL_EXCHANGE_IN_OR_OUT // exchanging in == OT_TRUE, out ==
                                            // OT_FALSE.
        );

    EXPORT static int32_t notarizeWithdrawal(const std::string& SERVER_ID,
                                             const std::string& USER_ID,
                                             const std::string& ACCT_ID,
                                             const int64_t& AMOUNT);

    EXPORT static int32_t notarizeDeposit(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& ACCT_ID,
                                          const std::string& THE_PURSE);

    EXPORT static int32_t notarizeTransfer(const std::string& SERVER_ID,
                                           const std::string& USER_ID,
                                           const std::string& ACCT_FROM,
                                           const std::string& ACCT_TO,
                                           const int64_t& AMOUNT,
                                           const std::string& NOTE);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    // NOTE: Deprecated. Replaced by getAccountFiles.
    EXPORT static int32_t getInbox(const std::string& SERVER_ID,
                                   const std::string& USER_ID,
                                   const std::string& ACCT_ID);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    // NOTE: Deprecated. Replaced by getAccountFiles.
    EXPORT static int32_t getOutbox(const std::string& SERVER_ID,
                                    const std::string& USER_ID,
                                    const std::string& ACCT_ID);

    // from server (pop message buf for the response)
    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getNymbox(const std::string& SERVER_ID,
                                    const std::string& USER_ID);

    // from local storage.
    EXPORT static std::string LoadNymbox(const std::string& SERVER_ID,
                                         const std::string& USER_ID); // Returns
    // nullptr,
    // or a
    // Nymbox.

    EXPORT static std::string LoadNymboxNoVerify(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Returns nullptr, or a Nymbox.

    EXPORT static std::string Nymbox_GetReplyNotice(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const int64_t& REQUEST_NUMBER); // returns replyNotice transaction by
                                        // requestNumber.

    EXPORT static bool HaveAlreadySeenReply(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const int64_t& REQUEST_NUMBER); // returns OT_BOOL

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getBoxReceipt(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, // If for Nymbox (vs inbox/outbox) then
                                       // pass USER_ID in this field also.
        const int32_t& nBoxType,       // 0/nymbox, 1/inbox, 2/outbox
        const int64_t& TRANSACTION_NUMBER);

    //
    EXPORT static bool DoesBoxReceiptExist(
        const std::string& SERVER_ID,
        const std::string& USER_ID,    // Unused here for now, but still
                                       // convention.
        const std::string& ACCOUNT_ID, // If for Nymbox (vs inbox/outbox) then
                                       // pass USER_ID in this field also.
        const int32_t& nBoxType,       // 0/nymbox, 1/inbox, 2/outbox
        const int64_t& TRANSACTION_NUMBER);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t processInbox(const std::string& SERVER_ID,
                                       const std::string& USER_ID,
                                       const std::string& ACCT_ID,
                                       const std::string& ACCT_LEDGER);

    EXPORT static int32_t processNymbox(const std::string& SERVER_ID,
                                        const std::string& USER_ID);

    EXPORT static int32_t withdrawVoucher(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& ACCT_ID,
                                          const std::string& RECIPIENT_USER_ID,
                                          const std::string& CHEQUE_MEMO,
                                          const int64_t& AMOUNT);

    //
    EXPORT static int32_t payDividend(
        const std::string& SERVER_ID,
        const std::string& ISSUER_USER_ID,        // must be issuer of
                                                  // SHARES_ASSET_TYPE_ID
        const std::string& DIVIDEND_FROM_ACCT_ID, // if dollars paid for pepsi
                                                  // shares, then this is the
                                                  // issuer's dollars account.
        const std::string& SHARES_ASSET_TYPE_ID,  // if dollars paid for pepsi
                                                  // shares, then this is the
                                                  // pepsi shares asset type id.
        const std::string& DIVIDEND_MEMO, // user-configurable note that's added
                                          // to the payout request message.
        const int64_t& AMOUNT_PER_SHARE // number of dollars to be paid out PER
                                        // SHARE (multiplied by total number of
                                        // shares issued.)
        );

    EXPORT static int32_t depositCheque(const std::string& SERVER_ID,
                                        const std::string& USER_ID,
                                        const std::string& ACCT_ID,
                                        const std::string& THE_CHEQUE);

    EXPORT static int32_t depositPaymentPlan(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& THE_PAYMENT_PLAN);

    EXPORT static int32_t issueMarketOffer(
        const std::string& ASSET_ACCT_ID, // Perhaps this is the wheat market.
        const std::string& CURRENCY_ACCT_ID, // Perhaps I'm buying the wheat
                                             // with rubles.
        const int64_t& MARKET_SCALE,         // Defaults to minimum of 1. Market
                                             // granularity.
        const int64_t& MINIMUM_INCREMENT,    // This will be multiplied by the
                                             // Scale. Min 1.
        const int64_t& TOTAL_ASSETS_ON_OFFER, // Total assets available for sale
                                              // or purchase. Will be multiplied
                                              // by minimum increment.
        const int64_t& PRICE_LIMIT,           // Per Minimum Increment...
        const bool& bBuyingOrSelling, // SELLING == true, BUYING == false.
        const time64_t& LIFESPAN_IN_SECONDS, // Pass 0 for the default behavior:
                                             // 86400 seconds aka 1 day.
        const std::string& STOP_SIGN, // Must be "" (for market/limit orders) or
                                      // "<" or ">"  (for stop orders.)
        const int64_t& ACTIVATION_PRICE); // Must be provided if STOP_SIGN is
                                          // also set. Determines the price
                                          // threshold for stop orders.

    //
    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getMarketList(const std::string& SERVER_ID,
                                        const std::string& USER_ID);

    // maximum depth)
    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getMarketOffers(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& MARKET_ID, const int64_t& MAX_DEPTH // Market Depth
        );

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getMarketRecentTrades(const std::string& SERVER_ID,
                                                const std::string& USER_ID,
                                                const std::string& MARKET_ID);

    // Market_GetOffers() call, which seems similar otherwise.
    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t getNym_MarketOffers(
        const std::string& SERVER_ID,
        const std::string& USER_ID); // Offers this Nym has out on market.
    // These may just be the Cron Receipts...

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t killMarketOffer(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& ASSET_ACCT_ID,
                                          const int64_t& TRANSACTION_NUMBER);

    // Returns int32_t:
    // -1 means error; no message was sent.
    // -2 means the message was sent, but the request number must be passed as a
    // string, so call GetLargeRequestNum.
    // 0 means NO error, but also: no message was sent.
    // >0 means NO error, and the message was sent, and the request number fits
    // into an integer...
    // ...and in fact the requestNum IS the return value!
    // ===> In 99% of cases, this LAST option is what actually happens!!
    //
    EXPORT static int32_t killPaymentPlan(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& FROM_ACCT_ID,
                                          const int64_t& TRANSACTION_NUMBER);

    EXPORT static std::string PopMessageBuffer(const int64_t& REQUEST_NUMBER,
                                               const std::string& SERVER_ID,
                                               const std::string& USER_ID);

    EXPORT static void FlushMessageBuffer();

    // Outgoing:

    EXPORT static std::string GetSentMessage(const int64_t& REQUEST_NUMBER,
                                             const std::string& SERVER_ID,
                                             const std::string& USER_ID);

    EXPORT static bool RemoveSentMessage(const int64_t& REQUEST_NUMBER,
                                         const std::string& SERVER_ID,
                                         const std::string& USER_ID);

    // Note: Might remove this from API. Basically, the sent messages queue must
    // store
    // messages (by request number) until we know for SURE whether we have a
    // success, a failure,
    // or a lost/rejected message. That is, until we DOWNLOAD the Nymbox, and
    // thus know for SURE
    // that a response to a given message is there...or not. Why do we care? For
    // making this
    // choice:
    //
    // Messages that DO have a reply are therefore already "in the system" and
    // will be handled
    // normally--they can be ignored and flushed from the "sent messages" queue.
    // Whereas messages
    // that do NOT have a reply in the Nymbox (yet are still in the "sent
    // messages" queue) can be
    // assumed safely to have been rejected at "message level" (before any
    // transaction could
    // have processed) and the reply must have been dropped on the network, OR
    // the server never
    // even received the message in the first place. EITHER WAY the trans #s can
    // be harvested
    // accordingly and then removed from the sent buffer. In a perfect world
    // (read: iteration 2)
    // these sent messages will be serialized somehow along with the Nym, and
    // not just stored in
    // RAM like this version does.

    EXPORT static void FlushSentMessages(
        const bool& bHarvestingForRetry, // bHarvestingForRetry is actually
                                         // OT_BOOL
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& THE_NYMBOX);

    EXPORT static void Sleep(const int64_t& MILLISECONDS);

    /* For emergency/testing use only. This call forces you to trust the server.
    You should never need to call this for any normal use, and hopefully
    you should never need to actually call it at all, ever. But if your Nym
    ever gets out of sync with the server, this will resync it based on
    the server's version of the data.

    Note: actually returns OT_BOOL.
    */
    // Make sure you download your Nymbox (getNymbox) before calling this,
    // so when it loads the Nymbox it will have the latest version of it.
    //
    // Also, call createUserAccount() and pass the server reply message in
    // here, so that it can read theMessageNym (to sync the transaction
    // numbers.)
    //
    EXPORT static bool ResyncNymWithServer(const std::string& SERVER_ID,
                                           const std::string& USER_ID,
                                           const std::string& THE_MESSAGE);
    EXPORT static std::string Message_GetCommand(
        const std::string& THE_MESSAGE);
    EXPORT static int32_t Message_GetSuccess(const std::string& THE_MESSAGE);
    EXPORT static int32_t queryAssetTypes(const std::string& SERVER_ID,
                                          const std::string& USER_ID,
                                          const std::string& ENCODED_MAP);
    EXPORT static std::string Message_GetPayload(
        const std::string& THE_MESSAGE);
    EXPORT static int32_t Message_GetDepth(const std::string& THE_MESSAGE);

    EXPORT static int32_t Message_GetTransactionSuccess(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_MESSAGE);

    EXPORT static int32_t Message_IsTransactionCanceled(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_MESSAGE);
    EXPORT static int32_t Message_GetBalanceAgreementSuccess(
        const std::string& SERVER_ID, const std::string& USER_ID,
        const std::string& ACCOUNT_ID, const std::string& THE_MESSAGE);
    EXPORT static std::string Message_GetLedger(const std::string& THE_MESSAGE);

    EXPORT static std::string Message_GetNewAssetTypeID(
        const std::string& THE_MESSAGE);

    EXPORT static std::string Message_GetNewIssuerAcctID(
        const std::string& THE_MESSAGE);

    EXPORT static std::string Message_GetNewAcctID(
        const std::string& THE_MESSAGE);

    EXPORT static std::string Message_GetNymboxHash(
        const std::string& THE_MESSAGE);

private:
    OTAPI_Wrap();
    ~OTAPI_Wrap()
    {
    }
};

} // namespace opentxs

#endif // OPENTXS_CLIENT_OTAPI_HPP