@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/tx/v1beta1/service.lcd.ts

@@ -0,0 +1,57 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { GetTxRequest, GetTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse } from "./service";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* GetTx fetches a tx by hash. */
+  getTx = async (params: GetTxRequest): Promise<GetTxResponse> => {
+    const endpoint = `cosmos/tx/v1beta1/txs/${params.hash}`;
+    return await this.req.get<GetTxResponse>(endpoint);
+  };
+  /* GetTxsEvent fetches txs by event. */
+  getTxsEvent = async (params: GetTxsEventRequest): Promise<GetTxsEventResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.events !== "undefined") {
+      options.params.events = params.events;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.orderBy !== "undefined") {
+      options.params.order_by = params.orderBy;
+    }
+    if (typeof params?.page !== "undefined") {
+      options.params.page = params.page;
+    }
+    if (typeof params?.limit !== "undefined") {
+      options.params.limit = params.limit;
+    }
+    if (typeof params?.query !== "undefined") {
+      options.params.query = params.query;
+    }
+    const endpoint = `cosmos/tx/v1beta1/txs`;
+    return await this.req.get<GetTxsEventResponse>(endpoint, options);
+  };
+  /* GetBlockWithTxs fetches a block with decoded txs.
+  
+   Since: cosmos-sdk 0.45.2 */
+  getBlockWithTxs = async (params: GetBlockWithTxsRequest): Promise<GetBlockWithTxsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/tx/v1beta1/txs/block/${params.height}`;
+    return await this.req.get<GetBlockWithTxsResponse>(endpoint, options);
+  };
+}

package/src/cosmos/tx/v1beta1/service.rpc.Service.ts

@@ -0,0 +1,148 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { SimulateRequest, SimulateResponse, GetTxRequest, GetTxResponse, BroadcastTxRequest, BroadcastTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse, TxDecodeRequest, TxDecodeResponse, TxEncodeRequest, TxEncodeResponse, TxEncodeAminoRequest, TxEncodeAminoResponse, TxDecodeAminoRequest, TxDecodeAminoResponse } from "./service";
+/** Service defines a gRPC service for interacting with transactions. */
+export interface Service {
+  /** Simulate simulates executing a transaction for estimating gas usage. */
+  simulate(request: SimulateRequest): Promise<SimulateResponse>;
+  /** GetTx fetches a tx by hash. */
+  getTx(request: GetTxRequest): Promise<GetTxResponse>;
+  /** BroadcastTx broadcast transaction. */
+  broadcastTx(request: BroadcastTxRequest): Promise<BroadcastTxResponse>;
+  /** GetTxsEvent fetches txs by event. */
+  getTxsEvent(request: GetTxsEventRequest): Promise<GetTxsEventResponse>;
+  /**
+   * GetBlockWithTxs fetches a block with decoded txs.
+   * 
+   * Since: cosmos-sdk 0.45.2
+   */
+  getBlockWithTxs(request: GetBlockWithTxsRequest): Promise<GetBlockWithTxsResponse>;
+  /**
+   * TxDecode decodes the transaction.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  txDecode(request: TxDecodeRequest): Promise<TxDecodeResponse>;
+  /**
+   * TxEncode encodes the transaction.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  txEncode(request: TxEncodeRequest): Promise<TxEncodeResponse>;
+  /**
+   * TxEncodeAmino encodes an Amino transaction from JSON to encoded bytes.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  txEncodeAmino(request: TxEncodeAminoRequest): Promise<TxEncodeAminoResponse>;
+  /**
+   * TxDecodeAmino decodes an Amino transaction from encoded bytes to JSON.
+   * 
+   * Since: cosmos-sdk 0.47
+   */
+  txDecodeAmino(request: TxDecodeAminoRequest): Promise<TxDecodeAminoResponse>;
+}
+export class ServiceClientImpl implements Service {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* Simulate simulates executing a transaction for estimating gas usage. */
+  simulate = async (request: SimulateRequest): Promise<SimulateResponse> => {
+    const data = SimulateRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "Simulate", data);
+    return promise.then(data => SimulateResponse.decode(new BinaryReader(data)));
+  };
+  /* GetTx fetches a tx by hash. */
+  getTx = async (request: GetTxRequest): Promise<GetTxResponse> => {
+    const data = GetTxRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTx", data);
+    return promise.then(data => GetTxResponse.decode(new BinaryReader(data)));
+  };
+  /* BroadcastTx broadcast transaction. */
+  broadcastTx = async (request: BroadcastTxRequest): Promise<BroadcastTxResponse> => {
+    const data = BroadcastTxRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "BroadcastTx", data);
+    return promise.then(data => BroadcastTxResponse.decode(new BinaryReader(data)));
+  };
+  /* GetTxsEvent fetches txs by event. */
+  getTxsEvent = async (request: GetTxsEventRequest): Promise<GetTxsEventResponse> => {
+    const data = GetTxsEventRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetTxsEvent", data);
+    return promise.then(data => GetTxsEventResponse.decode(new BinaryReader(data)));
+  };
+  /* GetBlockWithTxs fetches a block with decoded txs.
+  
+   Since: cosmos-sdk 0.45.2 */
+  getBlockWithTxs = async (request: GetBlockWithTxsRequest): Promise<GetBlockWithTxsResponse> => {
+    const data = GetBlockWithTxsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "GetBlockWithTxs", data);
+    return promise.then(data => GetBlockWithTxsResponse.decode(new BinaryReader(data)));
+  };
+  /* TxDecode decodes the transaction.
+  
+   Since: cosmos-sdk 0.47 */
+  txDecode = async (request: TxDecodeRequest): Promise<TxDecodeResponse> => {
+    const data = TxDecodeRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "TxDecode", data);
+    return promise.then(data => TxDecodeResponse.decode(new BinaryReader(data)));
+  };
+  /* TxEncode encodes the transaction.
+  
+   Since: cosmos-sdk 0.47 */
+  txEncode = async (request: TxEncodeRequest): Promise<TxEncodeResponse> => {
+    const data = TxEncodeRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "TxEncode", data);
+    return promise.then(data => TxEncodeResponse.decode(new BinaryReader(data)));
+  };
+  /* TxEncodeAmino encodes an Amino transaction from JSON to encoded bytes.
+  
+   Since: cosmos-sdk 0.47 */
+  txEncodeAmino = async (request: TxEncodeAminoRequest): Promise<TxEncodeAminoResponse> => {
+    const data = TxEncodeAminoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "TxEncodeAmino", data);
+    return promise.then(data => TxEncodeAminoResponse.decode(new BinaryReader(data)));
+  };
+  /* TxDecodeAmino decodes an Amino transaction from encoded bytes to JSON.
+  
+   Since: cosmos-sdk 0.47 */
+  txDecodeAmino = async (request: TxDecodeAminoRequest): Promise<TxDecodeAminoResponse> => {
+    const data = TxDecodeAminoRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.tx.v1beta1.Service", "TxDecodeAmino", data);
+    return promise.then(data => TxDecodeAminoResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new ServiceClientImpl(rpc);
+  return {
+    simulate(request: SimulateRequest): Promise<SimulateResponse> {
+      return queryService.simulate(request);
+    },
+    getTx(request: GetTxRequest): Promise<GetTxResponse> {
+      return queryService.getTx(request);
+    },
+    broadcastTx(request: BroadcastTxRequest): Promise<BroadcastTxResponse> {
+      return queryService.broadcastTx(request);
+    },
+    getTxsEvent(request: GetTxsEventRequest): Promise<GetTxsEventResponse> {
+      return queryService.getTxsEvent(request);
+    },
+    getBlockWithTxs(request: GetBlockWithTxsRequest): Promise<GetBlockWithTxsResponse> {
+      return queryService.getBlockWithTxs(request);
+    },
+    txDecode(request: TxDecodeRequest): Promise<TxDecodeResponse> {
+      return queryService.txDecode(request);
+    },
+    txEncode(request: TxEncodeRequest): Promise<TxEncodeResponse> {
+      return queryService.txEncode(request);
+    },
+    txEncodeAmino(request: TxEncodeAminoRequest): Promise<TxEncodeAminoResponse> {
+      return queryService.txEncodeAmino(request);
+    },
+    txDecodeAmino(request: TxDecodeAminoRequest): Promise<TxDecodeAminoResponse> {
+      return queryService.txDecodeAmino(request);
+    }
+  };
+};

package/src/cosmos/tx/v1beta1/service.rpc.func.d.ts

@@ -0,0 +1,11 @@
+import { RpcResolver } from "../../../helper-func-types";
+import { SimulateRequest, SimulateResponse, GetTxRequest, GetTxResponse, BroadcastTxRequest, BroadcastTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse, TxDecodeRequest, TxDecodeResponse, TxEncodeRequest, TxEncodeResponse, TxEncodeAminoRequest, TxEncodeAminoResponse, TxDecodeAminoRequest, TxDecodeAminoResponse } from "./service";
+export declare const createGetSimulate: (clientResolver?: RpcResolver) => (request: SimulateRequest) => Promise<SimulateResponse>;
+export declare const createGetGetTx: (clientResolver?: RpcResolver) => (request: GetTxRequest) => Promise<GetTxResponse>;
+export declare const createGetBroadcastTx: (clientResolver?: RpcResolver) => (request: BroadcastTxRequest) => Promise<BroadcastTxResponse>;
+export declare const createGetGetTxsEvent: (clientResolver?: RpcResolver) => (request: GetTxsEventRequest) => Promise<GetTxsEventResponse>;
+export declare const createGetGetBlockWithTxs: (clientResolver?: RpcResolver) => (request: GetBlockWithTxsRequest) => Promise<GetBlockWithTxsResponse>;
+export declare const createGetTxDecode: (clientResolver?: RpcResolver) => (request: TxDecodeRequest) => Promise<TxDecodeResponse>;
+export declare const createGetTxEncode: (clientResolver?: RpcResolver) => (request: TxEncodeRequest) => Promise<TxEncodeResponse>;
+export declare const createGetTxEncodeAmino: (clientResolver?: RpcResolver) => (request: TxEncodeAminoRequest) => Promise<TxEncodeAminoResponse>;
+export declare const createGetTxDecodeAmino: (clientResolver?: RpcResolver) => (request: TxDecodeAminoRequest) => Promise<TxDecodeAminoResponse>;

package/src/cosmos/tx/v1beta1/service.rpc.func.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetTxDecodeAmino = exports.createGetTxEncodeAmino = exports.createGetTxEncode = exports.createGetTxDecode = exports.createGetGetBlockWithTxs = exports.createGetGetTxsEvent = exports.createGetBroadcastTx = exports.createGetGetTx = exports.createGetSimulate = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const service_1 = require("./service");
+const createGetSimulate = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.SimulateRequest.encode,
+    decode: service_1.SimulateResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "Simulate",
+    clientResolver
+});
+exports.createGetSimulate = createGetSimulate;
+const createGetGetTx = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.GetTxRequest.encode,
+    decode: service_1.GetTxResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "GetTx",
+    clientResolver
+});
+exports.createGetGetTx = createGetGetTx;
+const createGetBroadcastTx = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.BroadcastTxRequest.encode,
+    decode: service_1.BroadcastTxResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "BroadcastTx",
+    clientResolver
+});
+exports.createGetBroadcastTx = createGetBroadcastTx;
+const createGetGetTxsEvent = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.GetTxsEventRequest.encode,
+    decode: service_1.GetTxsEventResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "GetTxsEvent",
+    clientResolver
+});
+exports.createGetGetTxsEvent = createGetGetTxsEvent;
+const createGetGetBlockWithTxs = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.GetBlockWithTxsRequest.encode,
+    decode: service_1.GetBlockWithTxsResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "GetBlockWithTxs",
+    clientResolver
+});
+exports.createGetGetBlockWithTxs = createGetGetBlockWithTxs;
+const createGetTxDecode = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.TxDecodeRequest.encode,
+    decode: service_1.TxDecodeResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "TxDecode",
+    clientResolver
+});
+exports.createGetTxDecode = createGetTxDecode;
+const createGetTxEncode = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.TxEncodeRequest.encode,
+    decode: service_1.TxEncodeResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "TxEncode",
+    clientResolver
+});
+exports.createGetTxEncode = createGetTxEncode;
+const createGetTxEncodeAmino = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.TxEncodeAminoRequest.encode,
+    decode: service_1.TxEncodeAminoResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "TxEncodeAmino",
+    clientResolver
+});
+exports.createGetTxEncodeAmino = createGetTxEncodeAmino;
+const createGetTxDecodeAmino = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: service_1.TxDecodeAminoRequest.encode,
+    decode: service_1.TxDecodeAminoResponse.decode,
+    service: "cosmos.tx.v1beta1.Service",
+    method: "TxDecodeAmino",
+    clientResolver
+});
+exports.createGetTxDecodeAmino = createGetTxDecodeAmino;

package/src/cosmos/tx/v1beta1/service.rpc.func.ts

@@ -0,0 +1,65 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { SimulateRequest, SimulateResponse, GetTxRequest, GetTxResponse, BroadcastTxRequest, BroadcastTxResponse, GetTxsEventRequest, GetTxsEventResponse, GetBlockWithTxsRequest, GetBlockWithTxsResponse, TxDecodeRequest, TxDecodeResponse, TxEncodeRequest, TxEncodeResponse, TxEncodeAminoRequest, TxEncodeAminoResponse, TxDecodeAminoRequest, TxDecodeAminoResponse } from "./service";
+export const createGetSimulate = (clientResolver?: RpcResolver) => buildQuery<SimulateRequest, SimulateResponse>({
+  encode: SimulateRequest.encode,
+  decode: SimulateResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "Simulate",
+  clientResolver
+});
+export const createGetGetTx = (clientResolver?: RpcResolver) => buildQuery<GetTxRequest, GetTxResponse>({
+  encode: GetTxRequest.encode,
+  decode: GetTxResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "GetTx",
+  clientResolver
+});
+export const createGetBroadcastTx = (clientResolver?: RpcResolver) => buildQuery<BroadcastTxRequest, BroadcastTxResponse>({
+  encode: BroadcastTxRequest.encode,
+  decode: BroadcastTxResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "BroadcastTx",
+  clientResolver
+});
+export const createGetGetTxsEvent = (clientResolver?: RpcResolver) => buildQuery<GetTxsEventRequest, GetTxsEventResponse>({
+  encode: GetTxsEventRequest.encode,
+  decode: GetTxsEventResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "GetTxsEvent",
+  clientResolver
+});
+export const createGetGetBlockWithTxs = (clientResolver?: RpcResolver) => buildQuery<GetBlockWithTxsRequest, GetBlockWithTxsResponse>({
+  encode: GetBlockWithTxsRequest.encode,
+  decode: GetBlockWithTxsResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "GetBlockWithTxs",
+  clientResolver
+});
+export const createGetTxDecode = (clientResolver?: RpcResolver) => buildQuery<TxDecodeRequest, TxDecodeResponse>({
+  encode: TxDecodeRequest.encode,
+  decode: TxDecodeResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "TxDecode",
+  clientResolver
+});
+export const createGetTxEncode = (clientResolver?: RpcResolver) => buildQuery<TxEncodeRequest, TxEncodeResponse>({
+  encode: TxEncodeRequest.encode,
+  decode: TxEncodeResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "TxEncode",
+  clientResolver
+});
+export const createGetTxEncodeAmino = (clientResolver?: RpcResolver) => buildQuery<TxEncodeAminoRequest, TxEncodeAminoResponse>({
+  encode: TxEncodeAminoRequest.encode,
+  decode: TxEncodeAminoResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "TxEncodeAmino",
+  clientResolver
+});
+export const createGetTxDecodeAmino = (clientResolver?: RpcResolver) => buildQuery<TxDecodeAminoRequest, TxDecodeAminoResponse>({
+  encode: TxDecodeAminoRequest.encode,
+  decode: TxDecodeAminoResponse.decode,
+  service: "cosmos.tx.v1beta1.Service",
+  method: "TxDecodeAmino",
+  clientResolver
+});