carbon-js-sdk 0.4.21 → 0.4.22

package/lib/util/ethermint/evm-ibc.d.ts

@@ -0,0 +1,97 @@
+import { TxRaw } from "../../codec/cosmos/tx/v1beta1/tx";
+import { Network } from "../../constant";
+import { StdFee, StdSignDoc } from "@cosmjs/amino";
+import { EncodeObject, Registry } from "@cosmjs/proto-signing";
+import { Blockchain } from "../blockchain";
+declare type SupportedBlockchains = Blockchain.Canto | Blockchain.Evmos;
+declare namespace EvmIbcHelper {
+    interface TypedDomain {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+        salt: string;
+    }
+    interface TypedDataV4 {
+        types: object;
+        primaryType: string;
+        message: StdSignDoc;
+        domain: TypedDomain;
+    }
+    interface SignFee extends StdFee {
+        feePayer: string;
+    }
+    interface SignDoc extends StdSignDoc {
+        fee: SignFee;
+    }
+    const TYPED_DATA_REQUEST_METHOD = "eth_signTypedData_v4";
+    const DEFAULT_EIP712_TYPES: {
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+        Fee: {
+            name: string;
+            type: string;
+        }[];
+        Coin: {
+            name: string;
+            type: string;
+        }[];
+        Msg: {
+            name: string;
+            type: string;
+        }[];
+    };
+    const getEvmChainId: (blockchain: SupportedBlockchains, network?: Network) => 7700 | 9001;
+    const getIbcTransferTypes: () => {
+        MsgValue: {
+            name: string;
+            type: string;
+        }[];
+        TypeToken: {
+            name: string;
+            type: string;
+        }[];
+        TypeTimeoutHeight: {
+            name: string;
+            type: string;
+        }[];
+        EIP712Domain: {
+            name: string;
+            type: string;
+        }[];
+        Tx: {
+            name: string;
+            type: string;
+        }[];
+        Fee: {
+            name: string;
+            type: string;
+        }[];
+        Coin: {
+            name: string;
+            type: string;
+        }[];
+        Msg: {
+            name: string;
+            type: string;
+        }[];
+    };
+    const getCosmosWeb3Domain: (blockchain: SupportedBlockchains) => {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+        salt: string;
+    };
+    const getSignatureExtension: (blockchain: SupportedBlockchains, address: string, signature: Uint8Array) => EncodeObject;
+    const getEIP712TypedData: (blockchain: SupportedBlockchains, tx: EvmIbcHelper.SignDoc, types?: object, domain?: EvmIbcHelper.TypedDomain, primaryType?: string) => TypedDataV4;
+    const makeSignedTx: (blockchain: SupportedBlockchains, msgs: EncodeObject[], tx: EvmIbcHelper.SignDoc, address: string, publicKey: Uint8Array, signature: Uint8Array, registry: Registry) => TxRaw;
+    const registerEthermintCodec: (registry: Registry) => void;
+}
+export default EvmIbcHelper;

package/lib/util/ethermint/evm-ibc.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tx_1 = require("../../codec/cosmos/tx/v1beta1/tx");
+const constant_1 = require("../../constant");
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const signing_1 = require("cosmjs-types/cosmos/tx/signing/v1beta1/signing");
+const blockchain_1 = require("../blockchain");
+const keys_1 = require("./keys");
+const web3_1 = require("./web3");
+const _DEFAULT_EIP712_TYPES = {
+    EIP712Domain: [
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'string' },
+        { name: 'salt', type: 'string' },
+    ],
+    Tx: [
+        { name: 'account_number', type: 'string' },
+        { name: 'chain_id', type: 'string' },
+        { name: 'fee', type: 'Fee' },
+        { name: 'memo', type: 'string' },
+        { name: 'msgs', type: 'Msg[]' },
+        { name: 'sequence', type: 'string' },
+    ],
+    Fee: [
+        { name: 'feePayer', type: 'string' },
+        { name: 'amount', type: 'Coin[]' },
+        { name: 'gas', type: 'string' },
+    ],
+    Coin: [
+        { name: 'denom', type: 'string' },
+        { name: 'amount', type: 'string' },
+    ],
+    Msg: [
+        { name: 'type', type: 'string' },
+        { name: 'value', type: 'MsgValue' },
+    ],
+};
+var EvmIbcHelper;
+(function (EvmIbcHelper) {
+    ;
+    EvmIbcHelper.TYPED_DATA_REQUEST_METHOD = "eth_signTypedData_v4";
+    EvmIbcHelper.DEFAULT_EIP712_TYPES = _DEFAULT_EIP712_TYPES;
+    EvmIbcHelper.getEvmChainId = (blockchain, network = constant_1.Network.MainNet) => {
+        switch (network) {
+            case constant_1.Network.MainNet:
+                switch (blockchain) {
+                    case blockchain_1.Blockchain.Canto:
+                        return 7700;
+                    case blockchain_1.Blockchain.Evmos:
+                        return 9001;
+                    default:
+                        throw new Error("network not supported");
+                }
+            default:
+                throw new Error("network not supported");
+        }
+    };
+    EvmIbcHelper.getIbcTransferTypes = () => {
+        return Object.assign(Object.assign({}, EvmIbcHelper.DEFAULT_EIP712_TYPES), { MsgValue: [
+                { name: 'source_port', type: 'string' },
+                { name: 'source_channel', type: 'string' },
+                { name: 'token', type: 'TypeToken' },
+                { name: 'sender', type: 'string' },
+                { name: 'receiver', type: 'string' },
+                { name: 'timeout_height', type: 'TypeTimeoutHeight' },
+                { name: 'timeout_timestamp', type: 'uint64' },
+            ], TypeToken: [
+                { name: 'denom', type: 'string' },
+                { name: 'amount', type: 'string' },
+            ], TypeTimeoutHeight: [
+                { name: 'revision_number', type: 'uint64' },
+                { name: 'revision_height', type: 'uint64' },
+            ] });
+    };
+    EvmIbcHelper.getCosmosWeb3Domain = (blockchain) => {
+        return {
+            name: "Cosmos Web3",
+            version: "1.0.0",
+            chainId: EvmIbcHelper.getEvmChainId(blockchain),
+            verifyingContract: "cosmos",
+            salt: "0",
+        };
+    };
+    EvmIbcHelper.getSignatureExtension = (blockchain, address, signature) => {
+        return {
+            typeUrl: "/ethermint.types.v1.ExtensionOptionsWeb3Tx",
+            value: web3_1.ExtensionOptionsWeb3Tx.encode(web3_1.ExtensionOptionsWeb3Tx.fromPartial({
+                typedDataChainId: EvmIbcHelper.getEvmChainId(blockchain),
+                feePayer: address,
+                feePayerSig: signature,
+            })).finish(),
+        };
+    };
+    EvmIbcHelper.getEIP712TypedData = (blockchain, tx, types = EvmIbcHelper.getIbcTransferTypes(), domain = EvmIbcHelper.getCosmosWeb3Domain(blockchain), primaryType = "Tx") => {
+        const typedData = {
+            types,
+            primaryType,
+            domain,
+            message: tx,
+        };
+        return typedData;
+    };
+    EvmIbcHelper.makeSignedTx = (blockchain, msgs, tx, address, publicKey, signature, registry) => {
+        EvmIbcHelper.registerEthermintCodec(registry);
+        const pubkey = registry.encodeAsAny({
+            typeUrl: '/ethermint.crypto.v1.ethsecp256k1.PubKey',
+            value: keys_1.PubKey.fromPartial({
+                key: publicKey,
+            }),
+        });
+        const signatureExtension = EvmIbcHelper.getSignatureExtension(blockchain, address, signature);
+        const txBodyBytes = registry.encodeTxBody({
+            extensionOptions: [signatureExtension],
+            messages: msgs,
+            memo: tx.memo,
+        });
+        const txRaw = tx_1.TxRaw.fromPartial({
+            authInfoBytes: proto_signing_1.makeAuthInfoBytes([{
+                    pubkey,
+                    sequence: parseInt(tx.sequence),
+                }], tx.fee.amount, parseInt(tx.fee.gas), signing_1.SignMode.SIGN_MODE_LEGACY_AMINO_JSON),
+            bodyBytes: txBodyBytes,
+            signatures: [new Uint8Array()],
+        });
+        return txRaw;
+    };
+    EvmIbcHelper.registerEthermintCodec = (registry) => {
+        registry.register('/ethermint.types.v1.ExtensionOptionsWeb3Tx', web3_1.ExtensionOptionsWeb3Tx);
+        registry.register('/ethermint.crypto.v1.ethsecp256k1.PubKey', keys_1.PubKey);
+    };
+})(EvmIbcHelper || (EvmIbcHelper = {}));
+exports.default = EvmIbcHelper;

package/lib/util/ethermint/index.d.ts

@@ -0,0 +1,3 @@
+export { PubKey } from "./keys";
+export { ExtensionOptionsWeb3Tx } from "./web3";
+export { default as EvmIbcHelper } from "./evm-ibc";

package/lib/util/ethermint/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmIbcHelper = exports.ExtensionOptionsWeb3Tx = exports.PubKey = void 0;
+var keys_1 = require("./keys");
+Object.defineProperty(exports, "PubKey", { enumerable: true, get: function () { return keys_1.PubKey; } });
+var web3_1 = require("./web3");
+Object.defineProperty(exports, "ExtensionOptionsWeb3Tx", { enumerable: true, get: function () { return web3_1.ExtensionOptionsWeb3Tx; } });
+var evm_ibc_1 = require("./evm-ibc");
+Object.defineProperty(exports, "EvmIbcHelper", { enumerable: true, get: function () { return __importDefault(evm_ibc_1).default; } });

package/lib/util/ethermint/keys.d.ts

@@ -0,0 +1,39 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.crypto.v1.ethsecp256k1";
+/**
+ * PubKey defines a type alias for an ecdsa.PublicKey that implements
+ * Tendermint's PubKey interface. It represents the 33-byte compressed public
+ * key format.
+ */
+export interface PubKey {
+    /** key is the public key in byte form */
+    key: Uint8Array;
+}
+/**
+ * PrivKey defines a type alias for an ecdsa.PrivateKey that implements
+ * Tendermint's PrivateKey interface.
+ */
+export interface PrivKey {
+    /** key is the private key in byte form */
+    key: Uint8Array;
+}
+export declare const PubKey: {
+    encode(message: PubKey, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PubKey;
+    fromJSON(object: any): PubKey;
+    toJSON(message: PubKey): unknown;
+    fromPartial(object: DeepPartial<PubKey>): PubKey;
+};
+export declare const PrivKey: {
+    encode(message: PrivKey, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PrivKey;
+    fromJSON(object: any): PrivKey;
+    toJSON(message: PrivKey): unknown;
+    fromPartial(object: DeepPartial<PrivKey>): PrivKey;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/util/ethermint/keys.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivKey = exports.PubKey = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.crypto.v1.ethsecp256k1";
+const basePubKey = {};
+exports.PubKey = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, basePubKey);
+        message.key = new Uint8Array();
+        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;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, basePubKey);
+        message.key =
+            object.key !== undefined && object.key !== null
+                ? bytesFromBase64(object.key)
+                : new Uint8Array();
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, basePubKey);
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        return message;
+    },
+};
+const basePrivKey = {};
+exports.PrivKey = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, basePrivKey);
+        message.key = new Uint8Array();
+        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;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, basePrivKey);
+        message.key =
+            object.key !== undefined && object.key !== null
+                ? bytesFromBase64(object.key)
+                : new Uint8Array();
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.key !== undefined &&
+            (obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, basePrivKey);
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        return message;
+    },
+};
+var globalThis = (() => {
+    if (typeof globalThis !== "undefined")
+        return globalThis;
+    if (typeof self !== "undefined")
+        return self;
+    if (typeof window !== "undefined")
+        return window;
+    if (typeof global !== "undefined")
+        return global;
+    throw "Unable to locate global object";
+})();
+const atob = globalThis.atob ||
+    ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+const btoa = globalThis.btoa ||
+    ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr) {
+    const bin = [];
+    for (const byte of arr) {
+        bin.push(String.fromCharCode(byte));
+    }
+    return btoa(bin.join(""));
+}
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/util/ethermint/web3.d.ts

@@ -0,0 +1,36 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "ethermint.types.v1";
+/**
+ * ExtensionOptionsWeb3Tx is an extension option that specifies the typed chain id,
+ * the fee payer as well as its signature data.
+ */
+export interface ExtensionOptionsWeb3Tx {
+    /**
+     * typed_data_chain_id is used only in EIP712 Domain and should match
+     * Ethereum network ID in a Web3 provider (e.g. Metamask).
+     */
+    typedDataChainId: Long;
+    /**
+     * fee_payer is an account address for the fee payer. It will be validated
+     * during EIP712 signature checking.
+     */
+    feePayer: string;
+    /**
+     * fee_payer_sig is a signature data from the fee paying account,
+     * allows to perform fee delegation when using EIP712 Domain.
+     */
+    feePayerSig: Uint8Array;
+}
+export declare const ExtensionOptionsWeb3Tx: {
+    encode(message: ExtensionOptionsWeb3Tx, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ExtensionOptionsWeb3Tx;
+    fromJSON(object: any): ExtensionOptionsWeb3Tx;
+    toJSON(message: ExtensionOptionsWeb3Tx): unknown;
+    fromPartial(object: DeepPartial<ExtensionOptionsWeb3Tx>): ExtensionOptionsWeb3Tx;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/util/ethermint/web3.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionOptionsWeb3Tx = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "ethermint.types.v1";
+const baseExtensionOptionsWeb3Tx = {
+    typedDataChainId: long_1.default.UZERO,
+    feePayer: "",
+};
+exports.ExtensionOptionsWeb3Tx = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (!message.typedDataChainId.isZero()) {
+            writer.uint32(8).uint64(message.typedDataChainId);
+        }
+        if (message.feePayer !== "") {
+            writer.uint32(18).string(message.feePayer);
+        }
+        if (message.feePayerSig.length !== 0) {
+            writer.uint32(26).bytes(message.feePayerSig);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseExtensionOptionsWeb3Tx);
+        message.feePayerSig = new Uint8Array();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.typedDataChainId = reader.uint64();
+                    break;
+                case 2:
+                    message.feePayer = reader.string();
+                    break;
+                case 3:
+                    message.feePayerSig = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseExtensionOptionsWeb3Tx);
+        message.typedDataChainId =
+            object.typedDataChainId !== undefined && object.typedDataChainId !== null
+                ? long_1.default.fromString(object.typedDataChainId)
+                : long_1.default.UZERO;
+        message.feePayer =
+            object.feePayer !== undefined && object.feePayer !== null
+                ? String(object.feePayer)
+                : "";
+        message.feePayerSig =
+            object.feePayerSig !== undefined && object.feePayerSig !== null
+                ? bytesFromBase64(object.feePayerSig)
+                : new Uint8Array();
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.typedDataChainId !== undefined &&
+            (obj.typedDataChainId = (message.typedDataChainId || long_1.default.UZERO).toString());
+        message.feePayer !== undefined && (obj.feePayer = message.feePayer);
+        message.feePayerSig !== undefined &&
+            (obj.feePayerSig = base64FromBytes(message.feePayerSig !== undefined
+                ? message.feePayerSig
+                : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = Object.assign({}, baseExtensionOptionsWeb3Tx);
+        message.typedDataChainId =
+            object.typedDataChainId !== undefined && object.typedDataChainId !== null
+                ? long_1.default.fromValue(object.typedDataChainId)
+                : long_1.default.UZERO;
+        message.feePayer = (_a = object.feePayer) !== null && _a !== void 0 ? _a : "";
+        message.feePayerSig = (_b = object.feePayerSig) !== null && _b !== void 0 ? _b : new Uint8Array();
+        return message;
+    },
+};
+var globalThis = (() => {
+    if (typeof globalThis !== "undefined")
+        return globalThis;
+    if (typeof self !== "undefined")
+        return self;
+    if (typeof window !== "undefined")
+        return window;
+    if (typeof global !== "undefined")
+        return global;
+    throw "Unable to locate global object";
+})();
+const atob = globalThis.atob ||
+    ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
+function bytesFromBase64(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+const btoa = globalThis.btoa ||
+    ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
+function base64FromBytes(arr) {
+    const bin = [];
+    for (const byte of arr) {
+        bin.push(String.fromCharCode(byte));
+    }
+    return btoa(bin.join(""));
+}
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/util/fetch.js

@@ -10,7 +10,7 @@ function fetch(url, init) {
         return window.fetch(url, Object.assign({}, init));
     }
     else {
-        return node_fetch_1.default(url, init);
+        return (0, node_fetch_1.default)(url, init);
     }
 }
 exports.fetch = fetch;

package/lib/util/generic.js

@@ -22,7 +22,7 @@ const overrideConfig = (defaults, override) => {
             continue;
         if (typeof member === "object") {
             // @ts-ignore
-            result[key] = exports.overrideConfig(result[key], member);
+            result[key] = (0, exports.overrideConfig)(result[key], member);
         }
         else {
             // @ts-ignore
@@ -41,7 +41,7 @@ const sortObject = (input) => {
     Object.keys(input)
         .sort()
         // @ts-ignore noImplicitAny
-        .forEach((key) => (output[key] = exports.sortObject(input[key])));
+        .forEach((key) => (output[key] = (0, exports.sortObject)(input[key])));
     return output;
 };
 exports.sortObject = sortObject;
@@ -56,7 +56,7 @@ exports.appendHexPrefix = appendHexPrefix;
 const computeTxHash = (bytes) => {
     if (!bytes)
         return bytes;
-    return exports.toTxHash(crypto_1.sha256(bytes));
+    return (0, exports.toTxHash)((0, crypto_1.sha256)(bytes));
 };
 exports.computeTxHash = computeTxHash;
 const toTxHash = (bytes) => {

package/lib/util/number.js

@@ -18,26 +18,26 @@ const parseBN = (input, defaultValue) => {
 };
 exports.parseBN = parseBN;
 const bnOrZero = (input, defaultValue = exports.BN_ZERO) => {
-    return exports.parseBN(input, defaultValue);
+    return (0, exports.parseBN)(input, defaultValue);
 };
 exports.bnOrZero = bnOrZero;
 const toHuman = (value, decimals) => {
     if (value === undefined || value === null)
         return undefined;
-    const valueBN = exports.bnOrZero(value);
+    const valueBN = (0, exports.bnOrZero)(value);
     if (!decimals)
         return valueBN; // decimals = 0 or nullish
-    const decimalsBN = exports.bnOrZero(decimals);
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
     return valueBN.shiftedBy(decimalsBN.negated().toNumber());
 };
 exports.toHuman = toHuman;
 const toUnitless = (value, decimals) => {
     if (value === undefined || value === null)
         return undefined;
-    const valueBN = exports.bnOrZero(value);
+    const valueBN = (0, exports.bnOrZero)(value);
     if (!decimals)
         return valueBN; // decimals = 0 or nullish
-    const decimalsBN = exports.bnOrZero(decimals);
+    const decimalsBN = (0, exports.bnOrZero)(decimals);
     return valueBN.shiftedBy(decimalsBN.toNumber());
 };
 exports.toUnitless = toUnitless;

package/lib/wallet/CarbonSigner.js

@@ -106,9 +106,9 @@ class CarbonLedgerSigner {
         return __awaiter(this, void 0, void 0, function* () {
             const account = yield this.retrieveAccount();
             const { pubkey } = account;
-            const msg = JSON.stringify(generic_1.sortObject(doc));
+            const msg = JSON.stringify((0, generic_1.sortObject)(doc));
             const signBytes = yield this.ledger.sign(msg);
-            const signature = amino_1.encodeSecp256k1Signature(pubkey, signBytes);
+            const signature = (0, amino_1.encodeSecp256k1Signature)(pubkey, signBytes);
             return {
                 signed: doc,
                 signature,