@xpla/xpla-react 1.7.0-beta.0

package/src/ibc/applications/interchain_accounts/v1/metadata.ts

@@ -0,0 +1,191 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/**
+ * Metadata defines a set of protocol specific data encoded into the ICS27 channel version bytestring
+ * See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
+ */
+export interface Metadata {
+  /** version defines the ICS27 protocol version */
+  version: string;
+  /** controller_connection_id is the connection identifier associated with the controller chain */
+  controllerConnectionId: string;
+  /** host_connection_id is the connection identifier associated with the host chain */
+  hostConnectionId: string;
+  /**
+   * address defines the interchain account address to be fulfilled upon the OnChanOpenTry handshake step
+   * NOTE: the address field is empty on the OnChanOpenInit handshake step
+   */
+  address: string;
+  /** encoding defines the supported codec format */
+  encoding: string;
+  /** tx_type defines the type of transactions the interchain account can execute */
+  txType: string;
+}
+export interface MetadataProtoMsg {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata";
+  value: Uint8Array;
+}
+/**
+ * Metadata defines a set of protocol specific data encoded into the ICS27 channel version bytestring
+ * See ICS004: https://github.com/cosmos/ibc/tree/master/spec/core/ics-004-channel-and-packet-semantics#Versioning
+ */
+export interface MetadataAmino {
+  /** version defines the ICS27 protocol version */
+  version: string;
+  /** controller_connection_id is the connection identifier associated with the controller chain */
+  controller_connection_id: string;
+  /** host_connection_id is the connection identifier associated with the host chain */
+  host_connection_id: string;
+  /**
+   * address defines the interchain account address to be fulfilled upon the OnChanOpenTry handshake step
+   * NOTE: the address field is empty on the OnChanOpenInit handshake step
+   */
+  address: string;
+  /** encoding defines the supported codec format */
+  encoding: string;
+  /** tx_type defines the type of transactions the interchain account can execute */
+  tx_type: string;
+}
+export interface MetadataAminoMsg {
+  type: "cosmos-sdk/Metadata";
+  value: MetadataAmino;
+}
+function createBaseMetadata(): Metadata {
+  return {
+    version: "",
+    controllerConnectionId: "",
+    hostConnectionId: "",
+    address: "",
+    encoding: "",
+    txType: ""
+  };
+}
+export const Metadata = {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata",
+  aminoType: "cosmos-sdk/Metadata",
+  is(o: any): o is Metadata {
+    return o && (o.$typeUrl === Metadata.typeUrl || typeof o.version === "string" && typeof o.controllerConnectionId === "string" && typeof o.hostConnectionId === "string" && typeof o.address === "string" && typeof o.encoding === "string" && typeof o.txType === "string");
+  },
+  isAmino(o: any): o is MetadataAmino {
+    return o && (o.$typeUrl === Metadata.typeUrl || typeof o.version === "string" && typeof o.controller_connection_id === "string" && typeof o.host_connection_id === "string" && typeof o.address === "string" && typeof o.encoding === "string" && typeof o.tx_type === "string");
+  },
+  encode(message: Metadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.version !== "") {
+      writer.uint32(10).string(message.version);
+    }
+    if (message.controllerConnectionId !== "") {
+      writer.uint32(18).string(message.controllerConnectionId);
+    }
+    if (message.hostConnectionId !== "") {
+      writer.uint32(26).string(message.hostConnectionId);
+    }
+    if (message.address !== "") {
+      writer.uint32(34).string(message.address);
+    }
+    if (message.encoding !== "") {
+      writer.uint32(42).string(message.encoding);
+    }
+    if (message.txType !== "") {
+      writer.uint32(50).string(message.txType);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Metadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.version = reader.string();
+          break;
+        case 2:
+          message.controllerConnectionId = reader.string();
+          break;
+        case 3:
+          message.hostConnectionId = reader.string();
+          break;
+        case 4:
+          message.address = reader.string();
+          break;
+        case 5:
+          message.encoding = reader.string();
+          break;
+        case 6:
+          message.txType = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Metadata>): Metadata {
+    const message = createBaseMetadata();
+    message.version = object.version ?? "";
+    message.controllerConnectionId = object.controllerConnectionId ?? "";
+    message.hostConnectionId = object.hostConnectionId ?? "";
+    message.address = object.address ?? "";
+    message.encoding = object.encoding ?? "";
+    message.txType = object.txType ?? "";
+    return message;
+  },
+  fromAmino(object: MetadataAmino): Metadata {
+    const message = createBaseMetadata();
+    if (object.version !== undefined && object.version !== null) {
+      message.version = object.version;
+    }
+    if (object.controller_connection_id !== undefined && object.controller_connection_id !== null) {
+      message.controllerConnectionId = object.controller_connection_id;
+    }
+    if (object.host_connection_id !== undefined && object.host_connection_id !== null) {
+      message.hostConnectionId = object.host_connection_id;
+    }
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    if (object.encoding !== undefined && object.encoding !== null) {
+      message.encoding = object.encoding;
+    }
+    if (object.tx_type !== undefined && object.tx_type !== null) {
+      message.txType = object.tx_type;
+    }
+    return message;
+  },
+  toAmino(message: Metadata): MetadataAmino {
+    const obj: any = {};
+    obj.version = message.version === "" ? undefined : message.version;
+    obj.controller_connection_id = message.controllerConnectionId === "" ? undefined : message.controllerConnectionId;
+    obj.host_connection_id = message.hostConnectionId === "" ? undefined : message.hostConnectionId;
+    obj.address = message.address === "" ? undefined : message.address;
+    obj.encoding = message.encoding === "" ? undefined : message.encoding;
+    obj.tx_type = message.txType === "" ? undefined : message.txType;
+    return obj;
+  },
+  fromAminoMsg(object: MetadataAminoMsg): Metadata {
+    return Metadata.fromAmino(object.value);
+  },
+  toAminoMsg(message: Metadata): MetadataAminoMsg {
+    return {
+      type: "cosmos-sdk/Metadata",
+      value: Metadata.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: MetadataProtoMsg): Metadata {
+    return Metadata.decode(message.value);
+  },
+  toProto(message: Metadata): Uint8Array {
+    return Metadata.encode(message).finish();
+  },
+  toProtoMsg(message: Metadata): MetadataProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.interchain_accounts.v1.Metadata",
+      value: Metadata.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Metadata.typeUrl, Metadata);
+GlobalDecoderRegistry.registerAminoProtoMapping(Metadata.aminoType, Metadata.typeUrl);

package/src/ibc/applications/interchain_accounts/v1/packet.ts

@@ -0,0 +1,259 @@
+import { Any, AnyAmino } from "../../../../google/protobuf/any";
+import { isSet, DeepPartial, bytesFromBase64, base64FromBytes } from "../../../../helpers";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/**
+ * Type defines a classification of message issued from a controller chain to its associated interchain accounts
+ * host
+ */
+export enum Type {
+  /** TYPE_UNSPECIFIED - Default zero value enumeration */
+  TYPE_UNSPECIFIED = 0,
+  /** TYPE_EXECUTE_TX - Execute a transaction on an interchain accounts host chain */
+  TYPE_EXECUTE_TX = 1,
+  UNRECOGNIZED = -1,
+}
+export const TypeAmino = Type;
+export function typeFromJSON(object: any): Type {
+  switch (object) {
+    case 0:
+    case "TYPE_UNSPECIFIED":
+      return Type.TYPE_UNSPECIFIED;
+    case 1:
+    case "TYPE_EXECUTE_TX":
+      return Type.TYPE_EXECUTE_TX;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Type.UNRECOGNIZED;
+  }
+}
+export function typeToJSON(object: Type): string {
+  switch (object) {
+    case Type.TYPE_UNSPECIFIED:
+      return "TYPE_UNSPECIFIED";
+    case Type.TYPE_EXECUTE_TX:
+      return "TYPE_EXECUTE_TX";
+    case Type.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+/** InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field. */
+export interface InterchainAccountPacketData {
+  type: Type;
+  data: Uint8Array;
+  memo: string;
+}
+export interface InterchainAccountPacketDataProtoMsg {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData";
+  value: Uint8Array;
+}
+/** InterchainAccountPacketData is comprised of a raw transaction, type of transaction and optional memo field. */
+export interface InterchainAccountPacketDataAmino {
+  type: Type;
+  data: string;
+  memo: string;
+}
+export interface InterchainAccountPacketDataAminoMsg {
+  type: "cosmos-sdk/InterchainAccountPacketData";
+  value: InterchainAccountPacketDataAmino;
+}
+/** CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain. */
+export interface CosmosTx {
+  messages: Any[];
+}
+export interface CosmosTxProtoMsg {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.CosmosTx";
+  value: Uint8Array;
+}
+/** CosmosTx contains a list of sdk.Msg's. It should be used when sending transactions to an SDK host chain. */
+export interface CosmosTxAmino {
+  messages: AnyAmino[];
+}
+export interface CosmosTxAminoMsg {
+  type: "cosmos-sdk/CosmosTx";
+  value: CosmosTxAmino;
+}
+function createBaseInterchainAccountPacketData(): InterchainAccountPacketData {
+  return {
+    type: 0,
+    data: new Uint8Array(),
+    memo: ""
+  };
+}
+export const InterchainAccountPacketData = {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData",
+  aminoType: "cosmos-sdk/InterchainAccountPacketData",
+  is(o: any): o is InterchainAccountPacketData {
+    return o && (o.$typeUrl === InterchainAccountPacketData.typeUrl || isSet(o.type) && (o.data instanceof Uint8Array || typeof o.data === "string") && typeof o.memo === "string");
+  },
+  isAmino(o: any): o is InterchainAccountPacketDataAmino {
+    return o && (o.$typeUrl === InterchainAccountPacketData.typeUrl || isSet(o.type) && (o.data instanceof Uint8Array || typeof o.data === "string") && typeof o.memo === "string");
+  },
+  encode(message: InterchainAccountPacketData, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(18).bytes(message.data);
+    }
+    if (message.memo !== "") {
+      writer.uint32(26).string(message.memo);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): InterchainAccountPacketData {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseInterchainAccountPacketData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.type = reader.int32() as any;
+          break;
+        case 2:
+          message.data = reader.bytes();
+          break;
+        case 3:
+          message.memo = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<InterchainAccountPacketData>): InterchainAccountPacketData {
+    const message = createBaseInterchainAccountPacketData();
+    message.type = object.type ?? 0;
+    message.data = object.data ?? new Uint8Array();
+    message.memo = object.memo ?? "";
+    return message;
+  },
+  fromAmino(object: InterchainAccountPacketDataAmino): InterchainAccountPacketData {
+    const message = createBaseInterchainAccountPacketData();
+    if (object.type !== undefined && object.type !== null) {
+      message.type = object.type;
+    }
+    if (object.data !== undefined && object.data !== null) {
+      message.data = bytesFromBase64(object.data);
+    }
+    if (object.memo !== undefined && object.memo !== null) {
+      message.memo = object.memo;
+    }
+    return message;
+  },
+  toAmino(message: InterchainAccountPacketData): InterchainAccountPacketDataAmino {
+    const obj: any = {};
+    obj.type = message.type === 0 ? undefined : message.type;
+    obj.data = message.data ? base64FromBytes(message.data) : undefined;
+    obj.memo = message.memo === "" ? undefined : message.memo;
+    return obj;
+  },
+  fromAminoMsg(object: InterchainAccountPacketDataAminoMsg): InterchainAccountPacketData {
+    return InterchainAccountPacketData.fromAmino(object.value);
+  },
+  toAminoMsg(message: InterchainAccountPacketData): InterchainAccountPacketDataAminoMsg {
+    return {
+      type: "cosmos-sdk/InterchainAccountPacketData",
+      value: InterchainAccountPacketData.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: InterchainAccountPacketDataProtoMsg): InterchainAccountPacketData {
+    return InterchainAccountPacketData.decode(message.value);
+  },
+  toProto(message: InterchainAccountPacketData): Uint8Array {
+    return InterchainAccountPacketData.encode(message).finish();
+  },
+  toProtoMsg(message: InterchainAccountPacketData): InterchainAccountPacketDataProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.interchain_accounts.v1.InterchainAccountPacketData",
+      value: InterchainAccountPacketData.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(InterchainAccountPacketData.typeUrl, InterchainAccountPacketData);
+GlobalDecoderRegistry.registerAminoProtoMapping(InterchainAccountPacketData.aminoType, InterchainAccountPacketData.typeUrl);
+function createBaseCosmosTx(): CosmosTx {
+  return {
+    messages: []
+  };
+}
+export const CosmosTx = {
+  typeUrl: "/ibc.applications.interchain_accounts.v1.CosmosTx",
+  aminoType: "cosmos-sdk/CosmosTx",
+  is(o: any): o is CosmosTx {
+    return o && (o.$typeUrl === CosmosTx.typeUrl || Array.isArray(o.messages) && (!o.messages.length || Any.is(o.messages[0])));
+  },
+  isAmino(o: any): o is CosmosTxAmino {
+    return o && (o.$typeUrl === CosmosTx.typeUrl || Array.isArray(o.messages) && (!o.messages.length || Any.isAmino(o.messages[0])));
+  },
+  encode(message: CosmosTx, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    for (const v of message.messages) {
+      Any.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): CosmosTx {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCosmosTx();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.messages.push(Any.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<CosmosTx>): CosmosTx {
+    const message = createBaseCosmosTx();
+    message.messages = object.messages?.map(e => Any.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: CosmosTxAmino): CosmosTx {
+    const message = createBaseCosmosTx();
+    message.messages = object.messages?.map(e => Any.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: CosmosTx): CosmosTxAmino {
+    const obj: any = {};
+    if (message.messages) {
+      obj.messages = message.messages.map(e => e ? Any.toAmino(e) : undefined);
+    } else {
+      obj.messages = message.messages;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: CosmosTxAminoMsg): CosmosTx {
+    return CosmosTx.fromAmino(object.value);
+  },
+  toAminoMsg(message: CosmosTx): CosmosTxAminoMsg {
+    return {
+      type: "cosmos-sdk/CosmosTx",
+      value: CosmosTx.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: CosmosTxProtoMsg): CosmosTx {
+    return CosmosTx.decode(message.value);
+  },
+  toProto(message: CosmosTx): Uint8Array {
+    return CosmosTx.encode(message).finish();
+  },
+  toProtoMsg(message: CosmosTx): CosmosTxProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.interchain_accounts.v1.CosmosTx",
+      value: CosmosTx.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(CosmosTx.typeUrl, CosmosTx);
+GlobalDecoderRegistry.registerAminoProtoMapping(CosmosTx.aminoType, CosmosTx.typeUrl);