assets.h

Go to the documentation of this file.

// Copyright (c) 2017-2019 The Raven Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.


#ifndef RAVENCOIN_ASSET_PROTOCOL_H
#define RAVENCOIN_ASSET_PROTOCOL_H

#include "amount.h"
#include "tinyformat.h"
#include "assettypes.h"

#include <string>
#include <set>
#include <map>
#include <unordered_map>
#include <list>

#define RVN_R 114
#define RVN_V 118
#define RVN_N 110
#define RVN_Q 113
#define RVN_T 116
#define RVN_O 111

#define DEFAULT_UNITS 0
#define DEFAULT_REISSUABLE 1
#define DEFAULT_HAS_IPFS 0
#define DEFAULT_IPFS ""
#define MIN_ASSET_LENGTH 3
#define MAX_ASSET_LENGTH 32
#define OWNER_TAG "!"
#define OWNER_LENGTH 1
#define OWNER_UNITS 0
#define OWNER_ASSET_AMOUNT 1 * COIN
#define UNIQUE_ASSET_AMOUNT 1 * COIN
#define UNIQUE_ASSET_UNITS 0
#define UNIQUE_ASSETS_REISSUABLE 0

#define RESTRICTED_CHAR '$'
#define QUALIFIER_CHAR '#'

#define QUALIFIER_ASSET_MIN_AMOUNT 1 * COIN
#define QUALIFIER_ASSET_MAX_AMOUNT 10 * COIN
#define QUALIFIER_ASSET_UNITS 0

#define ASSET_TRANSFER_STRING "transfer_asset"
#define ASSET_NEW_STRING "new_asset"
#define ASSET_REISSUE_STRING "reissue_asset"

class CScript;
class CDataStream;
class CTransaction;
class CTxOut;
class Coin;
class CWallet;
class CReserveKey;
class CWalletTx;
struct CAssetOutputEntry;
class CCoinControl;
struct CBlockAssetUndo;
class COutput;

// 2500 * 82 Bytes == 205 KB (kilobytes) of memory
#define MAX_CACHE_ASSETS_SIZE 2500

// Create map that store that state of current reissued transaction that the mempool as accepted.
// If an asset name is in this map, any other reissue transactions wont be accepted into the mempool
extern std::map<uint256, std::string> mapReissuedTx;
extern std::map<std::string, uint256> mapReissuedAssets;

class CAssets {
public:
    std::map<std::pair<std::string, std::string>, CAmount> mapAssetsAddressAmount; // pair < Asset Name , Address > -> Quantity of tokens in the address

    // Dirty, Gets wiped once flushed to database
    std::map<std::string, CNewAsset> mapReissuedAssetData; // Asset Name -> New Asset Data

    CAssets(const CAssets& assets) {
        this->mapAssetsAddressAmount = assets.mapAssetsAddressAmount;
        this->mapReissuedAssetData = assets.mapReissuedAssetData;
    }

    CAssets& operator=(const CAssets& other) {
        mapAssetsAddressAmount = other.mapAssetsAddressAmount;
        mapReissuedAssetData = other.mapReissuedAssetData;
        return *this;
    }

    CAssets() {
        SetNull();
    }

    void SetNull() {
        mapAssetsAddressAmount.clear();
        mapReissuedAssetData.clear();
    }
};

class CAssetsCache : public CAssets
{
private:
    bool AddBackSpentAsset(const Coin& coin, const std::string& assetName, const std::string& address, const CAmount& nAmount, const COutPoint& out);
    void AddToAssetBalance(const std::string& strName, const std::string& address, const CAmount& nAmount);
    bool UndoTransfer(const CAssetTransfer& transfer, const std::string& address, const COutPoint& outToRemove);
public :
    std::vector<CAssetCacheUndoAssetAmount> vUndoAssetAmount;
    std::vector<CAssetCacheSpendAsset> vSpentAssets;

    std::set<CAssetCacheNewAsset> setNewAssetsToRemove;
    std::set<CAssetCacheNewAsset> setNewAssetsToAdd;

    std::set<CAssetCacheReissueAsset> setNewReissueToRemove;
    std::set<CAssetCacheReissueAsset> setNewReissueToAdd;

    std::set<CAssetCacheNewOwner> setNewOwnerAssetsToAdd;
    std::set<CAssetCacheNewOwner> setNewOwnerAssetsToRemove;

    std::set<CAssetCacheNewTransfer> setNewTransferAssetsToAdd;
    std::set<CAssetCacheNewTransfer> setNewTransferAssetsToRemove;

    std::set<CAssetCacheQualifierAddress> setNewQualifierAddressToAdd;
    std::set<CAssetCacheQualifierAddress> setNewQualifierAddressToRemove;

    std::set<CAssetCacheRestrictedAddress> setNewRestrictedAddressToAdd;
    std::set<CAssetCacheRestrictedAddress> setNewRestrictedAddressToRemove;

    std::set<CAssetCacheRestrictedGlobal> setNewRestrictedGlobalToAdd;
    std::set<CAssetCacheRestrictedGlobal> setNewRestrictedGlobalToRemove;

    std::set<CAssetCacheRestrictedVerifiers> setNewRestrictedVerifierToAdd;
    std::set<CAssetCacheRestrictedVerifiers> setNewRestrictedVerifierToRemove;

    std::map<CAssetCacheRootQualifierChecker, std::set<std::string> > mapRootQualifierAddressesAdd;
    std::map<CAssetCacheRootQualifierChecker, std::set<std::string> > mapRootQualifierAddressesRemove;

    CAssetsCache() : CAssets()
    {
        SetNull();
        ClearDirtyCache();
    }

    CAssetsCache(const CAssetsCache& cache) : CAssets(cache)
    {
        this->vSpentAssets = cache.vSpentAssets;
        this->vUndoAssetAmount = cache.vUndoAssetAmount;

        this->setNewTransferAssetsToAdd = cache.setNewTransferAssetsToAdd;
        this->setNewTransferAssetsToRemove = cache.setNewTransferAssetsToRemove;

        this->setNewAssetsToRemove = cache.setNewAssetsToRemove;
        this->setNewAssetsToAdd = cache.setNewAssetsToAdd;

        this->setNewReissueToRemove = cache.setNewReissueToRemove;
        this->setNewReissueToAdd = cache.setNewReissueToAdd;

        this->setNewOwnerAssetsToAdd = cache.setNewOwnerAssetsToAdd;
        this->setNewOwnerAssetsToRemove = cache.setNewOwnerAssetsToRemove;

        this->setNewQualifierAddressToAdd = cache.setNewQualifierAddressToAdd;
        this->setNewQualifierAddressToRemove = cache.setNewQualifierAddressToRemove;

        this->setNewRestrictedAddressToAdd = cache.setNewRestrictedAddressToAdd;
        this->setNewRestrictedAddressToRemove = cache.setNewRestrictedAddressToRemove;

        this->setNewRestrictedGlobalToAdd = cache.setNewRestrictedGlobalToAdd;
        this->setNewRestrictedGlobalToRemove = cache.setNewRestrictedGlobalToRemove;

        this->setNewRestrictedVerifierToAdd = cache.setNewRestrictedVerifierToAdd;
        this->setNewRestrictedVerifierToRemove = cache.setNewRestrictedVerifierToRemove;

        this->mapRootQualifierAddressesAdd = cache.mapRootQualifierAddressesAdd;
        this->mapRootQualifierAddressesRemove = cache.mapRootQualifierAddressesRemove;
    }

    CAssetsCache& operator=(const CAssetsCache& cache)
    {
        this->mapAssetsAddressAmount = cache.mapAssetsAddressAmount;
        this->mapReissuedAssetData = cache.mapReissuedAssetData;

        this->vSpentAssets = cache.vSpentAssets;
        this->vUndoAssetAmount = cache.vUndoAssetAmount;

        this->setNewTransferAssetsToAdd = cache.setNewTransferAssetsToAdd;
        this->setNewTransferAssetsToRemove = cache.setNewTransferAssetsToRemove;

        this->setNewAssetsToRemove = cache.setNewAssetsToRemove;
        this->setNewAssetsToAdd = cache.setNewAssetsToAdd;

        this->setNewReissueToRemove = cache.setNewReissueToRemove;
        this->setNewReissueToAdd = cache.setNewReissueToAdd;

        this->setNewOwnerAssetsToAdd = cache.setNewOwnerAssetsToAdd;
        this->setNewOwnerAssetsToRemove = cache.setNewOwnerAssetsToRemove;

        this->setNewQualifierAddressToAdd = cache.setNewQualifierAddressToAdd;
        this->setNewQualifierAddressToRemove = cache.setNewQualifierAddressToRemove;

        this->setNewRestrictedAddressToAdd = cache.setNewRestrictedAddressToAdd;
        this->setNewRestrictedAddressToRemove = cache.setNewRestrictedAddressToRemove;

        this->setNewRestrictedGlobalToAdd = cache.setNewRestrictedGlobalToAdd;
        this->setNewRestrictedGlobalToRemove = cache.setNewRestrictedGlobalToRemove;

        this->setNewRestrictedVerifierToAdd = cache.setNewRestrictedVerifierToAdd;
        this->setNewRestrictedVerifierToRemove = cache.setNewRestrictedVerifierToRemove;

        this->mapRootQualifierAddressesAdd = cache.mapRootQualifierAddressesAdd;
        this->mapRootQualifierAddressesRemove = cache.mapRootQualifierAddressesRemove;

        return *this;
    }

    bool RemoveNewAsset(const CNewAsset& asset, const std::string address);
    bool RemoveTransfer(const CAssetTransfer& transfer, const std::string& address, const COutPoint& out);
    bool RemoveOwnerAsset(const std::string& assetsName, const std::string address);
    bool RemoveReissueAsset(const CReissueAsset& reissue, const std::string address, const COutPoint& out, const std::vector<std::pair<std::string, CBlockAssetUndo> >& vUndoIPFS);
    bool UndoAssetCoin(const Coin& coin, const COutPoint& out);
    bool RemoveQualifierAddress(const std::string& assetName, const std::string& address, const QualifierType type);
    bool RemoveRestrictedAddress(const std::string& assetName, const std::string& address, const RestrictedType type);
    bool RemoveGlobalRestricted(const std::string& assetName, const RestrictedType type);
    bool RemoveRestrictedVerifier(const std::string& assetName, const std::string& verifier, const bool fUndoingReissue = false);

    bool AddNewAsset(const CNewAsset& asset, const std::string address, const int& nHeight, const uint256& blockHash);
    bool AddTransferAsset(const CAssetTransfer& transferAsset, const std::string& address, const COutPoint& out, const CTxOut& txOut);
    bool AddOwnerAsset(const std::string& assetsName, const std::string address);
    bool AddReissueAsset(const CReissueAsset& reissue, const std::string address, const COutPoint& out);
    bool AddQualifierAddress(const std::string& assetName, const std::string& address, const QualifierType type);
    bool AddRestrictedAddress(const std::string& assetName, const std::string& address, const RestrictedType type);
    bool AddGlobalRestricted(const std::string& assetName, const RestrictedType type);
    bool AddRestrictedVerifier(const std::string& assetName, const std::string& verifier);

    bool TrySpendCoin(const COutPoint& out, const CTxOut& coin);

    bool ContainsAsset(const CNewAsset& asset);
    bool ContainsAsset(const std::string& assetName);

    bool CheckIfAssetExists(const std::string& name, bool fForceDuplicateCheck = true);

    bool GetAssetMetaDataIfExists(const std::string &name, CNewAsset &asset);
    bool GetAssetMetaDataIfExists(const std::string &name, CNewAsset &asset, int& nHeight, uint256& blockHash);

    bool GetAssetVerifierStringIfExists(const std::string &name, CNullAssetTxVerifierString& verifier, bool fSkipTempCache = false);

    bool CheckForAddressQualifier(const std::string &qualifier_name, const std::string& address, bool fSkipTempCache = false);

    bool CheckForAddressRestriction(const std::string &restricted_name, const std::string& address, bool fSkipTempCache = false);

    bool CheckForGlobalRestriction(const std::string &restricted_name, bool fSkipTempCache = false);

    size_t DynamicMemoryUsage() const;

    size_t GetCacheSize() const;
    size_t GetCacheSizeV2() const;

    bool Flush();

    bool DumpCacheToDatabase();

    void ClearDirtyCache() {

        vUndoAssetAmount.clear();
        vSpentAssets.clear();

        setNewAssetsToRemove.clear();
        setNewAssetsToAdd.clear();

        setNewReissueToAdd.clear();
        setNewReissueToRemove.clear();

        setNewTransferAssetsToAdd.clear();
        setNewTransferAssetsToRemove.clear();

        setNewOwnerAssetsToAdd.clear();
        setNewOwnerAssetsToRemove.clear();

        mapReissuedAssetData.clear();
        mapAssetsAddressAmount.clear();

        setNewQualifierAddressToAdd.clear();
        setNewQualifierAddressToRemove.clear();

        setNewRestrictedAddressToAdd.clear();
        setNewRestrictedAddressToRemove.clear();

        setNewRestrictedGlobalToAdd.clear();
        setNewRestrictedGlobalToRemove.clear();

        setNewRestrictedVerifierToAdd.clear();
        setNewRestrictedVerifierToRemove.clear();

        mapRootQualifierAddressesAdd.clear();
        mapRootQualifierAddressesRemove.clear();
    }

   std::string CacheToString() const {

       return strprintf(
               "vNewAssetsToRemove size : %d, vNewAssetsToAdd size : %d, vNewTransfer size : %d, vSpentAssets : %d\n"
               "setNewQualifierAddressToAdd size : %d, setNewQualifierAddressToRemove size : %d, setNewRestrictedAddressToAdd size : %d\n"
               "setNewRestrictedAddressToRemove size : %d, setNewRestrictedGlobalToAdd size : %d, setNewRestrictedGlobalToRemove : %d",
               setNewAssetsToRemove.size(), setNewAssetsToAdd.size(), setNewTransferAssetsToAdd.size(),
               vSpentAssets.size(), setNewQualifierAddressToAdd.size(), setNewQualifierAddressToRemove.size(), setNewRestrictedAddressToAdd.size(),
               setNewRestrictedAddressToRemove.size(), setNewRestrictedGlobalToAdd.size(), setNewRestrictedGlobalToRemove.size());
   }
};

CAmount GetIssueAssetBurnAmount();
CAmount GetReissueAssetBurnAmount();
CAmount GetIssueSubAssetBurnAmount();
CAmount GetIssueUniqueAssetBurnAmount();
CAmount GetIssueMsgChannelAssetBurnAmount();
CAmount GetIssueQualifierAssetBurnAmount();
CAmount GetIssueSubQualifierAssetBurnAmount();
CAmount GetIssueRestrictedAssetBurnAmount();
CAmount GetAddNullQualifierTagBurnAmount();
CAmount GetBurnAmount(const AssetType type);
CAmount GetBurnAmount(const int nType);

std::string GetBurnAddress(const AssetType type);
std::string GetBurnAddress(const int nType);

void GetTxOutAssetTypes(const std::vector<CTxOut>& vout, int& issues, int& reissues, int& transfers, int& owners);

bool IsAssetNameValid(const std::string& name);
bool IsAssetNameValid(const std::string& name, AssetType& assetType);
bool IsAssetNameValid(const std::string& name, AssetType& assetType, std::string& error);

bool IsUniqueTagValid(const std::string& tag);

bool IsAssetNameAnOwner(const std::string& name);

bool IsAssetNameAnRestricted(const std::string& name);

bool IsAssetNameAQualifier(const std::string& name);

bool IsAssetNameASubQualifier(const std::string& name);

bool IsAssetNameAnMsgChannel(const std::string& name);

std::string GetParentName(const std::string& name); // Gets the parent name of a subasset TEST/TESTSUB would return TEST

std::string GetUniqueAssetName(const std::string& parent, const std::string& tag);

bool IsTypeCheckNameValid(const AssetType type, const std::string& name, std::string& error);

bool AssetFromTransaction(const CTransaction& tx, CNewAsset& asset, std::string& strAddress);
bool OwnerFromTransaction(const CTransaction& tx, std::string& ownerName, std::string& strAddress);
bool ReissueAssetFromTransaction(const CTransaction& tx, CReissueAsset& reissue, std::string& strAddress);
bool UniqueAssetFromTransaction(const CTransaction& tx, CNewAsset& asset, std::string& strAddress);
bool MsgChannelAssetFromTransaction(const CTransaction& tx, CNewAsset& asset, std::string& strAddress);
bool QualifierAssetFromTransaction(const CTransaction& tx, CNewAsset& asset, std::string& strAddress);
bool RestrictedAssetFromTransaction(const CTransaction& tx, CNewAsset& asset, std::string& strAddress);

bool TransferAssetFromScript(const CScript& scriptPubKey, CAssetTransfer& assetTransfer, std::string& strAddress);
bool AssetFromScript(const CScript& scriptPubKey, CNewAsset& asset, std::string& strAddress);
bool OwnerAssetFromScript(const CScript& scriptPubKey, std::string& assetName, std::string& strAddress);
bool ReissueAssetFromScript(const CScript& scriptPubKey, CReissueAsset& reissue, std::string& strAddress);
bool MsgChannelAssetFromScript(const CScript& scriptPubKey, CNewAsset& asset, std::string& strAddress);
bool QualifierAssetFromScript(const CScript& scriptPubKey, CNewAsset& asset, std::string& strAddress);
bool RestrictedAssetFromScript(const CScript& scriptPubKey, CNewAsset& asset, std::string& strAddress);
bool AssetNullDataFromScript(const CScript& scriptPubKey, CNullAssetTxData& assetData, std::string& strAddress);
bool AssetNullVerifierDataFromScript(const CScript& scriptPubKey, CNullAssetTxVerifierString& verifierData);
bool GlobalAssetNullDataFromScript(const CScript& scriptPubKey, CNullAssetTxData& assetData);

bool CheckIssueBurnTx(const CTxOut& txOut, const AssetType& type, const int numberIssued);
bool CheckIssueBurnTx(const CTxOut& txOut, const AssetType& type);

// TODO, maybe remove this function and input that check into the CheckIssueBurnTx.
bool CheckReissueBurnTx(const CTxOut& txOut);

bool CheckIssueDataTx(const CTxOut& txOut); // OP_RAVEN_ASSET RVNQ (That is a Q as in Que not an O)
bool CheckOwnerDataTx(const CTxOut& txOut);// OP_RAVEN_ASSET RVNO
bool CheckReissueDataTx(const CTxOut& txOut);// OP_RAVEN_ASSET RVNR
bool CheckTransferOwnerTx(const CTxOut& txOut);// OP_RAVEN_ASSET RVNT

bool CheckEncoded(const std::string& hash, std::string& strError);

bool CheckAmountWithUnits(const CAmount& nAmount, const int8_t nUnits);

bool IsScriptNewAsset(const CScript& scriptPubKey);
bool IsScriptNewAsset(const CScript& scriptPubKey, int& nStartingIndex);

bool IsScriptNewUniqueAsset(const CScript& scriptPubKey);
bool IsScriptNewUniqueAsset(const CScript &scriptPubKey, int &nStartingIndex);

bool IsScriptOwnerAsset(const CScript& scriptPubKey);
bool IsScriptOwnerAsset(const CScript& scriptPubKey, int& nStartingIndex);

bool IsScriptReissueAsset(const CScript& scriptPubKey);
bool IsScriptReissueAsset(const CScript& scriptPubKey, int& nStartingIndex);

bool IsScriptTransferAsset(const CScript& scriptPubKey);
bool IsScriptTransferAsset(const CScript& scriptPubKey, int& nStartingIndex);

bool IsScriptNewMsgChannelAsset(const CScript& scriptPubKey);
bool IsScriptNewMsgChannelAsset(const CScript& scriptPubKey, int& nStartingIndex);

bool IsScriptNewQualifierAsset(const CScript& scriptPubKey);
bool IsScriptNewQualifierAsset(const CScript &scriptPubKey, int &nStartingIndex);

bool IsScriptNewRestrictedAsset(const CScript& scriptPubKey);
bool IsScriptNewRestrictedAsset(const CScript &scriptPubKey, int &nStartingIndex);

bool IsNewOwnerTxValid(const CTransaction& tx, const std::string& assetName, const std::string& address, std::string& errorMsg);

void GetAllAdministrativeAssets(CWallet *pwallet, std::vector<std::string> &names, int nMinConf = 1);
void GetAllMyAssets(CWallet* pwallet, std::vector<std::string>& names, int nMinConf = 1, bool fIncludeAdministrator = false, bool fOnlyAdministrator = false);

bool GetAssetInfoFromCoin(const Coin& coin, std::string& strName, CAmount& nAmount);
bool GetAssetInfoFromScript(const CScript& scriptPubKey, std::string& strName, CAmount& nAmount);

bool GetAssetData(const CScript& script, CAssetOutputEntry& data);

bool GetBestAssetAddressAmount(CAssetsCache& cache, const std::string& assetName, const std::string& address);

bool GetAllMyAssetBalances(std::map<std::string, std::vector<COutput> >& outputs, std::map<std::string, CAmount>& amounts, const int confirmations = 0, const std::string& prefix = "");

bool VerifyWalletHasAsset(const std::string& asset_name, std::pair<int, std::string>& pairError);

std::string DecodeAssetData(std::string encoded);
std::string EncodeAssetData(std::string decoded);
std::string DecodeIPFS(std::string encoded);
std::string EncodeIPFS(std::string decoded);

bool CreateAssetTransaction(CWallet* pwallet, CCoinControl& coinControl, const CNewAsset& asset, const std::string& address, std::pair<int, std::string>& error, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRequired, std::string* verifier_string = nullptr);
bool CreateAssetTransaction(CWallet* pwallet, CCoinControl& coinControl, const std::vector<CNewAsset> assets, const std::string& address, std::pair<int, std::string>& error, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRequired, std::string* verifier_string = nullptr);

bool CreateReissueAssetTransaction(CWallet* pwallet, CCoinControl& coinControl, const CReissueAsset& asset, const std::string& address, std::pair<int, std::string>& error, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRequired, std::string* verifier_string = nullptr);

bool CreateTransferAssetTransaction(CWallet* pwallet, const CCoinControl& coinControl, const std::vector< std::pair<CAssetTransfer, std::string> >vTransfers, const std::string& changeAddress, std::pair<int, std::string>& error, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRequired, std::vector<std::pair<CNullAssetTxData, std::string> >* nullAssetTxData = nullptr, std::vector<CNullAssetTxData>* nullGlobalRestrictionData = nullptr);

bool SendAssetTransaction(CWallet* pwallet, CWalletTx& transaction, CReserveKey& reserveKey, std::pair<int, std::string>& error, std::string& txid);

bool ParseAssetScript(CScript scriptPubKey, uint160 &hashBytes, std::string &assetName, CAmount &assetAmount);

void ExtractVerifierStringQualifiers(const std::string& verifier, std::set<std::string>& qualifiers, bool fWithTag = true);
bool CheckVerifierString(const std::string& verifier, std::set<std::string>& setFoundQualifiers, std::string& strError, bool fWithTags = false);
std::string GetStrippedVerifierString(const std::string& verifier);

bool VerifyNullAssetDataFlag(const int& flag, std::string& strError);
bool VerifyQualifierChange(CAssetsCache& cache, const CNullAssetTxData& data, const std::string& address, std::string& strError);
bool VerifyRestrictedAddressChange(CAssetsCache& cache, const CNullAssetTxData& data, const std::string& address, std::string& strError);
bool VerifyGlobalRestrictedChange(CAssetsCache& cache, const CNullAssetTxData& data, std::string& strError);

bool CheckVerifierAssetTxOut(const CTxOut& txout, std::string& strError);
bool CheckNewAsset(const CNewAsset& asset, std::string& strError);
bool CheckReissueAsset(const CReissueAsset& asset, std::string& strError);

bool ContextualCheckNullAssetTxOut(const CTxOut& txout, CAssetsCache* assetCache, std::string& strError);
bool ContextualCheckGlobalAssetTxOut(const CTxOut& txout, CAssetsCache* assetCache, std::string& strError);
bool ContextualCheckVerifierAssetTxOut(const CTxOut& txout, CAssetsCache* assetCache, std::string& strError);
bool ContextualCheckVerifierString(CAssetsCache* cache, const std::string& verifier, const std::string& check_address, std::string& strError, bool fWithTags = false);
bool ContextualCheckNewAsset(CAssetsCache* assetCache, const CNewAsset& asset, std::string& strError, bool fCheckMempool = false);
bool ContextualCheckTransferAsset(CAssetsCache* assetCache, const CAssetTransfer& transfer, const std::string& address, std::string& strError);
bool ContextualCheckReissueAsset(CAssetsCache* assetCache, const CReissueAsset& reissue_asset, std::string& strError, const CTransaction& tx);
bool ContextualCheckReissueAsset(CAssetsCache* assetCache, const CReissueAsset& reissue_asset, std::string& strError);
bool ContextualCheckUniqueAssetTx(CAssetsCache* assetCache, std::string& strError, const CTransaction& tx);
bool ContextualCheckUniqueAsset(CAssetsCache* assetCache, const CNewAsset& unique_asset, std::string& strError);

#endif //RAVENCOIN_ASSET_PROTOCOL_H