@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/interface/service/helper.ts

@@ -0,0 +1,426 @@
+import {
+  SdkStatusCode,
+  sdkStatusCodeFromJSON,
+} from "../../../bop-sdk/proto/bop-sdk-common";
+import {
+  GetChainInfoResponse,
+  GetNetworkIdResponse,
+  LedgerResponse,
+  LedgerNumberResponse,
+  LedgerLeaderResponse,
+  LedgerValidatorsResponse,
+  LedgerTxHashesResponse,
+  GetAccountBalanceResponse,
+  GetAccountIncreaseNonceResponse,
+  GetAccountMetadataResponse,
+  GetAccountPrivResponse,
+  GetAccountResponse,
+  contractTypeFromJSON,
+  CheckContractAccountResponse,
+  GetContractInfoResponse,
+  GetTxPoolSizeResponse,
+  GetTransactionCacheResponse,
+  GetTransactionHistoryResponse,
+  GetTxResponse,
+  SubmitTransactionResponse,
+  TransactionCacheChain,
+  TransactionHistory,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+import {
+  GetTransactionHistoryResponse as GetTransactionHistoryBopResponse,
+  GetLedgerResponse,
+  HelloResponse,
+  StatusCodes,
+  GetAccountBaseResponse,
+  GetAccountResponse as GetAccountBopResponse,
+  GetTxCacheSizeResponse,
+  GetTransactionCacheChainResponse,
+  GetTransactionCacheChainResult,
+  GetTransactionHistoryResult,
+  SubmitTransactionResponse as SubmitTransactionBopResponse,
+} from "../../../bop/bop-proto/bop";
+
+export function ChainHelloToChainInfo(
+  from: HelloResponse,
+): GetChainInfoResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: GetChainInfoResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: {
+        licenseVersion: from.result?.licenseVersion,
+        websocketPort: from.result?.websocketPort,
+        chainVersion: from.result?.chainVersion,
+        currentTime: from.result?.currentTime,
+        hashType: from.result?.hashType,
+        ledgerVersion: from.result?.ledgerVersion,
+        networkId: from.result?.networkId,
+      },
+    };
+    return response;
+  } else {
+    const response: GetChainInfoResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function ChainHelloToNetworkId(
+  from: HelloResponse,
+): GetNetworkIdResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: GetNetworkIdResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.networkId,
+    };
+    return response;
+  } else {
+    const response: GetNetworkIdResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function LedgerHeaderToHeader(from: GetLedgerResponse): LedgerResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: LedgerResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: {
+        seq: from.result?.header?.seq,
+        hash: from.result?.header?.hash,
+        previousHash: from.result?.header?.previousHash,
+        accountTreeHash: from.result?.header?.accountTreeHash,
+        closeTime: from.result?.header?.closeTime,
+        consensusValueHash: from.result?.header?.consensusValueHash,
+        version: from.result?.header?.version,
+        txCount: from.result?.header?.txCount,
+        validatorsHash: from.result?.header?.validatorsHash,
+        feesHash: from.result?.header?.feesHash,
+      },
+    };
+    return response;
+  } else {
+    const response: LedgerResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function LedgerHeaderToLedgerNumber(
+  from: GetLedgerResponse,
+): LedgerNumberResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: LedgerNumberResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.header?.seq,
+    };
+    return response;
+  } else {
+    const response: LedgerNumberResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function LedgerHeaderToLedgerLeader(
+  from: GetLedgerResponse,
+): LedgerLeaderResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: LedgerLeaderResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.leader,
+    };
+    return response;
+  } else {
+    const response: LedgerLeaderResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function LedgerHeaderToLedgerValidators(
+  from: GetLedgerResponse,
+): LedgerValidatorsResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    const response: LedgerValidatorsResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.validators,
+    };
+    return response;
+  } else {
+    const response: LedgerValidatorsResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function LedgerHeaderToLedgerTxHashes(
+  from: GetTransactionHistoryBopResponse,
+): LedgerTxHashesResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: LedgerTxHashesResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: [],
+    };
+
+    for (let element of from.result?.transactions) {
+      response.result.push(element?.hash);
+    }
+    return response;
+  } else {
+    const response: LedgerTxHashesResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function AccountAccountResultToAccountInfo(
+  from: GetAccountBaseResponse,
+): GetAccountResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetAccountResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: {
+        address: from.result?.address,
+        balance: from.result?.balance,
+        nonce: from.result?.nonce,
+        authTransfer: from.result?.authTransfer,
+        metadatasHash: from.result?.metadatasHash,
+        contract: {
+          type: contractTypeFromJSON(from.result?.contract?.type),
+          payload: from.result?.contract?.payload,
+        },
+        priv: from.result?.priv,
+      },
+    };
+    return response;
+  } else {
+    const response: GetAccountResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function AccountAccountToAccountMetadatas(
+  from: GetAccountBopResponse,
+): GetAccountMetadataResponse {
+  console.log(from);
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetAccountMetadataResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: [],
+    };
+    for (let element of from.result?.metadatas) {
+      response.result.push(element);
+    }
+    return response;
+  } else {
+    const response: GetAccountMetadataResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function AccountAccountResultToIncreaseNonce(
+  from: GetAccountBaseResponse,
+): GetAccountIncreaseNonceResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetAccountIncreaseNonceResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.nonce === undefined ? 0 : from.result?.nonce,
+    };
+    return response;
+  } else {
+    const response: GetAccountIncreaseNonceResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function AccountAccountResultToBalance(
+  from: GetAccountBaseResponse,
+): GetAccountBalanceResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetAccountBalanceResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.balance,
+    };
+    return response;
+  } else {
+    const response: GetAccountBalanceResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function AccountAccountResultToPriv(
+  from: GetAccountBaseResponse,
+): GetAccountPrivResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetAccountPrivResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.priv,
+    };
+    return response;
+  } else {
+    const response: GetAccountPrivResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function ContractAccountResultToCheckContractAccount(
+  from: GetAccountBaseResponse,
+): CheckContractAccountResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: CheckContractAccountResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result:
+        from.result?.contract !== undefined &&
+        from.result?.contract?.payload !== "",
+    };
+    return response;
+  } else {
+    const response: CheckContractAccountResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function ContractAccountResultToGetContractInfo(
+  from: GetAccountBaseResponse,
+): GetContractInfoResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    if (from.result?.contract === undefined) {
+      let response: GetContractInfoResponse = {
+        errorCode: SdkStatusCode.CONTRACTADDRESS_NOT_CONTRACTACCOUNT_ERROR,
+        errorDesc: "address not contract account",
+      };
+      return response;
+    } else {
+      let response: GetContractInfoResponse = {
+        errorCode: sdkStatusCodeFromJSON(from.errorCode),
+        errorDesc: from.errorDesc,
+        result: {
+          type: contractTypeFromJSON(from.result?.contract?.type),
+          payload: from.result?.contract?.payload,
+        },
+      };
+      return response;
+    }
+  } else {
+    const response: GetContractInfoResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function TxTxCacheSizeToTxPoolSizeResponse(
+  from: GetTxCacheSizeResponse,
+): GetTxPoolSizeResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetTxPoolSizeResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: from.result?.queueSize,
+    };
+    return response;
+  } else {
+    const response: GetTxPoolSizeResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function TxTxCacheChainToTxCacheResponse(
+  from: GetTransactionCacheChainResponse,
+): GetTransactionCacheResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetTransactionCacheResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: TransactionCacheChain.fromJSON(
+        GetTransactionCacheChainResult.toJSON(from.result),
+      ),
+    };
+    return response;
+  } else {
+    const response: GetTransactionCacheResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function TxTxHistoryToTxHistoryResponse(
+  from: GetTransactionHistoryBopResponse,
+): GetTransactionHistoryResponse {
+  if (from.errorCode === StatusCodes.SUCCESS) {
+    let response: GetTransactionHistoryResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+      result: TransactionHistory.fromJSON(
+        GetTransactionHistoryResult.toJSON(from.result),
+      ),
+    };
+    return response;
+  } else {
+    const response: GetTransactionHistoryResponse = {
+      errorCode: sdkStatusCodeFromJSON(from.errorCode),
+      errorDesc: from.errorDesc,
+    };
+    return response;
+  }
+}
+
+export function TxSubmitTxToSubmitTransactionResponse(
+  from: SubmitTransactionBopResponse,
+): SubmitTransactionResponse {
+  let response: SubmitTransactionResponse = SubmitTransactionResponse.fromJSON(
+    SubmitTransactionBopResponse.toJSON(from),
+  );
+  return response;
+}

package/src/bop-sdk/interface/service/ledger.ts

@@ -0,0 +1,75 @@
+import {
+  GetLedgerRequest,
+  GetTransactionHistoryRequest,
+} from "../../../bop/bop-proto/bop";
+import {
+  LedgerResponse,
+  LedgerNumberResponse,
+  LedgerLeaderResponse,
+  LedgerValidatorsResponse,
+  LedgerTxHashesResponse,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+import { BopInterface } from "../../../bop/bop-base";
+import { ledger } from "../abstract-service/abstract-ledger";
+import * as trans from "./helper";
+
+export class LedgerByBop extends ledger {
+  readonly bopInterface: BopInterface;
+  constructor(bop: BopInterface) {
+    super();
+    this.bopInterface = bop;
+  }
+
+  public async getLedgerNumber(): Promise<LedgerNumberResponse> {
+    const request: GetLedgerRequest = {};
+    return trans.LedgerHeaderToLedgerNumber(
+      await this.bopInterface.callService("base_getLedger", request),
+    );
+  }
+
+  public async getLedger(seq?: number): Promise<LedgerResponse> {
+    const request: GetLedgerRequest = {};
+    if (seq !== undefined) request.seq = seq;
+    return trans.LedgerHeaderToHeader(
+      await this.bopInterface.callService("base_getLedger", request),
+    );
+  }
+
+  public async getLedgerLeader(seq?: number): Promise<LedgerLeaderResponse> {
+    const request: GetLedgerRequest = {
+      withLeader: true,
+    };
+    if (seq !== undefined) request.seq = seq;
+    return trans.LedgerHeaderToLedgerLeader(
+      await this.bopInterface.callService("base_getLedger", request),
+    );
+  }
+
+  public async getLedgerValidators(
+    seq?: number,
+  ): Promise<LedgerValidatorsResponse> {
+    const request: GetLedgerRequest = {
+      withValidator: true,
+    };
+    if (seq !== undefined) request.seq = seq;
+    return trans.LedgerHeaderToLedgerValidators(
+      await this.bopInterface.callService("base_getLedger", request),
+    );
+  }
+
+  public async getLedgerTxHashes(
+    seq?: number,
+  ): Promise<LedgerTxHashesResponse> {
+    const request: GetTransactionHistoryRequest = {
+      limit: 1000,
+    };
+    if (seq !== undefined) request.ledgerSeq = seq;
+
+    return trans.LedgerHeaderToLedgerTxHashes(
+      await this.bopInterface.callService(
+        "base_getTransactionHistory",
+        request,
+      ),
+    );
+  }
+}

package/src/bop-sdk/interface/service/offline/check/index.js

@@ -0,0 +1,138 @@
+const util = require("../common/util");
+const keyPair = require("@caict/bif-encryption");
+const errors = require("../exception");
+const config = require("../common/constant");
+const is = require("is-type-of");
+
+function validateType(request) {
+  // 检测参数是否是数组或者不是对象
+  if (
+    is.array(request) ||
+    !is.object(request) ||
+    JSON.stringify(request) === "{}"
+  ) {
+    return util._responseError(errors.REQUEST_NULL_ERROR);
+  }
+  return request;
+}
+
+// 参数校验
+function validateObject(object) {
+  let request = validateType(object);
+  if (request.errorCode) {
+    return request;
+  }
+  let {
+    amount,
+    operations,
+    senderAddress,
+    contractAddress,
+    sourceAddress,
+    feeLimit,
+    gasPrice,
+    ceilLedgerSeq,
+    nonceType,
+    initBalance,
+    type,
+  } = request;
+  // 检测ceilLedgerSeq、feeLimit、gasPrice、domainId、nonceType、sourceAddress是否是有效的
+  if (
+    ceilLedgerSeq != null &&
+    ceilLedgerSeq !== "" &&
+    !util._isAvailableValue(ceilLedgerSeq)
+  ) {
+    return util._responseError(errors.INVALID_CEILLEDGERSEQ_ERROR);
+  }
+  if (
+    feeLimit != null &&
+    feeLimit !== "" &&
+    !util._isAvailableValue(feeLimit)
+  ) {
+    return util._responseError(errors.INVALID_FEELIMIT_ERROR);
+  }
+  if (
+    gasPrice != null &&
+    gasPrice !== "" &&
+    !util._isAvailableValue(gasPrice)
+  ) {
+    return util._responseError(errors.INVALID_GASPRICE_ERROR);
+  }
+  if (nonceType == null || nonceType === "") {
+    nonceType = config.INIT_ZERO;
+  } else if (!(nonceType == "0" || nonceType == "1")) {
+    return util._responseError(errors.INVALID_NONCE_TYPE_ERROR);
+  }
+
+  if (amount !== undefined) {
+    if (amount == null || amount === "" || !util._isAvailableValue(amount)) {
+      return util._responseError(errors.INVALID_AMOUNT_ERROR);
+    }
+  }
+  if (type !== undefined) {
+    if (type != null && type !== "" && !(type === 0 || type === 1)) {
+      return util._responseError(errors.INVALID_CONTRACT_TYPE_ERROR);
+    }
+    if (type == null || type === "") {
+      type = 0;
+    }
+  }
+  if (operations !== undefined) {
+    if (is.array(operations)) {
+      if (operations.length == 0) {
+        return util._responseError(errors.OPERATIONS_EMPTY_ERROR);
+      }
+    }
+    if (!is.object(operations) || operations == null || operations === "") {
+      return util._responseError(errors.OPERATIONS_EMPTY_ERROR);
+    }
+  }
+  if (sourceAddress !== undefined) {
+    if (
+      sourceAddress != null &&
+      sourceAddress !== "" &&
+      !keyPair.isAddress(sourceAddress)
+    ) {
+      return util._responseError(errors.INVALID_ADDRESS_ERROR);
+    }
+    if (sourceAddress == null || sourceAddress == "") {
+      return util._responseError(errors.INVALID_ADDRESS_ERROR);
+    }
+  }
+  if (contractAddress !== undefined) {
+    if (
+      contractAddress != null &&
+      contractAddress !== "" &&
+      !keyPair.isAddress(contractAddress)
+    ) {
+      return util._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+    if (contractAddress == null || contractAddress == "") {
+      return util._responseError(errors.INVALID_CONTRACTADDRESS_ERROR);
+    }
+  }
+  if (initBalance !== undefined) {
+    if (!util._verifyIInitBalancelValue(initBalance)) {
+      return util._responseError(errors.INVALID_INITBALANCE_ERROR);
+    }
+  }
+  if (senderAddress !== undefined) {
+    if (!keyPair.isAddress(senderAddress)) {
+      return util._responseError(errors.INVALID_ADDRESS_ERROR);
+    }
+  }
+  // 如果没有feeLimit、gasPrice、domainId传递值则赋给默认值
+  if (feeLimit == null || feeLimit === "") {
+    request.feeLimit = config.feeLimit;
+  }
+  if (gasPrice == null || gasPrice === "") {
+    request.gasPrice = config.gasPrice;
+  }
+  return request;
+}
+
+module.exports = {
+  // 参数校验
+  validateObject: validateObject,
+  // 参数类型校验
+  validateType: validateType,
+};

package/src/bop-sdk/interface/service/offline/common/constant.js

@@ -0,0 +1,6 @@
+let config = {
+  feeLimit: "10000000",
+  gasPrice: "1",
+  INIT_ZERO: "0",
+};
+module.exports = config;