@xpla/xpla-react 1.7.0-beta.0

package/src/ibc/applications/transfer/v1/transfer.ts

@@ -0,0 +1,261 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+export interface DenomTrace {
+  /**
+   * path defines the chain of port/channel identifiers used for tracing the
+   * source of the fungible token.
+   */
+  path: string;
+  /** base denomination of the relayed fungible token. */
+  baseDenom: string;
+}
+export interface DenomTraceProtoMsg {
+  typeUrl: "/ibc.applications.transfer.v1.DenomTrace";
+  value: Uint8Array;
+}
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+export interface DenomTraceAmino {
+  /**
+   * path defines the chain of port/channel identifiers used for tracing the
+   * source of the fungible token.
+   */
+  path: string;
+  /** base denomination of the relayed fungible token. */
+  base_denom: string;
+}
+export interface DenomTraceAminoMsg {
+  type: "cosmos-sdk/DenomTrace";
+  value: DenomTraceAmino;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+export interface Params {
+  /**
+   * send_enabled enables or disables all cross-chain token transfers from this
+   * chain.
+   */
+  sendEnabled: boolean;
+  /**
+   * receive_enabled enables or disables all cross-chain token transfers to this
+   * chain.
+   */
+  receiveEnabled: boolean;
+}
+export interface ParamsProtoMsg {
+  typeUrl: "/ibc.applications.transfer.v1.Params";
+  value: Uint8Array;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+export interface ParamsAmino {
+  /**
+   * send_enabled enables or disables all cross-chain token transfers from this
+   * chain.
+   */
+  send_enabled: boolean;
+  /**
+   * receive_enabled enables or disables all cross-chain token transfers to this
+   * chain.
+   */
+  receive_enabled: boolean;
+}
+export interface ParamsAminoMsg {
+  type: "cosmos-sdk/Params";
+  value: ParamsAmino;
+}
+function createBaseDenomTrace(): DenomTrace {
+  return {
+    path: "",
+    baseDenom: ""
+  };
+}
+export const DenomTrace = {
+  typeUrl: "/ibc.applications.transfer.v1.DenomTrace",
+  aminoType: "cosmos-sdk/DenomTrace",
+  is(o: any): o is DenomTrace {
+    return o && (o.$typeUrl === DenomTrace.typeUrl || typeof o.path === "string" && typeof o.baseDenom === "string");
+  },
+  isAmino(o: any): o is DenomTraceAmino {
+    return o && (o.$typeUrl === DenomTrace.typeUrl || typeof o.path === "string" && typeof o.base_denom === "string");
+  },
+  encode(message: DenomTrace, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.path !== "") {
+      writer.uint32(10).string(message.path);
+    }
+    if (message.baseDenom !== "") {
+      writer.uint32(18).string(message.baseDenom);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): DenomTrace {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDenomTrace();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.path = reader.string();
+          break;
+        case 2:
+          message.baseDenom = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<DenomTrace>): DenomTrace {
+    const message = createBaseDenomTrace();
+    message.path = object.path ?? "";
+    message.baseDenom = object.baseDenom ?? "";
+    return message;
+  },
+  fromAmino(object: DenomTraceAmino): DenomTrace {
+    const message = createBaseDenomTrace();
+    if (object.path !== undefined && object.path !== null) {
+      message.path = object.path;
+    }
+    if (object.base_denom !== undefined && object.base_denom !== null) {
+      message.baseDenom = object.base_denom;
+    }
+    return message;
+  },
+  toAmino(message: DenomTrace): DenomTraceAmino {
+    const obj: any = {};
+    obj.path = message.path === "" ? undefined : message.path;
+    obj.base_denom = message.baseDenom === "" ? undefined : message.baseDenom;
+    return obj;
+  },
+  fromAminoMsg(object: DenomTraceAminoMsg): DenomTrace {
+    return DenomTrace.fromAmino(object.value);
+  },
+  toAminoMsg(message: DenomTrace): DenomTraceAminoMsg {
+    return {
+      type: "cosmos-sdk/DenomTrace",
+      value: DenomTrace.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: DenomTraceProtoMsg): DenomTrace {
+    return DenomTrace.decode(message.value);
+  },
+  toProto(message: DenomTrace): Uint8Array {
+    return DenomTrace.encode(message).finish();
+  },
+  toProtoMsg(message: DenomTrace): DenomTraceProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.transfer.v1.DenomTrace",
+      value: DenomTrace.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(DenomTrace.typeUrl, DenomTrace);
+GlobalDecoderRegistry.registerAminoProtoMapping(DenomTrace.aminoType, DenomTrace.typeUrl);
+function createBaseParams(): Params {
+  return {
+    sendEnabled: false,
+    receiveEnabled: false
+  };
+}
+export const Params = {
+  typeUrl: "/ibc.applications.transfer.v1.Params",
+  aminoType: "cosmos-sdk/Params",
+  is(o: any): o is Params {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.sendEnabled === "boolean" && typeof o.receiveEnabled === "boolean");
+  },
+  isAmino(o: any): o is ParamsAmino {
+    return o && (o.$typeUrl === Params.typeUrl || typeof o.send_enabled === "boolean" && typeof o.receive_enabled === "boolean");
+  },
+  encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.sendEnabled === true) {
+      writer.uint32(8).bool(message.sendEnabled);
+    }
+    if (message.receiveEnabled === true) {
+      writer.uint32(16).bool(message.receiveEnabled);
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Params {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseParams();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.sendEnabled = reader.bool();
+          break;
+        case 2:
+          message.receiveEnabled = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: DeepPartial<Params>): Params {
+    const message = createBaseParams();
+    message.sendEnabled = object.sendEnabled ?? false;
+    message.receiveEnabled = object.receiveEnabled ?? false;
+    return message;
+  },
+  fromAmino(object: ParamsAmino): Params {
+    const message = createBaseParams();
+    if (object.send_enabled !== undefined && object.send_enabled !== null) {
+      message.sendEnabled = object.send_enabled;
+    }
+    if (object.receive_enabled !== undefined && object.receive_enabled !== null) {
+      message.receiveEnabled = object.receive_enabled;
+    }
+    return message;
+  },
+  toAmino(message: Params): ParamsAmino {
+    const obj: any = {};
+    obj.send_enabled = message.sendEnabled === false ? undefined : message.sendEnabled;
+    obj.receive_enabled = message.receiveEnabled === false ? undefined : message.receiveEnabled;
+    return obj;
+  },
+  fromAminoMsg(object: ParamsAminoMsg): Params {
+    return Params.fromAmino(object.value);
+  },
+  toAminoMsg(message: Params): ParamsAminoMsg {
+    return {
+      type: "cosmos-sdk/Params",
+      value: Params.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: ParamsProtoMsg): Params {
+    return Params.decode(message.value);
+  },
+  toProto(message: Params): Uint8Array {
+    return Params.encode(message).finish();
+  },
+  toProtoMsg(message: Params): ParamsProtoMsg {
+    return {
+      typeUrl: "/ibc.applications.transfer.v1.Params",
+      value: Params.encode(message).finish()
+    };
+  }
+};
+GlobalDecoderRegistry.register(Params.typeUrl, Params);
+GlobalDecoderRegistry.registerAminoProtoMapping(Params.aminoType, Params.typeUrl);

package/src/ibc/applications/transfer/v1/tx.registry.ts

@@ -0,0 +1,47 @@
+import { TelescopeGeneratedType } from "../../../../types";
+import { MsgTransfer, MsgUpdateParams } from "./tx";
+export const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]> = [["/ibc.applications.transfer.v1.MsgTransfer", MsgTransfer], ["/ibc.applications.transfer.v1.MsgUpdateParams", MsgUpdateParams]];
+export const MessageComposer = {
+  encoded: {
+    transfer(value: MsgTransfer) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+        value: MsgTransfer.encode(value).finish()
+      };
+    },
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParams",
+        value: MsgUpdateParams.encode(value).finish()
+      };
+    }
+  },
+  withTypeUrl: {
+    transfer(value: MsgTransfer) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+        value
+      };
+    },
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParams",
+        value
+      };
+    }
+  },
+  fromPartial: {
+    transfer(value: MsgTransfer) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgTransfer",
+        value: MsgTransfer.fromPartial(value)
+      };
+    },
+    updateParams(value: MsgUpdateParams) {
+      return {
+        typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParams",
+        value: MsgUpdateParams.fromPartial(value)
+      };
+    }
+  }
+};

package/src/ibc/applications/transfer/v1/tx.rpc.func.ts

@@ -0,0 +1,22 @@
+import { buildTx, SigningClientResolver } from "../../../../helper-func-types";
+import { buildUseMutation } from "../../../../react-query";
+import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
+import { MsgTransfer, MsgUpdateParams } from "./tx";
+export const createTransfer = (clientResolver?: SigningClientResolver) => buildTx<MsgTransfer>({
+  clientResolver,
+  typeUrl: MsgTransfer.typeUrl,
+  encoders: toEncoders(MsgTransfer),
+  converters: toConverters(MsgTransfer)
+});
+export const useTransfer = buildUseMutation<MsgTransfer, Error>({
+  builderMutationFn: createTransfer
+});
+export const createUpdateParams = (clientResolver?: SigningClientResolver) => buildTx<MsgUpdateParams>({
+  clientResolver,
+  typeUrl: MsgUpdateParams.typeUrl,
+  encoders: toEncoders(MsgUpdateParams),
+  converters: toConverters(MsgUpdateParams)
+});
+export const useUpdateParams = buildUseMutation<MsgUpdateParams, Error>({
+  builderMutationFn: createUpdateParams
+});