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

package/types/ibc/core/client/v2/config.ts

@@ -0,0 +1,115 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/**
+ * Config is a **per-client** configuration struct that sets which relayers are allowed to relay v2 IBC messages
+ * for a given client.
+ * If it is set, then only relayers in the allow list can send v2 messages
+ * If it is not set, then the client allows permissionless relaying of v2 messages
+ */
+export interface Config {
+  /** allowed_relayers defines the set of allowed relayers for IBC V2 protocol for the given client */
+  allowedRelayers: string[];
+}
+export interface ConfigProtoMsg {
+  typeUrl: "/ibc.core.client.v2.Config";
+  value: Uint8Array;
+}
+/**
+ * Config is a **per-client** configuration struct that sets which relayers are allowed to relay v2 IBC messages
+ * for a given client.
+ * If it is set, then only relayers in the allow list can send v2 messages
+ * If it is not set, then the client allows permissionless relaying of v2 messages
+ * @name ConfigAmino
+ * @package ibc.core.client.v2
+ * @see proto type: ibc.core.client.v2.Config
+ */
+export interface ConfigAmino {
+  /**
+   * allowed_relayers defines the set of allowed relayers for IBC V2 protocol for the given client
+   */
+  allowed_relayers?: string[];
+}
+export interface ConfigAminoMsg {
+  type: "cosmos-sdk/Config";
+  value: ConfigAmino;
+}
+/**
+ * Config is a **per-client** configuration struct that sets which relayers are allowed to relay v2 IBC messages
+ * for a given client.
+ * If it is set, then only relayers in the allow list can send v2 messages
+ * If it is not set, then the client allows permissionless relaying of v2 messages
+ */
+export interface ConfigSDKType {
+  allowed_relayers: string[];
+}
+function createBaseConfig(): Config {
+  return {
+    allowedRelayers: []
+  };
+}
+export const Config = {
+  typeUrl: "/ibc.core.client.v2.Config",
+  encode(message: Config, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.allowedRelayers) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Config {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.allowedRelayers.push(reader.string());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Config>): Config {
+    const message = createBaseConfig();
+    message.allowedRelayers = object.allowedRelayers?.map(e => e) || [];
+    return message;
+  },
+  fromAmino(object: ConfigAmino): Config {
+    const message = createBaseConfig();
+    message.allowedRelayers = object.allowed_relayers?.map(e => e) || [];
+    return message;
+  },
+  toAmino(message: Config): ConfigAmino {
+    const obj: any = {};
+    if (message.allowedRelayers) {
+      obj.allowed_relayers = message.allowedRelayers.map(e => e);
+    } else {
+      obj.allowed_relayers = message.allowedRelayers;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: ConfigAminoMsg): Config {
+    return Config.fromAmino(object.value);
+  },
+  toAminoMsg(message: Config): ConfigAminoMsg {
+    return {
+      type: "cosmos-sdk/Config",
+      value: Config.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ConfigProtoMsg): Config {
+    return Config.decode(message.value);
+  },
+  toProto(message: Config): Uint8Array {
+    return Config.encode(message).finish();
+  },
+  toProtoMsg(message: Config): ConfigProtoMsg {
+    return {
+      typeUrl: "/ibc.core.client.v2.Config",
+      value: Config.encode(message).finish()
+    };
+  }
+};

package/types/ibc/core/client/v2/counterparty.ts

@@ -0,0 +1,122 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+/** CounterpartyInfo defines the key that the counterparty will use to message our client */
+export interface CounterpartyInfo {
+  /** merkle prefix key is the prefix that ics provable keys are stored under */
+  merklePrefix: Uint8Array[];
+  /** client identifier is the identifier used to send packet messages to our client */
+  clientId: string;
+}
+export interface CounterpartyInfoProtoMsg {
+  typeUrl: "/ibc.core.client.v2.CounterpartyInfo";
+  value: Uint8Array;
+}
+/**
+ * CounterpartyInfo defines the key that the counterparty will use to message our client
+ * @name CounterpartyInfoAmino
+ * @package ibc.core.client.v2
+ * @see proto type: ibc.core.client.v2.CounterpartyInfo
+ */
+export interface CounterpartyInfoAmino {
+  /**
+   * merkle prefix key is the prefix that ics provable keys are stored under
+   */
+  merkle_prefix?: string[];
+  /**
+   * client identifier is the identifier used to send packet messages to our client
+   */
+  client_id?: string;
+}
+export interface CounterpartyInfoAminoMsg {
+  type: "cosmos-sdk/CounterpartyInfo";
+  value: CounterpartyInfoAmino;
+}
+/** CounterpartyInfo defines the key that the counterparty will use to message our client */
+export interface CounterpartyInfoSDKType {
+  merkle_prefix: Uint8Array[];
+  client_id: string;
+}
+function createBaseCounterpartyInfo(): CounterpartyInfo {
+  return {
+    merklePrefix: [],
+    clientId: ""
+  };
+}
+export const CounterpartyInfo = {
+  typeUrl: "/ibc.core.client.v2.CounterpartyInfo",
+  encode(message: CounterpartyInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.merklePrefix) {
+      writer.uint32(10).bytes(v!);
+    }
+    if (message.clientId !== "") {
+      writer.uint32(18).string(message.clientId);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CounterpartyInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCounterpartyInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.merklePrefix.push(reader.bytes());
+          break;
+        case 2:
+          message.clientId = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<CounterpartyInfo>): CounterpartyInfo {
+    const message = createBaseCounterpartyInfo();
+    message.merklePrefix = object.merklePrefix?.map(e => e) || [];
+    message.clientId = object.clientId ?? "";
+    return message;
+  },
+  fromAmino(object: CounterpartyInfoAmino): CounterpartyInfo {
+    const message = createBaseCounterpartyInfo();
+    message.merklePrefix = object.merkle_prefix?.map(e => bytesFromBase64(e)) || [];
+    if (object.client_id !== undefined && object.client_id !== null) {
+      message.clientId = object.client_id;
+    }
+    return message;
+  },
+  toAmino(message: CounterpartyInfo): CounterpartyInfoAmino {
+    const obj: any = {};
+    if (message.merklePrefix) {
+      obj.merkle_prefix = message.merklePrefix.map(e => base64FromBytes(e));
+    } else {
+      obj.merkle_prefix = message.merklePrefix;
+    }
+    obj.client_id = message.clientId === "" ? undefined : message.clientId;
+    return obj;
+  },
+  fromAminoMsg(object: CounterpartyInfoAminoMsg): CounterpartyInfo {
+    return CounterpartyInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message: CounterpartyInfo): CounterpartyInfoAminoMsg {
+    return {
+      type: "cosmos-sdk/CounterpartyInfo",
+      value: CounterpartyInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CounterpartyInfoProtoMsg): CounterpartyInfo {
+    return CounterpartyInfo.decode(message.value);
+  },
+  toProto(message: CounterpartyInfo): Uint8Array {
+    return CounterpartyInfo.encode(message).finish();
+  },
+  toProtoMsg(message: CounterpartyInfo): CounterpartyInfoProtoMsg {
+    return {
+      typeUrl: "/ibc.core.client.v2.CounterpartyInfo",
+      value: CounterpartyInfo.encode(message).finish()
+    };
+  }
+};

package/types/ibc/core/client/v2/genesis.ts

@@ -0,0 +1,220 @@
+//@ts-nocheck
+import { CounterpartyInfo, CounterpartyInfoAmino, CounterpartyInfoSDKType } from "./counterparty";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+/** GenesisCounterpartyInfo defines the state associating a client with a counterparty. */
+export interface GenesisCounterpartyInfo {
+  /** ClientId is the ID of the given client. */
+  clientId: string;
+  /** CounterpartyInfo is the counterparty info of the given client. */
+  counterpartyInfo: CounterpartyInfo;
+}
+export interface GenesisCounterpartyInfoProtoMsg {
+  typeUrl: "/ibc.core.client.v2.GenesisCounterpartyInfo";
+  value: Uint8Array;
+}
+/**
+ * GenesisCounterpartyInfo defines the state associating a client with a counterparty.
+ * @name GenesisCounterpartyInfoAmino
+ * @package ibc.core.client.v2
+ * @see proto type: ibc.core.client.v2.GenesisCounterpartyInfo
+ */
+export interface GenesisCounterpartyInfoAmino {
+  /**
+   * ClientId is the ID of the given client.
+   */
+  client_id?: string;
+  /**
+   * CounterpartyInfo is the counterparty info of the given client.
+   */
+  counterparty_info?: CounterpartyInfoAmino;
+}
+export interface GenesisCounterpartyInfoAminoMsg {
+  type: "cosmos-sdk/GenesisCounterpartyInfo";
+  value: GenesisCounterpartyInfoAmino;
+}
+/** GenesisCounterpartyInfo defines the state associating a client with a counterparty. */
+export interface GenesisCounterpartyInfoSDKType {
+  client_id: string;
+  counterparty_info: CounterpartyInfoSDKType;
+}
+/** GenesisState defines the ibc client v2 submodule's genesis state. */
+export interface GenesisState {
+  /** counterparty info for each client */
+  counterpartyInfos: GenesisCounterpartyInfo[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/ibc.core.client.v2.GenesisState";
+  value: Uint8Array;
+}
+/**
+ * GenesisState defines the ibc client v2 submodule's genesis state.
+ * @name GenesisStateAmino
+ * @package ibc.core.client.v2
+ * @see proto type: ibc.core.client.v2.GenesisState
+ */
+export interface GenesisStateAmino {
+  /**
+   * counterparty info for each client
+   */
+  counterparty_infos?: GenesisCounterpartyInfoAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the ibc client v2 submodule's genesis state. */
+export interface GenesisStateSDKType {
+  counterparty_infos: GenesisCounterpartyInfoSDKType[];
+}
+function createBaseGenesisCounterpartyInfo(): GenesisCounterpartyInfo {
+  return {
+    clientId: "",
+    counterpartyInfo: CounterpartyInfo.fromPartial({})
+  };
+}
+export const GenesisCounterpartyInfo = {
+  typeUrl: "/ibc.core.client.v2.GenesisCounterpartyInfo",
+  encode(message: GenesisCounterpartyInfo, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.clientId !== "") {
+      writer.uint32(10).string(message.clientId);
+    }
+    if (message.counterpartyInfo !== undefined) {
+      CounterpartyInfo.encode(message.counterpartyInfo, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisCounterpartyInfo {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisCounterpartyInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.clientId = reader.string();
+          break;
+        case 2:
+          message.counterpartyInfo = CounterpartyInfo.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisCounterpartyInfo>): GenesisCounterpartyInfo {
+    const message = createBaseGenesisCounterpartyInfo();
+    message.clientId = object.clientId ?? "";
+    message.counterpartyInfo = object.counterpartyInfo !== undefined && object.counterpartyInfo !== null ? CounterpartyInfo.fromPartial(object.counterpartyInfo) : undefined;
+    return message;
+  },
+  fromAmino(object: GenesisCounterpartyInfoAmino): GenesisCounterpartyInfo {
+    const message = createBaseGenesisCounterpartyInfo();
+    if (object.client_id !== undefined && object.client_id !== null) {
+      message.clientId = object.client_id;
+    }
+    if (object.counterparty_info !== undefined && object.counterparty_info !== null) {
+      message.counterpartyInfo = CounterpartyInfo.fromAmino(object.counterparty_info);
+    }
+    return message;
+  },
+  toAmino(message: GenesisCounterpartyInfo): GenesisCounterpartyInfoAmino {
+    const obj: any = {};
+    obj.client_id = message.clientId === "" ? undefined : message.clientId;
+    obj.counterparty_info = message.counterpartyInfo ? CounterpartyInfo.toAmino(message.counterpartyInfo) : undefined;
+    return obj;
+  },
+  fromAminoMsg(object: GenesisCounterpartyInfoAminoMsg): GenesisCounterpartyInfo {
+    return GenesisCounterpartyInfo.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisCounterpartyInfo): GenesisCounterpartyInfoAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisCounterpartyInfo",
+      value: GenesisCounterpartyInfo.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisCounterpartyInfoProtoMsg): GenesisCounterpartyInfo {
+    return GenesisCounterpartyInfo.decode(message.value);
+  },
+  toProto(message: GenesisCounterpartyInfo): Uint8Array {
+    return GenesisCounterpartyInfo.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisCounterpartyInfo): GenesisCounterpartyInfoProtoMsg {
+    return {
+      typeUrl: "/ibc.core.client.v2.GenesisCounterpartyInfo",
+      value: GenesisCounterpartyInfo.encode(message).finish()
+    };
+  }
+};
+function createBaseGenesisState(): GenesisState {
+  return {
+    counterpartyInfos: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/ibc.core.client.v2.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.counterpartyInfos) {
+      GenesisCounterpartyInfo.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.counterpartyInfos.push(GenesisCounterpartyInfo.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.counterpartyInfos = object.counterpartyInfos?.map(e => GenesisCounterpartyInfo.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    message.counterpartyInfos = object.counterparty_infos?.map(e => GenesisCounterpartyInfo.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    if (message.counterpartyInfos) {
+      obj.counterparty_infos = message.counterpartyInfos.map(e => e ? GenesisCounterpartyInfo.toAmino(e) : undefined);
+    } else {
+      obj.counterparty_infos = message.counterpartyInfos;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/ibc.core.client.v2.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};

package/types/ibc/core/client/v2/query.lcd.ts

@@ -0,0 +1,25 @@
+//@ts-nocheck
+import { LCDClient } from "@cosmology/lcd";
+import { QueryCounterpartyInfoRequest, QueryCounterpartyInfoResponseSDKType, QueryConfigRequest, QueryConfigResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.counterpartyInfo = this.counterpartyInfo.bind(this);
+    this.config = this.config.bind(this);
+  }
+  /* CounterpartyInfo queries an IBC light counter party info. */
+  async counterpartyInfo(params: QueryCounterpartyInfoRequest): Promise<QueryCounterpartyInfoResponseSDKType> {
+    const endpoint = `ibc/core/client/v2/counterparty_info/${params.clientId}`;
+    return await this.req.get<QueryCounterpartyInfoResponseSDKType>(endpoint);
+  }
+  /* Config queries the IBC client v2 configuration for a given client. */
+  async config(params: QueryConfigRequest): Promise<QueryConfigResponseSDKType> {
+    const endpoint = `ibc/core/client/v2/config/${params.clientId}`;
+    return await this.req.get<QueryConfigResponseSDKType>(endpoint);
+  }
+}

package/types/ibc/core/client/v2/query.rpc.Query.ts

@@ -0,0 +1,42 @@
+//@ts-nocheck
+import { Rpc } from "../../../../helpers";
+import { BinaryReader } from "../../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryCounterpartyInfoRequest, QueryCounterpartyInfoResponse, QueryConfigRequest, QueryConfigResponse } from "./query";
+/** Query provides defines the gRPC querier service */
+export interface Query {
+  /** CounterpartyInfo queries an IBC light counter party info. */
+  counterpartyInfo(request: QueryCounterpartyInfoRequest): Promise<QueryCounterpartyInfoResponse>;
+  /** Config queries the IBC client v2 configuration for a given client. */
+  config(request: QueryConfigRequest): Promise<QueryConfigResponse>;
+}
+export class QueryClientImpl implements Query {
+  private readonly rpc: Rpc;
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.counterpartyInfo = this.counterpartyInfo.bind(this);
+    this.config = this.config.bind(this);
+  }
+  counterpartyInfo(request: QueryCounterpartyInfoRequest): Promise<QueryCounterpartyInfoResponse> {
+    const data = QueryCounterpartyInfoRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v2.Query", "CounterpartyInfo", data);
+    return promise.then(data => QueryCounterpartyInfoResponse.decode(new BinaryReader(data)));
+  }
+  config(request: QueryConfigRequest): Promise<QueryConfigResponse> {
+    const data = QueryConfigRequest.encode(request).finish();
+    const promise = this.rpc.request("ibc.core.client.v2.Query", "Config", data);
+    return promise.then(data => QueryConfigResponse.decode(new BinaryReader(data)));
+  }
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    counterpartyInfo(request: QueryCounterpartyInfoRequest): Promise<QueryCounterpartyInfoResponse> {
+      return queryService.counterpartyInfo(request);
+    },
+    config(request: QueryConfigRequest): Promise<QueryConfigResponse> {
+      return queryService.config(request);
+    }
+  };
+};