@sparkdreamnft/sparkdreamjs 0.0.28 → 0.0.29

package/cosmos/client.d.ts

@@ -1,5 +1,5 @@
 import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
-import { AminoTypes } from "@cosmjs/stargate";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
 import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
 export declare const cosmosAminoConverters: {
     "/cosmos.vesting.v1beta1.MsgCreateVestingAccount": {
@@ -346,4 +346,4 @@ export declare const getSigningCosmosClientOptions: () => {
 export declare const getSigningCosmosClient: ({ rpcEndpoint, signer }: {
     rpcEndpoint: string | HttpEndpoint;
     signer: OfflineSigner;
-}) => Promise<any>;
+}) => Promise<SigningStargateClient>;

package/cosmos/crypto/bls12_381/keys.d.ts

@@ -0,0 +1,106 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * PubKey is an bls12_381 public key for handling CometBFT keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use bls12_381 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ * @name PubKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PubKey
+ */
+export interface PubKey {
+    key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+    typeUrl: "/cosmos.crypto.bls12_381.PubKey";
+    value: Uint8Array;
+}
+/**
+ * PubKey is an bls12_381 public key for handling CometBFT keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use bls12_381 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ * @name PubKeyAmino
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PubKey
+ */
+export interface PubKeyAmino {
+    key?: string;
+}
+export interface PubKeyAminoMsg {
+    type: "cometbft/PubKeyBls12_381";
+    value: PubKeyAmino;
+}
+/**
+ * PrivKey defines a bls12_381 private key.
+ * @name PrivKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PrivKey
+ */
+export interface PrivKey {
+    key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+    typeUrl: "/cosmos.crypto.bls12_381.PrivKey";
+    value: Uint8Array;
+}
+/**
+ * PrivKey defines a bls12_381 private key.
+ * @name PrivKeyAmino
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PrivKey
+ */
+export interface PrivKeyAmino {
+    key?: string;
+}
+export interface PrivKeyAminoMsg {
+    type: "cometbft/PrivKeyBls12_381";
+    value: PrivKeyAmino;
+}
+/**
+ * PubKey is an bls12_381 public key for handling CometBFT keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use bls12_381 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ * @name PubKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PubKey
+ */
+export declare const PubKey: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: PubKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PubKey;
+    fromPartial(object: DeepPartial<PubKey>): PubKey;
+    fromAmino(object: PubKeyAmino): PubKey;
+    toAmino(message: PubKey): PubKeyAmino;
+    fromAminoMsg(object: PubKeyAminoMsg): PubKey;
+    toAminoMsg(message: PubKey): PubKeyAminoMsg;
+    fromProtoMsg(message: PubKeyProtoMsg): PubKey;
+    toProto(message: PubKey): Uint8Array;
+    toProtoMsg(message: PubKey): PubKeyProtoMsg;
+};
+/**
+ * PrivKey defines a bls12_381 private key.
+ * @name PrivKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PrivKey
+ */
+export declare const PrivKey: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: PrivKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PrivKey;
+    fromPartial(object: DeepPartial<PrivKey>): PrivKey;
+    fromAmino(object: PrivKeyAmino): PrivKey;
+    toAmino(message: PrivKey): PrivKeyAmino;
+    fromAminoMsg(object: PrivKeyAminoMsg): PrivKey;
+    toAminoMsg(message: PrivKey): PrivKeyAminoMsg;
+    fromProtoMsg(message: PrivKeyProtoMsg): PrivKey;
+    toProto(message: PrivKey): Uint8Array;
+    toProtoMsg(message: PrivKey): PrivKeyProtoMsg;
+};

package/cosmos/crypto/bls12_381/keys.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PubKey is an bls12_381 public key for handling CometBFT keys in SDK.
+ * It's needed for Any serialization and SDK compatibility.
+ * It must not be used in a non Tendermint key context because it doesn't implement
+ * ADR-28. Nevertheless, you will like to use bls12_381 in app user level
+ * then you must create a new proto message and follow ADR-28 for Address construction.
+ * @name PubKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PubKey
+ */
+exports.PubKey = {
+    typeUrl: "/cosmos.crypto.bls12_381.PubKey",
+    aminoType: "cometbft/PubKeyBls12_381",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PubKeyBls12_381",
+            value: exports.PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.bls12_381.PubKey",
+            value: exports.PubKey.encode(message).finish()
+        };
+    }
+};
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PrivKey defines a bls12_381 private key.
+ * @name PrivKey
+ * @package cosmos.crypto.bls12_381
+ * @see proto type: cosmos.crypto.bls12_381.PrivKey
+ */
+exports.PrivKey = {
+    typeUrl: "/cosmos.crypto.bls12_381.PrivKey",
+    aminoType: "cometbft/PrivKeyBls12_381",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PrivKeyBls12_381",
+            value: exports.PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.bls12_381.PrivKey",
+            value: exports.PrivKey.encode(message).finish()
+        };
+    }
+};

package/cosmos/crypto/mldsa65/keys.d.ts

@@ -0,0 +1,106 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * PubKey is an ML-DSA-65 (FIPS 204) public key for handling CometBFT keys in
+ * the SDK. It is intended for validator-key use and must not be used in
+ * application-level account contexts because it does not implement ADR-28
+ * address derivation. If you want to use ML-DSA-65 at the user/account level,
+ * define a new proto message and follow ADR-28 for address construction.
+ * @name PubKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PubKey
+ */
+export interface PubKey {
+    key: Uint8Array;
+}
+export interface PubKeyProtoMsg {
+    typeUrl: "/cosmos.crypto.mldsa65.PubKey";
+    value: Uint8Array;
+}
+/**
+ * PubKey is an ML-DSA-65 (FIPS 204) public key for handling CometBFT keys in
+ * the SDK. It is intended for validator-key use and must not be used in
+ * application-level account contexts because it does not implement ADR-28
+ * address derivation. If you want to use ML-DSA-65 at the user/account level,
+ * define a new proto message and follow ADR-28 for address construction.
+ * @name PubKeyAmino
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PubKey
+ */
+export interface PubKeyAmino {
+    key?: string;
+}
+export interface PubKeyAminoMsg {
+    type: "cometbft/PubKeyMlDsa65";
+    value: PubKeyAmino;
+}
+/**
+ * PrivKey defines an ML-DSA-65 private key (FIPS 204 packed form).
+ * @name PrivKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PrivKey
+ */
+export interface PrivKey {
+    key: Uint8Array;
+}
+export interface PrivKeyProtoMsg {
+    typeUrl: "/cosmos.crypto.mldsa65.PrivKey";
+    value: Uint8Array;
+}
+/**
+ * PrivKey defines an ML-DSA-65 private key (FIPS 204 packed form).
+ * @name PrivKeyAmino
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PrivKey
+ */
+export interface PrivKeyAmino {
+    key?: string;
+}
+export interface PrivKeyAminoMsg {
+    type: "cometbft/PrivKeyMlDsa65";
+    value: PrivKeyAmino;
+}
+/**
+ * PubKey is an ML-DSA-65 (FIPS 204) public key for handling CometBFT keys in
+ * the SDK. It is intended for validator-key use and must not be used in
+ * application-level account contexts because it does not implement ADR-28
+ * address derivation. If you want to use ML-DSA-65 at the user/account level,
+ * define a new proto message and follow ADR-28 for address construction.
+ * @name PubKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PubKey
+ */
+export declare const PubKey: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: PubKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PubKey;
+    fromPartial(object: DeepPartial<PubKey>): PubKey;
+    fromAmino(object: PubKeyAmino): PubKey;
+    toAmino(message: PubKey): PubKeyAmino;
+    fromAminoMsg(object: PubKeyAminoMsg): PubKey;
+    toAminoMsg(message: PubKey): PubKeyAminoMsg;
+    fromProtoMsg(message: PubKeyProtoMsg): PubKey;
+    toProto(message: PubKey): Uint8Array;
+    toProtoMsg(message: PubKey): PubKeyProtoMsg;
+};
+/**
+ * PrivKey defines an ML-DSA-65 private key (FIPS 204 packed form).
+ * @name PrivKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PrivKey
+ */
+export declare const PrivKey: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: PrivKey, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): PrivKey;
+    fromPartial(object: DeepPartial<PrivKey>): PrivKey;
+    fromAmino(object: PrivKeyAmino): PrivKey;
+    toAmino(message: PrivKey): PrivKeyAmino;
+    fromAminoMsg(object: PrivKeyAminoMsg): PrivKey;
+    toAminoMsg(message: PrivKey): PrivKeyAminoMsg;
+    fromProtoMsg(message: PrivKeyProtoMsg): PrivKey;
+    toProto(message: PrivKey): Uint8Array;
+    toProtoMsg(message: PrivKey): PrivKeyProtoMsg;
+};

package/cosmos/crypto/mldsa65/keys.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+function createBasePubKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PubKey is an ML-DSA-65 (FIPS 204) public key for handling CometBFT keys in
+ * the SDK. It is intended for validator-key use and must not be used in
+ * application-level account contexts because it does not implement ADR-28
+ * address derivation. If you want to use ML-DSA-65 at the user/account level,
+ * define a new proto message and follow ADR-28 for address construction.
+ * @name PubKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PubKey
+ */
+exports.PubKey = {
+    typeUrl: "/cosmos.crypto.mldsa65.PubKey",
+    aminoType: "cometbft/PubKeyMlDsa65",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePubKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePubKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PubKeyMlDsa65",
+            value: exports.PubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PubKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.mldsa65.PubKey",
+            value: exports.PubKey.encode(message).finish()
+        };
+    }
+};
+function createBasePrivKey() {
+    return {
+        key: new Uint8Array()
+    };
+}
+/**
+ * PrivKey defines an ML-DSA-65 private key (FIPS 204 packed form).
+ * @name PrivKey
+ * @package cosmos.crypto.mldsa65
+ * @see proto type: cosmos.crypto.mldsa65.PrivKey
+ */
+exports.PrivKey = {
+    typeUrl: "/cosmos.crypto.mldsa65.PrivKey",
+    aminoType: "cometbft/PrivKeyMlDsa65",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        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 = createBasePrivKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePrivKey();
+        message.key = object.key ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePrivKey();
+        if (object.key !== undefined && object.key !== null) {
+            message.key = (0, helpers_1.bytesFromBase64)(object.key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.key = message.key ? (0, helpers_1.base64FromBytes)(message.key) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.PrivKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cometbft/PrivKeyMlDsa65",
+            value: exports.PrivKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.PrivKey.decode(message.value);
+    },
+    toProto(message) {
+        return exports.PrivKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.mldsa65.PrivKey",
+            value: exports.PrivKey.encode(message).finish()
+        };
+    }
+};

package/cosmos_proto/bundle.d.ts

@@ -1,31 +1,31 @@
-import * as _1 from "./cosmos";
+import * as _113 from "./cosmos";
 export declare const cosmos_proto: {
-    scalarTypeFromJSON(object: any): _1.ScalarType;
-    scalarTypeToJSON(object: _1.ScalarType): string;
-    ScalarType: typeof _1.ScalarType;
-    ScalarTypeAmino: typeof _1.ScalarType;
+    scalarTypeFromJSON(object: any): _113.ScalarType;
+    scalarTypeToJSON(object: _113.ScalarType): string;
+    ScalarType: typeof _113.ScalarType;
+    ScalarTypeAmino: typeof _113.ScalarType;
     InterfaceDescriptor: {
         typeUrl: string;
-        encode(message: _1.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _1.InterfaceDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_1.InterfaceDescriptor>): _1.InterfaceDescriptor;
-        fromAmino(object: _1.InterfaceDescriptorAmino): _1.InterfaceDescriptor;
-        toAmino(message: _1.InterfaceDescriptor): _1.InterfaceDescriptorAmino;
-        fromAminoMsg(object: _1.InterfaceDescriptorAminoMsg): _1.InterfaceDescriptor;
-        fromProtoMsg(message: _1.InterfaceDescriptorProtoMsg): _1.InterfaceDescriptor;
-        toProto(message: _1.InterfaceDescriptor): Uint8Array;
-        toProtoMsg(message: _1.InterfaceDescriptor): _1.InterfaceDescriptorProtoMsg;
+        encode(message: _113.InterfaceDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.InterfaceDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_113.InterfaceDescriptor>): _113.InterfaceDescriptor;
+        fromAmino(object: _113.InterfaceDescriptorAmino): _113.InterfaceDescriptor;
+        toAmino(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorAmino;
+        fromAminoMsg(object: _113.InterfaceDescriptorAminoMsg): _113.InterfaceDescriptor;
+        fromProtoMsg(message: _113.InterfaceDescriptorProtoMsg): _113.InterfaceDescriptor;
+        toProto(message: _113.InterfaceDescriptor): Uint8Array;
+        toProtoMsg(message: _113.InterfaceDescriptor): _113.InterfaceDescriptorProtoMsg;
     };
     ScalarDescriptor: {
         typeUrl: string;
-        encode(message: _1.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _1.ScalarDescriptor;
-        fromPartial(object: import("../helpers").DeepPartial<_1.ScalarDescriptor>): _1.ScalarDescriptor;
-        fromAmino(object: _1.ScalarDescriptorAmino): _1.ScalarDescriptor;
-        toAmino(message: _1.ScalarDescriptor): _1.ScalarDescriptorAmino;
-        fromAminoMsg(object: _1.ScalarDescriptorAminoMsg): _1.ScalarDescriptor;
-        fromProtoMsg(message: _1.ScalarDescriptorProtoMsg): _1.ScalarDescriptor;
-        toProto(message: _1.ScalarDescriptor): Uint8Array;
-        toProtoMsg(message: _1.ScalarDescriptor): _1.ScalarDescriptorProtoMsg;
+        encode(message: _113.ScalarDescriptor, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+        decode(input: import("..").BinaryReader | Uint8Array, length?: number): _113.ScalarDescriptor;
+        fromPartial(object: import("../helpers").DeepPartial<_113.ScalarDescriptor>): _113.ScalarDescriptor;
+        fromAmino(object: _113.ScalarDescriptorAmino): _113.ScalarDescriptor;
+        toAmino(message: _113.ScalarDescriptor): _113.ScalarDescriptorAmino;
+        fromAminoMsg(object: _113.ScalarDescriptorAminoMsg): _113.ScalarDescriptor;
+        fromProtoMsg(message: _113.ScalarDescriptorProtoMsg): _113.ScalarDescriptor;
+        toProto(message: _113.ScalarDescriptor): Uint8Array;
+        toProtoMsg(message: _113.ScalarDescriptor): _113.ScalarDescriptorProtoMsg;
     };
 };

package/cosmos_proto/bundle.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cosmos_proto = void 0;
 //@ts-nocheck
-const _1 = __importStar(require("./cosmos"));
+const _113 = __importStar(require("./cosmos"));
 exports.cosmos_proto = {
-    ..._1
+    ..._113
 };