@caict/bop-typescript-sdk 1.0.0

package/src/bop/bop-base/base.ts

@@ -0,0 +1,366 @@
+import {
+  HelloResponse,
+  HelloResult,
+  GetAccountRequest,
+  GetAccountResponse,
+  GetAccountBaseRequest,
+  GetAccountBaseResponse,
+  GetAccountMetadataRequest,
+  GetAccountMetadataResponse,
+  GetLedgerRequest,
+  GetLedgerResponse,
+  SubmitTransactionRequest,
+  SubmitTransactionResponse,
+  GetTransactionHistoryRequest,
+  GetTransactionHistoryResponse,
+  TestTransactionRequest,
+  TestTransactionResponse,
+  CallContractRequest,
+  CallContractResponse,
+  QueryReturn,
+  QueryRequest,
+  QueryResponse,
+  QueryRequest_TxType,
+  GetTransactionCacheRequest,
+  GetTransactionCacheRequest_PoolType,
+  GetTransactionCacheChainResponse,
+  GetTransactionCachePlatResponse,
+  DiscardRequest,
+  DiscardResponse,
+  GetTxCacheSizeResponse,
+  GetTxCacheSizeResult,
+  StatusCodes,
+} from "../bop-proto/bop";
+
+import JSONbig from "json-bigint";
+
+export class BaseService {
+  private readonly apiKey: string;
+  private readonly host: string;
+  private readonly apiSecret: string;
+  private readonly baseUrl: string;
+
+  private _hasApiSecret: boolean;
+
+  constructor(host: string, apiKey: string, apiSecret: string) {
+    this.host = host;
+    this.apiKey = apiKey;
+    this.apiSecret = apiSecret;
+    this.baseUrl = `${this.host}/base/${this.apiKey}`;
+    this._hasApiSecret = !(this.apiSecret === "");
+  }
+
+  private async fetchData(
+    endpoint: string,
+    params: any,
+    method: "GET" | "POST" = "GET",
+    timeout: number = 10000, // 默认超时时间为10秒
+  ): Promise<any> {
+    // 创建一个AbortController实例
+    const controller = new AbortController();
+    const { signal } = controller;
+    // 设置一个超时
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+      throw new Error("Request timed out");
+    }, timeout);
+    try {
+      let url = `${this.baseUrl}/${endpoint}`;
+      if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        throw new Error("URL must start with 'http://' or 'https://'");
+      }
+      const headers = {
+        "Content-Type": "application/json",
+        ...(this._hasApiSecret ? { "api-secret": this.apiSecret } : {}),
+      };
+      // 对params进行判断，如果是GET请求，则将params转为URL查询字符串并附加到URL上
+      let queryString = "";
+      if (method === "GET" && params) {
+        queryString = new URLSearchParams(params).toString();
+        if (queryString) {
+          url += `?${queryString}`;
+        }
+      }
+
+      // 创建body，仅在POST请求且params存在时创建
+      let body: string | null = null;
+      if (method === "POST" && params) {
+        body = JSON.stringify(params);
+      }
+
+      //console.log(url);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body,
+        signal, // 将signal传递给fetch
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! Status: ${response.status}, Message: ${response.statusText}`,
+        );
+      }
+      const responseText = await response.text();
+      const data = JSONbig.parse(responseText);
+      clearTimeout(timeoutId); // 请求成功，清除超时计时器
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId); // 无论请求是否成功，都清除超时计时器
+      let errorDesc = "invalid url";
+      if (typeof error === "string") {
+        errorDesc = error;
+      } else if (error instanceof Error) {
+        errorDesc = error.message;
+      }
+
+      const obj = {
+        error_code: StatusCodes.URL_ERROR,
+        error_desc: errorDesc,
+      };
+      return obj;
+    }
+  }
+
+  public async hello(): Promise<HelloResponse> {
+    let helloResponse: HelloResponse;
+    helloResponse = HelloResponse.fromJSON(await this.fetchData("/hello", {}));
+    if (helloResponse.errorCode === 0) {
+      helloResponse.errorCode = 0;
+      helloResponse.errorDesc = "ok";
+      helloResponse.result = HelloResult.fromJSON(
+        await this.fetchData("/hello", {}),
+      );
+      helloResponse.success = true;
+    }
+
+    return helloResponse;
+  }
+
+  public async getAccount(
+    params: GetAccountRequest,
+  ): Promise<GetAccountResponse> {
+    return GetAccountResponse.fromJSON(
+      await this.fetchData("/getAccount", params),
+    );
+  }
+
+  public async getAccountBase(
+    params: GetAccountBaseRequest,
+  ): Promise<GetAccountBaseResponse> {
+    return GetAccountBaseResponse.fromJSON(
+      await this.fetchData("/getAccountBase", params),
+    );
+  }
+
+  public async getAccountMetaData(
+    params: GetAccountMetadataRequest,
+  ): Promise<GetAccountMetadataResponse> {
+    return GetAccountMetadataResponse.fromJSON(
+      await this.fetchData("/getAccountMetaData", params),
+    );
+  }
+
+  public async getLedger(params: GetLedgerRequest): Promise<GetLedgerResponse> {
+    interface InternalGetLedgerRequest {
+      seq?: number;
+      with_validator?: boolean;
+      with_leader?: boolean;
+    }
+
+    let request: InternalGetLedgerRequest = {};
+
+    // 复制并转换 params 中的属性到 request 中
+    if (params.seq !== undefined) request.seq = params.seq;
+    if (params.withLeader !== undefined)
+      request.with_leader = params.withLeader;
+    if (params.withValidator !== undefined)
+      request.with_validator = params.withValidator;
+
+    return GetLedgerResponse.fromJSON(
+      await this.fetchData("/getLedger", request),
+    );
+  }
+
+  public async submitTransaction(
+    params: SubmitTransactionRequest,
+  ): Promise<SubmitTransactionResponse> {
+    console.log(JSON.stringify(SubmitTransactionRequest.toJSON(params)));
+
+    return SubmitTransactionResponse.fromJSON(
+      await this.fetchData(
+        "/submitTransaction",
+        SubmitTransactionRequest.toJSON(params),
+        "POST",
+      ),
+    );
+  }
+
+  public async getTransactionHistory(
+    params: GetTransactionHistoryRequest,
+  ): Promise<GetTransactionHistoryResponse> {
+    interface InternalGetTransactionHistoryRequest {
+      hash?: string | undefined;
+      ledger_seq?: number | undefined;
+      start?: number | undefined;
+      limit?: number | undefined;
+    }
+
+    let request: InternalGetTransactionHistoryRequest = {};
+
+    if (params.hash !== undefined) request.hash = params.hash;
+    if (params.ledgerSeq !== undefined) request.ledger_seq = params.ledgerSeq;
+    if (params.start !== undefined) request.start = params.start;
+    if (params.limit !== undefined) request.limit = params.limit;
+
+    return GetTransactionHistoryResponse.fromJSON(
+      await this.fetchData("/getTransactionHistory", request),
+    );
+  }
+
+  public async testTransaction(
+    params: TestTransactionRequest,
+  ): Promise<TestTransactionResponse> {
+    console.log(JSON.stringify(TestTransactionRequest.toJSON(params)));
+    return TestTransactionResponse.fromJSON(
+      await this.fetchData(
+        "/testTransaction",
+        TestTransactionRequest.toJSON(params),
+        "POST",
+      ),
+    );
+  }
+
+  public async callContract(
+    params: CallContractRequest,
+  ): Promise<CallContractResponse> {
+    params.optType = 2; //query
+
+    function parseCallContractResponse(data: any): CallContractResponse {
+      const queryRets: QueryReturn[] = (data.result?.query_rets || []).map(
+        (queryRet) => ({
+          error: JSON.stringify(queryRet.error), // 将error对象转换为字符串
+          result: queryRet.result ? JSON.stringify(queryRet.result) : undefined, // 将result对象转换为字符串（如果存在）
+        }),
+      );
+
+      return {
+        result: {
+          queryRets: queryRets.length > 0 ? queryRets : undefined, // 如果queryRets数组为空，则不设置该字段
+        },
+        success: data.success,
+        errorCode: data.error_code,
+        errorDesc: data.error_desc,
+        trace: data.trace,
+      };
+    }
+    return parseCallContractResponse(
+      await this.fetchData(
+        "/callContract",
+        CallContractRequest.toJSON(params),
+        "POST",
+      ),
+    );
+  }
+
+  public async query(params: QueryRequest): Promise<QueryResponse> {
+    interface InternalQueryRequest {
+      bid?: string | undefined;
+      hash?: string | undefined;
+      tx_id?: string | undefined;
+      start_time?: string | undefined;
+      end_time?: string | undefined;
+      tx_type?: QueryRequest_TxType | undefined;
+      page?: number | undefined;
+      page_size?: number | undefined;
+      ledger_seq?: number | undefined;
+    }
+
+    let request: InternalQueryRequest = {};
+    if (params.bid !== undefined) request.bid = params.bid;
+    if (params.hash !== undefined) request.hash = params.hash;
+    if (params.txId !== undefined) request.tx_id = params.txId;
+    if (params.startTime !== undefined) request.start_time = params.startTime;
+    if (params.endTime !== undefined) request.end_time = params.endTime;
+    if (params.txType !== undefined) request.tx_type = params.txType;
+    if (params.page !== undefined) request.page = params.page;
+    if (params.pageSize !== undefined) request.page_size = params.pageSize;
+    if (params.ledgerSeq !== undefined) request.ledger_seq = params.ledgerSeq;
+
+    return QueryResponse.fromJSON(await this.fetchData("/query", request));
+  }
+
+  public async getTransactionCachePlat(
+    params: GetTransactionCacheRequest,
+  ): Promise<GetTransactionCachePlatResponse> {
+    interface InternalGetTransactionCacheRequest {
+      pool_type?: GetTransactionCacheRequest_PoolType | undefined;
+      limit?: number | undefined;
+      hash?: string | undefined;
+      address?: string | undefined;
+    }
+
+    let request: InternalGetTransactionCacheRequest = {};
+    if (params.limit !== undefined) request.limit = params.limit;
+    if (params.hash !== undefined) request.hash = params.hash;
+    if (params.address !== undefined) request.address = params.address;
+    request.pool_type = GetTransactionCacheRequest_PoolType.PLATFORM;
+
+    return GetTransactionCachePlatResponse.fromJSON(
+      await this.fetchData("/getTransactionCache", request),
+    );
+  }
+
+  public async getTransactionCacheChain(
+    params: GetTransactionCacheRequest,
+  ): Promise<GetTransactionCacheChainResponse> {
+    interface InternalGetTransactionCacheRequest {
+      pool_type?: GetTransactionCacheRequest_PoolType | undefined;
+      limit?: number | undefined;
+      hash?: string | undefined;
+      address?: string | undefined;
+    }
+
+    let request: InternalGetTransactionCacheRequest = {};
+    if (params.limit !== undefined) request.limit = params.limit;
+    if (params.hash !== undefined) request.hash = params.hash;
+    if (params.address !== undefined) request.address = params.address;
+    request.pool_type = GetTransactionCacheRequest_PoolType.CHAIN;
+    return GetTransactionCacheChainResponse.fromJSON(
+      await this.fetchData("/getTransactionCache", request),
+    );
+  }
+
+  public async discard(params: DiscardRequest): Promise<DiscardResponse> {
+    interface InternalDiscardResponse {
+      hash?: string | undefined;
+      page?: number | undefined;
+      page_size?: number | undefined;
+    }
+
+    let request: InternalDiscardResponse = {};
+    if (params.hash !== undefined) request.hash = params.hash;
+    if (params.page !== undefined) request.page = params.page;
+    if (params.pageSize !== undefined) request.page_size = params.pageSize;
+    return DiscardResponse.fromJSON(
+      await this.fetchData("/query/discard", request),
+    );
+  }
+
+  public async getTxCacheSize(): Promise<GetTxCacheSizeResponse> {
+    let getTxCacheSizeResponse: GetTxCacheSizeResponse;
+    getTxCacheSizeResponse = GetTxCacheSizeResponse.fromJSON(
+      await this.fetchData("/getTxCacheSize", {}),
+    );
+    if (getTxCacheSizeResponse.errorCode === 0) {
+      getTxCacheSizeResponse.errorCode = 0;
+      getTxCacheSizeResponse.errorDesc = "ok";
+      getTxCacheSizeResponse.result = GetTxCacheSizeResult.fromJSON(
+        await this.fetchData("/getTxCacheSize", {}),
+      );
+      getTxCacheSizeResponse.success = true;
+    }
+
+    return getTxCacheSizeResponse;
+  }
+}

package/src/bop/bop-base/index.ts

@@ -0,0 +1,83 @@
+import { PermitService } from "./permit";
+import { BaseService } from "./base";
+
+export class Config {
+  constructor(
+    public readonly host: string,
+    public readonly apiKey: string,
+    public readonly apiSecret: string,
+  ) {}
+}
+
+class ServiceFactory {
+  private readonly config: Config;
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  createPermitService(): PermitService {
+    return new PermitService(this.config.host);
+  }
+
+  createBaseService(): BaseService {
+    return new BaseService(
+      this.config.host,
+      this.config.apiKey,
+      this.config.apiSecret,
+    );
+  }
+}
+
+export class BopInterface {
+  private permitService: PermitService;
+  private baseService: BaseService;
+
+  constructor(config: Config) {
+    const factory = new ServiceFactory(config);
+    this.permitService = factory.createPermitService();
+    this.baseService = factory.createBaseService();
+  }
+
+  public getPermitService(): PermitService {
+    return this.permitService;
+  }
+
+  public getBaseService(): BaseService {
+    return this.baseService;
+  }
+
+  // 调用服务方法
+  public callService(methodName: string, ...args: any[]): any {
+    const [prefix, functionName] = methodName.split("_", 2);
+
+    switch (prefix) {
+      case "permit":
+        return this.callPermitService(functionName, ...args);
+      case "base":
+        return this.callBaseService(functionName, ...args);
+      default:
+        throw new Error(`Unknown service prefix: ${prefix}`);
+    }
+  }
+
+  // 调用 PermitService 的方法
+  private callPermitService(methodName: string, ...args: any[]): any {
+    const method = this.permitService[methodName] as Function;
+    if (!method) {
+      throw new Error(`Method ${methodName} not found in PermitService`);
+    }
+    const boundMethod = method.bind(this.permitService);
+    return boundMethod(...args);
+  }
+
+  // 调用 BaseService 的方法
+  private callBaseService(methodName: string, ...args: any[]): any {
+    const method = this.baseService[methodName] as Function;
+    if (!method) {
+      throw new Error(`Method ${methodName} not found in BaseService`);
+    }
+    const boundMethod = method.bind(this.baseService);
+    return boundMethod(...args);
+  }
+}

package/src/bop/bop-base/permit.ts

@@ -0,0 +1,116 @@
+import {
+  ApplyRequest,
+  ApplyResponse,
+  ApplyStatusRequest,
+  ApplyStatusResponse,
+  DetailRequest,
+  DetailResponse,
+  StatusCodes,
+} from "../bop-proto/bop";
+
+import JSONbig from "json-bigint";
+
+export class PermitService {
+  private readonly host: string;
+  private readonly baseUrl: string;
+
+  private readonly _hasApiSecret: boolean;
+
+  constructor(host: string) {
+    this.host = host;
+    this.baseUrl = `${this.host}/permit`;
+    this._hasApiSecret = false;
+  }
+
+  private async fetchData(
+    endpoint: string,
+    params: any,
+    method: "GET" | "POST" = "GET",
+    timeout: number = 10000, // 默认超时时间为10秒
+  ): Promise<any> {
+    // 创建一个AbortController实例
+    const controller = new AbortController();
+    const { signal } = controller;
+    // 设置一个超时
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+      throw new Error("Request timed out");
+    }, timeout);
+    try {
+      let url = `${this.baseUrl}/${endpoint}`;
+      if (!url.startsWith("http://") && !url.startsWith("https://")) {
+        throw new Error("URL must start with 'http://' or 'https://'");
+      }
+      const headers = {
+        "Content-Type": "application/json",
+      };
+      // 对params进行判断，如果是GET请求，则将params转为URL查询字符串并附加到URL上
+      let queryString = "";
+      if (method === "GET" && params) {
+        queryString = new URLSearchParams(params).toString();
+        if (queryString) {
+          url += `?${queryString}`;
+        }
+      }
+
+      // 创建body，仅在POST请求且params存在时创建
+      let body: string | null = null;
+      if (method === "POST" && params) {
+        body = JSON.stringify(params);
+      }
+
+      //console.log(url);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body,
+        signal, // 将signal传递给fetch
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! Status: ${response.status}, Message: ${response.statusText}`,
+        );
+      }
+
+      const responseText = await response.text();
+      const data = JSONbig.parse(responseText);
+      clearTimeout(timeoutId); // 请求成功，清除超时计时器
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId); // 无论请求是否成功，都清除超时计时器
+      let errorDesc = "invalid url";
+      if (typeof error === "string") {
+        errorDesc = error;
+      } else if (error instanceof Error) {
+        errorDesc = error.message;
+      }
+
+      const obj = {
+        error_code: StatusCodes.URL_ERROR,
+        error_desc: errorDesc,
+      };
+      return obj;
+    }
+  }
+
+  public async apply(params: ApplyRequest): Promise<ApplyResponse> {
+    return ApplyResponse.fromJSON(
+      await this.fetchData("/data/apply", params, "POST"),
+    );
+  }
+
+  public async status(
+    params: ApplyStatusRequest,
+  ): Promise<ApplyStatusResponse> {
+    return ApplyStatusResponse.fromJSON(
+      await this.fetchData("/data/query/status", params, "POST"),
+    );
+  }
+
+  public async detail(params: DetailRequest): Promise<DetailResponse> {
+    return DetailResponse.fromJSON(
+      await this.fetchData("/data/query/detail", params, "POST"),
+    );
+  }
+}