juno-network 0.15.1 → 0.17.0

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

@@ -1,10 +1,8 @@
-import * as _m0 from "protobufjs/minimal";
-import { DeepPartial } from "../../../../helpers";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
 /**
  * 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
@@ -12,22 +10,35 @@ export interface DenomTrace {
    */
   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 DenomTraceSDKType {
+export interface DenomTraceAmino {
   /**
    * path defines the chain of port/channel identifiers used for tracing the
    * source of the fungible token.
    */
-  path: string;
+  path?: string;
   /** base denomination of the relayed fungible token. */
-
+  base_denom?: string;
+}
+export interface DenomTraceAminoMsg {
+  type: "cosmos-sdk/DenomTrace";
+  value: DenomTraceAmino;
+}
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+export interface DenomTraceSDKType {
+  path: string;
   base_denom: string;
 }
 /**
@@ -36,7 +47,6 @@ export interface DenomTraceSDKType {
  * 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
@@ -47,136 +57,203 @@ export interface Params {
    * 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 ParamsSDKType {
+export interface ParamsAmino {
   /**
    * send_enabled enables or disables all cross-chain token transfers from this
    * chain.
    */
-  send_enabled: boolean;
+  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;
+}
+/**
+ * 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 ParamsSDKType {
+  send_enabled: boolean;
   receive_enabled: boolean;
 }
-
 function createBaseDenomTrace(): DenomTrace {
   return {
     path: "",
     baseDenom: ""
   };
 }
-
 export const DenomTrace = {
-  encode(message: DenomTrace, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/ibc.applications.transfer.v1.DenomTrace",
+  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: _m0.Reader | Uint8Array, length?: number): DenomTrace {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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 {
+  fromPartial(object: Partial<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;
+    obj.base_denom = 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()
+    };
   }
-
 };
-
 function createBaseParams(): Params {
   return {
     sendEnabled: false,
     receiveEnabled: false
   };
 }
-
 export const Params = {
-  encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  typeUrl: "/ibc.applications.transfer.v1.Params",
+  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: _m0.Reader | Uint8Array, length?: number): Params {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  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 {
+  fromPartial(object: Partial<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;
+    obj.receive_enabled = 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()
+    };
   }
-
 };

package/src/codegen/ibc/applications/transfer/v1/tx.amino.ts

@@ -1,73 +1,8 @@
-import { AminoMsg } from "@cosmjs/amino";
-import { AminoHeight, Long, omitDefault } from "../../../../helpers";
 import { MsgTransfer } from "./tx";
-export interface AminoMsgTransfer extends AminoMsg {
-  type: "cosmos-sdk/MsgTransfer";
-  value: {
-    source_port: string;
-    source_channel: string;
-    token: {
-      denom: string;
-      amount: string;
-    };
-    sender: string;
-    receiver: string;
-    timeout_height: AminoHeight;
-    timeout_timestamp: string;
-  };
-}
 export const AminoConverter = {
   "/ibc.applications.transfer.v1.MsgTransfer": {
     aminoType: "cosmos-sdk/MsgTransfer",
-    toAmino: ({
-      sourcePort,
-      sourceChannel,
-      token,
-      sender,
-      receiver,
-      timeoutHeight,
-      timeoutTimestamp
-    }: MsgTransfer): AminoMsgTransfer["value"] => {
-      return {
-        source_port: sourcePort,
-        source_channel: sourceChannel,
-        token: {
-          denom: token.denom,
-          amount: Long.fromValue(token.amount).toString()
-        },
-        sender,
-        receiver,
-        timeout_height: timeoutHeight ? {
-          revision_height: omitDefault(timeoutHeight.revisionHeight)?.toString(),
-          revision_number: omitDefault(timeoutHeight.revisionNumber)?.toString()
-        } : {},
-        timeout_timestamp: timeoutTimestamp.toString()
-      };
-    },
-    fromAmino: ({
-      source_port,
-      source_channel,
-      token,
-      sender,
-      receiver,
-      timeout_height,
-      timeout_timestamp
-    }: AminoMsgTransfer["value"]): MsgTransfer => {
-      return {
-        sourcePort: source_port,
-        sourceChannel: source_channel,
-        token: {
-          denom: token.denom,
-          amount: token.amount
-        },
-        sender,
-        receiver,
-        timeoutHeight: timeout_height ? {
-          revisionHeight: Long.fromString(timeout_height.revision_height || "0", true),
-          revisionNumber: Long.fromString(timeout_height.revision_number || "0", true)
-        } : undefined,
-        timeoutTimestamp: Long.fromString(timeout_timestamp)
-      };
-    }
+    toAmino: MsgTransfer.toAmino,
+    fromAmino: MsgTransfer.fromAmino
   }
 };

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

@@ -14,7 +14,6 @@ export const MessageComposer = {
         value: MsgTransfer.encode(value).finish()
       };
     }
-
   },
   withTypeUrl: {
     transfer(value: MsgTransfer) {
@@ -23,7 +22,6 @@ export const MessageComposer = {
         value
       };
     }
-
   },
   fromPartial: {
     transfer(value: MsgTransfer) {
@@ -32,6 +30,5 @@ export const MessageComposer = {
         value: MsgTransfer.fromPartial(value)
       };
     }
-
   }
 };

package/src/codegen/ibc/applications/transfer/v1/tx.rpc.msg.ts

@@ -1,24 +1,20 @@
 import { Rpc } from "../../../../helpers";
-import * as _m0 from "protobufjs/minimal";
+import { BinaryReader } from "../../../../binary";
 import { MsgTransfer, MsgTransferResponse } from "./tx";
 /** Msg defines the ibc/transfer Msg service. */
-
 export interface Msg {
   /** Transfer defines a rpc handler method for MsgTransfer. */
   transfer(request: MsgTransfer): Promise<MsgTransferResponse>;
 }
 export class MsgClientImpl implements Msg {
   private readonly rpc: Rpc;
-
   constructor(rpc: Rpc) {
     this.rpc = rpc;
     this.transfer = this.transfer.bind(this);
   }
-
   transfer(request: MsgTransfer): Promise<MsgTransferResponse> {
     const data = MsgTransfer.encode(request).finish();
     const promise = this.rpc.request("ibc.applications.transfer.v1.Msg", "Transfer", data);
-    return promise.then(data => MsgTransferResponse.decode(new _m0.Reader(data)));
+    return promise.then(data => MsgTransferResponse.decode(new BinaryReader(data)));
   }
-
 }