opentxs::Transactor Class Reference

#include <Transactor.hpp>

Public Member Functions
	Transactor (OTServer *server)
	~Transactor ()
bool	issueNextTransactionNumber (OTPseudonym &nym, int64_t &txNumber, bool storeNumber=true)
bool	verifyTransactionNumber (OTPseudonym &nym, const int64_t &transactionNumber)
bool	removeTransactionNumber (OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
bool	removeIssuedNumber (OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
int64_t	transactionNumber () const
void	transactionNumber (int64_t value)
bool	addAssetContract (OTAssetContract &contract)
OTAssetContract *	getAssetContract (const OTIdentifier &id)
bool	addBasketAccountID (const OTIdentifier &basketId, const OTIdentifier &basketAccountId, const OTIdentifier &basketContractId)
bool	lookupBasketAccountID (const OTIdentifier &basketId, OTIdentifier &basketAccountId)
bool	lookupBasketAccountIDByContractID (const OTIdentifier &basketContractId, OTIdentifier &basketAccountId)
bool	lookupBasketContractIDByAccountID (const OTIdentifier &basketAccountId, OTIdentifier &basketContractId)
std::shared_ptr< OTAccount >	getVoucherAccount (const OTIdentifier &assetTypeId)
Mint *	getMint (const OTIdentifier &assetTypeId, int32_t seriesCount)
	Lookup the current mint for any given asset type ID and series. More...

Friends
class	MainFile

Detailed Description

Definition at line 153 of file Transactor.hpp.

Constructor & Destructor Documentation

opentxs::Transactor::Transactor ( OTServer *  server )

explicit

Definition at line 148 of file Transactor.cpp.

    : transactionNumber_(0)
    , server_(server)
{
}

opentxs::Transactor::~Transactor

(

)

Definition at line 154 of file Transactor.cpp.

{
    while (!contractsMap_.empty()) {
        auto it = contractsMap_.begin();
        OTAssetContract* pContract = it->second;
        OT_ASSERT(nullptr != pContract);
        contractsMap_.erase(it);
        delete pContract;
        pContract = nullptr;
    }

    while (!mintsMap_.empty()) {
        auto it = mintsMap_.begin();
        Mint* pMint = it->second;
        OT_ASSERT(nullptr != pMint);
        mintsMap_.erase(it);
        delete pMint;
        pMint = nullptr;
    }
}

Member Function Documentation

bool opentxs::Transactor::addAssetContract

(

OTAssetContract &

theContract

)

OTServer will take ownership of theContract from this point on, and will be responsible for deleting it. MUST be allocated on the heap.

Definition at line 411 of file Transactor.cpp.

{
    OTAssetContract* pContract = nullptr;

    OTString STR_CONTRACT_ID;
    OTIdentifier CONTRACT_ID;
    theContract.GetIdentifier(STR_CONTRACT_ID);
    theContract.GetIdentifier(CONTRACT_ID);

    pContract = getAssetContract(CONTRACT_ID);

    // already exists
    if (nullptr != pContract) // if not null
        return false;

    contractsMap_[STR_CONTRACT_ID.Get()] = &theContract;

    return true;
}

bool opentxs::Transactor::addBasketAccountID	(	const OTIdentifier &	basketId,
		const OTIdentifier &	basketAccountId,
		const OTIdentifier &	basketContractId
	)

Definition at line 432 of file Transactor.cpp.

{
    OTIdentifier theBasketAcctID;

    if (lookupBasketAccountID(BASKET_ID, theBasketAcctID)) {
        OTLog::Output(0, "User attempted to add Basket that already exists.\n");
        return false;
    }

    OTString strBasketID(BASKET_ID), strBasketAcctID(BASKET_ACCOUNT_ID),
        strBasketContractID(BASKET_CONTRACT_ID);

    idToBasketMap_[strBasketID.Get()] = strBasketAcctID.Get();
    contractIdToBasketAccountId_[strBasketContractID.Get()] =
        strBasketAcctID.Get();

    return true;
}

OTAssetContract * opentxs::Transactor::getAssetContract

(

const OTIdentifier &

ASSET_TYPE_ID

)

The server supports various different asset types. Any user may create a new asset type by uploading the asset contract to the server. The server stores the contract in a directory and in its in-memory list of asset types. You can call this function to look up any asset contract by ID. If it returns nullptr, you can add it yourself by uploading the contract. But be sure that the public key in the contract, used to sign the contract, is also the public key of the Nym of the issuer. They must match. In the future I may create a special key category just for this purpose. Right now I'm using the "contract" key which is already used to verify any asset or server contract.

Definition at line 394 of file Transactor.cpp.

{
    for (auto& it : contractsMap_) {
        OTAssetContract* pContract = it.second;
        OT_ASSERT(nullptr != pContract);

        OTIdentifier theContractID;
        pContract->GetIdentifier(theContractID);

        if (theContractID == ASSET_TYPE_ID) return pContract;
    }

    return nullptr;
}

Mint * opentxs::Transactor::getMint	(	const OTIdentifier &	assetTypeId,
		int32_t	seriesCount
	)

Lookup the current mint for any given asset type ID and series.

Definition at line 565 of file Transactor.cpp.

{
    Mint* pMint = nullptr;

    for (auto& it : mintsMap_) {
        pMint = it.second;
        OT_ASSERT_MSG(nullptr != pMint,
                      "nullptr mint pointer in Transactor::getMint\n");

        OTIdentifier theID;
        pMint->GetIdentifier(theID);

        if ((ASSET_TYPE_ID ==
             theID) && // if the ID on the Mint matches the ID passed in
            (nSeries == pMint->GetSeries())) // and the series also matches...
            return pMint; // return the pointer right here, we're done.
    }
    // The mint isn't in memory for the series requested.
    const OTString ASSET_ID_STR(ASSET_TYPE_ID);

    OTString strMintFilename;
    strMintFilename.Format("%s%s%s%s%d", server_->m_strServerID.Get(),
                           OTLog::PathSeparator(), ASSET_ID_STR.Get(), ".",
                           nSeries);

    const char* szFoldername = OTFolders::Mint().Get();
    const char* szFilename = strMintFilename.Get();
    pMint = Mint::MintFactory(server_->m_strServerID,
                              server_->m_strServerUserID, ASSET_ID_STR);

    // You cannot hash the Mint to get its ID. (The ID is a hash of the asset
    // contract.)
    // Instead, you must READ the ID from the Mint file, and then compare it to
    // the one expected
    // to see if they match (similar to how Account IDs are verified.)

    OT_ASSERT_MSG(nullptr != pMint,
                  "Error allocating memory for Mint in Transactor::getMint");
    OTString strSeries;
    strSeries.Format("%s%d", ".", nSeries);
    //
    if (pMint->LoadMint(strSeries.Get())) {
        if (pMint->VerifyMint(server_->m_nymServer)) // I don't verify the
                                                     // Mint's
        // expiration date here, just its
        // signature, ID, etc.
        { // (Expiry dates are enforced on tokens during deposit--and checked
            // against mint--
            // but expiry dates are only enforced on the Mint itself during a
            // withdrawal.)
            // It's a multimap now...
            // mintsMap_[ASSET_ID_STR.Get()] = pMint;

            mintsMap_.insert(
                std::pair<std::string, Mint*>(ASSET_ID_STR.Get(), pMint));

            return pMint;
        }
        else {
            OTLog::vError(
                "Error verifying Mint in Transactor::getMint:\n%s%s%s\n",
                szFoldername, OTLog::PathSeparator(), szFilename);
        }
    }
    else {
        OTLog::vError("Error loading Mint in Transactor::getMint:\n%s%s%s\n",
                      szFoldername, OTLog::PathSeparator(), szFilename);
    }

    if (nullptr != pMint) delete pMint;
    pMint = nullptr;

    return nullptr;
}

std::shared_ptr< OTAccount > opentxs::Transactor::getVoucherAccount

(

const OTIdentifier &

ASSET_TYPE_ID

)

Looked up the voucher account (where cashier's cheques are issued for any given asset type) return a pointer to the account. Since it's SUPPOSED to exist, and since it's being requested, also will GENERATE it if it cannot be found, add it to the list, and return the pointer. Should always succeed.

Definition at line 536 of file Transactor.cpp.

{
    std::shared_ptr<OTAccount> pAccount;
    const OTIdentifier SERVER_USER_ID(server_->m_nymServer),
        SERVER_ID(server_->m_strServerID);
    bool bWasAcctCreated = false;
    pAccount = voucherAccounts_.GetOrCreateAccount(
        server_->m_nymServer, SERVER_USER_ID, ASSET_TYPE_ID, SERVER_ID,
        bWasAcctCreated);
    if (bWasAcctCreated) {
        OTString strAcctID;
        pAccount->GetIdentifier(strAcctID);
        const OTString strAssetTypeID(ASSET_TYPE_ID);

        OTLog::vOutput(0, "OTServer::GetVoucherAccount: Successfully created "
                          "voucher account ID: %s Asset Type ID: %s\n",
                       strAcctID.Get(), strAssetTypeID.Get());

        if (!server_->mainFile_.SaveMainFile()) {
            OTLog::Error("OTServer::GetVoucherAccount: Error saving main "
                         "server file containing new account ID!!\n");
        }
    }

    return pAccount;
}

bool opentxs::Transactor::issueNextTransactionNumber	(	OTPseudonym &	theNym,
		int64_t &	lTransactionNumber,
		bool	bStoreTheNumber = true
	)

Just as every request must be accompanied by a request number, so every transaction request must be accompanied by a transaction number. The request numbers can simply be incremented on both sides (per user.) But the transaction numbers must be issued by the server and they do not repeat from user to user. They are unique to transaction.

Users must ask the server to send them transaction numbers so that they can be used in transaction requests. The server keeps an internal counter and maintains a data file to store the latest one.

More specifically, the server file itself stores the latest transaction number (So it knows what number to issue and increment when the next request comes in.)

But once it issues the next number, that number needs to be recorded in the nym file for the user it was issued to, so that it can be verified later when he submits it for a transaction–and so it can be removed once the transaction is complete (so it won't work twice.)

The option to bSaveTheNumber defaults to true for this reason. But sometimes it will be sent to false, in cases where the number doesn't need to be saved because it's never going to be verified. For example, if the server creates a transaction number so it can put a transaction into your inbox, it's never going to have to verify that it actually put it into the inbox by checking it's own nymfile for that transaction number. Instead it would just check its own server signature on the inbox. But I digress...

Definition at line 211 of file Transactor.cpp.

{
    OTIdentifier NYM_ID(theNym), SERVER_NYM_ID(server_->m_nymServer);

    // If theNym has the same ID as server_->m_nymServer, then we'll use
    // server_->m_nymServer
    // instead of theNym.  (Since it's the same nym anyway, we'll stick to the
    // one we already loaded so any changes don't get overwritten later.)
    OTPseudonym* pNym = nullptr;

    if (NYM_ID == SERVER_NYM_ID)
        pNym = &server_->m_nymServer;
    else
        pNym = &theNym;

    // transactionNumber_ stores the last VALID AND ISSUED transaction number.
    // So first, we increment that, since we don't want to issue the same number
    // twice.
    transactionNumber_++;

    // Next, we save it to file.
    if (!server_->mainFile_.SaveMainFile()) {
        OTLog::Error("Error saving main server file.\n");
        transactionNumber_--;
        return false;
    }

    // Each Nym stores the transaction numbers that have been issued to it.
    // (On client AND server side.)
    //
    // So whenever the server issues a new number, it's to a specific Nym, then
    // it is recorded in his Nym file before being sent to the client (where it
    // is also recorded in his Nym file.)  That way the server always knows
    // which
    // numbers are valid for each Nym.
    else if (bStoreTheNumber && (false ==
                                 pNym->AddTransactionNum(server_->m_nymServer,
                                                         server_->m_strServerID,
                                                         transactionNumber_,
                                                         true))) // bSave = true
    {
        OTLog::Error("Error adding transaction number to Nym file.\n");
        transactionNumber_--;
        server_->mainFile_.SaveMainFile(); // Save it back how it was, since
                                           // we're not
                                           // issuing this
                                           // number after all.
        return false;
    }

    // SUCCESS?
    // Now the server main file has saved the latest transaction number,
    // and the number has been stored on the relevant nym file.
    // NOW we set it onto the parameter and return true.
    else {
        lTransactionNumber = transactionNumber_;
        return true;
    }
}

bool opentxs::Transactor::lookupBasketAccountID	(	const OTIdentifier &	BASKET_ID,
		OTIdentifier &	BASKET_ACCOUNT_ID
	)

Use this to find the basket account for this server (which is unique to this server) using the basket ID to look it up (the Basket ID is the same for all servers)

Definition at line 511 of file Transactor.cpp.

{
    // Server stores a map of BASKET_ID to BASKET_ACCOUNT_ID. Let's iterate
    // through that map...
    for (auto& it : idToBasketMap_) {
        OTString strBasketID = it.first.c_str();
        OTString strBasketAcctID = it.second.c_str();

        OTIdentifier id_BASKET(strBasketID), id_BASKET_ACCT(strBasketAcctID);

        if (BASKET_ID ==
            id_BASKET) // if the basket ID passed in matches this one...
        {
            BASKET_ACCOUNT_ID = id_BASKET_ACCT;
            return true;
        }
    }
    return false;
}

bool opentxs::Transactor::lookupBasketAccountIDByContractID	(	const OTIdentifier &	BASKET_CONTRACT_ID,
		OTIdentifier &	BASKET_ACCOUNT_ID
	)

Use this to find the basket account ID for this server (which is unique to this server) using the contract ID to look it up. (The basket contract ID is unique to this server.)

Definition at line 457 of file Transactor.cpp.

{
    // Server stores a map of BASKET_ID to BASKET_ACCOUNT_ID. Let's iterate
    // through that map...
    for (auto& it : contractIdToBasketAccountId_) {
        OTString strBasketContractID = it.first.c_str();
        OTString strBasketAcctID = it.second.c_str();

        OTIdentifier id_BASKET_CONTRACT(strBasketContractID),
            id_BASKET_ACCT(strBasketAcctID);

        if (BASKET_CONTRACT_ID == id_BASKET_CONTRACT) // if the basket contract
                                                      // ID passed in matches
                                                      // this one...
        {
            BASKET_ACCOUNT_ID = id_BASKET_ACCT;
            return true;
        }
    }
    return false;
}

bool opentxs::Transactor::lookupBasketContractIDByAccountID	(	const OTIdentifier &	BASKET_ACCOUNT_ID,
		OTIdentifier &	BASKET_CONTRACT_ID
	)

Use this to find the basket account ID for this server (which is unique to this server) using the contract ID to look it up. (The basket contract ID is unique to this server.)

Definition at line 484 of file Transactor.cpp.

{
    // Server stores a map of BASKET_ID to BASKET_ACCOUNT_ID. Let's iterate
    // through that map...
    for (auto& it : contractIdToBasketAccountId_) {
        OTString strBasketContractID = it.first.c_str();
        OTString strBasketAcctID = it.second.c_str();

        OTIdentifier id_BASKET_CONTRACT(strBasketContractID),
            id_BASKET_ACCT(strBasketAcctID);

        if (BASKET_ACCOUNT_ID == id_BASKET_ACCT) // if the basket contract ID
                                                 // passed in matches this
                                                 // one...
        {
            BASKET_CONTRACT_ID = id_BASKET_CONTRACT;
            return true;
        }
    }
    return false;
}

bool opentxs::Transactor::removeIssuedNumber	(	OTPseudonym &	theNym,
		const int64_t &	lTransactionNumber,
		bool	bSave = false
	)

Remove an issued number from the Nym record once that nym accepts the receipt from his inbox.

Definition at line 354 of file Transactor.cpp.

{
    OTIdentifier NYM_ID(theNym), SERVER_NYM_ID(server_->m_nymServer);

    // If theNym has the same ID as server_->m_nymServer, then we'll use
    // server_->m_nymServer
    // instead of theNym.  (Since it's the same nym anyway, we'll stick to the
    // one we already loaded so any changes don't get overwritten later.)
    OTPseudonym* pNym = nullptr;

    if (NYM_ID == SERVER_NYM_ID)
        pNym = &server_->m_nymServer;
    else
        pNym = &theNym;

    bool bRemoved =
        pNym->RemoveIssuedNum(server_->m_nymServer, server_->m_strServerID,
                              lTransactionNumber, bSave);

    return bRemoved;
}

bool opentxs::Transactor::removeTransactionNumber	(	OTPseudonym &	theNym,
		const int64_t &	lTransactionNumber,
		bool	bSave = false
	)

Remove a transaction number from the Nym record once it's officially used/spent.

Definition at line 320 of file Transactor.cpp.

{
    OTIdentifier NYM_ID(theNym), SERVER_NYM_ID(server_->m_nymServer);

    // If theNym has the same ID as server_->m_nymServer, then we'll use
    // server_->m_nymServer
    // instead of theNym.  (Since it's the same nym anyway, we'll stick to the
    // one we already loaded so any changes don't get overwritten later.)
    OTPseudonym* pNym = nullptr;

    if (NYM_ID == SERVER_NYM_ID)
        pNym = &server_->m_nymServer;
    else
        pNym = &theNym;

    bool bRemoved = false;

    if (bSave)
        bRemoved = pNym->RemoveTransactionNum(
            server_->m_nymServer, server_->m_strServerID,
            lTransactionNumber); // the version that passes in a signer nym --
                                 // saves to local storage.
    else
        bRemoved = pNym->RemoveTransactionNum(
            server_->m_strServerID,
            lTransactionNumber); // the version that doesn't save.

    return bRemoved;
}

int64_t opentxs::Transactor::transactionNumber ( ) const

inline

Definition at line 171 of file Transactor.hpp.

    {
        return transactionNumber_;
    }

void opentxs::Transactor::transactionNumber ( int64_t  value )

inline

Definition at line 176 of file Transactor.hpp.

    {
        transactionNumber_ = value;
    }

bool opentxs::Transactor::verifyTransactionNumber	(	OTPseudonym &	theNym,
		const int64_t &	lTransactionNumber
	)

Transaction numbers are now stored in the nym file (on client and server side) for whichever nym they were issued to. This function verifies whether or not the transaction number is present and valid for any specific nym (i.e. for the nym passed in.)

Definition at line 278 of file Transactor.cpp.

{
    OTIdentifier NYM_ID(theNym), SERVER_NYM_ID(server_->m_nymServer);

    // If theNym has the same ID as server_->m_nymServer, then we'll use
    // server_->m_nymServer
    // instead of theNym.  (Since it's the same nym anyway, we'll stick to the
    // one we already loaded so any changes don't get overwritten later.)
    OTPseudonym* pNym = nullptr;

    if (NYM_ID == SERVER_NYM_ID)
        pNym = &server_->m_nymServer;
    else
        pNym = &theNym;
    if (pNym->VerifyTransactionNum(server_->m_strServerID, lTransactionNumber))
        return true;
    else {
        const OTString strNymID(NYM_ID);
        const OTString strIssued(
            pNym->VerifyIssuedNum(server_->m_strServerID, lTransactionNumber)
                ? "(However, that number IS issued to that Nym... He must have "
                  "already used it.)\n"
                : "(In fact, that number isn't even issued to that Nym, though "
                  "perhaps it was at some time in the past?)\n");

        OTLog::vError("%s: %ld not available for Nym %s to use. \n%s",
                      __FUNCTION__,
                      //                    " Oh, and FYI, tangentially, the
                      // current Trns# counter is: %ld\n",
                      lTransactionNumber, strNymID.Get(), strIssued.Get());
        //                    transactionNumber_);
    }

    return false;
}

Friends And Related Function Documentation

friend class MainFile

friend

Definition at line 155 of file Transactor.hpp.

---

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

• /usr/local/src/opentxs/include/opentxs/server/Transactor.hpp
• /usr/local/src/opentxs/src/server/Transactor.cpp