合约 API与内置类库

合约 API 根据功能主要分为以下 4 类：

• 区块链交互 API

• 工具类 API

• Pedersen密码学API

• ElGamal隐私保护API（半同态加密）

• 调试类 API

• 内置类库

区块链交互 API

• bool CheckAccount(const Identity& id/*in*/);

检查当前状态下，id指定的账号是否存在。

请求参数：

返回值：

• uint64_t GetBlockNumber();

  获取上一个区块的区块号。

返回值：

• int GetBlockHash(uint64_t block_number/*in*/, std::string& block_hash/*out*/);

  获取指定区块的hash。

请求参数：

返回值：

• uint64_t GetBlockTimeStamp();

获取上一个区块的时间戳。

返回值：

• Identity GetOrigin();

获取交易的发起者的 ID。

返回值：

• int GetAuthMap(const Identity& id/*in*/, std::map<std::string,uint32_t>& auth);

获取账号权限列表。

请求参数：

返回值：

• int GetBalance(const Identity& id/*in*/, int64_t& value/*out*/);

获取指定账号的余额。

请求参数：

返回值：

• int GetCode(const Identity& id/*in*/, std::string& code/*out*/);

获取指定合约的代码。

请求参数：

返回值：

• int GetCodeHash(const Identity& id/*in*/, std::string& hash/*out*/);

获取指定合约的代码 hash。

请求参数：

返回值：

• int GetRecoverKey(const Identity& id/*in*/, std::string& recover_key/*out*/);

获取指定账号的恢复公钥。

请求参数：

返回值：

• int GetAccountStatus(const Identity& id/*in*/, uint32_t& status/*out*/);

获取指定账号的状态。

请求参数：

返回值：

• std::string GetTxHash();

获取交易的 hash（触发交易的 hash）。

返回值：

• int TransferBalance(const Identity& to/*in*/, int64_t balance/*in*/);

向指定账户转移资产。

请求参数：

返回值：

• int Revert(const std::string& exception/*in*/);

立即终止该合约的运行，并给区块链发送信号，附带 exception内容，表明该合约被异常终止。

请求参数：

返回值：

• int Require(bool condition/*in*/, const std::string& exception/*in*/);

  若条件condition值为false，则调用Revert。

  if (!condition) {
    Revert(exception);
  }

  请求参数：

返回值：

• template <class T>int Log(const T& data/*in*/, const std::vector<std::string>& topics/*in*/);

产生通知事件，data字段会做序列化, 每个topic会以十六进制字符串的格式记录在交易回执中。

请求参数：

返回值：

使用示例如下：

std::string topic1 = "good";
std::string topic2 = "morning";
Log("hi"s, {topic1, topic2});
// 上链后对应字段为：
// "data":"026869"
// "topics":["676f6f64","6d6f726e696e67"],
// data字段会先做序列化, "hi"序列化后, 对应"026869"
// 针对topic字段, "good"对应"676f6f64", "morning"对应"6d6f726e696e67"

• template <typename T, typename... Args> inline decltype(auto) CallContract(const Identity& contract_id/*in*/, const std::string& method/*in*/, uint64_t value/*in*/, uint64_t gas/*in*/, Args... args);

调用另一个合约。

请求参数：

返回值：

• int DelegateCall(const Identity& contract_id/*in*/, const std::string& method/*in*/, ...);

代理调用另一个合约。

请求参数：

返回值：

• uint64_t GetGas();

获取本合约当前剩余的可用gas数量。如果是交易调用某个合约，则 gas 值就是交易中指定的 gas。如果是合约调用另一个合约，则 gas 值是 CallContract()方法中指定的 gas。如果是合约代理调用另一个合约，那么 gas 值与父合约中的GetGas()值相同。

返回值：

• uint64_t GetValue();

获取本次合约调用本合约接收的资产数量。如果是交易调用合约，value的值就是交易中指定的 value值；如果是合约调用另一个合约，value的值就是 CallContract()方法中指定的 value值。

返回值：

• std::string GetData();

获取触发交易的 data字段值（本次合约调用传入的参数）。

返回值：

• Identity GetSender();

返回调用者的 ID（账号或合约），合约执行过程中，消耗调用方（sender）的 gas。

返回值：

• Identity GetSelf();

获取本合约的 ID。

返回值：

• uint32_t GetRelatedTransactionListSize(const Identity& recipient_id,uint64_t deposit_flag,uint64_t& count);

  获取指定账户、指定flag的关联存证交易数量。

请求参数：

返回值：

• uint32_t GetRelatedTransactionList(const Identity& recipient_id,uint64_t deposit_flag,uint64_t start_indexuint32_t number,std::vector<std::string>& tx_list);

  查询指定账户、指定flag的关联存证交易列表。

请求参数：

返回值：

• uint32_t GetTransactionSender(const std::string& tx_hash, Identity& sender);

  查询指定交易的发送者。

请求参数：

返回值：

• uint32_t GetTransactionReceiver(const std::string& tx_hash Identity& receiver);

  查询指定交易的接收者。

请求参数：

返回值：

• uint32_t GetTransactionTimestamp(const std::string& tx_hash, uint64_t& timestamp);

  查询指定交易的上链时间。

请求参数：

返回值：

• uint32_t GetTransactionData(const std::string& tx_hash, std::string& data);

  查询指定交易存证数据。

请求参数：

返回值：

• uint32_t GetTransactionBlockIndex(const std::string& tx_hash, uint64_t& block_number, uint32_t& index);

  查询指定交易的所在区块和在区块中的顺序。

请求参数：

返回值：

• uint32_t GetTransactionDepositFlag(const std::string& tx_hash, uint64_t& deposit_flag);

  查询指定交易的关联性标识。

请求参数：

返回值：

• uint32_t GetConfidentialDepositData(const std::string& tx_hash, std::string& data);

  查询指定交易机密存证数据。

请求参数：

返回值：

• uint32_t GetConfidentialDepositFlag(const std::string& tx_hash, uint64_t& deposit_flag);

  查询指定交易机密存证的关联性标识。

请求参数：

返回值：

• int CreateContract(const Identity& src, const Identity& new_id);

  根据合约模版创建新合约。

请求参数：

返回值：

• bool IsLocalTx();

  判断当前交易的执行环境是否是local执行。

请求参数：无

返回值：

• bool GetTargetAddress(std::string targetName, Identity& id);

  采用平台特定的hash算法计算 targetName字符串的hash值, 平台的hash算法在创世块中配置, 可以是： sha256, SM3, KECCAK256...

请求参数：

返回值：

工具类 API

• template <class T> std::string pack(T t);

将 t序列化为 std::string。

请求参数：

返回值：

• template <typename T> T unpack(const std::string& b);

将 std::string 反序列化为指定类型的数据。

请求参数：

返回值：

pack和 unpack使用示例：

```C++

std::string buff = pack(“hello”s);std::string str = unpack

(buff);//str的值为hello

std::string buff = pack(1234);int n = unpack

(buff);//n的值为1234

```

• bool Digest(const std::string& data/*in*/, DigestType type/*in*/, std::string& output/*out*/);

返回 data的 SHA256 散列值。

请求参数：

返回值：

• bool VerifyRsa(const std::string &pk/*in*/, const std::string &sig/*in*/, const std::string &msg/*in*/, DigestType hash_type=SHA256);

验证一个 RSA 签名是否有效。

请求参数：

返回值：

• std::string Hex2Bin(const std::string& input/*in*/);

Hex字符串转字节串std::string。

请求参数：

返回值：

• std::string Bin2Hex(const std::string& input/*in*/, bool uppercase=false/*in*/);

字节串转 16 进制字符串。

请求参数：

返回值：

• bool Base64Encode(const std::string& input/*in*/, std::string& output/*out*/);

base64编码。

请求参数：

返回值：

• bool Base64Decode(const std::string& input/*in*/, std::string& output/*out*/);

base64解码。

请求参数：

返回值：

• bool Ecrecovery(const std::string& hash/*in*/, const std::string signature/*in*/, Identity& id/*out*/);

根据 hash 和签名恢复 ID。

请求参数：

返回值：

• bool VerifyMessageSM2(const std::string& pk, const std::string& sig, const std::string& msg);

  验证SM2国密签名。

请求参数：

返回值：

• bool VerifyMessageECCK1(const std::string& pubkey, const std::string& sig, const std::string& msg, DigestType hash_type);

  验证ECC椭圆曲线K1产生的签名。

请求参数：

返回值：

• bool VerifyMessageECCR1(const std::string& pubkey, const std::string& sig, const std::string& msg, DigestType hash_type);

  验证ECC椭圆曲线R1产生的签名。

请求参数：

返回值：

• int BellmanSnarkVerify(const std::string& verification_key, const std::vector<std::string>& inputs, const std::string& proof);

  验证zksnarks的proof是否合法。

请求参数：

返回值：

Pedersen密码学API

• int32_t RangeProofVerify(const std::string& proof, const std::vector<PC>& pc_list);

  Pedersen范围验证。

请求参数：

返回值：

• int AddPedersenCommit(PC& PC_result, const PC& PC_left, const PC& PC_right);

  PC相加，PC即std::string。

请求参数：

返回值：

• int SubPedersenCommit(PC& PC_result, const PC& PC_left, const PC& PC_right);

  PC相减，PC即std::string。

请求参数：

返回值：

• int32_t CalculatePedersenCommit(PC& dst_pc, const PC& src_pc, const std::vector<PC>& positive, const std::vector<PC>& negative);

  PC计算。

请求参数：

返回值：

• int PedersenCommitEqualityVerify(const std::vector<PC>& positive, const std::vector<PC>& negative);

  PC等式验证。

请求参数：

返回值：

ElGamal隐私保护API（半同态加密）

• int LiftedElgamalContractHomomorphicAdd( const std::string& first, const std::string& second, std::string& res);

  计算两个密文相加。

请求参数：

返回值：

• int LiftedElgamalContractHomomorphicSub(const std::string& first, const std::string& second, std::string& res);

  计算两个密文相减。

请求参数：

返回值：

• int LiftedElgamalScalarMultiply(const std::string& src, uint64_t scalar, std::string& res);

  同态相乘。

请求参数：

返回值：

• int LiftedElgamalContractZeroCheckVerify(const std::string& ciphertext, const std::string& proof, int& verify_result);零值检测。

请求参数：

返回值：

• int LiftedElgamalContractRangeVerify(const std::vector<std::string>& ciphertext, const int per_value_bit_size, const std::string& public_key, const std::string& proof, int& verify_result);

  范围检测。

请求参数：

返回值：

调试类 API

• int print(const char* format, ...);

打印输出函数。

请求参数：

返回值：

内置类库

时间格式化

wasm 合约内无法直接获取系统时间信息，因为区块链不同节点的时间无法保证一致。用户可以通过GetBlockTimeStamp，或者合约调用传参的方式，在合约内获取一个有一致性保证的时间信息。

MYCDT 提供了标准的 C/C++ 时间格式化接口，可以把此类时间信息按照用户需求格式化成一个字符串。

接口定义

• localtime

  struct tm *localtime (const time_t * t);
  struct tm *localtime64 (const time64_t * t);

  把以秒为单位的时间t分解后转换存入struct tm格式。该接口默认时区是CST北京时区。

  返回值	参数
  分解后的时间信息结构体tm，后续时间格式化函数strftime需要。返回的tm中会被隐含初始化为CST北京时区。	分解后的时间信息结构体tm，后续时间格式化函数strftime需要。返回的tm中会被隐含初始化为CST北京时区。

• strftime

  size_t strftime (char *__restrict, size_t, const char *__restrict, const struct tm *__restrict);

  根据指定的格式符，格式化tm格式的时间，并把结果放入指定的buffer。

  返回值	参数
  恒为0	参数1：存放格式后结果字符串的buffer指针 参数2：buffer长度 参数3：格式化格式符组合 参数4：struct tm格式的时间信息

• gmtime

  struct tm *gmtime (const time_t *);
  struct tm *gmtime64 (const time64_t *);

  把以秒为单位的时间t分解后转换存入struct tm格式。该接口默认时区是GMT。

  返回值	参数
  分解后的时间信息结构体tm，后续时间格式化函数strftime需要。返回的tm中会被隐含初始化为GMT时区。	以秒为单位的时间，如果原始时间戳是以毫秒为单位，需要除以1000，转换成秒后再传入。

示例一

#include <mychainlib/contract.h>
#include <locale_impl.h>
#include <time.h>
#include <locale.h>

using namespace mychain;

class hello:public Contract {
public:
    INTERFACE void hi(uint64_t x ) {

      //长度26，此处是示例值。请设置为实际格式化后字符串的长度。
      //此处指定长度可以大于实际长度
      //如果小于实际长度，则会发生截断
      char buffer[26];

      struct tm *pt;

      //此处假定1585018706922是调用 GetBlockTimeStamp() 获得的毫秒时间戳
      //其长度是64位整型
      //因此需要先除以1000转换为秒
      time_t mytime = (time_t)(1585018706922 / 1000);

      //CST: 20200324105826
      pt = localtime(&mytime);
      strftime(buffer, 26, "%Y%m%d%H%M%S", pt);
      println("CST: %s\n", buffer);

      //Full: Tue Mar 24 10:58:26 2020
      strftime(buffer, 26, "%c", pt);
      println("Full: %s\n", buffer);

      //GMT: 20200324025826
      pt = gmtime(&mytime);
      strftime(buffer, 26, "%Y%m%d%H%M%S", pt);
      println("GMT: %s\n", buffer);
    }
};
INTERFACE_EXPORT(hello, (hi))

示例二

以下给出使用std::put_time接口来格式化时间戳的例子。

#include <mychainlib/contract.h>
#include<iomanip>
#include<ctime>
#include<sstream>
#include<string>

using namespace mychain;

class hello:public Contract {
public:
    INTERFACE void hi(uint64_t x ) {

            //此处假定1585018706922是调用 GetBlockTimeStamp() 获得的毫秒时间戳
            //其长度是64位整型
            //因此需要先除以1000转换为秒
            std::time_t mytime = (std::time_t)(1585018706922 / 1000);

            //也可以调用gmtime接口格式化为0时区时间
            std::tm tm = *std::localtime(&mytime);

            std::stringstream ssTp;
            ssTp << std::put_time(&tm, "%Y%m%d%H%M%S");

            //ssTp.str() 返回一个string对象
            println("PUT_TIME: %s\n", ssTp.str().c_str());
    }
};
INTERFACE_EXPORT(hello, (hi))

示例三

下面使用time64_t类型来表示 2038 年以后的时间。

#include <mychainlib/contract.h>
#include <ctime>
#include <iomanip>
#include <sstream>

class Hello {
public:
    INTERFACE void hi() {
        time64_t t = 2234491342; // 某个 2040 年的时间

        std::ostringstream oss;
        oss << std::put_time(localtime64(&t), "%c");
        mychain::println("%s", oss.str().c_str());
        // 输出：Mon Oct 22 12:02:22 2040

        oss.str("");
        oss << std::put_time(gmtime64(&t), "%c");
        mychain::println("%s", oss.str().c_str());
        // 输出：Mon Oct 22 04:02:22 2040
    }
};
INTERFACE_EXPORT(Hello, (hi))

第三方库

• XML 库版本 v1.1.0，需要包含头文件。

  #include <third_party/rapidxml/rapidxml.hpp>
  #include <third_party/rapidxml/rapidxml_print.hpp>

  使用示例：

    #include <mychainlib/contract.h>
    #include <third_party/rapidxml/rapidxml.hpp>
    #include <third_party/rapidxml/rapidxml_print.hpp>
  
    using namespace mychain;  // NOLINT
    class TestXMLParse : public Contract {
    public:
        INTERFACE XMLParse() {
            std::string for_parse = R"(<?xml version="1.0" encoding="UTF-8"?>
    <EllipsoidParams>
      <Datum Name="BeiJing54" SemiMajorAxis="6378245.0" Flattening="298.3"/>
      <Datum Name="XiAn80" SemiMajorAxis="6378140.0" Flattening="298.257"/>
      <Datum Name="CGCS2000" SemiMajorAxis="6378137.0" Flattening="298.257222101"/>
    </EllipsoidParams>)";
  
            // need memory more than 64*1024, so the stack can't hold it, use "static" to
            // make it allocate in global
            static rapidxml::xml_document<> doc;
            doc.parse<0>(for_parse.data());
  
            const rapidxml::xml_node<>* ellipsoid = doc.first_node("EllipsoidParams");
            if (NULL != ellipsoid) {
                for (rapidxml::xml_node<>* datum = ellipsoid->first_node("Datum");
                     NULL != datum; datum = datum->next_sibling()) {
                    std::string szTmp;
                    for (rapidxml::xml_attribute<char>* attr =
                             datum->first_attribute("Name");
                         attr != NULL; attr = attr->next_attribute()) {
                        szTmp.append(attr->name());
                        szTmp.append(": ");
                        szTmp.append(attr->value());
                        szTmp.append(", ");
                    }
                    print("%s\n", szTmp.c_str());
                }
            }
        }
    };
  
    INTERFACE_EXPORT(TestXMLParse, (XMLParse))

• JSON 库版本 v1.1.0

  智能合约平台目前支持 rapidjson 和 jsoncpp 两种JSON 解析库，您可以根据自己的需要选择使用。下面展示两种 JSON 解析库的简单用法，您也可以到官方网站查询更详细的使用方法。

  rapidjson 使用示例

    #include <mychainlib/contract.h>
    #include <third_party/rapidjson/document.h>
    #include <third_party/rapidjson/stringbuffer.h>
    #include <third_party/rapidjson/writer.h>
  
    using namespace mychain;  // NOLINT
  
    class TestJsonParse : public Contract {
    public:
        INTERFACE JsonParse() {
            using namespace ::rapidjson;
            std::string stringFromStream = R"({
        "dictVersion": 1,  
        "content":  
        [   
            {"key": "word1", "value": "单词1"} ,
            {"key": "word2", "value": "单词2"} ,
            {"key": "word3", "value": "单词3"} ,
            {"key": "word4", "value": "单词4"} ,
            {"key": "word5", "value": "单词5"} 
        ]
        })";
  
            // ---------------------------- read json --------------------
            // parse json from string.
            using rapidjson::Document;
            Document doc;
            doc.Parse<0>(stringFromStream.c_str());
            if (doc.HasParseError()) {
                rapidjson::ParseErrorCode code = doc.GetParseError();
                MyAssert(code == kParseErrorNone, "parse from string");
            }
  
            // use values in parse result.
            using rapidjson::Value;
            Value& v = doc["dictVersion"];
            if (v.IsInt()) {
                print("%d\n", v.GetInt());
            }
  
            Value& contents = doc["content"];
            if (contents.IsArray()) {
                for (size_t i = 0; i < contents.Size(); ++i) {
                    Value& v = contents[i];
                    assert(v.IsObject());
                    if (v.HasMember("key") && v["key"].IsString()) {
                        print("%s\n", v["key"].GetString());
                    }
                    if (v.HasMember("value") && v["value"].IsString()) {
                        print("%s\n", v["value"].GetString());
                    }
                }
            }
            // ---------------------------- write json --------------------
            print("add a value into array\n");
  
            Value item(Type::kObjectType);
            item.AddMember("key", "word5", doc.GetAllocator());
            item.AddMember("value", "单词5", doc.GetAllocator());
            contents.PushBack(item, doc.GetAllocator());
  
            // convert dom to string.
            StringBuffer buffer;                  // in rapidjson/stringbuffer.h
            Writer<StringBuffer> writer(buffer);  // in rapidjson/writer.h
            doc.Accept(writer);
  
            print("%s\n", buffer.GetString());
        }
    };
  
    INTERFACE_EXPORT(TestJsonParse, (JsonParse))

  jsoncpp 使用示例

    #include <mychainlib/contract.h>
    #include <third_party/jsoncpp/json.h>
  
    using namespace mychain;
  
    class TestJsoncpp : public Contract {
    public:
        INTERFACE void parse()
        {
            std::string strValue =
            "{                      \
              \"key\": \"value1\",  \
              \"array\": [          \
                 {\"arraykey\": 1}, \
                 {\"arraykey\": 2}  \
               ]                    \
             }";
            Json::Reader reader;
            Json::Value root;
            if (reader.parse(strValue, root))
            {
                if (!root["key"].isNull())
                {
                    std::string strValue= root["key"].asString();
                    println("%s\n", strValue.c_str());
                }
  
                Json::Value arrayObj = root["array"];
                for (int i=0; i<arrayObj.size(); i++)
                {
                    int iarrayValue = arrayObj[i]["arraykey"].asInt();
                    println("%d\n", iarrayValue);
                }
            }
        }
    };
  
    INTERFACE_EXPORT(TestJsoncpp, (parse))

• 定点数库，需要包含头文件

    #include <third_party/bcmath/bcmath_stl.h>

  使用示例

    #include <mychainlib/contract.h>
    #include <third_party/bcmath/bcmath_stl.h>
    using namespace mychain;
    using namespace bcmath;
  
    void test_bcmath();
  
    class BCMathTest: public Contract {
    public:
        INTERFACE void run() {
            test_bcmath();
        }
    };
  
    INTERFACE_EXPORT(BCMathTest, (run))
  
    void test_bcmath()
    {
        BCMath::bcscale(4); //Num Decimals
        BCMath test("-5978");
        std::string gold;
  
        auto require = [](bool cond, const char* msg) {
            Require(cond, "Test failed: "s + msg);
        };
  
        test^=30; //Pow, only integers. Not work decimals.
        gold = "198005530669253749533290222782634796336450786581284861381777714804795900171726938603997395193921984842256586113024";
        require(test.toString() == gold, "BigDecimal 1");
  
        test-=1.23; //sub
        gold = "198005530669253749533290222782634796336450786581284861381777714804795900171726938603997395193921984842256586113022.7700";
        require(test.toString() == gold, "BigDecimal 2");
  
        test*=1.23; //mul
        gold = "243546802723182111925946974022640799493834467494980379499586589209898957211224134482916796088524041355975600919018.0071";
        require(test.toString() == gold, "BigDecimal 3");
  
        test*=-1.23; //mul
        gold = "-299562567349513997668914778047848183377416395018825866784491504728175717369805685413987659188884570867849989130392.1487";
        require(test.toString() == gold, "BigDecimal 4");
  
        BCMath::bcscale(70); //Num Decimals
  
        BCMath randNum("-5943534512345234545.8998928392839247844353457");
        BCMath pi("3.1415926535897932384626433832795028841971693993751058209749445923078164062862");
  
        BCMath result1 = randNum + pi;
        BCMath result2 = randNum - pi;
        BCMath result3 = randNum * pi;
        BCMath result4 = randNum / pi;
  
        gold = "-5943534512345234542.7583001856941315459727023167204971158028306006248941790250554076921835";
        require(result1.toString() == gold, "Super Precision 1");
        gold = "-5943534512345234549.0414854928737180228979890832795028841971693993751058209749445923078164";
        require(result2.toString() == gold, "Super Precision 2");
        gold = "-18672164360341183116.9114783895073349180904753962992796943871920962352436079118338887287186";
        require(result3.toString() == gold, "Super Precision 3");
        gold = "-1891885794154043400.2804849527556211973567525043250278948318788149660700494315139982452600";
        require(result4.toString() == gold, "Super Precision 4");
  
        //Other example
        BCMath::bcscale(4); //Num Decimals
        gold = "8023400.1075";
        require(BCMath::bcmul("1000000.0134", "8.0234") == gold, "Other 1");
        gold = "1000008.0368";
        require(BCMath::bcadd("1000000.0134", "8.0234") == gold, "Other 2");
  
        require(BCMath::bccomp("1", "2") == -1, "Compare 1");
        require(BCMath::bccomp("1.00001", "1", 3) == 0, "Compare 2");
        require(BCMath::bccomp("1.00001", "1", 5) == 1, "Compare 3");
        require(BCMath("1")< BCMath("2"), "Compare 4");
        require(BCMath("1")<=BCMath("2"), "Compare 5");
        require(!(BCMath("1")> BCMath("2")), "Compare 6");
        require(!(BCMath("1")>=BCMath("2")), "Compare 7");
        require(!(BCMath("2")< BCMath("2")), "Compare 8");
        require(BCMath("2")<=BCMath("2"), "Compare 9");
        require(!(BCMath("2")> BCMath("2")), "Compare 10");
        require(BCMath("2")>=BCMath("2"), "Compare 11");
  
        gold = "123.0125";
        require(BCMath::bcround("123.01254") == gold, "Round 1");
        gold = "-123.013";
        require(BCMath::bcround("-123.01254", 3) == gold, "Round 2");
        gold = "123.01";
        require(BCMath::bcround("123.01254", 2) == gold, "Round 3");
        pi.round(3);
        gold = "3.142";
        require(pi.toString() == gold, "Round 4");
  
        BCMath part1("-.123");
        BCMath part2(".123");
        BCMath part3("123");
        require(part1.getIntPart() == "-0", "Int part 1");
        require(part1.getDecPart() == "123", "Dec part 1");
        require(part2.getIntPart() == "0", "Int part 2");
        require(part2.getDecPart() == "123", "Dec part 2");
        require(part3.getIntPart() == "123", "Int part 3");
        require(part3.getDecPart() == "0", "Dec part 3");
    }