@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/ibc/applications/gmp/v1/tx.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgSendCallResponse = exports.MsgSendCall = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+function createBaseMsgSendCall() {
+    return {
+        sourceClient: "",
+        sender: "",
+        receiver: "",
+        salt: new Uint8Array(),
+        payload: new Uint8Array(),
+        timeoutTimestamp: BigInt(0),
+        memo: "",
+        encoding: ""
+    };
+}
+/**
+ * MsgSendCall defines a msg to send a call to a contract/receiver on a ICS27-2 enabled chain.
+ * @name MsgSendCall
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCall
+ */
+exports.MsgSendCall = {
+    typeUrl: "/ibc.applications.gmp.v1.MsgSendCall",
+    aminoType: "cosmos-sdk/MsgSendCall",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.sourceClient !== "") {
+            writer.uint32(10).string(message.sourceClient);
+        }
+        if (message.sender !== "") {
+            writer.uint32(18).string(message.sender);
+        }
+        if (message.receiver !== "") {
+            writer.uint32(26).string(message.receiver);
+        }
+        if (message.salt.length !== 0) {
+            writer.uint32(34).bytes(message.salt);
+        }
+        if (message.payload.length !== 0) {
+            writer.uint32(42).bytes(message.payload);
+        }
+        if (message.timeoutTimestamp !== BigInt(0)) {
+            writer.uint32(48).uint64(message.timeoutTimestamp);
+        }
+        if (message.memo !== "") {
+            writer.uint32(58).string(message.memo);
+        }
+        if (message.encoding !== "") {
+            writer.uint32(66).string(message.encoding);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgSendCall();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sourceClient = reader.string();
+                    break;
+                case 2:
+                    message.sender = reader.string();
+                    break;
+                case 3:
+                    message.receiver = reader.string();
+                    break;
+                case 4:
+                    message.salt = reader.bytes();
+                    break;
+                case 5:
+                    message.payload = reader.bytes();
+                    break;
+                case 6:
+                    message.timeoutTimestamp = reader.uint64();
+                    break;
+                case 7:
+                    message.memo = reader.string();
+                    break;
+                case 8:
+                    message.encoding = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSendCall();
+        message.sourceClient = object.sourceClient ?? "";
+        message.sender = object.sender ?? "";
+        message.receiver = object.receiver ?? "";
+        message.salt = object.salt ?? new Uint8Array();
+        message.payload = object.payload ?? new Uint8Array();
+        message.timeoutTimestamp = object.timeoutTimestamp !== undefined && object.timeoutTimestamp !== null ? BigInt(object.timeoutTimestamp.toString()) : BigInt(0);
+        message.memo = object.memo ?? "";
+        message.encoding = object.encoding ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSendCall();
+        if (object.source_client !== undefined && object.source_client !== null) {
+            message.sourceClient = object.source_client;
+        }
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.receiver !== undefined && object.receiver !== null) {
+            message.receiver = object.receiver;
+        }
+        if (object.salt !== undefined && object.salt !== null) {
+            message.salt = (0, helpers_1.bytesFromBase64)(object.salt);
+        }
+        if (object.payload !== undefined && object.payload !== null) {
+            message.payload = (0, helpers_1.bytesFromBase64)(object.payload);
+        }
+        if (object.timeout_timestamp !== undefined && object.timeout_timestamp !== null) {
+            message.timeoutTimestamp = BigInt(object.timeout_timestamp);
+        }
+        if (object.memo !== undefined && object.memo !== null) {
+            message.memo = object.memo;
+        }
+        if (object.encoding !== undefined && object.encoding !== null) {
+            message.encoding = object.encoding;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.source_client = message.sourceClient === "" ? undefined : message.sourceClient;
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.receiver = message.receiver === "" ? undefined : message.receiver;
+        obj.salt = message.salt ? (0, helpers_1.base64FromBytes)(message.salt) : undefined;
+        obj.payload = message.payload ? (0, helpers_1.base64FromBytes)(message.payload) : undefined;
+        obj.timeout_timestamp = message.timeoutTimestamp !== BigInt(0) ? message.timeoutTimestamp?.toString() : undefined;
+        obj.memo = message.memo === "" ? undefined : message.memo;
+        obj.encoding = message.encoding === "" ? undefined : message.encoding;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgSendCall.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgSendCall",
+            value: exports.MsgSendCall.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgSendCall.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgSendCall.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.MsgSendCall",
+            value: exports.MsgSendCall.encode(message).finish()
+        };
+    }
+};
+function createBaseMsgSendCallResponse() {
+    return {
+        sequence: BigInt(0)
+    };
+}
+/**
+ * MsgSendCallResponse defines the Msg/SendCall response type.
+ * @name MsgSendCallResponse
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCallResponse
+ */
+exports.MsgSendCallResponse = {
+    typeUrl: "/ibc.applications.gmp.v1.MsgSendCallResponse",
+    aminoType: "cosmos-sdk/MsgSendCallResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.sequence !== BigInt(0)) {
+            writer.uint32(8).uint64(message.sequence);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgSendCallResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sequence = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSendCallResponse();
+        message.sequence = object.sequence !== undefined && object.sequence !== null ? BigInt(object.sequence.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMsgSendCallResponse();
+        if (object.sequence !== undefined && object.sequence !== null) {
+            message.sequence = BigInt(object.sequence);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sequence = message.sequence !== BigInt(0) ? message.sequence?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.MsgSendCallResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MsgSendCallResponse",
+            value: exports.MsgSendCallResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.MsgSendCallResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.MsgSendCallResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.MsgSendCallResponse",
+            value: exports.MsgSendCallResponse.encode(message).finish()
+        };
+    }
+};

package/ibc/applications/gmp/v1/tx.registry.d.ts

@@ -0,0 +1,25 @@
+import { TelescopeGeneratedType } from "../../../../types";
+import { Registry } from "@cosmjs/proto-signing";
+import { MsgSendCall } from "./tx";
+export declare const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]>;
+export declare const load: (protoRegistry: Registry) => void;
+export declare const MessageComposer: {
+    encoded: {
+        sendCall(value: MsgSendCall): {
+            typeUrl: string;
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    };
+    withTypeUrl: {
+        sendCall(value: MsgSendCall): {
+            typeUrl: string;
+            value: MsgSendCall;
+        };
+    };
+    fromPartial: {
+        sendCall(value: MsgSendCall): {
+            typeUrl: string;
+            value: MsgSendCall;
+        };
+    };
+};

package/ibc/applications/gmp/v1/tx.registry.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageComposer = exports.load = exports.registry = void 0;
+const tx_1 = require("./tx");
+exports.registry = [["/ibc.applications.gmp.v1.MsgSendCall", tx_1.MsgSendCall]];
+const load = (protoRegistry) => {
+    exports.registry.forEach(([typeUrl, mod]) => {
+        protoRegistry.register(typeUrl, mod);
+    });
+};
+exports.load = load;
+exports.MessageComposer = {
+    encoded: {
+        sendCall(value) {
+            return {
+                typeUrl: "/ibc.applications.gmp.v1.MsgSendCall",
+                value: tx_1.MsgSendCall.encode(value).finish()
+            };
+        }
+    },
+    withTypeUrl: {
+        sendCall(value) {
+            return {
+                typeUrl: "/ibc.applications.gmp.v1.MsgSendCall",
+                value
+            };
+        }
+    },
+    fromPartial: {
+        sendCall(value) {
+            return {
+                typeUrl: "/ibc.applications.gmp.v1.MsgSendCall",
+                value: tx_1.MsgSendCall.fromPartial(value)
+            };
+        }
+    }
+};

package/ibc/applications/gmp/v1/tx.rpc.msg.d.ts

@@ -0,0 +1,13 @@
+import { TxRpc } from "../../../../types";
+import { MsgSendCall, MsgSendCallResponse } from "./tx";
+/** Msg defines the ibc/gmp Msg service. */
+export interface Msg {
+    /** SendCall defines a rpc handler method for MsgSendCall. */
+    sendCall(request: MsgSendCall): Promise<MsgSendCallResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    sendCall: (request: MsgSendCall) => Promise<MsgSendCallResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/ibc/applications/gmp/v1/tx.rpc.msg.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../../binary");
+const tx_1 = require("./tx");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* SendCall defines a rpc handler method for MsgSendCall. */
+    sendCall = async (request) => {
+        const data = tx_1.MsgSendCall.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.gmp.v1.Msg", "SendCall", data);
+        return promise.then(data => tx_1.MsgSendCallResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/ibc/applications/packet_forward_middleware/v1/genesis.d.ts

@@ -87,7 +87,6 @@ export interface InFlightPacket {
     refundSequence: bigint;
     retriesRemaining: number;
     timeout: bigint;
-    nonrefundable: boolean;
 }
 export interface InFlightPacketProtoMsg {
     typeUrl: "/ibc.applications.packet_forward_middleware.v1.InFlightPacket";
@@ -112,7 +111,6 @@ export interface InFlightPacketAmino {
     refund_sequence?: string;
     retries_remaining?: number;
     timeout?: string;
-    nonrefundable?: boolean;
 }
 export interface InFlightPacketAminoMsg {
     type: "cosmos-sdk/InFlightPacket";

package/ibc/applications/packet_forward_middleware/v1/genesis.js

@@ -184,8 +184,7 @@ function createBaseInFlightPacket() {
         packetData: new Uint8Array(),
         refundSequence: BigInt(0),
         retriesRemaining: 0,
-        timeout: BigInt(0),
-        nonrefundable: false
+        timeout: BigInt(0)
     };
 }
 /**
@@ -232,9 +231,6 @@ exports.InFlightPacket = {
         if (message.timeout !== BigInt(0)) {
             writer.uint32(88).uint64(message.timeout);
         }
-        if (message.nonrefundable === true) {
-            writer.uint32(96).bool(message.nonrefundable);
-        }
         return writer;
     },
     decode(input, length) {
@@ -277,9 +273,6 @@ exports.InFlightPacket = {
                 case 11:
                     message.timeout = reader.uint64();
                     break;
-                case 12:
-                    message.nonrefundable = reader.bool();
-                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -300,7 +293,6 @@ exports.InFlightPacket = {
         message.refundSequence = object.refundSequence !== undefined && object.refundSequence !== null ? BigInt(object.refundSequence.toString()) : BigInt(0);
         message.retriesRemaining = object.retriesRemaining ?? 0;
         message.timeout = object.timeout !== undefined && object.timeout !== null ? BigInt(object.timeout.toString()) : BigInt(0);
-        message.nonrefundable = object.nonrefundable ?? false;
         return message;
     },
     fromAmino(object) {
@@ -338,9 +330,6 @@ exports.InFlightPacket = {
         if (object.timeout !== undefined && object.timeout !== null) {
             message.timeout = BigInt(object.timeout);
         }
-        if (object.nonrefundable !== undefined && object.nonrefundable !== null) {
-            message.nonrefundable = object.nonrefundable;
-        }
         return message;
     },
     toAmino(message) {
@@ -356,7 +345,6 @@ exports.InFlightPacket = {
         obj.refund_sequence = message.refundSequence !== BigInt(0) ? message.refundSequence?.toString() : undefined;
         obj.retries_remaining = message.retriesRemaining === 0 ? undefined : message.retriesRemaining;
         obj.timeout = message.timeout !== BigInt(0) ? message.timeout?.toString() : undefined;
-        obj.nonrefundable = message.nonrefundable === false ? undefined : message.nonrefundable;
         return obj;
     },
     fromAminoMsg(object) {

package/ibc/applications/rate_limiting/v1/genesis.d.ts

@@ -13,6 +13,7 @@ export interface GenesisState {
     blacklistedDenoms: string[];
     pendingSendPacketSequenceNumbers: string[];
     hourEpoch: HourEpoch;
+    pendingRecvPacketSequenceNumbers: string[];
 }
 export interface GenesisStateProtoMsg {
     typeUrl: "/ibc.applications.rate_limiting.v1.GenesisState";
@@ -30,6 +31,7 @@ export interface GenesisStateAmino {
     blacklisted_denoms?: string[];
     pending_send_packet_sequence_numbers?: string[];
     hour_epoch?: HourEpochAmino;
+    pending_recv_packet_sequence_numbers?: string[];
 }
 export interface GenesisStateAminoMsg {
     type: "cosmos-sdk/GenesisState";

package/ibc/applications/rate_limiting/v1/genesis.js

@@ -10,7 +10,8 @@ function createBaseGenesisState() {
         whitelistedAddressPairs: [],
         blacklistedDenoms: [],
         pendingSendPacketSequenceNumbers: [],
-        hourEpoch: rate_limiting_1.HourEpoch.fromPartial({})
+        hourEpoch: rate_limiting_1.HourEpoch.fromPartial({}),
+        pendingRecvPacketSequenceNumbers: []
     };
 }
 /**
@@ -38,6 +39,9 @@ exports.GenesisState = {
         if (message.hourEpoch !== undefined) {
             rate_limiting_1.HourEpoch.encode(message.hourEpoch, writer.uint32(42).fork()).ldelim();
         }
+        for (const v of message.pendingRecvPacketSequenceNumbers) {
+            writer.uint32(50).string(v);
+        }
         return writer;
     },
     decode(input, length) {
@@ -62,6 +66,9 @@ exports.GenesisState = {
                 case 5:
                     message.hourEpoch = rate_limiting_1.HourEpoch.decode(reader, reader.uint32());
                     break;
+                case 6:
+                    message.pendingRecvPacketSequenceNumbers.push(reader.string());
+                    break;
                 default:
                     reader.skipType(tag & 7);
                     break;
@@ -76,6 +83,7 @@ exports.GenesisState = {
         message.blacklistedDenoms = object.blacklistedDenoms?.map(e => e) || [];
         message.pendingSendPacketSequenceNumbers = object.pendingSendPacketSequenceNumbers?.map(e => e) || [];
         message.hourEpoch = object.hourEpoch !== undefined && object.hourEpoch !== null ? rate_limiting_1.HourEpoch.fromPartial(object.hourEpoch) : undefined;
+        message.pendingRecvPacketSequenceNumbers = object.pendingRecvPacketSequenceNumbers?.map(e => e) || [];
         return message;
     },
     fromAmino(object) {
@@ -87,6 +95,7 @@ exports.GenesisState = {
         if (object.hour_epoch !== undefined && object.hour_epoch !== null) {
             message.hourEpoch = rate_limiting_1.HourEpoch.fromAmino(object.hour_epoch);
         }
+        message.pendingRecvPacketSequenceNumbers = object.pending_recv_packet_sequence_numbers?.map(e => e) || [];
         return message;
     },
     toAmino(message) {
@@ -116,6 +125,12 @@ exports.GenesisState = {
             obj.pending_send_packet_sequence_numbers = message.pendingSendPacketSequenceNumbers;
         }
         obj.hour_epoch = message.hourEpoch ? rate_limiting_1.HourEpoch.toAmino(message.hourEpoch) : undefined;
+        if (message.pendingRecvPacketSequenceNumbers) {
+            obj.pending_recv_packet_sequence_numbers = message.pendingRecvPacketSequenceNumbers.map(e => e);
+        }
+        else {
+            obj.pending_recv_packet_sequence_numbers = message.pendingRecvPacketSequenceNumbers;
+        }
         return obj;
     },
     fromAminoMsg(object) {