@xpla/xpla-react 1.7.0 → 1.8.0-rc.1

package/esm/cosmos/crisis/v1beta1/tx.js

@@ -1,325 +0,0 @@
-import { Coin } from "../../base/v1beta1/coin";
-import { BinaryReader, BinaryWriter } from "../../../binary";
-import { GlobalDecoderRegistry } from "../../../registry";
-function createBaseMsgVerifyInvariant() {
-    return {
-        sender: "",
-        invariantModuleName: "",
-        invariantRoute: ""
-    };
-}
-export const MsgVerifyInvariant = {
-    typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
-    aminoType: "cosmos-sdk/MsgVerifyInvariant",
-    is(o) {
-        return o && (o.$typeUrl === MsgVerifyInvariant.typeUrl || typeof o.sender === "string" && typeof o.invariantModuleName === "string" && typeof o.invariantRoute === "string");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === MsgVerifyInvariant.typeUrl || typeof o.sender === "string" && typeof o.invariant_module_name === "string" && typeof o.invariant_route === "string");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.sender !== "") {
-            writer.uint32(10).string(message.sender);
-        }
-        if (message.invariantModuleName !== "") {
-            writer.uint32(18).string(message.invariantModuleName);
-        }
-        if (message.invariantRoute !== "") {
-            writer.uint32(26).string(message.invariantRoute);
-        }
-        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 = createBaseMsgVerifyInvariant();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.sender = reader.string();
-                    break;
-                case 2:
-                    message.invariantModuleName = reader.string();
-                    break;
-                case 3:
-                    message.invariantRoute = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMsgVerifyInvariant();
-        message.sender = object.sender ?? "";
-        message.invariantModuleName = object.invariantModuleName ?? "";
-        message.invariantRoute = object.invariantRoute ?? "";
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMsgVerifyInvariant();
-        if (object.sender !== undefined && object.sender !== null) {
-            message.sender = object.sender;
-        }
-        if (object.invariant_module_name !== undefined && object.invariant_module_name !== null) {
-            message.invariantModuleName = object.invariant_module_name;
-        }
-        if (object.invariant_route !== undefined && object.invariant_route !== null) {
-            message.invariantRoute = object.invariant_route;
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.sender = message.sender === "" ? undefined : message.sender;
-        obj.invariant_module_name = message.invariantModuleName === "" ? undefined : message.invariantModuleName;
-        obj.invariant_route = message.invariantRoute === "" ? undefined : message.invariantRoute;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgVerifyInvariant.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MsgVerifyInvariant",
-            value: MsgVerifyInvariant.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgVerifyInvariant.decode(message.value);
-    },
-    toProto(message) {
-        return MsgVerifyInvariant.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
-            value: MsgVerifyInvariant.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgVerifyInvariant.typeUrl, MsgVerifyInvariant);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVerifyInvariant.aminoType, MsgVerifyInvariant.typeUrl);
-function createBaseMsgVerifyInvariantResponse() {
-    return {};
-}
-export const MsgVerifyInvariantResponse = {
-    typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariantResponse",
-    aminoType: "cosmos-sdk/MsgVerifyInvariantResponse",
-    is(o) {
-        return o && o.$typeUrl === MsgVerifyInvariantResponse.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === MsgVerifyInvariantResponse.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 = createBaseMsgVerifyInvariantResponse();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseMsgVerifyInvariantResponse();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseMsgVerifyInvariantResponse();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgVerifyInvariantResponse.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MsgVerifyInvariantResponse",
-            value: MsgVerifyInvariantResponse.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgVerifyInvariantResponse.decode(message.value);
-    },
-    toProto(message) {
-        return MsgVerifyInvariantResponse.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariantResponse",
-            value: MsgVerifyInvariantResponse.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgVerifyInvariantResponse.typeUrl, MsgVerifyInvariantResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgVerifyInvariantResponse.aminoType, MsgVerifyInvariantResponse.typeUrl);
-function createBaseMsgUpdateParams() {
-    return {
-        authority: "",
-        constantFee: Coin.fromPartial({})
-    };
-}
-export const MsgUpdateParams = {
-    typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParams",
-    aminoType: "cosmos-sdk/x/crisis/MsgUpdateParams",
-    is(o) {
-        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Coin.is(o.constantFee));
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Coin.isAmino(o.constant_fee));
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.authority !== "") {
-            writer.uint32(10).string(message.authority);
-        }
-        if (message.constantFee !== undefined) {
-            Coin.encode(message.constantFee, 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 = createBaseMsgUpdateParams();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.authority = reader.string();
-                    break;
-                case 2:
-                    message.constantFee = Coin.decode(reader, reader.uint32());
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseMsgUpdateParams();
-        message.authority = object.authority ?? "";
-        message.constantFee = object.constantFee !== undefined && object.constantFee !== null ? Coin.fromPartial(object.constantFee) : undefined;
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseMsgUpdateParams();
-        if (object.authority !== undefined && object.authority !== null) {
-            message.authority = object.authority;
-        }
-        if (object.constant_fee !== undefined && object.constant_fee !== null) {
-            message.constantFee = Coin.fromAmino(object.constant_fee);
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.authority = message.authority === "" ? undefined : message.authority;
-        obj.constant_fee = message.constantFee ? Coin.toAmino(message.constantFee) : Coin.toAmino(Coin.fromPartial({}));
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgUpdateParams.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/x/crisis/MsgUpdateParams",
-            value: MsgUpdateParams.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgUpdateParams.decode(message.value);
-    },
-    toProto(message) {
-        return MsgUpdateParams.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParams",
-            value: MsgUpdateParams.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
-function createBaseMsgUpdateParamsResponse() {
-    return {};
-}
-export const MsgUpdateParamsResponse = {
-    typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParamsResponse",
-    aminoType: "cosmos-sdk/MsgUpdateParamsResponse",
-    is(o) {
-        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
-    },
-    isAmino(o) {
-        return o && o.$typeUrl === MsgUpdateParamsResponse.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 = createBaseMsgUpdateParamsResponse();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(_) {
-        const message = createBaseMsgUpdateParamsResponse();
-        return message;
-    },
-    fromAmino(_) {
-        const message = createBaseMsgUpdateParamsResponse();
-        return message;
-    },
-    toAmino(_) {
-        const obj = {};
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return MsgUpdateParamsResponse.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "cosmos-sdk/MsgUpdateParamsResponse",
-            value: MsgUpdateParamsResponse.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return MsgUpdateParamsResponse.decode(message.value);
-    },
-    toProto(message) {
-        return MsgUpdateParamsResponse.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParamsResponse",
-            value: MsgUpdateParamsResponse.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
-GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParamsResponse.aminoType, MsgUpdateParamsResponse.typeUrl);

package/esm/cosmos/crisis/v1beta1/tx.registry.js

@@ -1,46 +0,0 @@
-import { MsgVerifyInvariant, MsgUpdateParams } from "./tx";
-export const registry = [["/cosmos.crisis.v1beta1.MsgVerifyInvariant", MsgVerifyInvariant], ["/cosmos.crisis.v1beta1.MsgUpdateParams", MsgUpdateParams]];
-export const MessageComposer = {
-    encoded: {
-        verifyInvariant(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
-                value: MsgVerifyInvariant.encode(value).finish()
-            };
-        },
-        updateParams(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParams",
-                value: MsgUpdateParams.encode(value).finish()
-            };
-        }
-    },
-    withTypeUrl: {
-        verifyInvariant(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
-                value
-            };
-        },
-        updateParams(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParams",
-                value
-            };
-        }
-    },
-    fromPartial: {
-        verifyInvariant(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgVerifyInvariant",
-                value: MsgVerifyInvariant.fromPartial(value)
-            };
-        },
-        updateParams(value) {
-            return {
-                typeUrl: "/cosmos.crisis.v1beta1.MsgUpdateParams",
-                value: MsgUpdateParams.fromPartial(value)
-            };
-        }
-    }
-};

package/esm/cosmos/crisis/v1beta1/tx.rpc.func.js

@@ -1,22 +0,0 @@
-import { buildTx } from "../../../helper-func-types";
-import { buildUseMutation } from "../../../react-query";
-import { toEncoders, toConverters } from "@interchainjs/cosmos/utils";
-import { MsgVerifyInvariant, MsgUpdateParams } from "./tx";
-export const createVerifyInvariant = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgVerifyInvariant.typeUrl,
-    encoders: toEncoders(MsgVerifyInvariant),
-    converters: toConverters(MsgVerifyInvariant)
-});
-export const useVerifyInvariant = buildUseMutation({
-    builderMutationFn: createVerifyInvariant
-});
-export const createUpdateParams = (clientResolver) => buildTx({
-    clientResolver,
-    typeUrl: MsgUpdateParams.typeUrl,
-    encoders: toEncoders(MsgUpdateParams),
-    converters: toConverters(MsgUpdateParams)
-});
-export const useUpdateParams = buildUseMutation({
-    builderMutationFn: createUpdateParams
-});

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

@@ -1,159 +0,0 @@
-import { BinaryReader, BinaryWriter } from "../../../binary";
-import { bytesFromBase64, base64FromBytes } from "../../../helpers";
-import { GlobalDecoderRegistry } from "../../../registry";
-function createBasePubKey() {
-    return {
-        key: new Uint8Array()
-    };
-}
-export const PubKey = {
-    typeUrl: "/cosmos.crypto.ed25519.PubKey",
-    aminoType: "tendermint/PubKeyEd25519",
-    is(o) {
-        return o && (o.$typeUrl === PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === PubKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.key.length !== 0) {
-            writer.uint32(10).bytes(message.key);
-        }
-        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 = 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 = bytesFromBase64(object.key);
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.key = message.key ? base64FromBytes(message.key) : undefined;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return PubKey.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "tendermint/PubKeyEd25519",
-            value: PubKey.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return PubKey.decode(message.value);
-    },
-    toProto(message) {
-        return PubKey.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crypto.ed25519.PubKey",
-            value: PubKey.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(PubKey.typeUrl, PubKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PubKey.aminoType, PubKey.typeUrl);
-function createBasePrivKey() {
-    return {
-        key: new Uint8Array()
-    };
-}
-export const PrivKey = {
-    typeUrl: "/cosmos.crypto.ed25519.PrivKey",
-    aminoType: "tendermint/PrivKeyEd25519",
-    is(o) {
-        return o && (o.$typeUrl === PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === PrivKey.typeUrl || o.key instanceof Uint8Array || typeof o.key === "string");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.key.length !== 0) {
-            writer.uint32(10).bytes(message.key);
-        }
-        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 = 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 = bytesFromBase64(object.key);
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.key = message.key ? base64FromBytes(message.key) : undefined;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return PrivKey.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "tendermint/PrivKeyEd25519",
-            value: PrivKey.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return PrivKey.decode(message.value);
-    },
-    toProto(message) {
-        return PrivKey.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crypto.ed25519.PrivKey",
-            value: PrivKey.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(PrivKey.typeUrl, PrivKey);
-GlobalDecoderRegistry.registerAminoProtoMapping(PrivKey.aminoType, PrivKey.typeUrl);

package/esm/cosmos/crypto/hd/v1/hd.js

@@ -1,128 +0,0 @@
-import { BinaryReader, BinaryWriter } from "../../../../binary";
-import { GlobalDecoderRegistry } from "../../../../registry";
-function createBaseBIP44Params() {
-    return {
-        purpose: 0,
-        coinType: 0,
-        account: 0,
-        change: false,
-        addressIndex: 0
-    };
-}
-export const BIP44Params = {
-    typeUrl: "/cosmos.crypto.hd.v1.BIP44Params",
-    aminoType: "crypto/keys/hd/BIP44Params",
-    is(o) {
-        return o && (o.$typeUrl === BIP44Params.typeUrl || typeof o.purpose === "number" && typeof o.coinType === "number" && typeof o.account === "number" && typeof o.change === "boolean" && typeof o.addressIndex === "number");
-    },
-    isAmino(o) {
-        return o && (o.$typeUrl === BIP44Params.typeUrl || typeof o.purpose === "number" && typeof o.coin_type === "number" && typeof o.account === "number" && typeof o.change === "boolean" && typeof o.address_index === "number");
-    },
-    encode(message, writer = BinaryWriter.create()) {
-        if (message.purpose !== 0) {
-            writer.uint32(8).uint32(message.purpose);
-        }
-        if (message.coinType !== 0) {
-            writer.uint32(16).uint32(message.coinType);
-        }
-        if (message.account !== 0) {
-            writer.uint32(24).uint32(message.account);
-        }
-        if (message.change === true) {
-            writer.uint32(32).bool(message.change);
-        }
-        if (message.addressIndex !== 0) {
-            writer.uint32(40).uint32(message.addressIndex);
-        }
-        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 = createBaseBIP44Params();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    message.purpose = reader.uint32();
-                    break;
-                case 2:
-                    message.coinType = reader.uint32();
-                    break;
-                case 3:
-                    message.account = reader.uint32();
-                    break;
-                case 4:
-                    message.change = reader.bool();
-                    break;
-                case 5:
-                    message.addressIndex = reader.uint32();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
-            }
-        }
-        return message;
-    },
-    fromPartial(object) {
-        const message = createBaseBIP44Params();
-        message.purpose = object.purpose ?? 0;
-        message.coinType = object.coinType ?? 0;
-        message.account = object.account ?? 0;
-        message.change = object.change ?? false;
-        message.addressIndex = object.addressIndex ?? 0;
-        return message;
-    },
-    fromAmino(object) {
-        const message = createBaseBIP44Params();
-        if (object.purpose !== undefined && object.purpose !== null) {
-            message.purpose = object.purpose;
-        }
-        if (object.coin_type !== undefined && object.coin_type !== null) {
-            message.coinType = object.coin_type;
-        }
-        if (object.account !== undefined && object.account !== null) {
-            message.account = object.account;
-        }
-        if (object.change !== undefined && object.change !== null) {
-            message.change = object.change;
-        }
-        if (object.address_index !== undefined && object.address_index !== null) {
-            message.addressIndex = object.address_index;
-        }
-        return message;
-    },
-    toAmino(message) {
-        const obj = {};
-        obj.purpose = message.purpose === 0 ? undefined : message.purpose;
-        obj.coin_type = message.coinType === 0 ? undefined : message.coinType;
-        obj.account = message.account === 0 ? undefined : message.account;
-        obj.change = message.change === false ? undefined : message.change;
-        obj.address_index = message.addressIndex === 0 ? undefined : message.addressIndex;
-        return obj;
-    },
-    fromAminoMsg(object) {
-        return BIP44Params.fromAmino(object.value);
-    },
-    toAminoMsg(message) {
-        return {
-            type: "crypto/keys/hd/BIP44Params",
-            value: BIP44Params.toAmino(message)
-        };
-    },
-    fromProtoMsg(message) {
-        return BIP44Params.decode(message.value);
-    },
-    toProto(message) {
-        return BIP44Params.encode(message).finish();
-    },
-    toProtoMsg(message) {
-        return {
-            typeUrl: "/cosmos.crypto.hd.v1.BIP44Params",
-            value: BIP44Params.encode(message).finish()
-        };
-    }
-};
-GlobalDecoderRegistry.register(BIP44Params.typeUrl, BIP44Params);
-GlobalDecoderRegistry.registerAminoProtoMapping(BIP44Params.aminoType, BIP44Params.typeUrl);