mirror of
https://github.com/ElementsProject/elements.git
synced 2026-08-14 12:43:40 +02:00
112 lines
3.4 KiB
C++
112 lines
3.4 KiB
C++
// Copyright (c) 2017-2017 The Elements Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include <assetsdir.h>
|
|
#include <chainparams.h>
|
|
|
|
#include <tinyformat.h>
|
|
#include <util/strencodings.h>
|
|
|
|
#include <boost/algorithm/string/classification.hpp>
|
|
#include <boost/algorithm/string/split.hpp>
|
|
|
|
void CAssetsDir::Set(const CAsset& asset, const AssetMetadata& metadata)
|
|
{
|
|
// No asset or label repetition
|
|
if (GetLabel(asset) != "")
|
|
throw std::runtime_error(strprintf("duplicated asset '%s'", asset.GetHex()));
|
|
if (GetAsset(metadata.GetLabel()) != CAsset())
|
|
throw std::runtime_error(strprintf("duplicated label '%s'", metadata.GetLabel()));
|
|
|
|
mapAssetMetadata[asset] = metadata;
|
|
mapAssets[metadata.GetLabel()] = asset;
|
|
}
|
|
|
|
void CAssetsDir::SetHex(const std::string& assetHex, const std::string& label)
|
|
{
|
|
if (!IsHex(assetHex) || assetHex.size() != 64)
|
|
throw std::runtime_error("The asset must be hex string of length 64");
|
|
|
|
const std::vector<std::string> protectedLabels = {"", "*", "bitcoin", "Bitcoin", "btc"};
|
|
for (const std::string& proLabel : protectedLabels) {
|
|
if (label == proLabel) {
|
|
throw std::runtime_error(strprintf("'%s' label is protected", proLabel));
|
|
}
|
|
}
|
|
Set(CAsset(uint256S(assetHex)), AssetMetadata(label));
|
|
}
|
|
|
|
void CAssetsDir::InitFromStrings(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name)
|
|
{
|
|
for (std::string strToSplit : assetsToInit) {
|
|
std::vector<std::string> vAssets;
|
|
boost::split(vAssets, strToSplit, boost::is_any_of(":"));
|
|
if (vAssets.size() != 2) {
|
|
throw std::runtime_error("-assetdir parameters malformed, expecting asset:label");
|
|
}
|
|
SetHex(vAssets[0], vAssets[1]);
|
|
}
|
|
// Set "bitcoin" to the pegged asset for tests
|
|
Set(Params().GetConsensus().pegged_asset, AssetMetadata(pegged_asset_name));
|
|
}
|
|
|
|
CAsset CAssetsDir::GetAsset(const std::string& label) const
|
|
{
|
|
auto it = mapAssets.find(label);
|
|
if (it != mapAssets.end())
|
|
return it->second;
|
|
return CAsset();
|
|
}
|
|
|
|
AssetMetadata CAssetsDir::GetMetadata(const CAsset& asset) const
|
|
{
|
|
auto it = mapAssetMetadata.find(asset);
|
|
if (it != mapAssetMetadata.end())
|
|
return it->second;
|
|
return AssetMetadata("");
|
|
}
|
|
|
|
std::string CAssetsDir::GetLabel(const CAsset& asset) const
|
|
{
|
|
return GetMetadata(asset).GetLabel();
|
|
}
|
|
|
|
std::string CAssetsDir::GetIdentifier(const CAsset& asset) const
|
|
{
|
|
std::string label = GetMetadata(asset).GetLabel();
|
|
if (!label.empty()) return label;
|
|
return asset.GetHex();
|
|
}
|
|
|
|
std::vector<CAsset> CAssetsDir::GetKnownAssets() const
|
|
{
|
|
std::vector<CAsset> knownAssets;
|
|
for (auto it = mapAssets.begin(); it != mapAssets.end(); it++) {
|
|
knownAssets.push_back(it->second);
|
|
}
|
|
return knownAssets;
|
|
}
|
|
|
|
CAsset GetAssetFromString(const std::string& strasset) {
|
|
CAsset asset = gAssetsDir.GetAsset(strasset);
|
|
if (asset.IsNull() && strasset.size() == 64 && IsHex(strasset)) {
|
|
asset = CAsset(uint256S(strasset));
|
|
}
|
|
return asset;
|
|
}
|
|
|
|
// GLOBAL:
|
|
CAssetsDir _gAssetsDir;
|
|
const CAssetsDir& gAssetsDir = _gAssetsDir;
|
|
|
|
void InitGlobalAssetDir(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name)
|
|
{
|
|
_gAssetsDir.InitFromStrings(assetsToInit, pegged_asset_name);
|
|
}
|
|
|
|
// Used in testing
|
|
void ClearGlobalAssetDir()
|
|
{
|
|
_gAssetsDir = CAssetsDir();
|
|
}
|