@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/interface/test/account.test.ts

@@ -0,0 +1,284 @@
+import { AccountByBop } from "../service/account";
+import { expect } from "chai";
+import * as sinon from "sinon";
+import { BopInterface, Config } from "../../../bop/bop-base";
+import {
+  GetAccountBalanceResponse,
+  GetAccountIncreaseNonceResponse,
+  GetAccountMetadataResponse,
+  GetAccountPrivResponse,
+  GetAccountResponse,
+} from "../../proto/bop-sdk-interface";
+
+// 使用 Sinon 创建模拟对象
+const sandbox = sinon.createSandbox();
+describe("provider-account-test", () => {
+  let account: AccountByBop;
+
+  let bopInterface: BopInterface;
+  let config: Config;
+
+  beforeEach(() => {
+    config = new Config("https://bif-mainnet.bitfactory.cn", "xxx", "xxx");
+    bopInterface = new BopInterface(config);
+
+    account = new AccountByBop(bopInterface);
+  });
+
+  afterEach(() => {
+    // 重置模拟对象
+    sandbox.restore();
+  });
+
+  describe("account test", () => {
+    it("account.getAccount", async () => {
+      let response: GetAccountResponse;
+      response = await account.getAccount(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result?.address).to.equal(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+    });
+
+    it("account.getAccount", async () => {
+      let response: GetAccountResponse;
+      response = await account.getAccount("");
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("account.getAccount", async () => {
+      let response: GetAccountResponse;
+      response = await account.getAccount("adfad$@");
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response?.result).to.be.an("array").that.is.not.empty;
+    });
+
+    it("account.getAccountMetadata key exist", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        undefined,
+        "layer_2_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result[0].key).to.equal(
+        "layer_2_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+    });
+
+    it("account.getAccountMetadata key not exist", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        undefined,
+        "layer_3_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+    });
+
+    it("account.getAccountMetadata account not exist", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata account not have metadata", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:effvm1wrsYv4NHtyjvMGcPg1CWX9TW2a",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+    });
+
+    it("account.getAccountMetadata account with seq and exist key", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        5000000,
+        "layer_2_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+    });
+
+    it("account.getAccountMetadata account with seq and not exist key", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        1,
+        "layer_3_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata account empty", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "",
+        1,
+        "layer_3_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("account.getAccountMetadata account invalid", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "xxx",
+        1,
+        "layer_3_confirm_seq_did:bid:efGeHdgd1AwmtgUBKac3bGqrmPoNhA1k4254791",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata account normal and seq(9999999)", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        9999999,
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata account normal and seq(-1)", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        -1,
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountMetadata account normal and key length more 1024", async () => {
+      let response: GetAccountMetadataResponse;
+      response = await account.getAccountMetadata(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+        undefined,
+        "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(11011);
+    });
+
+    it("account.getAccountIncreaseNonce", async () => {
+      let response: GetAccountIncreaseNonceResponse;
+      response = await account.getAccountIncreaseNonce(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result).to.greaterThan(79685);
+    });
+
+    it("account.getAccountIncreaseNonce account not exist", async () => {
+      let response: GetAccountIncreaseNonceResponse;
+      response = await account.getAccountIncreaseNonce(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountIncreaseNonce account empty", async () => {
+      let response: GetAccountIncreaseNonceResponse;
+      response = await account.getAccountIncreaseNonce("");
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("account.getAccountIncreaseNonce account invalid", async () => {
+      let response: GetAccountIncreaseNonceResponse;
+      response = await account.getAccountIncreaseNonce("xxxx");
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountBalance", async () => {
+      let response: GetAccountBalanceResponse;
+      response = await account.getAccountBalance(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result).to.equal(0);
+    });
+
+    it("account.getAccountBalance account not exist", async () => {
+      let response: GetAccountBalanceResponse;
+      response = await account.getAccountBalance(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountBalance account empty", async () => {
+      let response: GetAccountBalanceResponse;
+      response = await account.getAccountBalance("");
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("account.getAccountBalance account invalid", async () => {
+      let response: GetAccountBalanceResponse;
+      response = await account.getAccountBalance("xxxx");
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountPriv", async () => {
+      let response: GetAccountPrivResponse;
+      response = await account.getAccountPriv(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+    });
+
+    it("account.getAccountPriv account not exist", async () => {
+      let response: GetAccountPrivResponse;
+      response = await account.getAccountPriv(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("account.getAccountPriv account empty", async () => {
+      let response: GetAccountPrivResponse;
+      response = await account.getAccountPriv("");
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("account.getAccountPriv account invalid", async () => {
+      let response: GetAccountPrivResponse;
+      response = await account.getAccountPriv("xxx");
+      expect(response.errorCode).to.equal(4);
+    });
+  });
+});

package/src/bop-sdk/interface/test/chain.test.ts

@@ -0,0 +1,45 @@
+import { ChainByBop } from "../service/chain";
+import { expect } from "chai";
+import * as sinon from "sinon";
+import { BopInterface, Config } from "../../../bop/bop-base";
+import {
+  GetChainInfoResponse,
+  GetNetworkIdResponse,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+
+// 使用 Sinon 创建模拟对象
+const sandbox = sinon.createSandbox();
+describe("provider-chain-test", () => {
+  let chain: ChainByBop;
+
+  let bopInterface: BopInterface;
+  let config: Config;
+
+  beforeEach(() => {
+    config = new Config("https://bif-mainnet.bitfactory.cn", "xxx", "xxx");
+    bopInterface = new BopInterface(config);
+
+    chain = new ChainByBop(bopInterface);
+  });
+
+  afterEach(() => {
+    // 重置模拟对象
+    sandbox.restore();
+  });
+
+  describe("chain test", () => {
+    it("chain.getChainInfo", async () => {
+      let response: GetChainInfoResponse;
+      response = await chain.getChainInfo();
+      expect(response.errorCode).to.equal(0);
+      expect(response.result?.networkId).to.equal("16234539267878");
+    });
+
+    it("chain.getNetworkId", async () => {
+      let response: GetNetworkIdResponse;
+      response = await chain.getNetworkId();
+      expect(response.errorCode).to.equal(0);
+      expect(response.result).to.equal("16234539267878");
+    });
+  });
+});

package/src/bop-sdk/interface/test/contract.test.ts

@@ -0,0 +1,283 @@
+import { ContractByBop } from "../service/contract";
+import { expect } from "chai";
+import * as sinon from "sinon";
+import { BopInterface, Config } from "../../../bop/bop-base";
+import {
+  CheckContractAccountResponse,
+  GetContractInfoResponse,
+  CallContractRequest,
+  CallContractResponse,
+} from "../../proto/bop-sdk-interface";
+
+// 使用 Sinon 创建模拟对象
+const sandbox = sinon.createSandbox();
+describe("provider-contract-test", () => {
+  let contract: ContractByBop;
+
+  let bopInterface: BopInterface;
+  let config: Config;
+
+  beforeEach(() => {
+    config = new Config("https://bif-mainnet.bitfactory.cn", "xxx", "xxx");
+    bopInterface = new BopInterface(config);
+
+    contract = new ContractByBop(bopInterface);
+  });
+
+  afterEach(() => {
+    // 重置模拟对象
+    sandbox.restore();
+  });
+
+  describe("contract test", () => {
+    it("contract.checkContractAccount account exist and not contract address", async () => {
+      let response: CheckContractAccountResponse;
+      response = await contract.checkContractAccount(
+        "did:bid:efuDacbAeXdwBENVkPCYNQQVE7KvYVkP",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result).to.equal(false);
+    });
+
+    it("contract.checkContractAccount account exist and is contract address", async () => {
+      let response: CheckContractAccountResponse;
+      response = await contract.checkContractAccount(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result).to.equal(true);
+    });
+
+    it("contract.checkContractAccount account not exist", async () => {
+      let response: CheckContractAccountResponse;
+      response = await contract.checkContractAccount(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.checkContractAccount empty", async () => {
+      let response: CheckContractAccountResponse;
+      response = await contract.checkContractAccount("");
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+      expect(response.errorDesc).to.equal(
+        "The account address is a required field",
+      );
+    });
+
+    it("contract.checkContractAccount invalid address", async () => {
+      let response: CheckContractAccountResponse;
+      response = await contract.checkContractAccount("xxx");
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.getContractInfo is contract address", async () => {
+      let response: GetContractInfoResponse;
+      response = await contract.getContractInfo(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk8",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result?.type).to.equal(2);
+      expect(response.result?.payload).to.equal(
+        '{"params":{},"codeData":{"slogan":"this is config-manager contract"}}',
+      );
+    });
+
+    it("contract.getContractInfo not contract address", async () => {
+      let response: GetContractInfoResponse;
+      response = await contract.getContractInfo(
+        "did:bid:efuDacbAeXdwBENVkPCYNQQVE7KvYVkP",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(11038);
+      expect(response.errorDesc).to.equal("address not contract account");
+    });
+
+    it("contract.getContractInfo account not exist", async () => {
+      let response: GetContractInfoResponse;
+      response = await contract.getContractInfo(
+        "did:bid:efEnXEGWYjHRw1CzK4KpWTdusnaRokk9",
+      );
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.getContractInfo account empty", async () => {
+      let response: GetContractInfoResponse;
+      response = await contract.getContractInfo("");
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("contract.getContractInfo account invalid", async () => {
+      let response: GetContractInfoResponse;
+      response = await contract.getContractInfo("xxx");
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.callContract system", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efRH1Lbsuqwc6jRw3hK4H5Hp2RhHnryS",
+        input: '{"method":"getsuperlist"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0].result);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result?.queryRets[0].result).to.equal(
+        '{"data":{"superList":[["did:bid:efuwxbp8mzDt2MyPxXo4fmyYahQVtyMk","0","did:bid:efuwxbp8mzDt2MyPxXo4fmyYahQVtyMk"],["did:bid:efSspDxRFNe2QpeyYJvr2CMxZ35gVvXb","0","did:bid:efSspDxRFNe2QpeyYJvr2CMxZ35gVvXb"],["did:bid:efUZLM7v2FW72eMUiB3zYUKFrYcPmKQE","0","did:bid:efUZLM7v2FW72eMUiB3zYUKFrYcPmKQE"],["did:bid:efyxHe3UrF1PSSHDDrqVygxf8NYHZVuz","0","did:bid:efyxHe3UrF1PSSHDDrqVygxf8NYHZVuz"],["did:bid:efuDacbAeXdwBENVkPCYNQQVE7KvYVkP","0","did:bid:efuDacbAeXdwBENVkPCYNQQVE7KvYVkP"],["did:bid:efperBrbfFJrpRUebqDSmXjoLKoBiuGT","0","did:bid:efperBrbfFJrpRUebqDSmXjoLKoBiuGT"],["did:bid:ef16mauW9ukBbLqYpbZ8b7bavXTPeGMC","0","did:bid:ef16mauW9ukBbLqYpbZ8b7bavXTPeGMC"],["did:bid:efk8iXFgo533n7waZAym6WVeZNPKKyX5","0","did:bid:efk8iXFgo533n7waZAym6WVeZNPKKyX5"]]}}',
+      );
+    });
+
+    it("contract.callContract js", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:ef2AAQSLB2YAuWJE8mHdUXncGWRVPkoJT",
+        input:
+          '{"method":"queryBid", "params":"did:bid:ef2AAQSLB2YAuWJE8mHdUXncGWRVPkoJT"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0]?.error);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result?.queryRets[0]?.error).to.equal(
+        '{"data":{"contract":"did:bid:ef2AAQSLB2YAuWJE8mHdUXncGWRVPkoJT","exception":"10706,The bid document is not existed","linenum":1}}',
+      );
+    });
+
+    it("contract.callContract evm", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu",
+        input:
+          '{"function":"balanceOf(address)","args":"did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu","return":"returns(uint256)"',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0]?.result);
+      expect(response.errorCode).to.equal(0);
+      expect(response.errorDesc).to.equal("ok");
+      expect(response.result?.queryRets[0]?.result).to.equal(
+        '{"code":0,"data":"[0]","desc":"","evmcode":"0000000000000000000000000000000000000000000000000000000000000000","gasused":2767}',
+      );
+    });
+
+    it("contract.callContract with account not exist", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzx",
+        input:
+          '{"function":"balanceOf(address)","args":"did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu","return":"returns(uint256)"',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.callContract with account not contract address", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efC5REiFesaBuu1UXbMJWvEsqFRkQKiq",
+        input:
+          '{"function":"balanceOf(address)","args":"did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu","return":"returns(uint256)"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.callContract with empty input", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efC5REiFesaBuu1UXbMJWvEsqFRkQKiq",
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("contract.callContract with account empty", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "",
+        input:
+          '{"function":"balanceOf(address)","args":"did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu","return":"returns(uint256)"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+
+    it("contract.callContract with invalid account address", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "xxx",
+        input:
+          '{"function":"balanceOf(address)","args":"did:bid:efBcAumwRYrESbpRVTo4J4vYqXXfqBzu","return":"returns(uint256)"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(4);
+    });
+
+    it("contract.callContract with sourceAddress equal contractAddress", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efRH1Lbsuqwc6jRw3hK4H5Hp2RhHnryS",
+        sourceAddress: "did:bid:efRH1Lbsuqwc6jRw3hK4H5Hp2RhHnryS",
+        input: '{"method":"getsuperlist"}',
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0].result);
+      expect(response.errorCode).to.equal(0);
+    });
+
+    it("contract.callContract gasPrice negative", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efRH1Lbsuqwc6jRw3hK4H5Hp2RhHnryS",
+        input: '{"method":"getsuperlist"}',
+        gasPrice: -1,
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0].result);
+      expect(response.errorCode).to.equal(0);
+    });
+
+    it("contract.callContract gasPrice decimal", async () => {
+      let request: CallContractRequest = {
+        contractAddress: "did:bid:efRH1Lbsuqwc6jRw3hK4H5Hp2RhHnryS",
+        input: '{"method":"getsuperlist"}',
+        gasPrice: 1.6,
+      };
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      console.log(response.result?.queryRets[0].result);
+      expect(response.errorCode).to.equal(0);
+    });
+
+    it("contract.callContract null request", async () => {
+      let request: CallContractRequest = {};
+      let response: CallContractResponse;
+      response = await contract.callContract(request);
+      console.log(response);
+      expect(response.errorCode).to.equal(-9);
+    });
+  });
+});