@caict/bop-typescript-sdk 1.0.0

package/src/bop-sdk/interface/abstract-service/abstract-transaction.ts

@@ -0,0 +1,86 @@
+import {
+  GetTxPoolSizeResponse,
+  GetTransactionCacheResponse,
+  GetTransactionHistoryResponse,
+  OffLineTxResponse,
+  OpCreateAccountParams,
+  OpCreateContractParams,
+  OpGasSendParams,
+  OpContractInvokeParams,
+  OpSetMetadataParams,
+  OpSetPrivParams,
+  OpBatchGasSend,
+  OpBatchContractInvoke,
+  SubmitTransactionParams,
+  SubmitTransactionResponse,
+  TestTransactionRequest,
+  TestTransactionResponse,
+} from "bop-sdk/proto/bop-sdk-interface";
+import { Signer } from "./abstract-signer";
+
+export abstract class transaction {
+  abstract getTxPoolSize(): Promise<GetTxPoolSizeResponse>;
+  abstract getTxPoolTransactions(
+    limit?: number,
+    address?: string,
+    hash?: string,
+  ): Promise<GetTransactionCacheResponse>;
+  abstract getTransactionHistory(
+    seq?: number,
+    start?: number,
+    limit?: number,
+    hash?: string,
+  ): Promise<GetTransactionHistoryResponse>;
+  //构建离线交易数据
+  abstract buildAccountCreateTx(
+    params: OpCreateAccountParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+  abstract buildContractCreateTx(
+    params: OpCreateContractParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+  abstract buildGasSendTx(
+    params: OpGasSendParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+  abstract buildContractInvokeTx(
+    params: OpContractInvokeParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+  abstract buildSetMetadataTx(
+    params: OpSetMetadataParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+  abstract buildSetPrivilegeTx(
+    params: OpSetPrivParams,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+
+  //构建离线批量交易数据
+  abstract buildBatchGasSend(
+    params: OpBatchGasSend,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+
+  abstract buildBatchContractInvoke(
+    params: OpBatchContractInvoke,
+    signer: Signer[],
+    sourceAddress?: string,
+  ): Promise<OffLineTxResponse>;
+
+  abstract submitTransaction(
+    params: SubmitTransactionParams,
+  ): Promise<SubmitTransactionResponse>;
+
+  abstract estimateGas(
+    transaction: TestTransactionRequest,
+  ): Promise<TestTransactionResponse>;
+}

package/src/bop-sdk/interface/provider-ws.ts

@@ -0,0 +1,10 @@
+import { WsConfig, BopWsInterface } from "../../bop/bop-ws";
+
+//未拓展新功能，直接接入Bop平台的ws
+export class WsProviderByBop {
+  public bop: BopWsInterface;
+
+  constructor(config: WsConfig) {
+    this.bop = new BopWsInterface(config.url, config.heartBeatInterval);
+  }
+}

package/src/bop-sdk/interface/provider.ts

@@ -0,0 +1,22 @@
+import { Provider } from "./abstract-service/abstract-provider";
+import { BopInterface } from "../../bop/bop-base";
+import { ChainByBop } from "./service/chain";
+import { LedgerByBop } from "./service/ledger";
+import { AccountByBop } from "./service/account";
+import { TransactionByBop } from "./service/transaction";
+import { ContractByBop } from "./service/contract";
+import { BopByBop } from "./service/3rd";
+
+export class ProviderByBop extends Provider {
+  public bop: BopByBop;
+
+  constructor(bop: BopInterface) {
+    super();
+    this.chain = new ChainByBop(bop);
+    this.ledger = new LedgerByBop(bop);
+    this.account = new AccountByBop(bop);
+    this.transaction = new TransactionByBop(bop);
+    this.contract = new ContractByBop(bop);
+    this.bop = new BopByBop(bop);
+  }
+}

package/src/bop-sdk/interface/service/3rd.ts

@@ -0,0 +1,54 @@
+import { BopInterface } from "../../../bop/bop-base";
+import {
+  ApplyRequest,
+  ApplyResponse,
+  ApplyStatusRequest,
+  ApplyStatusResponse,
+  DetailRequest,
+  DetailResponse,
+  GetTransactionCacheRequest,
+  GetTransactionCachePlatResponse,
+  DiscardRequest,
+  DiscardResponse,
+  QueryRequest,
+  QueryResponse,
+} from "../../../bop/bop-proto/bop";
+
+export class BopByBop {
+  readonly bopInterface: BopInterface;
+
+  constructor(bop: BopInterface) {
+    this.bopInterface = bop;
+  }
+
+  public async apply(params: ApplyRequest): Promise<ApplyResponse> {
+    return this.bopInterface.callService("permit_apply", params);
+  }
+
+  public async status(
+    params: ApplyStatusRequest,
+  ): Promise<ApplyStatusResponse> {
+    return this.bopInterface.callService("permit_status", params);
+  }
+
+  public async detail(params: DetailRequest): Promise<DetailResponse> {
+    return this.bopInterface.callService("permit_detail", params);
+  }
+
+  public async getTransactionCache(
+    params: GetTransactionCacheRequest,
+  ): Promise<GetTransactionCachePlatResponse> {
+    return this.bopInterface.callService(
+      "base_getTransactionCachePlat",
+      params,
+    );
+  }
+
+  public async discard(params: DiscardRequest): Promise<DiscardResponse> {
+    return this.bopInterface.callService("base_discard", params);
+  }
+
+  public async query(params: QueryRequest): Promise<QueryResponse> {
+    return this.bopInterface.callService("base_query", params);
+  }
+}

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

@@ -0,0 +1,86 @@
+import { GetAccountBaseRequest, GetAccountRequest } from "bop/bop-proto/bop";
+import {
+  GetAccountBalanceResponse,
+  GetAccountIncreaseNonceResponse,
+  GetAccountMetadataResponse,
+  GetAccountPrivResponse,
+  GetAccountResponse,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+import { BopInterface } from "../../../bop/bop-base";
+import { account } from "../abstract-service/abstract-account";
+import * as trans from "./helper";
+import { SdkStatusCode } from "../../../bop-sdk/proto/bop-sdk-common";
+
+export class AccountByBop extends account {
+  readonly bopInterface: BopInterface;
+  constructor(bop: BopInterface) {
+    super();
+    this.bopInterface = bop;
+  }
+
+  public async getAccount(address: string): Promise<GetAccountResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.AccountAccountResultToAccountInfo(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+
+  public async getAccountMetadata(
+    address: string,
+    seq?: number,
+    key?: string,
+  ): Promise<GetAccountMetadataResponse> {
+    let request: GetAccountRequest = {
+      address: address,
+    };
+    if (seq !== undefined) request.height = seq;
+    if (key !== undefined) {
+      request.key = key;
+      if (key.length < 1 || key.length > 1024) {
+        let response: GetAccountMetadataResponse = {
+          errorCode: SdkStatusCode.INVALID_DATAKEY_ERROR,
+          errorDesc: "The length of key must be between 1 and 1024",
+        };
+        return response;
+      }
+    }
+    return trans.AccountAccountToAccountMetadatas(
+      await this.bopInterface.callService("base_getAccount", request),
+    );
+  }
+
+  public async getAccountIncreaseNonce(
+    address: string,
+  ): Promise<GetAccountIncreaseNonceResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.AccountAccountResultToIncreaseNonce(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+
+  public async getAccountBalance(
+    address: string,
+  ): Promise<GetAccountBalanceResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.AccountAccountResultToBalance(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+
+  public async getAccountPriv(
+    address: string,
+  ): Promise<GetAccountPrivResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.AccountAccountResultToPriv(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+}

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

@@ -0,0 +1,27 @@
+import {
+  GetChainInfoResponse,
+  GetNetworkIdResponse,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+import { BopInterface } from "../../../bop/bop-base";
+import { chain } from "../abstract-service/abstract-chain";
+import * as trans from "./helper";
+
+export class ChainByBop extends chain {
+  readonly bopInterface: BopInterface;
+  constructor(bop: BopInterface) {
+    super();
+    this.bopInterface = bop;
+  }
+
+  public async getChainInfo(): Promise<GetChainInfoResponse> {
+    return trans.ChainHelloToChainInfo(
+      await this.bopInterface.callService("base_hello"),
+    );
+  }
+
+  public async getNetworkId(): Promise<GetNetworkIdResponse> {
+    return trans.ChainHelloToNetworkId(
+      await this.bopInterface.callService("base_hello"),
+    );
+  }
+}

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

@@ -0,0 +1,51 @@
+import { GetAccountBaseRequest } from "bop/bop-proto/bop";
+import {
+  CheckContractAccountResponse,
+  GetContractInfoResponse,
+  CallContractRequest,
+  CallContractResponse,
+} from "../../../bop-sdk/proto/bop-sdk-interface";
+import { BopInterface } from "../../../bop/bop-base";
+import { contract } from "../abstract-service/abstract-contract";
+import * as trans from "./helper";
+
+export class ContractByBop extends contract {
+  readonly bopInterface: BopInterface;
+  constructor(bop: BopInterface) {
+    super();
+    this.bopInterface = bop;
+  }
+
+  public async checkContractAccount(
+    address: string,
+  ): Promise<CheckContractAccountResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.ContractAccountResultToCheckContractAccount(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+
+  public async getContractInfo(
+    address: string,
+  ): Promise<GetContractInfoResponse> {
+    const request: GetAccountBaseRequest = {
+      address: address,
+    };
+    return trans.ContractAccountResultToGetContractInfo(
+      await this.bopInterface.callService("base_getAccountBase", request),
+    );
+  }
+
+  public async callContract(
+    transaction: CallContractRequest,
+  ): Promise<CallContractResponse> {
+    transaction.optType = 2;
+
+    return await this.bopInterface.callService(
+      "base_callContract",
+      transaction,
+    );
+  }
+}