@burnt-labs/xion-types 0.0.1-test.1762962136

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

@@ -0,0 +1,100 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** 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.
+ * @name ModuleAmino
+ * @package cosmos.circuit.module.v1
+ * @see proto type: cosmos.circuit.module.v1.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;
+}
+/** Module is the config object of the circuit module. */
+export interface ModuleSDKType {
+  authority: string;
+}
+function createBaseModule(): Module {
+  return {
+    authority: ""
+  };
+}
+export const Module = {
+  typeUrl: "/cosmos.circuit.module.v1.Module",
+  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: Partial<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()
+    };
+  }
+};

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

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

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

@@ -0,0 +1,55 @@
+//@ts-nocheck
+import { Rpc } from "../../../helpers";
+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: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.account = this.account.bind(this);
+    this.accounts = this.accounts.bind(this);
+    this.disabledList = this.disabledList.bind(this);
+  }
+  account(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)));
+  }
+  accounts(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(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);
+    }
+  };
+};