@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

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

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryAccountIdentifierResponse = exports.QueryAccountIdentifierRequest = exports.QueryAccountAddressResponse = exports.QueryAccountAddressRequest = void 0;
+//@ts-nocheck
+const account_1 = require("./account");
+const binary_1 = require("../../../../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
+ */
+exports.QueryAccountAddressRequest = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressRequest",
+    aminoType: "cosmos-sdk/QueryAccountAddressRequest",
+    encode(message, writer = binary_1.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 binary_1.BinaryReader ? input : new binary_1.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 exports.QueryAccountAddressRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountAddressRequest",
+            value: exports.QueryAccountAddressRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAccountAddressRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAccountAddressRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressRequest",
+            value: exports.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
+ */
+exports.QueryAccountAddressResponse = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressResponse",
+    aminoType: "cosmos-sdk/QueryAccountAddressResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.accountAddress !== "") {
+            writer.uint32(10).string(message.accountAddress);
+        }
+        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 = 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 exports.QueryAccountAddressResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountAddressResponse",
+            value: exports.QueryAccountAddressResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAccountAddressResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAccountAddressResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountAddressResponse",
+            value: exports.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
+ */
+exports.QueryAccountIdentifierRequest = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierRequest",
+    aminoType: "cosmos-sdk/QueryAccountIdentifierRequest",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.accountAddress !== "") {
+            writer.uint32(10).string(message.accountAddress);
+        }
+        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 = 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 exports.QueryAccountIdentifierRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountIdentifierRequest",
+            value: exports.QueryAccountIdentifierRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAccountIdentifierRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAccountIdentifierRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierRequest",
+            value: exports.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
+ */
+exports.QueryAccountIdentifierResponse = {
+    typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierResponse",
+    aminoType: "cosmos-sdk/QueryAccountIdentifierResponse",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.accountId !== undefined) {
+            account_1.AccountIdentifier.encode(message.accountId, writer.uint32(10).fork()).ldelim();
+        }
+        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 = createBaseQueryAccountIdentifierResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accountId = account_1.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 ? account_1.AccountIdentifier.fromPartial(object.accountId) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryAccountIdentifierResponse();
+        if (object.account_id !== undefined && object.account_id !== null) {
+            message.accountId = account_1.AccountIdentifier.fromAmino(object.account_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.account_id = message.accountId ? account_1.AccountIdentifier.toAmino(message.accountId) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryAccountIdentifierResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryAccountIdentifierResponse",
+            value: exports.QueryAccountIdentifierResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryAccountIdentifierResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryAccountIdentifierResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.gmp.v1.QueryAccountIdentifierResponse",
+            value: exports.QueryAccountIdentifierResponse.encode(message).finish()
+        };
+    }
+};

package/ibc/applications/gmp/v1/query.lcd.d.ts

@@ -0,0 +1,10 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAccountAddressRequest, QueryAccountAddressResponse, QueryAccountIdentifierRequest, QueryAccountIdentifierResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    accountAddress: (params: QueryAccountAddressRequest) => Promise<QueryAccountAddressResponse>;
+    accountIdentifier: (params: QueryAccountIdentifierRequest) => Promise<QueryAccountIdentifierResponse>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+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);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/ibc/applications/gmp/v1/query.rpc.Query.d.ts

@@ -0,0 +1,23 @@
+import { TxRpc } from "../../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryAccountAddressRequest, QueryAccountAddressResponse, QueryAccountIdentifierRequest, QueryAccountIdentifierResponse } from "./query";
+/** Query provides defines the gRPC querier service. */
+export interface Query {
+    /**
+     * 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(request: QueryAccountAddressRequest): Promise<QueryAccountAddressResponse>;
+    /** AccountIdentifier queries the account identifier for a given interchain account address. */
+    accountIdentifier(request: QueryAccountIdentifierRequest): Promise<QueryAccountIdentifierResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    accountAddress: (request: QueryAccountAddressRequest) => Promise<QueryAccountAddressResponse>;
+    accountIdentifier: (request: QueryAccountIdentifierRequest) => Promise<QueryAccountIdentifierResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    accountAddress(request: QueryAccountAddressRequest): Promise<QueryAccountAddressResponse>;
+    accountIdentifier(request: QueryAccountIdentifierRequest): Promise<QueryAccountIdentifierResponse>;
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+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 = query_1.QueryAccountAddressRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.gmp.v1.Query", "AccountAddress", data);
+        return promise.then(data => query_1.QueryAccountAddressResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* AccountIdentifier queries the account identifier for a given interchain account address. */
+    accountIdentifier = async (request) => {
+        const data = query_1.QueryAccountIdentifierRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.gmp.v1.Query", "AccountIdentifier", data);
+        return promise.then(data => query_1.QueryAccountIdentifierResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        accountAddress(request) {
+            return queryService.accountAddress(request);
+        },
+        accountIdentifier(request) {
+            return queryService.accountIdentifier(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

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

@@ -0,0 +1,8 @@
+import { MsgSendCall } from "./tx";
+export declare const AminoConverter: {
+    "/ibc.applications.gmp.v1.MsgSendCall": {
+        aminoType: string;
+        toAmino: (message: MsgSendCall) => import("./tx").MsgSendCallAmino;
+        fromAmino: (object: import("./tx").MsgSendCallAmino) => MsgSendCall;
+    };
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+//@ts-nocheck
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/ibc.applications.gmp.v1.MsgSendCall": {
+        aminoType: "cosmos-sdk/MsgSendCall",
+        toAmino: tx_1.MsgSendCall.toAmino,
+        fromAmino: tx_1.MsgSendCall.fromAmino
+    }
+};

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

@@ -0,0 +1,162 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * 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
+ */
+export interface MsgSendCall {
+    /**
+     * the client by which the packet will be sent
+     */
+    sourceClient: string;
+    /**
+     * the sender address
+     */
+    sender: string;
+    /**
+     * the recipient address on the destination chain
+     */
+    receiver: string;
+    /**
+     * The salt used to generate the caller account address
+     */
+    salt: Uint8Array;
+    /**
+     * The payload of the call
+     */
+    payload: Uint8Array;
+    /**
+     * Timeout timestamp in absolute nanoseconds since unix epoch.
+     */
+    timeoutTimestamp: bigint;
+    /**
+     * optional memo
+     */
+    memo: string;
+    /**
+     * optional encoding
+     */
+    encoding: string;
+}
+export interface MsgSendCallProtoMsg {
+    typeUrl: "/ibc.applications.gmp.v1.MsgSendCall";
+    value: Uint8Array;
+}
+/**
+ * MsgSendCall defines a msg to send a call to a contract/receiver on a ICS27-2 enabled chain.
+ * @name MsgSendCallAmino
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCall
+ */
+export interface MsgSendCallAmino {
+    /**
+     * the client by which the packet will be sent
+     */
+    source_client?: string;
+    /**
+     * the sender address
+     */
+    sender?: string;
+    /**
+     * the recipient address on the destination chain
+     */
+    receiver?: string;
+    /**
+     * The salt used to generate the caller account address
+     */
+    salt?: string;
+    /**
+     * The payload of the call
+     */
+    payload?: string;
+    /**
+     * Timeout timestamp in absolute nanoseconds since unix epoch.
+     */
+    timeout_timestamp?: string;
+    /**
+     * optional memo
+     */
+    memo?: string;
+    /**
+     * optional encoding
+     */
+    encoding?: string;
+}
+export interface MsgSendCallAminoMsg {
+    type: "cosmos-sdk/MsgSendCall";
+    value: MsgSendCallAmino;
+}
+/**
+ * MsgSendCallResponse defines the Msg/SendCall response type.
+ * @name MsgSendCallResponse
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCallResponse
+ */
+export interface MsgSendCallResponse {
+    /**
+     * sequence number of the GMP packet sent
+     */
+    sequence: bigint;
+}
+export interface MsgSendCallResponseProtoMsg {
+    typeUrl: "/ibc.applications.gmp.v1.MsgSendCallResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgSendCallResponse defines the Msg/SendCall response type.
+ * @name MsgSendCallResponseAmino
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCallResponse
+ */
+export interface MsgSendCallResponseAmino {
+    /**
+     * sequence number of the GMP packet sent
+     */
+    sequence?: string;
+}
+export interface MsgSendCallResponseAminoMsg {
+    type: "cosmos-sdk/MsgSendCallResponse";
+    value: MsgSendCallResponseAmino;
+}
+/**
+ * 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
+ */
+export declare const MsgSendCall: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: MsgSendCall, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgSendCall;
+    fromPartial(object: DeepPartial<MsgSendCall>): MsgSendCall;
+    fromAmino(object: MsgSendCallAmino): MsgSendCall;
+    toAmino(message: MsgSendCall): MsgSendCallAmino;
+    fromAminoMsg(object: MsgSendCallAminoMsg): MsgSendCall;
+    toAminoMsg(message: MsgSendCall): MsgSendCallAminoMsg;
+    fromProtoMsg(message: MsgSendCallProtoMsg): MsgSendCall;
+    toProto(message: MsgSendCall): Uint8Array;
+    toProtoMsg(message: MsgSendCall): MsgSendCallProtoMsg;
+};
+/**
+ * MsgSendCallResponse defines the Msg/SendCall response type.
+ * @name MsgSendCallResponse
+ * @package ibc.applications.gmp.v1
+ * @see proto type: ibc.applications.gmp.v1.MsgSendCallResponse
+ */
+export declare const MsgSendCallResponse: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: MsgSendCallResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgSendCallResponse;
+    fromPartial(object: DeepPartial<MsgSendCallResponse>): MsgSendCallResponse;
+    fromAmino(object: MsgSendCallResponseAmino): MsgSendCallResponse;
+    toAmino(message: MsgSendCallResponse): MsgSendCallResponseAmino;
+    fromAminoMsg(object: MsgSendCallResponseAminoMsg): MsgSendCallResponse;
+    toAminoMsg(message: MsgSendCallResponse): MsgSendCallResponseAminoMsg;
+    fromProtoMsg(message: MsgSendCallResponseProtoMsg): MsgSendCallResponse;
+    toProto(message: MsgSendCallResponse): Uint8Array;
+    toProtoMsg(message: MsgSendCallResponse): MsgSendCallResponseProtoMsg;
+};