@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/ibc/lcd.d.ts

@@ -59,6 +59,9 @@ export declare const createLCDClient: ({ restEndpoint }: {
     };
     ibc: {
         applications: {
+            gmp: {
+                v1: import("./applications/gmp/v1/query.lcd").LCDQueryClient;
+            };
             interchain_accounts: {
                 controller: {
                     v1: import("./applications/interchain_accounts/controller/v1/query.lcd").LCDQueryClient;

package/ibc/lcd.js

@@ -135,6 +135,11 @@ const createLCDClient = async ({ restEndpoint }) => {
         },
         ibc: {
             applications: {
+                gmp: {
+                    v1: new (await Promise.resolve().then(() => __importStar(require("./applications/gmp/v1/query.lcd")))).LCDQueryClient({
+                        requestClient
+                    })
+                },
                 interchain_accounts: {
                     controller: {
                         v1: new (await Promise.resolve().then(() => __importStar(require("./applications/interchain_accounts/controller/v1/query.lcd")))).LCDQueryClient({

package/ibc/lightclients/attestations/v1/attestations.d.ts

@@ -0,0 +1,199 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * ClientState defines an attestor-based light client that tracks the current
+ * consensus state and if the client is frozen.
+ * @name ClientState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ClientState
+ */
+export interface ClientState {
+    /**
+     * trusted attestor set (EOA addresses)
+     */
+    attestorAddresses: string[];
+    /**
+     * quorum threshold (minimum number of unique attestor signatures required)
+     */
+    minRequiredSigs: number;
+    /**
+     * highest height that has been trusted
+     */
+    latestHeight: bigint;
+    /**
+     * when true, all verification and updates MUST fail
+     */
+    isFrozen: boolean;
+}
+export interface ClientStateProtoMsg {
+    typeUrl: "/ibc.lightclients.attestations.v1.ClientState";
+    value: Uint8Array;
+}
+/**
+ * ClientState defines an attestor-based light client that tracks the current
+ * consensus state and if the client is frozen.
+ * @name ClientStateAmino
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ClientState
+ */
+export interface ClientStateAmino {
+    /**
+     * trusted attestor set (EOA addresses)
+     */
+    attestor_addresses?: string[];
+    /**
+     * quorum threshold (minimum number of unique attestor signatures required)
+     */
+    min_required_sigs?: number;
+    /**
+     * highest height that has been trusted
+     */
+    latest_height?: string;
+    /**
+     * when true, all verification and updates MUST fail
+     */
+    is_frozen?: boolean;
+}
+export interface ClientStateAminoMsg {
+    type: "cosmos-sdk/ClientState";
+    value: ClientStateAmino;
+}
+/**
+ * ConsensusState defines an attestor consensus state. The timestamp of a
+ * consensus state is stored per height.
+ * @name ConsensusState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ConsensusState
+ */
+export interface ConsensusState {
+    /**
+     * trusted UNIX timestamp (nanoseconds) for the height
+     */
+    timestamp: bigint;
+}
+export interface ConsensusStateProtoMsg {
+    typeUrl: "/ibc.lightclients.attestations.v1.ConsensusState";
+    value: Uint8Array;
+}
+/**
+ * ConsensusState defines an attestor consensus state. The timestamp of a
+ * consensus state is stored per height.
+ * @name ConsensusStateAmino
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ConsensusState
+ */
+export interface ConsensusStateAmino {
+    /**
+     * trusted UNIX timestamp (nanoseconds) for the height
+     */
+    timestamp?: string;
+}
+export interface ConsensusStateAminoMsg {
+    type: "cosmos-sdk/ConsensusState";
+    value: ConsensusStateAmino;
+}
+/**
+ * AttestationProof is used for client updates and membership verification.
+ * All attestor signatures cover sha256(attestationData).
+ * @name AttestationProof
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.AttestationProof
+ */
+export interface AttestationProof {
+    /**
+     * the attestation data that was signed (ABI-encoded StateAttestation or PacketAttestation)
+     */
+    attestationData: Uint8Array;
+    /**
+     * array of 65-byte ECDSA signatures (r||s||v)
+     */
+    signatures: Uint8Array[];
+}
+export interface AttestationProofProtoMsg {
+    typeUrl: "/ibc.lightclients.attestations.v1.AttestationProof";
+    value: Uint8Array;
+}
+/**
+ * AttestationProof is used for client updates and membership verification.
+ * All attestor signatures cover sha256(attestationData).
+ * @name AttestationProofAmino
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.AttestationProof
+ */
+export interface AttestationProofAmino {
+    /**
+     * the attestation data that was signed (ABI-encoded StateAttestation or PacketAttestation)
+     */
+    attestation_data?: string;
+    /**
+     * array of 65-byte ECDSA signatures (r||s||v)
+     */
+    signatures?: string[];
+}
+export interface AttestationProofAminoMsg {
+    type: "cosmos-sdk/AttestationProof";
+    value: AttestationProofAmino;
+}
+/**
+ * ClientState defines an attestor-based light client that tracks the current
+ * consensus state and if the client is frozen.
+ * @name ClientState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ClientState
+ */
+export declare const ClientState: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: ClientState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ClientState;
+    fromPartial(object: DeepPartial<ClientState>): ClientState;
+    fromAmino(object: ClientStateAmino): ClientState;
+    toAmino(message: ClientState): ClientStateAmino;
+    fromAminoMsg(object: ClientStateAminoMsg): ClientState;
+    toAminoMsg(message: ClientState): ClientStateAminoMsg;
+    fromProtoMsg(message: ClientStateProtoMsg): ClientState;
+    toProto(message: ClientState): Uint8Array;
+    toProtoMsg(message: ClientState): ClientStateProtoMsg;
+};
+/**
+ * ConsensusState defines an attestor consensus state. The timestamp of a
+ * consensus state is stored per height.
+ * @name ConsensusState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ConsensusState
+ */
+export declare const ConsensusState: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: ConsensusState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ConsensusState;
+    fromPartial(object: DeepPartial<ConsensusState>): ConsensusState;
+    fromAmino(object: ConsensusStateAmino): ConsensusState;
+    toAmino(message: ConsensusState): ConsensusStateAmino;
+    fromAminoMsg(object: ConsensusStateAminoMsg): ConsensusState;
+    toAminoMsg(message: ConsensusState): ConsensusStateAminoMsg;
+    fromProtoMsg(message: ConsensusStateProtoMsg): ConsensusState;
+    toProto(message: ConsensusState): Uint8Array;
+    toProtoMsg(message: ConsensusState): ConsensusStateProtoMsg;
+};
+/**
+ * AttestationProof is used for client updates and membership verification.
+ * All attestor signatures cover sha256(attestationData).
+ * @name AttestationProof
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.AttestationProof
+ */
+export declare const AttestationProof: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: AttestationProof, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AttestationProof;
+    fromPartial(object: DeepPartial<AttestationProof>): AttestationProof;
+    fromAmino(object: AttestationProofAmino): AttestationProof;
+    toAmino(message: AttestationProof): AttestationProofAmino;
+    fromAminoMsg(object: AttestationProofAminoMsg): AttestationProof;
+    toAminoMsg(message: AttestationProof): AttestationProofAminoMsg;
+    fromProtoMsg(message: AttestationProofProtoMsg): AttestationProof;
+    toProto(message: AttestationProof): Uint8Array;
+    toProtoMsg(message: AttestationProof): AttestationProofProtoMsg;
+};

package/ibc/lightclients/attestations/v1/attestations.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestationProof = exports.ConsensusState = exports.ClientState = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../../binary");
+const helpers_1 = require("../../../../helpers");
+function createBaseClientState() {
+    return {
+        attestorAddresses: [],
+        minRequiredSigs: 0,
+        latestHeight: BigInt(0),
+        isFrozen: false
+    };
+}
+/**
+ * ClientState defines an attestor-based light client that tracks the current
+ * consensus state and if the client is frozen.
+ * @name ClientState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ClientState
+ */
+exports.ClientState = {
+    typeUrl: "/ibc.lightclients.attestations.v1.ClientState",
+    aminoType: "cosmos-sdk/ClientState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.attestorAddresses) {
+            writer.uint32(10).string(v);
+        }
+        if (message.minRequiredSigs !== 0) {
+            writer.uint32(16).uint32(message.minRequiredSigs);
+        }
+        if (message.latestHeight !== BigInt(0)) {
+            writer.uint32(24).uint64(message.latestHeight);
+        }
+        if (message.isFrozen === true) {
+            writer.uint32(32).bool(message.isFrozen);
+        }
+        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 = createBaseClientState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.attestorAddresses.push(reader.string());
+                    break;
+                case 2:
+                    message.minRequiredSigs = reader.uint32();
+                    break;
+                case 3:
+                    message.latestHeight = reader.uint64();
+                    break;
+                case 4:
+                    message.isFrozen = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseClientState();
+        message.attestorAddresses = object.attestorAddresses?.map(e => e) || [];
+        message.minRequiredSigs = object.minRequiredSigs ?? 0;
+        message.latestHeight = object.latestHeight !== undefined && object.latestHeight !== null ? BigInt(object.latestHeight.toString()) : BigInt(0);
+        message.isFrozen = object.isFrozen ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseClientState();
+        message.attestorAddresses = object.attestor_addresses?.map(e => e) || [];
+        if (object.min_required_sigs !== undefined && object.min_required_sigs !== null) {
+            message.minRequiredSigs = object.min_required_sigs;
+        }
+        if (object.latest_height !== undefined && object.latest_height !== null) {
+            message.latestHeight = BigInt(object.latest_height);
+        }
+        if (object.is_frozen !== undefined && object.is_frozen !== null) {
+            message.isFrozen = object.is_frozen;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.attestorAddresses) {
+            obj.attestor_addresses = message.attestorAddresses.map(e => e);
+        }
+        else {
+            obj.attestor_addresses = message.attestorAddresses;
+        }
+        obj.min_required_sigs = message.minRequiredSigs === 0 ? undefined : message.minRequiredSigs;
+        obj.latest_height = message.latestHeight !== BigInt(0) ? message.latestHeight?.toString() : undefined;
+        obj.is_frozen = message.isFrozen === false ? undefined : message.isFrozen;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ClientState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ClientState",
+            value: exports.ClientState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.ClientState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ClientState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.lightclients.attestations.v1.ClientState",
+            value: exports.ClientState.encode(message).finish()
+        };
+    }
+};
+function createBaseConsensusState() {
+    return {
+        timestamp: BigInt(0)
+    };
+}
+/**
+ * ConsensusState defines an attestor consensus state. The timestamp of a
+ * consensus state is stored per height.
+ * @name ConsensusState
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.ConsensusState
+ */
+exports.ConsensusState = {
+    typeUrl: "/ibc.lightclients.attestations.v1.ConsensusState",
+    aminoType: "cosmos-sdk/ConsensusState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.timestamp !== BigInt(0)) {
+            writer.uint32(8).uint64(message.timestamp);
+        }
+        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 = createBaseConsensusState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.timestamp = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseConsensusState();
+        message.timestamp = object.timestamp !== undefined && object.timestamp !== null ? BigInt(object.timestamp.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseConsensusState();
+        if (object.timestamp !== undefined && object.timestamp !== null) {
+            message.timestamp = BigInt(object.timestamp);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.timestamp = message.timestamp !== BigInt(0) ? message.timestamp?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ConsensusState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ConsensusState",
+            value: exports.ConsensusState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.ConsensusState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ConsensusState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.lightclients.attestations.v1.ConsensusState",
+            value: exports.ConsensusState.encode(message).finish()
+        };
+    }
+};
+function createBaseAttestationProof() {
+    return {
+        attestationData: new Uint8Array(),
+        signatures: []
+    };
+}
+/**
+ * AttestationProof is used for client updates and membership verification.
+ * All attestor signatures cover sha256(attestationData).
+ * @name AttestationProof
+ * @package ibc.lightclients.attestations.v1
+ * @see proto type: ibc.lightclients.attestations.v1.AttestationProof
+ */
+exports.AttestationProof = {
+    typeUrl: "/ibc.lightclients.attestations.v1.AttestationProof",
+    aminoType: "cosmos-sdk/AttestationProof",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.attestationData.length !== 0) {
+            writer.uint32(10).bytes(message.attestationData);
+        }
+        for (const v of message.signatures) {
+            writer.uint32(18).bytes(v);
+        }
+        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 = createBaseAttestationProof();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.attestationData = reader.bytes();
+                    break;
+                case 2:
+                    message.signatures.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAttestationProof();
+        message.attestationData = object.attestationData ?? new Uint8Array();
+        message.signatures = object.signatures?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAttestationProof();
+        if (object.attestation_data !== undefined && object.attestation_data !== null) {
+            message.attestationData = (0, helpers_1.bytesFromBase64)(object.attestation_data);
+        }
+        message.signatures = object.signatures?.map(e => (0, helpers_1.bytesFromBase64)(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.attestation_data = message.attestationData ? (0, helpers_1.base64FromBytes)(message.attestationData) : undefined;
+        if (message.signatures) {
+            obj.signatures = message.signatures.map(e => (0, helpers_1.base64FromBytes)(e));
+        }
+        else {
+            obj.signatures = message.signatures;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.AttestationProof.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/AttestationProof",
+            value: exports.AttestationProof.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.AttestationProof.decode(message.value);
+    },
+    toProto(message) {
+        return exports.AttestationProof.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.lightclients.attestations.v1.AttestationProof",
+            value: exports.AttestationProof.encode(message).finish()
+        };
+    }
+};

package/ibc/rpc.query.d.ts

@@ -198,6 +198,12 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
     };
     ibc: {
         applications: {
+            gmp: {
+                v1: {
+                    accountAddress(request: import("./applications/gmp/v1/query").QueryAccountAddressRequest): Promise<import("./applications/gmp/v1/query").QueryAccountAddressResponse>;
+                    accountIdentifier(request: import("./applications/gmp/v1/query").QueryAccountIdentifierRequest): Promise<import("./applications/gmp/v1/query").QueryAccountIdentifierResponse>;
+                };
+            };
             interchain_accounts: {
                 controller: {
                     v1: {

package/ibc/rpc.query.js

@@ -102,6 +102,9 @@ const createRPCQueryClient = async ({ rpcEndpoint }) => {
         },
         ibc: {
             applications: {
+                gmp: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./applications/gmp/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                },
                 interchain_accounts: {
                     controller: {
                         v1: (await Promise.resolve().then(() => __importStar(require("./applications/interchain_accounts/controller/v1/query.rpc.Query")))).createRpcQueryExtension(client)

package/ibc/rpc.tx.d.ts

@@ -55,6 +55,9 @@ export declare const createRPCMsgClient: ({ rpc }: {
     };
     ibc: {
         applications: {
+            gmp: {
+                v1: import("./applications/gmp/v1/tx.rpc.msg").MsgClientImpl;
+            };
             interchain_accounts: {
                 controller: {
                     v1: import("./applications/interchain_accounts/controller/v1/tx.rpc.msg").MsgClientImpl;

package/ibc/rpc.tx.js

@@ -88,6 +88,9 @@ const createRPCMsgClient = async ({ rpc }) => ({
     },
     ibc: {
         applications: {
+            gmp: {
+                v1: new (await Promise.resolve().then(() => __importStar(require("./applications/gmp/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+            },
             interchain_accounts: {
                 controller: {
                     v1: new (await Promise.resolve().then(() => __importStar(require("./applications/interchain_accounts/controller/v1/tx.rpc.msg")))).MsgClientImpl(rpc)

package/index.d.ts

@@ -3,6 +3,8 @@
   * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
     * and run the transpile command or npm scripts command that is used to regenerate this bundle.
   */
+export * from "./akash/bundle";
+export * from "./akash/client";
 export * from "./amino/bundle";
 export * from "./cosmos_proto/bundle";
 export * from "./cosmos/bundle";

package/index.js

@@ -20,6 +20,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./akash/bundle"), exports);
+__exportStar(require("./akash/client"), exports);
 __exportStar(require("./amino/bundle"), exports);
 __exportStar(require("./cosmos_proto/bundle"), exports);
 __exportStar(require("./cosmos/bundle"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparkdreamnft/sparkdreamjs",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "author": "kob <kob@sparkdream.io>",
   "description": "Spark Dream blockchain TypeScript library",
   "main": "index.js",
@@ -39,14 +39,17 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@cosmjs/proto-signing": "^0.39.0",
+    "@cosmjs/stargate": "^0.39.0",
+    "@cosmjs/tendermint-rpc": "^0.39.0",
+    "@cosmology/lcd": "^0.14.0",
+    "@cosmology/telescope": "^1.12.8",
     "@interchainjs/cosmos": "1.11.5",
     "@interchainjs/cosmos-types": "1.11.5",
     "@interchainjs/encoding": "1.11.5",
     "@interchainjs/pubkey": "1.11.5",
     "@interchainjs/types": "1.11.5",
-    "@interchainjs/utils": "1.11.5",
-    "@cosmology/lcd": "^0.14.0",
-    "@cosmology/telescope": "^1.12.8"
+    "@interchainjs/utils": "1.11.5"
   },
   "keywords": []
-}
+}