@xpla/xplajs 1.7.0-beta.0

package/src/cosmos/base/v1beta1/coin.ts

@@ -0,0 +1,439 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * Coin defines a token with a denomination and an amount.
+ * 
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface Coin {
+  denom: string;
+  amount: string;
+}
+export interface CoinProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.Coin";
+  value: Uint8Array;
+}
+/**
+ * Coin defines a token with a denomination and an amount.
+ * 
+ * NOTE: The amount field is an Int which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface CoinAmino {
+  denom: string;
+  amount: string;
+}
+export interface CoinAminoMsg {
+  type: "cosmos-sdk/Coin";
+  value: CoinAmino;
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ * 
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoin {
+  denom: string;
+  amount: string;
+}
+export interface DecCoinProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.DecCoin";
+  value: Uint8Array;
+}
+/**
+ * DecCoin defines a token with a denomination and a decimal amount.
+ * 
+ * NOTE: The amount field is an Dec which implements the custom method
+ * signatures required by gogoproto.
+ */
+export interface DecCoinAmino {
+  denom: string;
+  amount: string;
+}
+export interface DecCoinAminoMsg {
+  type: "cosmos-sdk/DecCoin";
+  value: DecCoinAmino;
+}
+/**
+ * IntProto defines a Protobuf wrapper around an Int object.
+ * Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
+ */
+export interface IntProto {
+  int: string;
+}
+export interface IntProtoProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.IntProto";
+  value: Uint8Array;
+}
+/**
+ * IntProto defines a Protobuf wrapper around an Int object.
+ * Deprecated: Prefer to use math.Int directly. It supports binary Marshal and Unmarshal.
+ */
+export interface IntProtoAmino {
+  int: string;
+}
+export interface IntProtoAminoMsg {
+  type: "cosmos-sdk/IntProto";
+  value: IntProtoAmino;
+}
+/**
+ * DecProto defines a Protobuf wrapper around a Dec object.
+ * Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
+ */
+export interface DecProto {
+  dec: string;
+}
+export interface DecProtoProtoMsg {
+  typeUrl: "/cosmos.base.v1beta1.DecProto";
+  value: Uint8Array;
+}
+/**
+ * DecProto defines a Protobuf wrapper around a Dec object.
+ * Deprecated: Prefer to use math.LegacyDec directly. It supports binary Marshal and Unmarshal.
+ */
+export interface DecProtoAmino {
+  dec: string;
+}
+export interface DecProtoAminoMsg {
+  type: "cosmos-sdk/DecProto";
+  value: DecProtoAmino;
+}
+function createBaseCoin(): Coin {
+  return {
+    denom: "",
+    amount: ""
+  };
+}
+export const Coin = {
+  typeUrl: "/cosmos.base.v1beta1.Coin",
+  aminoType: "cosmos-sdk/Coin",
+  is(o: any): o is Coin {
+    return o && (o.$typeUrl === Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+  },
+  isAmino(o: any): o is CoinAmino {
+    return o && (o.$typeUrl === Coin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+  },
+  encode(message: Coin, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Coin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.amount = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Coin>): Coin {
+    const message = createBaseCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+  fromAmino(object: CoinAmino): Coin {
+    const message = createBaseCoin();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.amount !== undefined && object.amount !== null) {
+      message.amount = object.amount;
+    }
+    return message;
+  },
+  toAmino(message: Coin): CoinAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.amount = message.amount ?? "";
+    return obj;
+  },
+  fromAminoMsg(object: CoinAminoMsg): Coin {
+    return Coin.fromAmino(object.value);
+  },
+  toAminoMsg(message: Coin): CoinAminoMsg {
+    return {
+      type: "cosmos-sdk/Coin",
+      value: Coin.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CoinProtoMsg): Coin {
+    return Coin.decode(message.value);
+  },
+  toProto(message: Coin): Uint8Array {
+    return Coin.encode(message).finish();
+  },
+  toProtoMsg(message: Coin): CoinProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.Coin",
+      value: Coin.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Coin.typeUrl, Coin);
+GlobalDecoderRegistry.registerAminoProtoMapping(Coin.aminoType, Coin.typeUrl);
+function createBaseDecCoin(): DecCoin {
+  return {
+    denom: "",
+    amount: ""
+  };
+}
+export const DecCoin = {
+  typeUrl: "/cosmos.base.v1beta1.DecCoin",
+  aminoType: "cosmos-sdk/DecCoin",
+  is(o: any): o is DecCoin {
+    return o && (o.$typeUrl === DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+  },
+  isAmino(o: any): o is DecCoinAmino {
+    return o && (o.$typeUrl === DecCoin.typeUrl || typeof o.denom === "string" && typeof o.amount === "string");
+  },
+  encode(message: DecCoin, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.denom !== "") {
+      writer.uint32(10).string(message.denom);
+    }
+    if (message.amount !== "") {
+      writer.uint32(18).string(message.amount);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DecCoin {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecCoin();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.denom = reader.string();
+          break;
+        case 2:
+          message.amount = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<DecCoin>): DecCoin {
+    const message = createBaseDecCoin();
+    message.denom = object.denom ?? "";
+    message.amount = object.amount ?? "";
+    return message;
+  },
+  fromAmino(object: DecCoinAmino): DecCoin {
+    const message = createBaseDecCoin();
+    if (object.denom !== undefined && object.denom !== null) {
+      message.denom = object.denom;
+    }
+    if (object.amount !== undefined && object.amount !== null) {
+      message.amount = object.amount;
+    }
+    return message;
+  },
+  toAmino(message: DecCoin): DecCoinAmino {
+    const obj: any = {};
+    obj.denom = message.denom === "" ? undefined : message.denom;
+    obj.amount = message.amount === "" ? undefined : message.amount;
+    return obj;
+  },
+  fromAminoMsg(object: DecCoinAminoMsg): DecCoin {
+    return DecCoin.fromAmino(object.value);
+  },
+  toAminoMsg(message: DecCoin): DecCoinAminoMsg {
+    return {
+      type: "cosmos-sdk/DecCoin",
+      value: DecCoin.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DecCoinProtoMsg): DecCoin {
+    return DecCoin.decode(message.value);
+  },
+  toProto(message: DecCoin): Uint8Array {
+    return DecCoin.encode(message).finish();
+  },
+  toProtoMsg(message: DecCoin): DecCoinProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.DecCoin",
+      value: DecCoin.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(DecCoin.typeUrl, DecCoin);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecCoin.aminoType, DecCoin.typeUrl);
+function createBaseIntProto(): IntProto {
+  return {
+    int: ""
+  };
+}
+export const IntProto = {
+  typeUrl: "/cosmos.base.v1beta1.IntProto",
+  aminoType: "cosmos-sdk/IntProto",
+  is(o: any): o is IntProto {
+    return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+  },
+  isAmino(o: any): o is IntProtoAmino {
+    return o && (o.$typeUrl === IntProto.typeUrl || typeof o.int === "string");
+  },
+  encode(message: IntProto, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.int !== "") {
+      writer.uint32(10).string(message.int);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): IntProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIntProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.int = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<IntProto>): IntProto {
+    const message = createBaseIntProto();
+    message.int = object.int ?? "";
+    return message;
+  },
+  fromAmino(object: IntProtoAmino): IntProto {
+    const message = createBaseIntProto();
+    if (object.int !== undefined && object.int !== null) {
+      message.int = object.int;
+    }
+    return message;
+  },
+  toAmino(message: IntProto): IntProtoAmino {
+    const obj: any = {};
+    obj.int = message.int === "" ? undefined : message.int;
+    return obj;
+  },
+  fromAminoMsg(object: IntProtoAminoMsg): IntProto {
+    return IntProto.fromAmino(object.value);
+  },
+  toAminoMsg(message: IntProto): IntProtoAminoMsg {
+    return {
+      type: "cosmos-sdk/IntProto",
+      value: IntProto.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: IntProtoProtoMsg): IntProto {
+    return IntProto.decode(message.value);
+  },
+  toProto(message: IntProto): Uint8Array {
+    return IntProto.encode(message).finish();
+  },
+  toProtoMsg(message: IntProto): IntProtoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.IntProto",
+      value: IntProto.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(IntProto.typeUrl, IntProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(IntProto.aminoType, IntProto.typeUrl);
+function createBaseDecProto(): DecProto {
+  return {
+    dec: ""
+  };
+}
+export const DecProto = {
+  typeUrl: "/cosmos.base.v1beta1.DecProto",
+  aminoType: "cosmos-sdk/DecProto",
+  is(o: any): o is DecProto {
+    return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+  },
+  isAmino(o: any): o is DecProtoAmino {
+    return o && (o.$typeUrl === DecProto.typeUrl || typeof o.dec === "string");
+  },
+  encode(message: DecProto, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.dec !== "") {
+      writer.uint32(10).string(message.dec);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DecProto {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDecProto();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.dec = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<DecProto>): DecProto {
+    const message = createBaseDecProto();
+    message.dec = object.dec ?? "";
+    return message;
+  },
+  fromAmino(object: DecProtoAmino): DecProto {
+    const message = createBaseDecProto();
+    if (object.dec !== undefined && object.dec !== null) {
+      message.dec = object.dec;
+    }
+    return message;
+  },
+  toAmino(message: DecProto): DecProtoAmino {
+    const obj: any = {};
+    obj.dec = message.dec === "" ? undefined : message.dec;
+    return obj;
+  },
+  fromAminoMsg(object: DecProtoAminoMsg): DecProto {
+    return DecProto.fromAmino(object.value);
+  },
+  toAminoMsg(message: DecProto): DecProtoAminoMsg {
+    return {
+      type: "cosmos-sdk/DecProto",
+      value: DecProto.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DecProtoProtoMsg): DecProto {
+    return DecProto.decode(message.value);
+  },
+  toProto(message: DecProto): Uint8Array {
+    return DecProto.encode(message).finish();
+  },
+  toProtoMsg(message: DecProto): DecProtoProtoMsg {
+    return {
+      typeUrl: "/cosmos.base.v1beta1.DecProto",
+      value: DecProto.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(DecProto.typeUrl, DecProto);
+GlobalDecoderRegistry.registerAminoProtoMapping(DecProto.aminoType, DecProto.typeUrl);

package/src/cosmos/circuit/module/v1/module.ts

@@ -0,0 +1,99 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/** Module is the config object of the circuit module. */
+export interface Module {
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleProtoMsg {
+  typeUrl: "/cosmos.circuit.module.v1.Module";
+  value: Uint8Array;
+}
+/** Module is the config object of the circuit module. */
+export interface ModuleAmino {
+  /** authority defines the custom module authority. If not set, defaults to the governance module. */
+  authority: string;
+}
+export interface ModuleAminoMsg {
+  type: "cosmos-sdk/Module";
+  value: ModuleAmino;
+}
+function createBaseModule(): Module {
+  return {
+    authority: ""
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.circuit.module.v1.Module",
+  aminoType: "cosmos-sdk/Module",
+  is(o: any): o is Module {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.authority === "string");
+  },
+  isAmino(o: any): o is ModuleAmino {
+    return o && (o.$typeUrl === Module.typeUrl || typeof o.authority === "string");
+  },
+  encode(message: Module, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Module {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseModule();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.authority = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Module>): Module {
+    const message = createBaseModule();
+    message.authority = object.authority ?? "";
+    return message;
+  },
+  fromAmino(object: ModuleAmino): Module {
+    const message = createBaseModule();
+    if (object.authority !== undefined && object.authority !== null) {
+      message.authority = object.authority;
+    }
+    return message;
+  },
+  toAmino(message: Module): ModuleAmino {
+    const obj: any = {};
+    obj.authority = message.authority === "" ? undefined : message.authority;
+    return obj;
+  },
+  fromAminoMsg(object: ModuleAminoMsg): Module {
+    return Module.fromAmino(object.value);
+  },
+  toAminoMsg(message: Module): ModuleAminoMsg {
+    return {
+      type: "cosmos-sdk/Module",
+      value: Module.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ModuleProtoMsg): Module {
+    return Module.decode(message.value);
+  },
+  toProto(message: Module): Uint8Array {
+    return Module.encode(message).finish();
+  },
+  toProtoMsg(message: Module): ModuleProtoMsg {
+    return {
+      typeUrl: "/cosmos.circuit.module.v1.Module",
+      value: Module.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Module.typeUrl, Module);
+GlobalDecoderRegistry.registerAminoProtoMapping(Module.aminoType, Module.typeUrl);

package/src/cosmos/circuit/v1/query.lcd.ts

@@ -0,0 +1,36 @@
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAccountRequest, AccountResponse, QueryAccountsRequest, AccountsResponse, QueryDisabledListRequest, DisabledListResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* Account returns account permissions. */
+  account = async (params: QueryAccountRequest): Promise<AccountResponse> => {
+    const endpoint = `cosmos/circuit/v1/accounts/${params.address}`;
+    return await this.req.get<AccountResponse>(endpoint);
+  };
+  /* Account returns account permissions. */
+  accounts = async (params: QueryAccountsRequest = {
+    pagination: undefined
+  }): Promise<AccountsResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/circuit/v1/accounts`;
+    return await this.req.get<AccountsResponse>(endpoint, options);
+  };
+  /* DisabledList returns a list of disabled message urls */
+  disabledList = async (_params: QueryDisabledListRequest = {}): Promise<DisabledListResponse> => {
+    const endpoint = `cosmos/circuit/v1/disable_list`;
+    return await this.req.get<DisabledListResponse>(endpoint);
+  };
+}

package/src/cosmos/circuit/v1/query.rpc.Query.ts

@@ -0,0 +1,54 @@
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAccountRequest, AccountResponse, QueryAccountsRequest, AccountsResponse, QueryDisabledListRequest, DisabledListResponse } from "./query";
+/** Query defines the circuit gRPC querier service. */
+export interface Query {
+  /** Account returns account permissions. */
+  account(request: QueryAccountRequest): Promise<AccountResponse>;
+  /** Account returns account permissions. */
+  accounts(request?: QueryAccountsRequest): Promise<AccountsResponse>;
+  /** DisabledList returns a list of disabled message urls */
+  disabledList(request?: QueryDisabledListRequest): Promise<DisabledListResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* Account returns account permissions. */
+  account = async (request: QueryAccountRequest): Promise<AccountResponse> => {
+    const data = QueryAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.circuit.v1.Query", "Account", data);
+    return promise.then(data => AccountResponse.decode(new BinaryReader(data)));
+  };
+  /* Account returns account permissions. */
+  accounts = async (request: QueryAccountsRequest = {
+    pagination: undefined
+  }): Promise<AccountsResponse> => {
+    const data = QueryAccountsRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.circuit.v1.Query", "Accounts", data);
+    return promise.then(data => AccountsResponse.decode(new BinaryReader(data)));
+  };
+  /* DisabledList returns a list of disabled message urls */
+  disabledList = async (request: QueryDisabledListRequest = {}): Promise<DisabledListResponse> => {
+    const data = QueryDisabledListRequest.encode(request).finish();
+    const promise = this.rpc.request("cosmos.circuit.v1.Query", "DisabledList", data);
+    return promise.then(data => DisabledListResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    account(request: QueryAccountRequest): Promise<AccountResponse> {
+      return queryService.account(request);
+    },
+    accounts(request?: QueryAccountsRequest): Promise<AccountsResponse> {
+      return queryService.accounts(request);
+    },
+    disabledList(request?: QueryDisabledListRequest): Promise<DisabledListResponse> {
+      return queryService.disabledList(request);
+    }
+  };
+};

package/src/cosmos/circuit/v1/query.rpc.func.ts

@@ -0,0 +1,23 @@
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { QueryAccountRequest, AccountResponse, QueryAccountsRequest, AccountsResponse, QueryDisabledListRequest, DisabledListResponse } from "./query";
+export const createGetAccount = (clientResolver?: RpcResolver) => buildQuery<QueryAccountRequest, AccountResponse>({
+  encode: QueryAccountRequest.encode,
+  decode: AccountResponse.decode,
+  service: "cosmos.circuit.v1.Query",
+  method: "Account",
+  clientResolver
+});
+export const createGetAccounts = (clientResolver?: RpcResolver) => buildQuery<QueryAccountsRequest, AccountsResponse>({
+  encode: QueryAccountsRequest.encode,
+  decode: AccountsResponse.decode,
+  service: "cosmos.circuit.v1.Query",
+  method: "Accounts",
+  clientResolver
+});
+export const createGetDisabledList = (clientResolver?: RpcResolver) => buildQuery<QueryDisabledListRequest, DisabledListResponse>({
+  encode: QueryDisabledListRequest.encode,
+  decode: DisabledListResponse.decode,
+  service: "cosmos.circuit.v1.Query",
+  method: "DisabledList",
+  clientResolver
+});