example-js-sdk 0.0.1

package/lib/modules/grant.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrantModule = void 0;
+const tx_1 = require("../codec/cosmos/authz/v1beta1/tx");
+const util_1 = require("../util");
+const codec_1 = require("../codec");
+const authz_1 = require("../codec/cosmos/authz/v1beta1/authz");
+const feegrant_1 = require("../codec/cosmos/feegrant/v1beta1/feegrant");
+const tx_2 = require("../codec/cosmos/feegrant/v1beta1/tx");
+const grant_1 = require("../util/grant");
+const base_1 = __importDefault(require("./base"));
+class GrantModule extends base_1.default {
+    static wrapInMsgExec(grantee, msgs) {
+        return [{
+                typeUrl: util_1.CarbonTx.Types.MsgExec,
+                value: tx_1.MsgExec.fromPartial({
+                    grantee,
+                    msgs: msgs.map((m) => codec_1.registry.encodeAsAny({ ...m })),
+                }),
+            }];
+    }
+    static getGenericAuthorizationMsg(granter, grantee, expiry, msgs) {
+        return msgs.map((msg) => {
+            const grantMsg = tx_1.MsgGrant.fromPartial({
+                granter,
+                grantee,
+                grant: {
+                    authorization: {
+                        typeUrl: grant_1.GrantTypes.GenericAuthorization,
+                        value: authz_1.GenericAuthorization.encode(authz_1.GenericAuthorization.fromPartial({
+                            msg,
+                        })).finish(),
+                    },
+                    expiration: expiry,
+                },
+            });
+            return {
+                typeUrl: util_1.CarbonTx.Types.MsgGrant, value: grantMsg,
+            };
+        });
+    }
+    static getMsgExecAllowanceMsg(granter, grantee, expiry) {
+        return {
+            typeUrl: util_1.CarbonTx.Types.MsgGrantAllowance,
+            value: tx_2.MsgGrantAllowance.fromPartial({
+                granter,
+                grantee,
+                allowance: {
+                    typeUrl: grant_1.GrantTypes.AllowedMsgAllowance,
+                    value: feegrant_1.AllowedMsgAllowance.encode(feegrant_1.AllowedMsgAllowance.fromPartial({
+                        allowance: {
+                            typeUrl: grant_1.GrantTypes.BasicAllowance,
+                            value: feegrant_1.BasicAllowance.encode(feegrant_1.BasicAllowance.fromPartial({
+                                expiration: expiry,
+                            })).finish(),
+                        },
+                        allowedMessages: [util_1.CarbonTx.Types.MsgExec],
+                    })).finish(),
+                },
+            }),
+        };
+    }
+    static getRevokeGrantMsg(granter, grantee, msgs) {
+        return msgs.map((msg) => {
+            const revokeMsg = tx_1.MsgRevoke.fromPartial({
+                granter,
+                grantee,
+                msgTypeUrl: msg,
+            });
+            return {
+                typeUrl: util_1.CarbonTx.Types.MsgRevoke,
+                value: revokeMsg,
+            };
+        });
+    }
+    static getRevokeAllowanceMsg(granter, grantee) {
+        return {
+            typeUrl: util_1.CarbonTx.Types.MsgRevokeAllowance,
+            value: tx_2.MsgRevokeAllowance.fromPartial({
+                granter,
+                grantee,
+            }),
+        };
+    }
+    static async getGrantMsgs(params, client) {
+        const { msgs, granter, grantee, expiry } = params;
+        const messages = this.getGenericAuthorizationMsg(granter, grantee, expiry, msgs);
+        const existingGrantee = await hasExistingGrantee(granter, grantee, client);
+        // can only have one existing grant between granter and grantee
+        // to 'extend' have to revoke existing fee-grant and approve new fee-grant with new expiration
+        if (existingGrantee)
+            messages.push(this.getRevokeAllowanceMsg(granter, grantee));
+        const allowanceMsg = this.getMsgExecAllowanceMsg(granter, grantee, expiry);
+        messages.push(allowanceMsg);
+        return messages;
+    }
+    static getRevokeMsgs(params) {
+        const { msgs = [], granter, grantee } = params;
+        return this.getRevokeGrantMsg(granter, grantee, msgs)
+            .concat(this.getRevokeAllowanceMsg(granter, params.grantee));
+    }
+    async grantAuthAndAllowance(params, opts) {
+        const wallet = this.getWallet();
+        const messages = await GrantModule.getGrantMsgs(params, this.sdkProvider.query.feegrant);
+        return await wallet.sendTxs(messages, opts);
+    }
+    async revokeAuthAndAllowance(params, opts) {
+        const wallet = this.getWallet();
+        const messages = GrantModule.getRevokeMsgs(params);
+        return await wallet.sendTxs(messages, opts);
+    }
+    async execute(msgs, opts) {
+        const wallet = this.getWallet();
+        const execMsgs = GrantModule.wrapInMsgExec(wallet.bech32Address, msgs);
+        return await wallet.sendTxs(execMsgs, opts);
+    }
+}
+exports.GrantModule = GrantModule;
+const hasExistingGrantee = async (granter, grantee, client) => {
+    try {
+        const existingGrantee = await client.Allowance({ granter, grantee });
+        return !!existingGrantee;
+    }
+    catch (e) {
+        const err = e;
+        if (isFeeGrantNotFound(err))
+            return false;
+        throw e;
+    }
+};
+const isFeeGrantNotFound = (error) => {
+    const errorMessage = 'fee-grant not found';
+    return error?.message.includes(errorMessage);
+};

package/lib/modules/ibc.d.ts

@@ -0,0 +1,46 @@
+import { Token } from "../codec/mememax/orbix/coin/token";
+import { DenomTrace } from "../codec/ibc/applications/transfer/v1/transfer";
+import { ChainRegistryItem, ExtendedChainInfo } from "../constant";
+import { ChainInfo } from "../provider";
+import { CarbonTx, TypeUtils } from "../util";
+import { AppCurrency } from "@keplr-wallet/types";
+import BigNumber from "bignumber.js";
+import BaseModule from "./base";
+export declare class IBCModule extends BaseModule {
+    /** @deprecated please use sendIbcTransferUpdated instead */
+    sendIBCTransfer(params: IBCModule.SendIBCTransferParams, msgOpts?: CarbonTx.SignTxOpts): Promise<import("..").CarbonWallet.SendTxResponse>;
+    sendIbcTransferV2(params: IBCModule.SendIBCTransferV2Params, msgOpts?: CarbonTx.SignTxOpts): Promise<import("..").CarbonWallet.SendTxResponse>;
+    getChainInfoMap(denomTraces?: TypeUtils.SimpleMap<DenomTrace>): Promise<TypeUtils.SimpleMap<ExtendedChainInfo>>;
+    getAppCurrency(coinMinimalDenom: string, coinGeckoId?: string, tokenInfo?: Token, cw20RegexArr?: RegExpMatchArray | null): AppCurrency;
+    getChainInfo(chainName: string): Promise<ChainInfo | undefined>;
+    getAssembledChainInfo(chainId: string, chainData?: ChainRegistryItem): Promise<ChainInfo | undefined>;
+}
+export declare namespace IBCModule {
+    /** @deprecated sendIBCTransfer function is deprecated, please use sendIbcTransferUpdated instead */
+    interface SendIBCTransferParams {
+        sender?: string;
+        receiver: string;
+        amount: BigNumber;
+        denom: string;
+        sourceChannel: string;
+        sourcePort: string;
+        revisionHeight?: number;
+        revisionNumber?: number;
+        timeoutTimestamp?: number;
+        memo?: string;
+    }
+    interface SendIBCTransferV2Params {
+        sender?: string;
+        receiver: string;
+        amount: BigNumber;
+        denom: string;
+        sourceChannel: string;
+        sourcePort: string;
+        timeoutHeight?: {
+            revisionNumber: BigNumber;
+            revisionHeight: BigNumber;
+        };
+        timeoutTimestamp?: BigNumber;
+        memo?: string;
+    }
+}

package/lib/modules/ibc.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBCModule = void 0;
+const tx_1 = require("../codec/ibc/applications/transfer/v1/tx");
+const constant_1 = require("../constant");
+const provider_1 = require("../provider");
+const util_1 = require("../util");
+const long_1 = __importDefault(require("long"));
+const base_1 = __importDefault(require("./base"));
+class IBCModule extends base_1.default {
+    /** @deprecated please use sendIbcTransferUpdated instead */
+    async sendIBCTransfer(params, msgOpts) {
+        const wallet = this.getWallet();
+        if (!params.revisionHeight) {
+            const lastHeight = await this.sdkProvider.query.chain.getHeight();
+            // Set the timeout height as the current height + 150.
+            params.revisionHeight = (lastHeight ?? 0) + 150;
+        }
+        const value = tx_1.MsgTransfer.fromPartial({
+            sourcePort: params.sourcePort,
+            sourceChannel: params.sourceChannel,
+            token: {
+                denom: params.denom,
+                amount: params.amount.toString(10),
+            },
+            sender: params.sender ?? wallet.bech32Address,
+            receiver: params.receiver,
+            timeoutHeight: {
+                revisionHeight: params.revisionHeight,
+                revisionNumber: params.revisionNumber ?? 1,
+            },
+            ...(params.timeoutTimestamp && {
+                timeoutTimestamp: params.timeoutTimestamp,
+            }),
+            memo: params.memo,
+        });
+        return await wallet.sendTx({
+            typeUrl: util_1.CarbonTx.Types.MsgTransfer,
+            value,
+        }, msgOpts);
+    }
+    async sendIbcTransferV2(params, msgOpts) {
+        const wallet = this.getWallet();
+        const value = tx_1.MsgTransfer.fromPartial({
+            sourcePort: params.sourcePort,
+            sourceChannel: params.sourceChannel,
+            token: {
+                denom: params.denom,
+                amount: params.amount.toString(10),
+            },
+            sender: params.sender ?? wallet.bech32Address,
+            receiver: params.receiver,
+            ...params.timeoutHeight && ({
+                timeoutHeight: {
+                    revisionHeight: new long_1.default(params.timeoutHeight.revisionHeight.toNumber()),
+                    revisionNumber: new long_1.default(params.timeoutHeight.revisionNumber.toNumber()),
+                },
+            }),
+            ...params.timeoutTimestamp && ({
+                timeoutTimestamp: params.timeoutTimestamp.toNumber(),
+            }),
+            memo: params.memo,
+        });
+        return await wallet.sendTx({
+            typeUrl: util_1.CarbonTx.Types.MsgTransfer,
+            value,
+        }, msgOpts);
+    }
+    async getChainInfoMap(denomTraces = {}) {
+        const tokenClient = this.sdkProvider.getTokenClient();
+        const ibcBridges = tokenClient.bridges.ibc;
+        const chainsResponse = await fetch(`https://chains.cosmos.directory/`);
+        const chainsData = await chainsResponse.json();
+        const chainInfoMap = {};
+        for (let ibc = 0; ibc < ibcBridges.length; ibc++) {
+            const ibcBridge = ibcBridges[ibc];
+            const chainId = ibcBridge.chain_id_name;
+            const chainName = ibcBridge.chain_id_name.match(constant_1.ibcNetworkRegex)?.[1] ?? "";
+            const chainData = chainsData.chains.find((d) => d.chain_id === chainId);
+            let chainInfo = await this.getChainInfo(chainName);
+            if (chainInfo === undefined) {
+                const fallbackChainInfo = await this.getAssembledChainInfo(chainId, chainData);
+                chainInfo = fallbackChainInfo;
+            }
+            if (chainInfo) {
+                chainInfoMap[ibcBridge.chain_id_name] = {
+                    ...chainInfo,
+                    minimalDenomMap: {},
+                    bestRpcs: chainData?.best_apis.rpc ?? [],
+                };
+            }
+        }
+        const carbonChainInfo = await provider_1.KeplrAccount.getChainInfo(this.sdkProvider);
+        if (carbonChainInfo) {
+            chainInfoMap[carbonChainInfo.chainId] = {
+                ...carbonChainInfo,
+                minimalDenomMap: {},
+                bestRpcs: [],
+            };
+        }
+        for (const key in denomTraces) {
+            const denomTrace = denomTraces[key];
+            const denom = util_1.IBCUtils.makeIBCMinimalDenom(denomTrace.path, denomTrace.baseDenom);
+            const token = tokenClient.tokenForDenom(denom);
+            if (!token)
+                continue;
+            const isChainNativeToken = denomTrace.path.split("/").length === 2;
+            const chainId = tokenClient.getIbcChainIdFromToken(token);
+            if (chainId && chainInfoMap[chainId]) {
+                const cw20RegexArr = denomTrace.baseDenom.match(constant_1.cw20TokenRegex);
+                const coinGeckoId = tokenClient.geckoTokenNames?.[denom] ?? tokenClient.geckoTokenNames?.[denomTrace.baseDenom];
+                const dstDenom = isChainNativeToken ? denomTrace.baseDenom.replace(/:/g, '/') : util_1.IBCUtils.makeIBCMinimalDenom(denomTrace.path.replace(constant_1.ibcTransferChannelRegex, "").replace(/^\//, ''), denomTrace.baseDenom);
+                const chainInfo = chainInfoMap[chainId];
+                chainInfo.minimalDenomMap[token.denom] = dstDenom;
+                const existingCurrencyIndex = chainInfo.currencies.findIndex(c => c.coinMinimalDenom === dstDenom);
+                if (existingCurrencyIndex !== -1) {
+                    continue;
+                }
+                const currency = this.getAppCurrency(dstDenom, coinGeckoId, token, cw20RegexArr);
+                chainInfo.currencies.push(currency);
+            }
+        }
+        return chainInfoMap;
+    }
+    getAppCurrency(coinMinimalDenom, coinGeckoId, tokenInfo, cw20RegexArr) {
+        const appCurrency = {
+            coinDenom: tokenInfo?.symbol ?? "",
+            coinMinimalDenom: coinMinimalDenom,
+            coinDecimals: tokenInfo?.decimals.toNumber() ?? 0,
+            coinGeckoId: coinGeckoId,
+            ...cw20RegexArr?.length && ({
+                type: "cw20",
+                contractAddress: cw20RegexArr[1] ?? "",
+            }),
+        };
+        return appCurrency;
+    }
+    async getChainInfo(chainName) {
+        if (!chainName || chainName === "mainnet")
+            return undefined;
+        const chainInfoResponse = await fetch(`https://raw.githubusercontent.com/chainapsis/keplr-chain-registry/master/cosmos/${chainName}.json`);
+        if (!chainInfoResponse.ok) {
+            if (chainInfoResponse.status === 404) {
+                return undefined;
+            }
+        }
+        const chainInfoJson = await chainInfoResponse.json();
+        return chainInfoJson;
+    }
+    async getAssembledChainInfo(chainId, chainData) {
+        const defaultChainInfo = util_1.IBCUtils.EmbedChainInfos[chainId];
+        if (chainData) {
+            try {
+                const chainInfoResponse = await fetch(`https://raw.githubusercontent.com/cosmos/chain-registry/master/${chainData.chain_name}/chain.json`);
+                const chainInfoJson = await chainInfoResponse.json();
+                const chainAssetListResponse = await fetch(`https://raw.githubusercontent.com/cosmos/chain-registry/master/${chainData.chain_name}/assetlist.json`);
+                const assetListJson = await chainAssetListResponse.json();
+                const features = [];
+                if (chainData.cosmwasm_enabled) {
+                    features.push("cosmwasm");
+                }
+                // Extract the staking currency denomination from chainInfoJson (min. denom)
+                const stakingCurrencyDenom = chainInfoJson.staking.staking_tokens?.[0]?.denom || '';
+                // Find the asset that matches the stakingCurrencyDenom
+                const stakingAsset = assetListJson.assets.find((asset) => {
+                    return asset.denom_units.some((unit) => unit.denom === stakingCurrencyDenom);
+                });
+                // Find the highest denom unit
+                const maxExponentDenomUnit = stakingAsset.denom_units.reduce((prev, current) => {
+                    return (prev.exponent > current.exponent) ? prev : current;
+                });
+                const stakeCurrency = {
+                    coinDenom: maxExponentDenomUnit.denom.toUpperCase(),
+                    coinMinimalDenom: stakingCurrencyDenom,
+                    coinDecimals: maxExponentDenomUnit.exponent,
+                    coinGeckoId: stakingAsset?.coingecko_id ?? '',
+                };
+                const currencies = assetListJson.assets.map((asset) => {
+                    // Find the denom_unit with the maximum exponent
+                    const maxExponentDenomUnit = asset.denom_units.reduce((prev, current) => {
+                        return (prev.exponent > current.exponent) ? prev : current;
+                    });
+                    return {
+                        coinDenom: maxExponentDenomUnit.denom.toUpperCase(),
+                        coinMinimalDenom: asset.base,
+                        coinDecimals: maxExponentDenomUnit.exponent,
+                        coinGeckoId: asset.coingecko_id,
+                    };
+                });
+                // Filter out fee tokens which do not have a corresponding asset
+                const validFeeTokens = chainInfoJson.fees.fee_tokens.filter((feeToken) => {
+                    const correspondingAsset = assetListJson.assets.find((asset) => asset.base === feeToken.denom);
+                    return correspondingAsset !== undefined;
+                });
+                const feeCurrencies = validFeeTokens.map((feeToken) => {
+                    // Find the corresponding asset for the fee token
+                    const correspondingAsset = assetListJson.assets.find((asset) => asset.base === feeToken.denom);
+                    // Find the denom_unit with the maximum exponent
+                    const maxExponentDenomUnit = correspondingAsset.denom_units.reduce((prev, current) => {
+                        return (prev.exponent > current.exponent) ? prev : current;
+                    });
+                    return {
+                        coinDenom: maxExponentDenomUnit.denom.toUpperCase(),
+                        coinMinimalDenom: feeToken.denom,
+                        coinDecimals: maxExponentDenomUnit.exponent,
+                        coinGeckoId: correspondingAsset.coingecko_id,
+                        gasPriceStep: {
+                            low: feeToken.low_gas_price,
+                            average: feeToken.average_gas_price,
+                            high: feeToken.high_gas_price,
+                        },
+                    };
+                });
+                return {
+                    rpc: defaultChainInfo.rpc ?? chainInfoJson.apis.rpc[0].address,
+                    rest: defaultChainInfo.rest ?? chainInfoJson.apis.rest[0].address,
+                    chainId: chainInfoJson.chain_id,
+                    chainName: chainInfoJson.chain_name,
+                    bip44: {
+                        coinType: chainInfoJson.slip44,
+                    },
+                    bech32Config: constant_1.IBCAddress.defaultBech32Config(chainInfoJson.bech32_prefix),
+                    stakeCurrency: stakeCurrency,
+                    currencies: currencies,
+                    feeCurrencies: feeCurrencies,
+                    features: [
+                        "ibc-transfer",
+                        "ibc-go",
+                    ],
+                };
+            }
+            catch (error) {
+                return defaultChainInfo;
+            }
+        }
+        else {
+            return defaultChainInfo;
+        }
+    }
+}
+exports.IBCModule = IBCModule;

package/lib/modules/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./admin";
+export * from "./alliance";
+export * from "./bank";
+export * from "./broker";
+export * from "./coin";
+export * from "./cosmwasm";
+export * from "./fee";
+export * from "./gov";
+export * from "./ibc";
+export * from "./leverage";
+export * from "./market";
+export * from "./oracle";
+export * from "./order";
+export * from "./position";
+export * from "./subaccount";
+export * from "./evm";
+export * from "./evmmerge";
+export * from "./perpspool";
+export * from "./bridge";

package/lib/modules/index.js

@@ -0,0 +1,35 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./admin"), exports);
+__exportStar(require("./alliance"), exports);
+__exportStar(require("./bank"), exports);
+__exportStar(require("./broker"), exports);
+__exportStar(require("./coin"), exports);
+__exportStar(require("./cosmwasm"), exports);
+__exportStar(require("./fee"), exports);
+__exportStar(require("./gov"), exports);
+__exportStar(require("./ibc"), exports);
+__exportStar(require("./leverage"), exports);
+__exportStar(require("./market"), exports);
+__exportStar(require("./oracle"), exports);
+__exportStar(require("./order"), exports);
+__exportStar(require("./position"), exports);
+__exportStar(require("./subaccount"), exports);
+__exportStar(require("./evm"), exports);
+__exportStar(require("./evmmerge"), exports);
+__exportStar(require("./perpspool"), exports);
+__exportStar(require("./bridge"), exports);

package/lib/modules/leverage.d.ts

@@ -0,0 +1,14 @@
+import { CarbonTx } from "../util";
+import BaseModule from "./base";
+import { BigNumber } from "bignumber.js";
+export declare class LeverageModule extends BaseModule {
+    set(params: LeverageModule.SetLeverageParams, opts?: CarbonTx.SignTxOpts): Promise<import("..").CarbonWallet.SendTxResponse>;
+    setLeverages(params: LeverageModule.SetLeverageParams[], opts?: CarbonTx.SignTxOpts): Promise<import("..").CarbonWallet.SendTxResponse>;
+}
+export declare namespace LeverageModule {
+    interface SetLeverageParams {
+        creator?: string;
+        marketId: string;
+        leverage: BigNumber;
+    }
+}

package/lib/modules/leverage.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeverageModule = void 0;
+const tx_1 = require("../codec/mememax/orbix/leverage/tx");
+const util_1 = require("../util");
+const base_1 = __importDefault(require("./base"));
+class LeverageModule extends base_1.default {
+    async set(params, opts) {
+        const wallet = this.getWallet();
+        const creator = params.creator ?? wallet.bech32Address;
+        const value = tx_1.MsgSetLeverage.fromPartial({
+            creator,
+            marketId: params.marketId,
+            leverage: params.leverage.shiftedBy(18).toString(10),
+        });
+        return await wallet.sendTx({
+            typeUrl: util_1.CarbonTx.Types.MsgSetLeverage,
+            value,
+        }, opts);
+    }
+    async setLeverages(params, opts) {
+        const wallet = this.getWallet();
+        const msgs = params.map((param) => {
+            const creator = param.creator ?? wallet.bech32Address;
+            const value = tx_1.MsgSetLeverage.fromPartial({
+                creator,
+                marketId: param.marketId,
+                leverage: param.leverage.shiftedBy(18).toString(10),
+            });
+            return {
+                typeUrl: util_1.CarbonTx.Types.MsgSetLeverage,
+                value,
+            };
+        });
+        return await wallet.sendTxs(msgs, opts);
+    }
+}
+exports.LeverageModule = LeverageModule;

package/lib/modules/market.d.ts

@@ -0,0 +1,104 @@
+import { Carbon } from "../CarbonSDK";
+import { Duration } from "../codec/google/protobuf/duration";
+import { CarbonTx } from "../util";
+import { BigNumber } from "bignumber.js";
+import BaseModule from "./base";
+export declare class MarketModule extends BaseModule {
+    getFeeTiers(marketType: string): Promise<Carbon.Market.FeeTier[]>;
+    getTradingFees(marketId: string, userAddress: string): Promise<Carbon.Market.TradingFees>;
+    update(params: MarketModule.UpdateMarketParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    createMarket(params: MarketModule.CreateMarketParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    disableSpotMarket(params: MarketModule.DisableSpotMarketParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    addFeeTier(params: MarketModule.AddFeeTierParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    updateFeeTier(params: MarketModule.UpdateFeeTierParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    removeFeeTier(params: MarketModule.RemoveFeeTierParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+    setStakeEquivalence(params: MarketModule.SetStakeEquivalenceParams, opts?: CarbonTx.SignTxOpts): Promise<import("../CarbonSDK").CarbonWallet.SendTxResponse>;
+}
+export declare namespace MarketModule {
+    interface UpdateMarketParams {
+        name: string;
+        displayName?: string;
+        description?: string;
+        lotSize: BigNumber;
+        tickSize: BigNumber;
+        minQuantity: BigNumber;
+        makerFee: BigNumber;
+        takerFee: BigNumber;
+        /** futures only */
+        riskStepSize: BigNumber;
+        initialMarginBase: BigNumber;
+        initialMarginStep: BigNumber;
+        maintenanceMarginRatio: BigNumber;
+        maxLiquidationOrderTicket: BigNumber;
+        maxLiquidationOrderDuration?: Duration;
+        impactSize: BigNumber;
+        markPriceBand?: number;
+        lastPriceProtectedBand?: number;
+        isActive?: boolean;
+        tradingBandwidth?: number;
+    }
+    interface CreateMarketParams {
+        creator: string;
+        marketType: string;
+        base: string;
+        quote: string;
+        currentBasePriceUsd: string;
+        currentQuotePriceUsd: string;
+        indexOracleId: string;
+        expiryTime?: Date;
+    }
+    interface DisableSpotMarketParams {
+        creator: string;
+        marketId: string;
+    }
+    interface AddFeeTierParams {
+        creator: string;
+        feeCategory: Carbon.Market.FeeCategory;
+        feeTier: FeeTierParams;
+    }
+    interface UpdateFeeTierParams {
+        updater: string;
+        feeCategory: Carbon.Market.FeeCategory;
+        feeTier: FeeTierParams;
+    }
+    interface RemoveFeeTierParams {
+        remover: string;
+        feeCategory: Carbon.Market.FeeCategory;
+        requiredStake: string;
+    }
+    interface FeeTierParams {
+        requiredStake: string;
+        makerFee: BigNumber;
+        takerFee: BigNumber;
+    }
+    interface SetStakeEquivalenceParams {
+        setter: string;
+        stakeEquivalence: StakeEquivalenceParams;
+    }
+    interface StakeEquivalenceParams {
+        denom: string;
+        ratio: BigNumber;
+    }
+}
+export declare function transformFeeTierParams(msg: MarketModule.FeeTierParams): Carbon.Market.FeeTier;
+export declare function transfromUpdateMarketParams(msg: MarketModule.UpdateMarketParams): {
+    name: string;
+    displayName: string | undefined;
+    description: string | undefined;
+    lotSize: string;
+    tickSize: string;
+    minQuantity: string;
+    makerFee: string;
+    takerFee: string;
+    riskStepSize: string;
+    initialMarginBase: string;
+    initialMarginStep: string;
+    maintenanceMarginRatio: string;
+    maxLiquidationOrderTicket: string;
+    maxLiquidationOrderDuration: Duration | undefined;
+    impactSize: string;
+    markPriceBand: number | undefined;
+    lastPriceProtectedBand: number | undefined;
+    isActive: boolean | undefined;
+    tradingBandwidth: number | undefined;
+};