example-js-sdk 0.0.1

package/lib/provider/amino/utils.js

@@ -0,0 +1,249 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneAmino = exports.generateAminoType = exports.paramConverter = exports.NANOS_IN_ONE_SECOND = exports.mapEachIndiv = exports.ConvertEncType = void 0;
+const util_1 = require("../../util");
+const index_1 = require("../../index");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const long_1 = __importDefault(require("long"));
+var ConvertEncType;
+(function (ConvertEncType) {
+    ConvertEncType["Long"] = "long";
+    ConvertEncType["LongToNum"] = "long-number";
+    ConvertEncType["Dec"] = "dec";
+    ConvertEncType["DecOrZero"] = "dec-or-zero";
+    ConvertEncType["NumToStr"] = "number-str";
+    ConvertEncType["Date"] = "date";
+    ConvertEncType["DateToNum"] = "date-number";
+    ConvertEncType["Duration"] = "duration";
+    ConvertEncType["Uint8Array"] = "uint8array";
+})(ConvertEncType || (exports.ConvertEncType = ConvertEncType = {}));
+/**
+ * checks if value is Long, BigNumber, Date, Duration or Uint8Array
+ * @param value value to check
+ */
+const typeCheck = (value) => {
+    return long_1.default.isLong(value)
+        || bignumber_js_1.default.isBigNumber(value)
+        || value instanceof Date
+        || value instanceof Uint8Array
+        || ((value.seconds !== undefined && long_1.default.isLong(value.seconds)) && (value.nanos !== undefined && typeof value.nanos === 'number')); // Check for Duration interface
+};
+const isArrayOfStrings = (value) => {
+    return Array.isArray(value) && value.length !== 0 && value.every(item => typeof item === "string");
+};
+const isConvertEncType = (value) => {
+    return Object.values(ConvertEncType).includes(value);
+};
+/**
+ * checks maps object to amino or direct form
+ * @param mapItem obj to be converted
+ * @param valueKey obj with labels that indicate how each value is treated
+ * @param toAmino indicates whether to convert to amino or direct
+ */
+const mapEachIndiv = (mapItem, valueKey, toAmino = false) => {
+    if (!mapItem) {
+        return mapItem;
+    }
+    const indivDirectKeys = Object.keys(mapItem) ?? [];
+    const directMap = {};
+    indivDirectKeys.forEach((key) => {
+        const altKey = toAmino ? util_1.TypeUtils.camelToSnake(key) : util_1.TypeUtils.snakeToCamel(key);
+        const keyMap = toAmino ? valueKey?.[key] : valueKey?.[altKey];
+        if (typeof keyMap !== "object") {
+            // Check if this is a Long/BigNumber/Buffer/Date/Duration obj or a non-object/array
+            if (typeCheck(mapItem[key]) || typeof mapItem[key] !== "object") {
+                if (!keyMap && mapItem[key] instanceof Date) {
+                    directMap[altKey] = (0, exports.paramConverter)(mapItem[key], ConvertEncType.Date, toAmino);
+                    return;
+                }
+                directMap[altKey] = (0, exports.paramConverter)(mapItem[key], keyMap, toAmino);
+                return;
+            }
+        }
+        if (mapItem[key].length && typeof mapItem[key] === "object") {
+            if (isArrayOfStrings(mapItem[key])) {
+                directMap[altKey] = mapItem[key];
+                return;
+            }
+            // If value is an array of objects, iterate through objects and call mapToObj function
+            directMap[altKey] = mapItem[key].map((newMap) => {
+                return (0, exports.mapEachIndiv)(newMap, valueKey, toAmino);
+            });
+            return;
+        }
+        else {
+            if (util_1.TypeUtils.isDurationType(mapItem[key])) {
+                directMap[altKey] = (0, exports.paramConverter)(mapItem[key], keyMap, toAmino);
+                return;
+            }
+            if (mapItem[key]?.length === 0) {
+                directMap[altKey] = [];
+                return;
+            }
+            directMap[altKey] = (0, exports.mapEachIndiv)(mapItem[key], keyMap, toAmino);
+        }
+    });
+    return directMap;
+};
+exports.mapEachIndiv = mapEachIndiv;
+exports.NANOS_IN_ONE_SECOND = new long_1.default(10 ** 9);
+/**
+ * convert direct params to corresponding amino params
+ * @param value direct params to be converted
+ * @param type param type (check ConvertEncType for list of types)
+ * @param toAmino indicates whether to convert to amino or direct
+ */
+const paramConverter = (value, type, toAmino = false) => {
+    if (!value) {
+        return value;
+    }
+    switch (type) {
+        case ConvertEncType.Dec: {
+            const bnVal = util_1.NumberUtils.bnOrZero(value);
+            if (bnVal.isZero())
+                return null;
+            return bnVal.toString(10);
+        }
+        case ConvertEncType.DecOrZero: {
+            const decBnVal = util_1.NumberUtils.bnOrZero(value);
+            if (decBnVal.isZero())
+                return "0";
+            return decBnVal.toString(10);
+        }
+        case ConvertEncType.Long:
+            return toAmino ? value.toString() : new long_1.default(Number(value));
+        case ConvertEncType.LongToNum:
+            return toAmino ? value.toNumber() : new long_1.default(value);
+        case ConvertEncType.NumToStr:
+            return toAmino ? value.toString() : Number(value);
+        case ConvertEncType.Date:
+            return toAmino ? value.toISOString().replace(".000", "") : new Date(value);
+        case ConvertEncType.DateToNum:
+            if (toAmino) {
+                const timestampBN = new bignumber_js_1.default(value.getTime() ?? 0).shiftedBy(-3).decimalPlaces(0, 1);
+                return timestampBN.toNumber();
+            }
+            else {
+                const timestampNum = (value ?? 0) * 1000;
+                return new Date(timestampNum);
+            }
+        case ConvertEncType.Duration:
+            // Process Duration model from google protobuf
+            if (toAmino) {
+                const nanosBN = new bignumber_js_1.default(value?.nanos ?? 0).shiftedBy(-6);
+                const seconds = value?.seconds ?? new long_1.default(0);
+                return `${nanosBN.plus(seconds.mul(exports.NANOS_IN_ONE_SECOND).toString()).toString(10)}`;
+            }
+            else {
+                const totalNanos = long_1.default.fromString(value);
+                return {
+                    seconds: totalNanos.divide(exports.NANOS_IN_ONE_SECOND),
+                    nanos: totalNanos.mod(exports.NANOS_IN_ONE_SECOND).toNumber(),
+                };
+            }
+        case ConvertEncType.Uint8Array:
+            return toAmino ? Buffer.from(value).toString('base64') : new Uint8Array(Buffer.from(value, 'base64'));
+        default:
+            return value;
+    }
+};
+exports.paramConverter = paramConverter;
+const generateAminoType = (amino, aminoProcess = {}) => {
+    const valueMap = amino.valueMap ?? {};
+    return {
+        ...amino,
+        toAmino: (input) => {
+            const processRes = aminoProcess?.toAminoProcess ? aminoProcess.toAminoProcess(valueMap, input, index_1.AminoTypesMap) : {};
+            const { input: newInput = input, amino: newAminoMap = valueMap } = processRes;
+            const aminoObj = {};
+            Object.keys(newInput).forEach((key) => {
+                const snakeKey = util_1.TypeUtils.camelToSnake(key);
+                if (!newInput[key])
+                    return;
+                if (typeCheck(newInput[key])) {
+                    aminoObj[snakeKey] = (0, exports.paramConverter)(newInput[key], newAminoMap[key], true);
+                    if (aminoObj[snakeKey] === null)
+                        delete aminoObj[snakeKey];
+                    return;
+                }
+                if (typeof newInput[key] !== "object" && typeof newAminoMap[key] !== "object") {
+                    aminoObj[snakeKey] = (0, exports.paramConverter)(newInput[key], newAminoMap[key], true);
+                    if (aminoObj[snakeKey] === null)
+                        delete aminoObj[snakeKey];
+                }
+                else {
+                    // empty array should be mapped over too
+                    if (newInput[key]?.length === 0) {
+                        aminoObj[snakeKey] = [];
+                        return;
+                    }
+                    if (newInput[key]?.length && typeof newInput[key] === "object") {
+                        aminoObj[snakeKey] = newInput[key].map((newItem) => (0, exports.mapEachIndiv)(newItem, newAminoMap[key], true));
+                        return;
+                    }
+                    aminoObj[snakeKey] = (0, exports.mapEachIndiv)(newInput[key], newAminoMap[key], true);
+                }
+            });
+            return aminoObj;
+        },
+        fromAmino: (input) => {
+            const processRes = aminoProcess?.fromAminoProcess
+                ? aminoProcess.fromAminoProcess(valueMap, input, index_1.AminoTypesMap)
+                : {};
+            const { input: newInput = input, amino: newAminoMap = valueMap } = processRes;
+            const aminoObj = {};
+            Object.keys(newInput).forEach((key) => {
+                const camelKey = util_1.TypeUtils.snakeToCamel(key);
+                if (isConvertEncType(newAminoMap[key])) {
+                    aminoObj[camelKey] = (0, exports.paramConverter)(newInput[key], newAminoMap[camelKey], false);
+                    return;
+                }
+                if (typeof newInput[key] !== "object" && typeof newAminoMap[key] !== "object") {
+                    aminoObj[camelKey] = (0, exports.paramConverter)(newInput[key], newAminoMap[camelKey], false);
+                    if (aminoObj[camelKey] === null)
+                        delete aminoObj[camelKey];
+                }
+                else {
+                    if (newInput[key]?.length && typeof newInput[key] === "object") {
+                        aminoObj[camelKey] = newInput[key].map((newItem) => (0, exports.mapEachIndiv)(newItem, newAminoMap[camelKey], false));
+                        return;
+                    }
+                    aminoObj[camelKey] = (0, exports.mapEachIndiv)(newInput[key], newAminoMap[camelKey], false);
+                }
+            });
+            return aminoObj;
+        },
+    };
+};
+exports.generateAminoType = generateAminoType;
+const pruneAmino = (value, pruneMap) => {
+    const newValue = value;
+    const newMsg = value.msg;
+    Object.entries(newMsg).forEach(([key, value]) => {
+        const camelKey = util_1.TypeUtils.snakeToCamel(key);
+        const pruneItem = pruneMap[camelKey];
+        switch (pruneItem) {
+            case ConvertEncType.Long:
+                if (long_1.default.isLong(value) && value.isZero()) {
+                    delete newMsg[key];
+                }
+                break;
+            default:
+                if (typeof value === "boolean" && !value) {
+                    delete newMsg[key];
+                }
+                if (typeof value === "string" && value === "") {
+                    delete newMsg[key];
+                }
+                if (typeof value === "number" && value === 0) {
+                    delete newMsg[key];
+                }
+        }
+    });
+    newValue.msg = newMsg;
+    return newValue;
+};
+exports.pruneAmino = pruneAmino;

package/lib/provider/chainProvider/GetSigningCosmosClientOptions.d.ts

@@ -0,0 +1,2 @@
+import { SigningStargateClientOptions } from "@cosmjs/stargate";
+export declare const getSigningCosmosClientOptions: () => SigningStargateClientOptions;

package/lib/provider/chainProvider/GetSigningCosmosClientOptions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningCosmosClientOptions = void 0;
+const amino_1 = require("../amino");
+const codec_1 = require("../../codec");
+const stargate_1 = require("@cosmjs/stargate");
+// import { GasPrice } from '@cosmjs/stargate';
+const getSigningCosmosClientOptions = () => {
+    const registry = codec_1.registry;
+    const aminoTypes = amino_1.AminoTypesMap;
+    const gasPrice = stargate_1.GasPrice.fromString("0.025uosmo");
+    return {
+        registry,
+        aminoTypes,
+        gasPrice,
+    };
+};
+exports.getSigningCosmosClientOptions = getSigningCosmosClientOptions;

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

@@ -0,0 +1,2 @@
+export { getSigningCosmosClientOptions } from "./GetSigningCosmosClientOptions";
+export { AssetList, Chain } from "@chain-registry/types";

package/lib/provider/chainProvider/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningCosmosClientOptions = void 0;
+var GetSigningCosmosClientOptions_1 = require("./GetSigningCosmosClientOptions");
+Object.defineProperty(exports, "getSigningCosmosClientOptions", { enumerable: true, get: function () { return GetSigningCosmosClientOptions_1.getSigningCosmosClientOptions; } });

package/lib/provider/eip6963Provider/Eip6963Provider.d.ts

@@ -0,0 +1,9 @@
+import { EIP6963ProviderDetail, SupportedEip6963Provider } from "../../constant";
+declare class Eip6963Provider {
+    private providers;
+    constructor();
+    getProvider(name: SupportedEip6963Provider): EIP6963ProviderDetail | undefined;
+    getDefaultProvider(): EIP6963ProviderDetail;
+    private getProviders;
+}
+export default Eip6963Provider;

package/lib/provider/eip6963Provider/Eip6963Provider.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Eip6963Provider {
+    constructor() {
+        this.providers = [];
+        this.getProviders();
+    }
+    getProvider(name) {
+        return this.providers.find(p => p.info.name === name);
+    }
+    getDefaultProvider() {
+        return this.providers[0];
+    }
+    getProviders() {
+        let providers = [];
+        function onAnnouncement(event) {
+            // Prevent adding a provider if it already exists in the list based on its uuid.
+            if (providers.some(p => p.info.uuid === event.detail.info.uuid))
+                return;
+            providers = [...providers, event.detail];
+        }
+        window.addEventListener("eip6963:announceProvider", onAnnouncement);
+        window.dispatchEvent(new Event("eip6963:requestProvider"));
+        this.providers = providers;
+    }
+}
+exports.default = Eip6963Provider;

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

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

package/lib/provider/eip6963Provider/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.Eip6963Provider = void 0;
+var Eip6963Provider_1 = require("./Eip6963Provider");
+Object.defineProperty(exports, "Eip6963Provider", { enumerable: true, get: function () { return __importDefault(Eip6963Provider_1).default; } });

package/lib/provider/index.d.ts

@@ -0,0 +1,10 @@
+export { AminoTypesMap } from "./amino";
+export { ChainInfo, default as KeplrAccount, Keplr, KeplrWindow } from "./keplr";
+export { default as LeapAccount, Leap, Key, LeapExtended } from "./leap";
+export { default as CosmosLedger } from "./ledger";
+export { CallContractArgs, MetaMask } from "./metamask";
+export { EVMChain, SyncResult as MetaMaskSyncResult } from "../constant";
+export { default as SDKProvider } from "./sdk";
+export { RainbowKitAccount } from './rainbowKit';
+export { Eip6963Provider } from './eip6963Provider';
+export { getSigningCosmosClientOptions, AssetList, Chain } from "./chainProvider";

package/lib/provider/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningCosmosClientOptions = exports.Eip6963Provider = exports.RainbowKitAccount = exports.MetaMask = exports.CosmosLedger = exports.LeapAccount = exports.KeplrAccount = exports.AminoTypesMap = void 0;
+var amino_1 = require("./amino");
+Object.defineProperty(exports, "AminoTypesMap", { enumerable: true, get: function () { return amino_1.AminoTypesMap; } });
+var keplr_1 = require("./keplr");
+Object.defineProperty(exports, "KeplrAccount", { enumerable: true, get: function () { return __importDefault(keplr_1).default; } });
+var leap_1 = require("./leap");
+Object.defineProperty(exports, "LeapAccount", { enumerable: true, get: function () { return __importDefault(leap_1).default; } });
+var ledger_1 = require("./ledger");
+Object.defineProperty(exports, "CosmosLedger", { enumerable: true, get: function () { return __importDefault(ledger_1).default; } });
+var metamask_1 = require("./metamask");
+Object.defineProperty(exports, "MetaMask", { enumerable: true, get: function () { return metamask_1.MetaMask; } });
+var rainbowKit_1 = require("./rainbowKit");
+Object.defineProperty(exports, "RainbowKitAccount", { enumerable: true, get: function () { return rainbowKit_1.RainbowKitAccount; } });
+var eip6963Provider_1 = require("./eip6963Provider");
+Object.defineProperty(exports, "Eip6963Provider", { enumerable: true, get: function () { return eip6963Provider_1.Eip6963Provider; } });
+var chainProvider_1 = require("./chainProvider");
+Object.defineProperty(exports, "getSigningCosmosClientOptions", { enumerable: true, get: function () { return chainProvider_1.getSigningCosmosClientOptions; } });

package/lib/provider/keplr/KeplrAccount.d.ts

@@ -0,0 +1,27 @@
+import { CarbonSigner } from "../../wallet";
+import { AppCurrency, ChainInfo, FeeCurrency, Keplr, Key } from "@keplr-wallet/types";
+import SDKProvider from "../sdk";
+declare class KeplrAccount {
+    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 createKeplrSigner(keplr: Keplr, chainInfo: ChainInfo, account: Key): CarbonSigner;
+    static createKeplrSignerAmino(keplr: Keplr, chainInfo: ChainInfo, account: Key): CarbonSigner;
+    static queryFeeCurrencies(configProvider: SDKProvider): Promise<FeeCurrency[]>;
+    static processCurrencies(feeCurrencies: FeeCurrency[]): AppCurrency[];
+    static getChainInfo(configProvider: SDKProvider): Promise<ChainInfo>;
+    static signPublicKeyMergeAccount(publicKey: string, address: string, chainId: string, keplr: Keplr): Promise<string>;
+    static signArbitrary(signerAddress: string, chainId: string, message: string, keplr: Keplr): Promise<string>;
+}
+declare namespace KeplrAccount { }
+export default KeplrAccount;

package/lib/provider/keplr/KeplrAccount.js

@@ -0,0 +1,229 @@
+"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 types_1 = require("@keplr-wallet/types");
+const ethers_1 = require("ethers");
+const ethermint_1 = require("../../util/ethermint");
+const provider_1 = require("../../util/provider");
+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 KeplrAccount {
+    static createKeplrSigner(keplr, chainInfo, account) {
+        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 keplr.signDirect(chainInfo.chainId, signerAddress, parsedDoc, signOpts);
+            });
+        };
+        const signAmino = async (signerAddress, doc) => {
+            return await (0, provider_1.signTransactionWrapper)(async () => {
+                const signOpts = { preferNoSetFee: true };
+                return await keplr.signAmino(chainInfo.chainId, signerAddress, doc, signOpts);
+            });
+        };
+        const getAccounts = async () => [
+            {
+                algo: "secp256k1",
+                address: account.bech32Address,
+                pubkey: account.pubKey,
+            },
+        ];
+        const sendEvmTransaction = async (api, req) => {
+            try {
+                const unsignedTx = await (0, ethermint_1.populateUnsignedEvmTranscation)(api, req);
+                const signedTx = await keplr.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;
+            }
+            catch (error) {
+                console.error(error);
+                throw ((0, error_1.parseEvmError)(error));
+            }
+        };
+        const signMessage = async (address, message) => {
+            const chainId = chainInfo.chainId;
+            const { signature } = await keplr.signArbitrary(chainId, address, message);
+            return Buffer.from(signature, 'base64').toString('hex');
+        };
+        return {
+            type: wallet_1.CarbonSignerTypes.BrowserInjected,
+            signDirect,
+            signAmino,
+            getAccounts,
+            sendEvmTransaction,
+            signMessage,
+        };
+    }
+    static createKeplrSignerAmino(keplr, chainInfo, account) {
+        const signAmino = async (signerAddress, doc) => {
+            const signOpts = { preferNoSetFee: true };
+            return await keplr.signAmino(chainInfo.chainId, signerAddress, doc, signOpts);
+        };
+        const getAccounts = async () => [
+            {
+                algo: "secp256k1",
+                address: account.bech32Address,
+                pubkey: account.pubKey,
+            },
+        ];
+        const sendEvmTransaction = async (api, req) => {
+            try {
+                const unsignedTx = await (0, ethermint_1.populateUnsignedEvmTranscation)(api, req);
+                const signedTx = await keplr.signEthereum(
+                // carbon chain id
+                api.wallet?.getChainId() ?? '', 
+                // cosmos address
+                api.wallet?.bech32Address ?? '', JSON.stringify(unsignedTx), types_1.EthSignType.TRANSACTION);
+                // const rlpEncodedHex = `0x${Buffer.from(signedTx).toString('hex')}`
+                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;
+            }
+            catch (error) {
+                console.error(error);
+                throw ((0, error_1.parseEvmError)(error));
+            }
+        };
+        const signMessage = async (address, message) => {
+            const chainId = chainInfo.chainId;
+            const { signature } = await keplr.signArbitrary(chainId, address, message);
+            return Buffer.from(signature, 'base64').toString('hex');
+        };
+        return {
+            type: wallet_1.CarbonSignerTypes.BrowserInjected,
+            signAmino,
+            getAccounts,
+            sendEvmTransaction,
+            signMessage,
+        };
+    }
+    static async queryFeeCurrencies(configProvider) {
+        const tokenClient = configProvider.getTokenClient();
+        const coingeckoIdMap = tokenClient.geckoTokenNames;
+        // Query minGasPrices from on-chain (for testnet/devnet/localhost)
+        const gasPricesResult = await configProvider.query.fee.MinGasPriceAll({});
+        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()
+                ? KeplrAccount.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;
+    }
+    static processCurrencies(feeCurrencies) {
+        return feeCurrencies.reduce((prevCurrencies, feeCurrency) => {
+            const currentFeeCurrency = {
+                coinDenom: feeCurrency.coinDenom,
+                coinMinimalDenom: feeCurrency.coinMinimalDenom,
+                coinDecimals: feeCurrency.coinDecimals,
+                coinGeckoId: feeCurrency.coinGeckoId,
+            };
+            prevCurrencies.push(currentFeeCurrency);
+            return prevCurrencies;
+        }, []);
+    }
+    static async getChainInfo(configProvider) {
+        const config = configProvider.getConfig();
+        const bech32Prefix = config.Bech32Prefix;
+        const isMainnet = config.network === constant_1.Network.MainNet;
+        const chainId = config.chainId;
+        const url = "https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/master/cosmos/carbon.json";
+        let keplrChainInfo;
+        try {
+            keplrChainInfo = await (await util_1.FetchUtils.fetch(url)).json();
+        }
+        catch (error) {
+            console.warn(error);
+        }
+        if (isMainnet && keplrChainInfo) {
+            if (keplrChainInfo.nodeProvider) {
+                delete keplrChainInfo.nodeProvider;
+            }
+            return keplrChainInfo;
+        }
+        const feeCurrencies = await this.queryFeeCurrencies(configProvider);
+        const networkFees = [KeplrAccount.SWTH_CURRENCY, ...feeCurrencies];
+        const currencies = this.processCurrencies(networkFees);
+        return {
+            feeCurrencies: networkFees,
+            bip44: KeplrAccount.BASE_CHAIN_INFO.bip44,
+            currencies: currencies,
+            stakeCurrency: KeplrAccount.SWTH_CURRENCY,
+            rest: config.restUrl,
+            rpc: config.tmRpcUrl,
+            chainName: `Carbon (${config.network})`,
+            chainId: chainId,
+            ...isMainnet && ({
+                evm: {
+                    chainId: Number((0, ethermint_1.parseChainId)(constant_1.CarbonEvmChainIDs[config.network])),
+                    rpc: config.evmJsonRpcUrl,
+                },
+            }),
+            bech32Config: {
+                bech32PrefixAccAddr: `${bech32Prefix}`,
+                bech32PrefixAccPub: `${bech32Prefix}pub`,
+                bech32PrefixValAddr: `${bech32Prefix}valoper`,
+                bech32PrefixValPub: `${bech32Prefix}valoperpub`,
+                bech32PrefixConsAddr: `${bech32Prefix}valcons`,
+                bech32PrefixConsPub: `${bech32Prefix}valconspub`,
+            },
+            features: ["ibc-transfer", "ibc-go"],
+        };
+    }
+    static async signPublicKeyMergeAccount(publicKey, address, chainId, keplr) {
+        const message = `${ethermint_1.PUBLIC_KEY_SIGNING_TEXT}${publicKey}`;
+        return KeplrAccount.signArbitrary(address, chainId, message, keplr);
+    }
+    static async signArbitrary(signerAddress, chainId, message, keplr) {
+        const signature = await keplr.signArbitrary(chainId, signerAddress, message);
+        return Buffer.from(signature.signature, 'base64').toString('hex');
+    }
+}
+KeplrAccount.SWTH_CURRENCY = SWTH;
+KeplrAccount.BASE_CHAIN_INFO = {
+    bip44: { coinType: util_1.AddressUtils.SWTHAddress.coinType() },
+    currencies: [],
+    feeCurrencies: [SWTH],
+    gasPriceStep: SWTH.gasPriceStep,
+};
+exports.default = KeplrAccount;

package/lib/provider/keplr/KeplrStore.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,3 @@
+export { default } from "./KeplrAccount";
+export { KeplrWindow } from "./window";
+export { Keplr, ChainInfo } from "@keplr-wallet/types";

package/lib/provider/keplr/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 KeplrAccount_1 = require("./KeplrAccount");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(KeplrAccount_1).default; } });