example-js-sdk 0.0.1

package/lib/provider/leap/LeapAccount.d.ts

@@ -0,0 +1,28 @@
+import { CarbonSigner } from "../../wallet";
+import { Leap } from "@cosmos-kit/leap-extension";
+import { AppCurrency, ChainInfo, FeeCurrency } from "@keplr-wallet/types";
+import SDKProvider from "../sdk";
+declare class LeapAccount {
+    static SWTH_CURRENCY: AppCurrency;
+    static BASE_CHAIN_INFO: {
+        readonly bip44: {
+            readonly coinType: number;
+        };
+        readonly currencies: readonly [];
+        readonly feeCurrencies: readonly [FeeCurrency];
+        readonly gasPriceStep: {
+            readonly low: number;
+            readonly average: number;
+            readonly high: number;
+        } | undefined;
+    };
+    static createLeapSigner(leap: Leap, chainId: string): CarbonSigner;
+    static createLeapSignerAmino(leap: Leap, chainId: string): CarbonSigner;
+    static getChainId(configProvider: SDKProvider): Promise<string>;
+    static getChainInfo(configProvider: SDKProvider): Promise<ChainInfo>;
+}
+declare namespace LeapAccount { }
+export interface LeapExtended extends Leap {
+    experimentalSuggestChain(chainInfo: ChainInfo): Promise<void>;
+}
+export default LeapAccount;

package/lib/provider/leap/LeapAccount.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../../constant");
+const util_1 = require("../../util");
+const wallet_1 = require("../../wallet");
+const ethermint_1 = require("../../util/ethermint");
+const provider_1 = require("../../util/provider");
+const types_1 = require("@keplr-wallet/types");
+const ethers_1 = require("ethers");
+const error_1 = require("../metamask/error");
+const long_1 = __importDefault(require("long"));
+const SWTH = {
+    coinDenom: "SWTH",
+    coinMinimalDenom: "swth",
+    coinDecimals: 8,
+    coinGeckoId: "switcheo",
+    gasPriceStep: constant_1.CARBON_GAS_PRICE,
+};
+class LeapAccount {
+    static createLeapSigner(leap, chainId) {
+        const signDirect = async (signerAddress, doc) => {
+            return await (0, provider_1.signTransactionWrapper)(async () => {
+                const signOpts = { preferNoSetFee: true };
+                const { bodyBytes, authInfoBytes, chainId, accountNumber } = doc;
+                const parsedDoc = {
+                    bodyBytes,
+                    authInfoBytes,
+                    chainId,
+                    accountNumber: new long_1.default(Number(accountNumber)),
+                };
+                return await leap.signDirect(chainId, signerAddress, parsedDoc, signOpts);
+            });
+        };
+        const signAmino = async (signerAddress, doc) => {
+            return await (0, provider_1.signTransactionWrapper)(async () => {
+                const signOpts = { preferNoSetFee: true };
+                return await leap.signAmino(chainId, signerAddress, doc, signOpts);
+            });
+        };
+        const getAccounts = async () => {
+            const account = await leap.getKey(chainId);
+            return [
+                {
+                    algo: "secp256k1",
+                    address: account.bech32Address,
+                    pubkey: account.pubKey,
+                },
+            ];
+        };
+        const sendEvmTransaction = async (api, req) => {
+            try {
+                // workaround for version mismatch in cosmos-kit/leap and leap-extension
+                const leapInterface = leap;
+                if (typeof leapInterface.signEthereum === 'function') {
+                    const unsignedTx = await (0, ethermint_1.populateUnsignedEvmTranscation)(api, req);
+                    const signedTx = await leapInterface.signEthereum(
+                    // carbon chain id
+                    api.wallet?.getChainId() ?? '', 
+                    // cosmos address
+                    api.wallet?.bech32Address ?? '', JSON.stringify(unsignedTx), types_1.EthSignType.TRANSACTION);
+                    const rlpEncodedHex = ethers_1.ethers.utils.serializeTransaction(unsignedTx, signedTx);
+                    const provider = new ethers_1.ethers.providers.JsonRpcProvider(constant_1.NetworkConfigs[api.network].evmJsonRpcUrl);
+                    return (await provider.sendTransaction(rlpEncodedHex)).hash;
+                }
+                else {
+                    throw new Error("signing not available");
+                }
+            }
+            catch (error) {
+                console.error(error);
+                throw ((0, error_1.parseEvmError)(error));
+            }
+        };
+        const signMessage = async (address, message) => {
+            const { signature } = await leap.signArbitrary(chainId, address, message);
+            return Buffer.from(signature, 'base64').toString('hex');
+        };
+        return {
+            type: wallet_1.CarbonSignerTypes.BrowserInjected,
+            signDirect,
+            signAmino,
+            getAccounts,
+            sendEvmTransaction,
+            signMessage,
+        };
+    }
+    static createLeapSignerAmino(leap, chainId) {
+        const signAmino = async (signerAddress, doc) => {
+            return await (0, provider_1.signTransactionWrapper)(async () => {
+                const signOpts = { preferNoSetFee: true };
+                return await leap.signAmino(chainId, signerAddress, doc, signOpts);
+            });
+        };
+        const getAccounts = async () => {
+            const account = await leap.getKey(chainId);
+            return [
+                {
+                    algo: "secp256k1",
+                    address: account.bech32Address,
+                    pubkey: account.pubKey,
+                },
+            ];
+        };
+        const sendEvmTransaction = async (api, req) => {
+            try {
+                const leapInterface = leap;
+                if (typeof leapInterface.signEthereum === 'function') {
+                    const unsignedTx = await (0, ethermint_1.populateUnsignedEvmTranscation)(api, req);
+                    const signedTx = await leapInterface.signEthereum(
+                    // carbon chain id
+                    api.wallet?.getChainId() ?? '', 
+                    // cosmos address
+                    api.wallet?.bech32Address ?? '', JSON.stringify(unsignedTx), types_1.EthSignType.TRANSACTION);
+                    const rlpEncodedHex = ethers_1.ethers.utils.serializeTransaction(unsignedTx, signedTx);
+                    const provider = new ethers_1.ethers.providers.JsonRpcProvider(constant_1.NetworkConfigs[api.network].evmJsonRpcUrl);
+                    return (await provider.sendTransaction(rlpEncodedHex)).hash;
+                }
+                else {
+                    throw new Error("signing not available");
+                }
+            }
+            catch (error) {
+                console.error(error);
+                throw ((0, error_1.parseEvmError)(error));
+            }
+        };
+        const signMessage = async (address, message) => {
+            const { signature } = await leap.signArbitrary(chainId, address, message);
+            return Buffer.from(signature, 'base64').toString('hex');
+        };
+        return {
+            type: wallet_1.CarbonSignerTypes.BrowserInjected,
+            signAmino,
+            getAccounts,
+            sendEvmTransaction,
+            signMessage,
+        };
+    }
+    static async getChainId(configProvider) {
+        const chainId = await configProvider.query.chain.getChainId();
+        return chainId;
+    }
+    static async getChainInfo(configProvider) {
+        const config = configProvider.getConfig();
+        const bech32Prefix = config.Bech32Prefix;
+        const chainId = config.chainId;
+        const gasPricesResult = await configProvider.query.fee.MinGasPriceAll({});
+        const tokenClient = configProvider.getTokenClient();
+        const coingeckoIdMap = tokenClient.geckoTokenNames;
+        const feeCurrencies = gasPricesResult.minGasPrices.reduce((result, price) => {
+            const token = tokenClient.tokenForDenom(price.denom);
+            if (!token || token.denom === "swth")
+                return result;
+            // Check if gas price is valid, else add default
+            const gasPriceAdjusted = util_1.NumberUtils.bnOrZero(price.gasPrice).shiftedBy(-constant_1.decTypeDecimals);
+            const minGasPrice = gasPriceAdjusted.isNaN() || gasPriceAdjusted.isZero()
+                ? LeapAccount.BASE_CHAIN_INFO.gasPriceStep?.low ?? constant_1.CARBON_GAS_PRICE.low
+                : gasPriceAdjusted.toNumber();
+            result.push({
+                coinDenom: token.symbol ?? token.denom,
+                coinMinimalDenom: token.denom,
+                coinDecimals: token.decimals.toNumber(),
+                coinGeckoId: coingeckoIdMap[token.denom],
+                gasPriceStep: {
+                    low: minGasPrice,
+                    average: minGasPrice,
+                    high: minGasPrice,
+                },
+            });
+            return result;
+        }, []);
+        return {
+            feeCurrencies: [LeapAccount.SWTH_CURRENCY, ...feeCurrencies],
+            bip44: LeapAccount.BASE_CHAIN_INFO.bip44,
+            currencies: [LeapAccount.SWTH_CURRENCY, ...feeCurrencies],
+            stakeCurrency: LeapAccount.SWTH_CURRENCY,
+            rest: config.restUrl,
+            rpc: config.tmRpcUrl,
+            chainName: config.network === constant_1.Network.MainNet ? `Carbon` : `Carbon (${config.network})`,
+            chainId: chainId,
+            bech32Config: {
+                bech32PrefixAccAddr: `${bech32Prefix}`,
+                bech32PrefixAccPub: `${bech32Prefix}pub`,
+                bech32PrefixValAddr: `${bech32Prefix}valoper`,
+                bech32PrefixValPub: `${bech32Prefix}valoperpub`,
+                bech32PrefixConsAddr: `${bech32Prefix}valcons`,
+                bech32PrefixConsPub: `${bech32Prefix}valconspub`,
+            },
+            features: ["stargate", "ibc-transfer", "ibc-go"],
+        };
+    }
+}
+LeapAccount.SWTH_CURRENCY = SWTH;
+LeapAccount.BASE_CHAIN_INFO = {
+    bip44: { coinType: util_1.AddressUtils.SWTHAddress.coinType() },
+    currencies: [],
+    feeCurrencies: [SWTH],
+    gasPriceStep: SWTH.gasPriceStep,
+};
+exports.default = LeapAccount;

package/lib/provider/leap/index.d.ts

@@ -0,0 +1,3 @@
+export { default, LeapExtended } from "./LeapAccount";
+export { Key } from "@cosmos-kit/core";
+export { Leap } from "@cosmos-kit/leap-extension";

package/lib/provider/leap/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var LeapAccount_1 = require("./LeapAccount");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(LeapAccount_1).default; } });

package/lib/provider/ledger/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./ledger";

package/lib/provider/ledger/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var ledger_1 = require("./ledger");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(ledger_1).default; } });

package/lib/provider/ledger/ledger.d.ts

@@ -0,0 +1,28 @@
+declare class CosmosLedger {
+    private readonly testModeAllowed;
+    private cosmosApp;
+    private hdPath;
+    private hrp;
+    platform: string;
+    userAgent: string;
+    constructor({ testModeAllowed }?: {
+        testModeAllowed?: Boolean;
+    }, hdPath?: Array<number>, hrp?: string);
+    testDevice(): Promise<this>;
+    private isReady;
+    connect(timeout?: number): Promise<this>;
+    disconnect(): Promise<void>;
+    getDeviceName(): Promise<any>;
+    getCosmosAppVersion(): Promise<string>;
+    isCosmosAppOpen(): Promise<void>;
+    getOpenApp(): Promise<any>;
+    getPubKey(): Promise<any>;
+    getCosmosAddress(): Promise<string>;
+    generateCosmosAddress(hdPath: Array<number>): Promise<string>;
+    changeBIP44Path(hdPath: Array<number>, hrp: string): Promise<void>;
+    confirmLedgerAddress(): Promise<void>;
+    sign(signMessage: string): Promise<Uint8Array<ArrayBufferLike>>;
+    private checkLedgerErrors;
+}
+export declare const checkAppMode: (testModeAllowed: Boolean, testMode: Boolean) => void;
+export default CosmosLedger;

package/lib/provider/ledger/ledger.js

@@ -0,0 +1,308 @@
+"use strict";
+/* eslint-disable */
+/* @ts-nocheck */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAppMode = void 0;
+// this file was inserted to fix Chrome 91 killing web u2f
+// original implementation: https://github.com/luniehq/cosmos-ledger
+const ledger_cosmos_js_1 = __importDefault(require("ledger-cosmos-js"));
+const bech32 = __importStar(require("bech32"));
+const ethers_1 = require("ethers");
+const secp256k1_1 = require("secp256k1");
+const provider_1 = require("../../util/provider");
+const semver = require("semver");
+const INTERACTION_TIMEOUT = 120; // seconds to wait for user action on Ledger, currently is always limited to 60
+const REQUIRED_COSMOS_APP_VERSION = "1.5.3";
+/*
+HD wallet derivation path (BIP44)
+DerivationPath{44, 118, account, 0, index}
+*/
+const HDPATH = [44, 118, 0, 0, 0];
+const BECH32PREFIX = `cosmos`;
+class CosmosLedger {
+    constructor({ testModeAllowed = false } = { testModeAllowed: false }, hdPath = HDPATH, hrp = BECH32PREFIX) {
+        this.testModeAllowed = testModeAllowed;
+        this.hdPath = hdPath;
+        this.hrp = hrp;
+        this.platform = navigator.platform; // set it here to overwrite in tests
+        this.userAgent = navigator.userAgent; // set it here to overwrite in tests
+    }
+    // quickly test connection and compatibility with the Ledger device throwing away the connection
+    async testDevice() {
+        // poll device with low timeout to check if the device is connected
+        const secondsTimeout = 3; // a lower value always timeouts
+        await this.connect(secondsTimeout);
+        this.cosmosApp = null;
+        return this;
+    }
+    // check if the Ledger device is ready to receive signing requests
+    async isReady() {
+        // check if the version is supported
+        const version = await this.getCosmosAppVersion();
+        if (!semver.gte(version, REQUIRED_COSMOS_APP_VERSION)) {
+            const msg = `Outdated version: Please update Ledger Cosmos App to the latest version.`;
+            throw new Error(msg);
+        }
+        // throws if not open
+        await this.isCosmosAppOpen();
+    }
+    // connects to the device and checks for compatibility
+    // the timeout is the time the user has to react to requests on the Ledger device
+    // set a low timeout to only check the connection without preparing the connection for user input
+    async connect(timeout = INTERACTION_TIMEOUT) {
+        // assume well connection if connected once
+        if (this.cosmosApp)
+            return this;
+        // check if browser is supported
+        getBrowser(this.userAgent);
+        const isChrome91 = parseInt(this.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./)?.[2] ?? "0") >= 91;
+        const isOpera95 = parseInt(this.userAgent.match(/OPR\/([0-9]+)\./)?.[1] ?? "0") >= 95;
+        let transport;
+        if (isWindows(this.platform) || (isChrome91 && !isOpera95)) {
+            if (!navigator.hid) {
+                throw new Error(`Your browser doesn't have HID enabled. Please enable this feature by visiting: chrome://flags/#enable-experimental-web-platform-features`);
+            }
+            const { default: TransportWebHID } = await Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "webhid" */ "@ledgerhq/hw-transport-webhid")));
+            transport = await TransportWebHID.create(timeout * 1000);
+        }
+        // OSX / Linux
+        else {
+            try {
+                const { default: TransportWebUSB } = await Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "webusb" */ "@ledgerhq/hw-transport-webusb")));
+                transport = await TransportWebUSB.create(timeout * 1000);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    /* istanbul ignore next: specific error rewrite */
+                    if (err.message.trim().startsWith("No WebUSB interface found for your Ledger device")) {
+                        throw new Error("Couldn't connect to a Ledger device. Please use Ledger Live to upgrade the Ledger firmware to version 1.5.5 or later.");
+                    }
+                    /* istanbul ignore next: specific error rewrite */
+                    if (err.message.trim().startsWith("Unable to claim interface")) {
+                        // apparently can't use it in several tabs in parallel
+                        throw new Error("Could not access Ledger device. Is it being used in another tab?");
+                    }
+                    /* istanbul ignore next: specific error rewrite */
+                    if (err.message.trim().startsWith("Not supported")) {
+                        // apparently can't use it in several tabs in parallel
+                        throw new Error("Your browser doesn't seem to support WebUSB yet. Try updating it to the latest version.");
+                    }
+                    /* istanbul ignore next: specific error rewrite */
+                    if (err.message.trim().startsWith("No device selected")) {
+                        // apparently can't use it in several tabs in parallel
+                        throw new Error("You did not select a Ledger device. If you didn't see your Ledger, check if the Ledger is plugged in and unlocked.");
+                    }
+                }
+                // throw unknown error
+                throw err;
+            }
+        }
+        const cosmosLedgerApp = new ledger_cosmos_js_1.default(transport);
+        this.cosmosApp = cosmosLedgerApp;
+        // checks if the Ledger is connected and the app is open
+        await this.isReady();
+        return this;
+    }
+    async disconnect() {
+        await this.cosmosApp.transport.close();
+    }
+    async getDeviceName() {
+        const deviceName = await this.cosmosApp.transport?.deviceModel?.productName;
+        if (deviceName) {
+            return deviceName;
+        }
+        return undefined;
+    }
+    // returns the cosmos app version as a string like "1.1.0"
+    async getCosmosAppVersion() {
+        await this.connect();
+        const response = await this.cosmosApp.getVersion();
+        await this.checkLedgerErrors(response);
+        const { major, minor, patch, test_mode } = response;
+        (0, exports.checkAppMode)(this.testModeAllowed, test_mode);
+        const version = versionString({ major, minor, patch });
+        return version;
+    }
+    // checks if the cosmos app is open
+    // to be used for a nicer UX
+    async isCosmosAppOpen() {
+        const appName = await this.getOpenApp();
+        if (appName.toLowerCase() === `dashboard`) {
+            throw new Error(`Please open the Cosmos Ledger app on your Ledger device.`);
+        }
+        if (appName.toLowerCase() !== `cosmos`) {
+            throw new Error(`Please close ${appName} and open the Cosmos Ledger app on your Ledger device.`);
+        }
+    }
+    async getOpenApp() {
+        await this.connect();
+        const response = await this.cosmosApp.appInfo();
+        await this.checkLedgerErrors(response);
+        const { appName } = response;
+        return appName;
+    }
+    // returns the public key from the Ledger device as a Buffer
+    async getPubKey() {
+        await this.connect();
+        const response = await this.cosmosApp.publicKey(this.hdPath);
+        await this.checkLedgerErrors(response);
+        return response.compressed_pk;
+    }
+    // returns the cosmos address from the Ledger as a string
+    async getCosmosAddress() {
+        await this.connect();
+        const pubKey = await this.getPubKey();
+        const res = await getBech32FromPK(this.hrp, pubKey);
+        return res;
+    }
+    async generateCosmosAddress(hdPath) {
+        await this.connect();
+        const pubKey = await this.cosmosApp.publicKey(hdPath);
+        await this.checkLedgerErrors(pubKey);
+        const compressedPk = pubKey.compressed_pk;
+        const response = await getBech32FromPK(this.hrp, compressedPk);
+        return response;
+    }
+    async changeBIP44Path(hdPath, hrp) {
+        try {
+            this.hdPath = hdPath;
+            this.hrp = hrp;
+        }
+        catch (error) {
+            throw new Error(`error`);
+        }
+        return;
+    }
+    // triggers a confirmation request of the cosmos address on the Ledger device
+    async confirmLedgerAddress() {
+        await this.connect();
+        const cosmosAppVersion = await this.getCosmosAppVersion();
+        if (semver.lt(cosmosAppVersion, REQUIRED_COSMOS_APP_VERSION)) {
+            // we can't check the address on an old cosmos app
+            return;
+        }
+        const response = await this.cosmosApp.showAddressAndPubKey(this.hdPath, this.hrp);
+        await this.checkLedgerErrors(response, {
+            rejectionMessage: "Displayed address was rejected",
+        });
+    }
+    // create a signature for any message
+    // in Cosmos this should be a serialized StdSignMsg
+    // this is ideally generated by the @lunie/cosmos-js library
+    async sign(signMessage) {
+        await this.connect();
+        const response = await (0, provider_1.signTransactionWrapper)(async () => {
+            return await this.cosmosApp.sign(this.hdPath, signMessage);
+        });
+        await this.checkLedgerErrors(response);
+        // we have to parse the signature from Ledger as it's in DER format
+        const parsedSignature = (0, secp256k1_1.signatureImport)(response.signature);
+        return parsedSignature;
+    }
+    // parse Ledger errors in a more user friendly format
+    /* istanbul ignore next: maps a bunch of errors */
+    async checkLedgerErrors({ error_message, device_locked }, { timeoutMessag = "Connection timed out. Please try again.", rejectionMessage = "User rejected the transaction" } = {}) {
+        if (device_locked) {
+            throw new Error(`Ledger's screensaver mode is on`);
+        }
+        if (error_message !== 'No errors') {
+            await this.disconnect();
+        }
+        switch (error_message) {
+            case `U2F: Timeout`:
+                throw new Error(timeoutMessag);
+            case `App does not seem to be open`:
+                throw new Error(`Please open the Cosmos App on your Ledger device`);
+            case `Command not allowed`:
+                throw new Error(`Transaction rejected`);
+            case `Transaction rejected`:
+                throw new Error(rejectionMessage);
+            case `Unknown Status Code: 26628`:
+                throw new Error(`Ledger's screensaver mode is on`);
+            case `Unknown Status Code: 28161`:
+                throw new Error(`Please open the Cosmos App on your Ledger device`);
+            case `Instruction not supported`:
+                throw new Error(`Your Cosmos Ledger App is not up to date. Please update to version ${REQUIRED_COSMOS_APP_VERSION}.`);
+            case `No errors`:
+                // do nothing
+                break;
+            default:
+                throw new Error(`Ledger Native Error: ${error_message}`);
+        }
+    }
+}
+// stiched version string from Ledger app version object
+function versionString({ major, minor, patch }) {
+    return `${major}.${minor}.${patch}`;
+}
+// wrapper to throw if app is in testmode but it is not allowed to be in testmode
+const checkAppMode = (testModeAllowed, testMode) => {
+    if (testMode && !testModeAllowed) {
+        throw new Error(`DANGER: The Cosmos Ledger app is in test mode and shouldn't be used on mainnet!`);
+    }
+};
+exports.checkAppMode = checkAppMode;
+// doesn't properly work in ledger-cosmos-js
+function getBech32FromPK(hrp, pk) {
+    if (pk.length !== 33) {
+        throw new Error("expected compressed public key [31 bytes]");
+    }
+    const hashSha256 = ethers_1.ethers.utils.sha256(pk);
+    const hashRip = ethers_1.ethers.utils.ripemd160(hashSha256);
+    return bech32.encode(hrp, bech32.toWords(Buffer.from(hashRip.replace(/^0x/, ""), "hex")));
+}
+function isWindows(platform) {
+    return platform.indexOf("Win") > -1;
+}
+function getBrowser(userAgent) {
+    const ua = userAgent.toLowerCase();
+    const isChrome = /chrome|crios/.test(ua) && !/edge\//.test(ua);
+    const isBrave = isChrome && !window?.google;
+    const isOpera = /opr/.test(ua);
+    if (!isChrome && !isBrave && !isOpera) {
+        throw new Error("Your browser doesn't support Ledger devices.");
+    }
+    if (isBrave)
+        return "brave";
+    else if (isOpera)
+        return "opera";
+    else
+        return "chrome";
+}
+exports.default = CosmosLedger;

package/lib/provider/metamask/MetaMask.d.ts

@@ -0,0 +1,83 @@
+import { Network, RequestArguments, SyncResult } from "../../constant";
+import { CarbonSDK } from "../../index";
+import { CarbonTx } from "../../util";
+import { SWTHAddressOptions } from "../../util/address";
+import { BlockchainV2, EVMChain } from "../../util/blockchain";
+import { CarbonSigner } from "../../wallet";
+import { AminoMsg } from "@cosmjs/amino";
+import { StdFee } from "@cosmjs/stargate";
+import { ethers } from "ethers";
+import { ChangeNetworkParam as MetaMaskChangeNetworkParam } from "../../constant";
+import { Eip6963Provider } from "../eip6963Provider";
+interface MetaMaskAPI {
+    isMetaMask: boolean;
+    chainId: string | null;
+    _state: {
+        isConnected: boolean;
+    };
+    request: (args: RequestArguments) => Promise<unknown>;
+    on: (eventName: string, listener: (...args: unknown[]) => void) => any;
+}
+export interface CallContractArgs {
+    from?: string;
+    value?: string;
+    data?: string;
+}
+export interface StoredMnemonicInfo {
+    mnemonic: string;
+    chain: EVMChain;
+    privateKey: string;
+    bech32Address: string;
+    evmHexAddress: string;
+}
+/**
+ * TODO: Add docs
+ */
+export declare class MetaMask extends Eip6963Provider {
+    readonly network: Network;
+    readonly legacyEip712SignMode: boolean;
+    private blockchain;
+    private connectedAccount;
+    static createMetamaskSigner(metamask: MetaMask, evmChainId: string, pubKeyBase64: string, addressOptions: SWTHAddressOptions): CarbonSigner;
+    static signAndRecoverPubKey(provider: MetaMask, enableJwtAuth?: boolean, customMsg?: string): Promise<{
+        publicKey: string;
+        signature: string;
+        message: string;
+    }>;
+    static getNetworkParams(network: Network, blockchain?: EVMChain): MetaMaskChangeNetworkParam;
+    static getCarbonEvmNetworkParams(network: Network): MetaMaskChangeNetworkParam;
+    static getRequiredChainId(network: Network, blockchain?: BlockchainV2): number;
+    constructor(network: Network, legacyEip712SignMode?: boolean);
+    private checkProvider;
+    getBlockchain(): BlockchainV2;
+    syncConnectedAccount(): Promise<string>;
+    syncBlockchain(): Promise<SyncResult>;
+    getSigner(): Promise<ethers.Signer>;
+    getDefaultMetamaskProvider(): MetaMaskAPI | undefined;
+    getConnectedAPI(): Promise<MetaMaskAPI>;
+    connect(): Promise<MetaMaskAPI>;
+    defaultAccount(): Promise<string>;
+    getEncryptedLegacyAccounts(network?: Network): Promise<StoredMnemonicInfo[] | undefined>;
+    changeNetworkIfRequired(blockchain: EVMChain, network: CarbonSDK.Network): Promise<void>;
+    isChangeNetworkRequired(blockchain: EVMChain, network: CarbonSDK.Network): Promise<boolean>;
+    verifyNetworkAndConnectedAccount(evmHexAddress: string, evmChainId: string): Promise<void>;
+    verifyNetwork(evmChainId: string): Promise<void>;
+    verifyConnectedAccount(address: string): Promise<void>;
+    getMnemonicInfo(connectedBlockchain: EVMChain): Promise<StoredMnemonicInfo | undefined>;
+    getStoredMnemonicCipher(account: string, blockchain?: EVMChain): Promise<string | undefined>;
+    encryptMnemonic(mnemonic: string): Promise<string>;
+    signPublicKeyMergeAccount(publicKey: string, address: string): Promise<string>;
+    personalSign(address: string, message: string): Promise<string>;
+    getEncryptionPublicKey(address: string): Promise<string>;
+    signEip712(evmHexAddress: string, accountNumber: string, evmChainId: string, msgs: readonly AminoMsg[], fee: StdFee, memo: string, sequence: string, feePayer?: string): Promise<{
+        sig: string;
+        signedDoc: CarbonTx.StdSignDoc;
+    }>;
+    sendEvmTransaction(req: ethers.providers.TransactionRequest): Promise<string>;
+    storeMnemonic(encryptedMnemonic: string, blockchain?: EVMChain): Promise<string>;
+    login(blockchain?: EVMChain): Promise<string | null>;
+    decryptCipher(cipherTextHex?: string): Promise<string | null>;
+    private getRequiredChain;
+    private getContractHash;
+}
+export {};