@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/esm/ibc/applications/gmp/v1/packet.js

@@ -0,0 +1,203 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+function createBaseGMPPacketData() {
+    return {
+        sender: "",
+        receiver: "",
+        salt: new Uint8Array(),
+        payload: new Uint8Array(),
+        memo: ""
+    };
+}
+/**
+ * GMPPacketData defines a struct for the packet payload
+ * @name GMPPacketData
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.GMPPacketData
+ */
+export const GMPPacketData = {
+    typeUrl: "/ibc.applications.gmp.v1.GMPPacketData",
+    aminoType: "cosmos-sdk/GMPPacketData",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sender !== "") {
+            writer.uint32(10).string(message.sender);
+        }
+        if (message.receiver !== "") {
+            writer.uint32(18).string(message.receiver);
+        }
+        if (message.salt.length !== 0) {
+            writer.uint32(26).bytes(message.salt);
+        }
+        if (message.payload.length !== 0) {
+            writer.uint32(34).bytes(message.payload);
+        }
+        if (message.memo !== "") {
+            writer.uint32(42).string(message.memo);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGMPPacketData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sender = reader.string();
+                    break;
+                case 2:
+                    message.receiver = reader.string();
+                    break;
+                case 3:
+                    message.salt = reader.bytes();
+                    break;
+                case 4:
+                    message.payload = reader.bytes();
+                    break;
+                case 5:
+                    message.memo = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGMPPacketData();
+        message.sender = object.sender ?? "";
+        message.receiver = object.receiver ?? "";
+        message.salt = object.salt ?? new Uint8Array();
+        message.payload = object.payload ?? new Uint8Array();
+        message.memo = object.memo ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGMPPacketData();
+        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 = bytesFromBase64(object.salt);
+        }
+        if (object.payload !== undefined && object.payload !== null) {
+            message.payload = bytesFromBase64(object.payload);
+        }
+        if (object.memo !== undefined && object.memo !== null) {
+            message.memo = object.memo;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.receiver = message.receiver === "" ? undefined : message.receiver;
+        obj.salt = message.salt ? base64FromBytes(message.salt) : undefined;
+        obj.payload = message.payload ? base64FromBytes(message.payload) : undefined;
+        obj.memo = message.memo === "" ? undefined : message.memo;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return GMPPacketData.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GMPPacketData",
+            value: GMPPacketData.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return GMPPacketData.decode(message.value);
+    },
+    toProto(message) {
+        return GMPPacketData.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.GMPPacketData",
+            value: GMPPacketData.encode(message).finish()
+        };
+    }
+};
+function createBaseAcknowledgement() {
+    return {
+        result: new Uint8Array()
+    };
+}
+/**
+ * Acknowledgement defines a struct for the ICS27-2 acknowledgement
+ * @name Acknowledgement
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.Acknowledgement
+ */
+export const Acknowledgement = {
+    typeUrl: "/ibc.applications.gmp.v1.Acknowledgement",
+    aminoType: "cosmos-sdk/Acknowledgement",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.result.length !== 0) {
+            writer.uint32(10).bytes(message.result);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAcknowledgement();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.result = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAcknowledgement();
+        message.result = object.result ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAcknowledgement();
+        if (object.result !== undefined && object.result !== null) {
+            message.result = bytesFromBase64(object.result);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.result = message.result ? base64FromBytes(message.result) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Acknowledgement.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Acknowledgement",
+            value: Acknowledgement.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Acknowledgement.decode(message.value);
+    },
+    toProto(message) {
+        return Acknowledgement.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.Acknowledgement",
+            value: Acknowledgement.encode(message).finish()
+        };
+    }
+};

package/esm/ibc/applications/gmp/v1/query.js

@@ -0,0 +1,331 @@
+//@ts-nocheck
+import { AccountIdentifier } from "./account";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseQueryAccountAddressRequest() {
+    return {
+        clientId: "",
+        sender: "",
+        salt: ""
+    };
+}
+/**
+ * QueryAccountAddressRequest is the request type for the Query/AccountAddress RPC method.
+ * @name QueryAccountAddressRequest
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.QueryAccountAddressRequest
+ */
+export const QueryAccountAddressRequest = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressRequest",
+    aminoType: "cosmos-sdk/QueryAccountAddressRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.clientId !== "") {
+            writer.uint32(10).string(message.clientId);
+        }
+        if (message.sender !== "") {
+            writer.uint32(18).string(message.sender);
+        }
+        if (message.salt !== "") {
+            writer.uint32(26).string(message.salt);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAccountAddressRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.clientId = reader.string();
+                    break;
+                case 2:
+                    message.sender = reader.string();
+                    break;
+                case 3:
+                    message.salt = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAccountAddressRequest();
+        message.clientId = object.clientId ?? "";
+        message.sender = object.sender ?? "";
+        message.salt = object.salt ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAccountAddressRequest();
+        if (object.client_id !== undefined && object.client_id !== null) {
+            message.clientId = object.client_id;
+        }
+        if (object.sender !== undefined && object.sender !== null) {
+            message.sender = object.sender;
+        }
+        if (object.salt !== undefined && object.salt !== null) {
+            message.salt = object.salt;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.client_id = message.clientId === "" ? undefined : message.clientId;
+        obj.sender = message.sender === "" ? undefined : message.sender;
+        obj.salt = message.salt === "" ? undefined : message.salt;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAccountAddressRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountAddressRequest",
+            value: QueryAccountAddressRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return QueryAccountAddressRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAccountAddressRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressRequest",
+            value: QueryAccountAddressRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAccountAddressResponse() {
+    return {
+        accountAddress: ""
+    };
+}
+/**
+ * QueryAccountAddressResponse is the response type for the Query/AccountAddress RPC method.
+ * @name QueryAccountAddressResponse
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.QueryAccountAddressResponse
+ */
+export const QueryAccountAddressResponse = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressResponse",
+    aminoType: "cosmos-sdk/QueryAccountAddressResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.accountAddress !== "") {
+            writer.uint32(10).string(message.accountAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAccountAddressResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accountAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAccountAddressResponse();
+        message.accountAddress = object.accountAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAccountAddressResponse();
+        if (object.account_address !== undefined && object.account_address !== null) {
+            message.accountAddress = object.account_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.account_address = message.accountAddress === "" ? undefined : message.accountAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAccountAddressResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountAddressResponse",
+            value: QueryAccountAddressResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return QueryAccountAddressResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAccountAddressResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressResponse",
+            value: QueryAccountAddressResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAccountIdentifierRequest() {
+    return {
+        accountAddress: ""
+    };
+}
+/**
+ * QueryAccountIdentifierRequest is the request type for querying the account identifier by account address.
+ * @name QueryAccountIdentifierRequest
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.QueryAccountIdentifierRequest
+ */
+export const QueryAccountIdentifierRequest = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierRequest",
+    aminoType: "cosmos-sdk/QueryAccountIdentifierRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.accountAddress !== "") {
+            writer.uint32(10).string(message.accountAddress);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAccountIdentifierRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accountAddress = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAccountIdentifierRequest();
+        message.accountAddress = object.accountAddress ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAccountIdentifierRequest();
+        if (object.account_address !== undefined && object.account_address !== null) {
+            message.accountAddress = object.account_address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.account_address = message.accountAddress === "" ? undefined : message.accountAddress;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAccountIdentifierRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountIdentifierRequest",
+            value: QueryAccountIdentifierRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return QueryAccountIdentifierRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAccountIdentifierRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierRequest",
+            value: QueryAccountIdentifierRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryAccountIdentifierResponse() {
+    return {
+        accountId: undefined
+    };
+}
+/**
+ * QueryAccountIdentifierResponse is the response type for querying the account identifier by account address.
+ * @name QueryAccountIdentifierResponse
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.QueryAccountIdentifierResponse
+ */
+export const QueryAccountIdentifierResponse = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierResponse",
+    aminoType: "cosmos-sdk/QueryAccountIdentifierResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.accountId !== undefined) {
+            AccountIdentifier.encode(message.accountId, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryAccountIdentifierResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accountId = AccountIdentifier.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryAccountIdentifierResponse();
+        message.accountId = object.accountId !== undefined && object.accountId !== null ? AccountIdentifier.fromPartial(object.accountId) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAccountIdentifierResponse();
+        if (object.account_id !== undefined && object.account_id !== null) {
+            message.accountId = AccountIdentifier.fromAmino(object.account_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.account_id = message.accountId ? AccountIdentifier.toAmino(message.accountId) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryAccountIdentifierResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountIdentifierResponse",
+            value: QueryAccountIdentifierResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return QueryAccountIdentifierResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryAccountIdentifierResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierResponse",
+            value: QueryAccountIdentifierResponse.encode(message).finish()
+        };
+    }
+};

package/esm/ibc/applications/gmp/v1/query.lcd.js

@@ -0,0 +1,23 @@
+export class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* AccountAddress queries the interchain account address for a given client_id, sender, and salt.
+     If the account is not registered, the address is computed deterministically */
+    accountAddress = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.salt !== "undefined") {
+            options.params.salt = params.salt;
+        }
+        const endpoint = `ibc/apps/gmp/v1/clients/${params.clientId}/accounts/${params.sender}/${params.salt}`;
+        return await this.req.get(endpoint, options);
+    };
+    /* AccountIdentifier queries the account identifier for a given interchain account address. */
+    accountIdentifier = async (params) => {
+        const endpoint = `ibc/apps/gmp/v1/accounts/${params.accountAddress}/identifier`;
+        return await this.req.get(endpoint);
+    };
+}

package/esm/ibc/applications/gmp/v1/query.rpc.Query.js

@@ -0,0 +1,34 @@
+import { BinaryReader } from "../../../../binary";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAccountAddressRequest, QueryAccountAddressResponse, QueryAccountIdentifierRequest, QueryAccountIdentifierResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* AccountAddress queries the interchain account address for a given client_id, sender, and salt.
+     If the account is not registered, the address is computed deterministically */
+    accountAddress = async (request) => {
+        const data = QueryAccountAddressRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.gmp.v1.Query", "AccountAddress", data);
+        return promise.then(data => QueryAccountAddressResponse.decode(new BinaryReader(data)));
+    };
+    /* AccountIdentifier queries the account identifier for a given interchain account address. */
+    accountIdentifier = async (request) => {
+        const data = QueryAccountIdentifierRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.gmp.v1.Query", "AccountIdentifier", data);
+        return promise.then(data => QueryAccountIdentifierResponse.decode(new BinaryReader(data)));
+    };
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        accountAddress(request) {
+            return queryService.accountAddress(request);
+        },
+        accountIdentifier(request) {
+            return queryService.accountIdentifier(request);
+        }
+    };
+};

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

@@ -0,0 +1,9 @@
+//@ts-nocheck
+import { MsgSendCall } from "./tx";
+export const AminoConverter = {
+    "/ibc.applications.gmp.v1.MsgSendCall": {
+        aminoType: "cosmos-sdk/MsgSendCall",
+        toAmino: MsgSendCall.toAmino,
+        fromAmino: MsgSendCall.fromAmino
+    }
+};