@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.10

package/esm/cosmos/crypto/keyring/v1/record.js

@@ -0,0 +1,428 @@
+import { Any } from "../../../../google/protobuf/any";
+import { BIP44Params } from "../../hd/v1/hd";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBaseRecord() {
+    return {
+        name: "",
+        pubKey: undefined,
+        local: undefined,
+        ledger: undefined,
+        multi: undefined,
+        offline: undefined
+    };
+}
+export const Record = {
+    typeUrl: "/cosmos.crypto.keyring.v1.Record",
+    aminoType: "cosmos-sdk/Record",
+    is(o) {
+        return o && (o.$typeUrl === Record.typeUrl || typeof o.name === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Record.typeUrl || typeof o.name === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.pubKey !== undefined) {
+            Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.local !== undefined) {
+            Record_Local.encode(message.local, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.ledger !== undefined) {
+            Record_Ledger.encode(message.ledger, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.multi !== undefined) {
+            Record_Multi.encode(message.multi, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.offline !== undefined) {
+            Record_Offline.encode(message.offline, writer.uint32(50).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 = createBaseRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.pubKey = Any.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.local = Record_Local.decode(reader, reader.uint32());
+                    break;
+                case 4:
+                    message.ledger = Record_Ledger.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.multi = Record_Multi.decode(reader, reader.uint32());
+                    break;
+                case 6:
+                    message.offline = Record_Offline.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecord();
+        message.name = object.name ?? "";
+        message.pubKey = object.pubKey !== undefined && object.pubKey !== null ? Any.fromPartial(object.pubKey) : undefined;
+        message.local = object.local !== undefined && object.local !== null ? Record_Local.fromPartial(object.local) : undefined;
+        message.ledger = object.ledger !== undefined && object.ledger !== null ? Record_Ledger.fromPartial(object.ledger) : undefined;
+        message.multi = object.multi !== undefined && object.multi !== null ? Record_Multi.fromPartial(object.multi) : undefined;
+        message.offline = object.offline !== undefined && object.offline !== null ? Record_Offline.fromPartial(object.offline) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecord();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.pub_key !== undefined && object.pub_key !== null) {
+            message.pubKey = Any.fromAmino(object.pub_key);
+        }
+        if (object.local !== undefined && object.local !== null) {
+            message.local = Record_Local.fromAmino(object.local);
+        }
+        if (object.ledger !== undefined && object.ledger !== null) {
+            message.ledger = Record_Ledger.fromAmino(object.ledger);
+        }
+        if (object.multi !== undefined && object.multi !== null) {
+            message.multi = Record_Multi.fromAmino(object.multi);
+        }
+        if (object.offline !== undefined && object.offline !== null) {
+            message.offline = Record_Offline.fromAmino(object.offline);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.pub_key = message.pubKey ? Any.toAmino(message.pubKey) : undefined;
+        obj.local = message.local ? Record_Local.toAmino(message.local) : undefined;
+        obj.ledger = message.ledger ? Record_Ledger.toAmino(message.ledger) : undefined;
+        obj.multi = message.multi ? Record_Multi.toAmino(message.multi) : undefined;
+        obj.offline = message.offline ? Record_Offline.toAmino(message.offline) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Record.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Record",
+            value: Record.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Record.decode(message.value);
+    },
+    toProto(message) {
+        return Record.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.keyring.v1.Record",
+            value: Record.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Record.typeUrl, Record);
+GlobalDecoderRegistry.registerAminoProtoMapping(Record.aminoType, Record.typeUrl);
+function createBaseRecord_Local() {
+    return {
+        privKey: undefined
+    };
+}
+export const Record_Local = {
+    typeUrl: "/cosmos.crypto.keyring.v1.Local",
+    aminoType: "cosmos-sdk/Local",
+    is(o) {
+        return o && o.$typeUrl === Record_Local.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Record_Local.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.privKey !== undefined) {
+            Any.encode(message.privKey, 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 = createBaseRecord_Local();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.privKey = Any.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecord_Local();
+        message.privKey = object.privKey !== undefined && object.privKey !== null ? Any.fromPartial(object.privKey) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecord_Local();
+        if (object.priv_key !== undefined && object.priv_key !== null) {
+            message.privKey = Any.fromAmino(object.priv_key);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.priv_key = message.privKey ? Any.toAmino(message.privKey) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Record_Local.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Local",
+            value: Record_Local.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Record_Local.decode(message.value);
+    },
+    toProto(message) {
+        return Record_Local.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.keyring.v1.Local",
+            value: Record_Local.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Record_Local.typeUrl, Record_Local);
+GlobalDecoderRegistry.registerAminoProtoMapping(Record_Local.aminoType, Record_Local.typeUrl);
+function createBaseRecord_Ledger() {
+    return {
+        path: undefined
+    };
+}
+export const Record_Ledger = {
+    typeUrl: "/cosmos.crypto.keyring.v1.Ledger",
+    aminoType: "cosmos-sdk/Ledger",
+    is(o) {
+        return o && o.$typeUrl === Record_Ledger.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Record_Ledger.typeUrl;
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.path !== undefined) {
+            BIP44Params.encode(message.path, 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 = createBaseRecord_Ledger();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.path = BIP44Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseRecord_Ledger();
+        message.path = object.path !== undefined && object.path !== null ? BIP44Params.fromPartial(object.path) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseRecord_Ledger();
+        if (object.path !== undefined && object.path !== null) {
+            message.path = BIP44Params.fromAmino(object.path);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.path = message.path ? BIP44Params.toAmino(message.path) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Record_Ledger.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Ledger",
+            value: Record_Ledger.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Record_Ledger.decode(message.value);
+    },
+    toProto(message) {
+        return Record_Ledger.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.keyring.v1.Ledger",
+            value: Record_Ledger.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Record_Ledger.typeUrl, Record_Ledger);
+GlobalDecoderRegistry.registerAminoProtoMapping(Record_Ledger.aminoType, Record_Ledger.typeUrl);
+function createBaseRecord_Multi() {
+    return {};
+}
+export const Record_Multi = {
+    typeUrl: "/cosmos.crypto.keyring.v1.Multi",
+    aminoType: "cosmos-sdk/Multi",
+    is(o) {
+        return o && o.$typeUrl === Record_Multi.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Record_Multi.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseRecord_Multi();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseRecord_Multi();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseRecord_Multi();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Record_Multi.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Multi",
+            value: Record_Multi.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Record_Multi.decode(message.value);
+    },
+    toProto(message) {
+        return Record_Multi.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.keyring.v1.Multi",
+            value: Record_Multi.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Record_Multi.typeUrl, Record_Multi);
+GlobalDecoderRegistry.registerAminoProtoMapping(Record_Multi.aminoType, Record_Multi.typeUrl);
+function createBaseRecord_Offline() {
+    return {};
+}
+export const Record_Offline = {
+    typeUrl: "/cosmos.crypto.keyring.v1.Offline",
+    aminoType: "cosmos-sdk/Offline",
+    is(o) {
+        return o && o.$typeUrl === Record_Offline.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === Record_Offline.typeUrl;
+    },
+    encode(_, writer = BinaryWriter.create()) {
+        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 = createBaseRecord_Offline();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseRecord_Offline();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseRecord_Offline();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Record_Offline.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Offline",
+            value: Record_Offline.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return Record_Offline.decode(message.value);
+    },
+    toProto(message) {
+        return Record_Offline.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.keyring.v1.Offline",
+            value: Record_Offline.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(Record_Offline.typeUrl, Record_Offline);
+GlobalDecoderRegistry.registerAminoProtoMapping(Record_Offline.aminoType, Record_Offline.typeUrl);

package/esm/cosmos/crypto/multisig/keys.js

@@ -0,0 +1,96 @@
+import { Any } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseLegacyAminoPubKey() {
+    return {
+        threshold: 0,
+        publicKeys: []
+    };
+}
+export const LegacyAminoPubKey = {
+    typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey",
+    aminoType: "tendermint/PubKeyMultisigThreshold",
+    is(o) {
+        return o && (o.$typeUrl === LegacyAminoPubKey.typeUrl || typeof o.threshold === "number" && Array.isArray(o.publicKeys) && (!o.publicKeys.length || Any.is(o.publicKeys[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === LegacyAminoPubKey.typeUrl || typeof o.threshold === "number" && Array.isArray(o.public_keys) && (!o.public_keys.length || Any.isAmino(o.public_keys[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.threshold !== 0) {
+            writer.uint32(8).uint32(message.threshold);
+        }
+        for (const v of message.publicKeys) {
+            Any.encode(v, writer.uint32(18).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 = createBaseLegacyAminoPubKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.threshold = reader.uint32();
+                    break;
+                case 2:
+                    message.publicKeys.push(Any.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseLegacyAminoPubKey();
+        message.threshold = object.threshold ?? 0;
+        message.publicKeys = object.publicKeys?.map(e => Any.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseLegacyAminoPubKey();
+        if (object.threshold !== undefined && object.threshold !== null) {
+            message.threshold = object.threshold;
+        }
+        message.publicKeys = object.public_keys?.map(e => Any.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.threshold = message.threshold === 0 ? undefined : message.threshold;
+        if (message.publicKeys) {
+            obj.public_keys = message.publicKeys.map(e => e ? Any.toAmino(e) : undefined);
+        }
+        else {
+            obj.public_keys = message.publicKeys;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return LegacyAminoPubKey.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "tendermint/PubKeyMultisigThreshold",
+            value: LegacyAminoPubKey.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return LegacyAminoPubKey.decode(message.value);
+    },
+    toProto(message) {
+        return LegacyAminoPubKey.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.multisig.LegacyAminoPubKey",
+            value: LegacyAminoPubKey.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(LegacyAminoPubKey.typeUrl, LegacyAminoPubKey);
+GlobalDecoderRegistry.registerAminoProtoMapping(LegacyAminoPubKey.aminoType, LegacyAminoPubKey.typeUrl);

package/esm/cosmos/crypto/multisig/v1beta1/multisig.js

@@ -0,0 +1,174 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../../../helpers";
+import { GlobalDecoderRegistry } from "../../../../registry";
+function createBaseMultiSignature() {
+    return {
+        signatures: []
+    };
+}
+export const MultiSignature = {
+    typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+    aminoType: "cosmos-sdk/MultiSignature",
+    is(o) {
+        return o && (o.$typeUrl === MultiSignature.typeUrl || Array.isArray(o.signatures) && (!o.signatures.length || o.signatures[0] instanceof Uint8Array || typeof o.signatures[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MultiSignature.typeUrl || Array.isArray(o.signatures) && (!o.signatures.length || o.signatures[0] instanceof Uint8Array || typeof o.signatures[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.signatures) {
+            writer.uint32(10).bytes(v);
+        }
+        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 = createBaseMultiSignature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.signatures.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMultiSignature();
+        message.signatures = object.signatures?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMultiSignature();
+        message.signatures = object.signatures?.map(e => bytesFromBase64(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.signatures) {
+            obj.signatures = message.signatures.map(e => base64FromBytes(e));
+        }
+        else {
+            obj.signatures = message.signatures;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MultiSignature.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MultiSignature",
+            value: MultiSignature.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MultiSignature.decode(message.value);
+    },
+    toProto(message) {
+        return MultiSignature.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+            value: MultiSignature.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MultiSignature.typeUrl, MultiSignature);
+GlobalDecoderRegistry.registerAminoProtoMapping(MultiSignature.aminoType, MultiSignature.typeUrl);
+function createBaseCompactBitArray() {
+    return {
+        extraBitsStored: 0,
+        elems: new Uint8Array()
+    };
+}
+export const CompactBitArray = {
+    typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+    aminoType: "cosmos-sdk/CompactBitArray",
+    is(o) {
+        return o && (o.$typeUrl === CompactBitArray.typeUrl || typeof o.extraBitsStored === "number" && (o.elems instanceof Uint8Array || typeof o.elems === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === CompactBitArray.typeUrl || typeof o.extra_bits_stored === "number" && (o.elems instanceof Uint8Array || typeof o.elems === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.extraBitsStored !== 0) {
+            writer.uint32(8).uint32(message.extraBitsStored);
+        }
+        if (message.elems.length !== 0) {
+            writer.uint32(18).bytes(message.elems);
+        }
+        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 = createBaseCompactBitArray();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.extraBitsStored = reader.uint32();
+                    break;
+                case 2:
+                    message.elems = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseCompactBitArray();
+        message.extraBitsStored = object.extraBitsStored ?? 0;
+        message.elems = object.elems ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseCompactBitArray();
+        if (object.extra_bits_stored !== undefined && object.extra_bits_stored !== null) {
+            message.extraBitsStored = object.extra_bits_stored;
+        }
+        if (object.elems !== undefined && object.elems !== null) {
+            message.elems = bytesFromBase64(object.elems);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.extra_bits_stored = message.extraBitsStored === 0 ? undefined : message.extraBitsStored;
+        obj.elems = message.elems ? base64FromBytes(message.elems) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return CompactBitArray.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/CompactBitArray",
+            value: CompactBitArray.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return CompactBitArray.decode(message.value);
+    },
+    toProto(message) {
+        return CompactBitArray.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+            value: CompactBitArray.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(CompactBitArray.typeUrl, CompactBitArray);
+GlobalDecoderRegistry.registerAminoProtoMapping(CompactBitArray.aminoType, CompactBitArray.typeUrl);