@mento-protocol/mento-sdk 0.1.4 → 0.2.0

package/dist/cjs/mento.js

@@ -13,6 +13,7 @@ exports.Mento = void 0;
 const mento_core_ts_1 = require("@mento-protocol/mento-core-ts");
 const ethers_1 = require("ethers");
 const utils_1 = require("./utils");
+const limits_1 = require("./limits");
 const assert_1 = require("assert");
 class Mento {
     /**
@@ -214,8 +215,8 @@ class Mento {
     }
     /**
      * Returns the Mento exchange (if any) for a given pair of tokens
-     * @param token0 the first token
-     * @param token1 the second token
+     * @param token0 the address of the first token
+     * @param token1 the address of the second token
      * @returns exchange
      */
     getExchangeForTokens(token0, token1) {
@@ -228,5 +229,83 @@ class Mento {
             return exchanges[0];
         });
     }
+    /**
+     * Returns the Mento exchange for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @returns the exchange with the given id
+     */
+    getExchangeById(exchangeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchanges = (yield this.getExchanges()).filter((e) => e.id === exchangeId);
+            if (exchanges.length === 0) {
+                throw Error(`No exchange found for id ${exchangeId}`);
+            }
+            (0, assert_1.strict)(exchanges.length === 1, `More than one exchange found with id ${exchangeId}`);
+            return exchanges[0];
+        });
+    }
+    /**
+     * Returns whether trading is enabled in the given mode for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @param mode the trading mode
+     * @returns true if trading is enabled in the given mode, false otherwise
+     */
+    isTradingEnabled(exchangeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeById(exchangeId);
+            const biPoolManager = mento_core_ts_1.BiPoolManager__factory.connect(exchange.providerAddr, this.signerOrProvider);
+            const [breakerBoxAddr, exchangeConfig] = yield Promise.all([
+                biPoolManager.breakerBox(),
+                biPoolManager.getPoolExchange(exchangeId),
+            ]);
+            const breakerBox = mento_core_ts_1.IBreakerBox__factory.connect(breakerBoxAddr, this.signerOrProvider);
+            const currentMode = yield breakerBox.getRateFeedTradingMode(exchangeConfig.config.referenceRateFeedID);
+            const BI_DIRECTIONAL_TRADING_MODE = 0;
+            return currentMode == BI_DIRECTIONAL_TRADING_MODE;
+        });
+    }
+    /**
+     * Return the trading limits for a given exchange id. Each limit is an object with the following fields:
+     * asset: the address of the asset with the limit
+     * maxIn: the maximum amount of the asset that can be sold
+     * maxOut: the maximum amount of the asset that can be bought
+     * until: the timestamp until which the limit is valid
+     * @param exchangeId the id of the exchange
+     * @returns the list of trading limits
+     */
+    getTradingLimits(exchangeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeById(exchangeId);
+            const broker = mento_core_ts_1.Broker__factory.connect(this.broker.address, this.signerOrProvider);
+            const assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return (0, limits_1.getLimits)(broker, exchangeId, assetWithLimit);
+        });
+    }
+    /**
+     * Returns the trading limits configuration for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @returns the trading limits configuration
+     */
+    getTradingLimitConfig(exchangeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeById(exchangeId);
+            const broker = mento_core_ts_1.Broker__factory.connect(this.broker.address, this.signerOrProvider);
+            const assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return (0, limits_1.getLimitsConfig)(broker, exchangeId, assetWithLimit);
+        });
+    }
+    /**
+     * Returns the trading limits state for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @returns the trading limits state
+     */
+    getTradingLimitState(exchangeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeById(exchangeId);
+            const broker = mento_core_ts_1.Broker__factory.connect(this.broker.address, this.signerOrProvider);
+            const assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return (0, limits_1.getLimitsState)(broker, exchangeId, assetWithLimit);
+        });
+    }
 }
 exports.Mento = Mento;

package/dist/cjs/types.d.ts

@@ -1 +1,49 @@
+import { ethers, providers } from "ethers";
 export type Address = string;
+export interface TradingLimit {
+    asset: Address;
+    maxIn: number;
+    maxOut: number;
+    until: number;
+}
+export interface TradingLimitsConfig {
+    timestep0: number;
+    timestep1: number;
+    limit0: number;
+    limit1: number;
+    limitGlobal: number;
+    flags: number;
+}
+export interface TradingLimitsState {
+    lastUpdated0: number;
+    lastUpdated1: number;
+    netflow0: number;
+    netflow1: number;
+    netflowGlobal: number;
+}
+export interface ContractAddressMap {
+    [chainId: string]: ContractAddresses;
+}
+export interface ContractAddresses {
+    Airgrab: string;
+    Emission: string;
+    MentoGovernor: string;
+    MentoToken: string;
+    TimelockController: string;
+    Locking: string;
+}
+export declare enum ProposalState {
+    PENDING = 0,
+    ACTIVE = 1,
+    CANCELED = 2,
+    DEFEATED = 3,
+    SUCCEEDED = 4,
+    QUEUED = 5,
+    EXPIRED = 6,
+    EXECUTED = 7
+}
+export interface IChainClient {
+    getSigner(): Promise<ethers.Signer | providers.Provider>;
+    getChainId(): Promise<number>;
+    populateTransaction(tx: ethers.PopulatedTransaction): Promise<providers.TransactionRequest>;
+}

package/dist/cjs/types.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProposalState = void 0;
+var ProposalState;
+(function (ProposalState) {
+    ProposalState[ProposalState["PENDING"] = 0] = "PENDING";
+    ProposalState[ProposalState["ACTIVE"] = 1] = "ACTIVE";
+    ProposalState[ProposalState["CANCELED"] = 2] = "CANCELED";
+    ProposalState[ProposalState["DEFEATED"] = 3] = "DEFEATED";
+    ProposalState[ProposalState["SUCCEEDED"] = 4] = "SUCCEEDED";
+    ProposalState[ProposalState["QUEUED"] = 5] = "QUEUED";
+    ProposalState[ProposalState["EXPIRED"] = 6] = "EXPIRED";
+    ProposalState[ProposalState["EXECUTED"] = 7] = "EXECUTED";
+})(ProposalState = exports.ProposalState || (exports.ProposalState = {}));

package/dist/cjs/utils.d.ts

@@ -1,5 +1,5 @@
 import { BigNumberish, providers, Signer } from 'ethers';
-import { Address } from './types';
+import { Address, ContractAddresses } from './types';
 /**
  * Ensures that given signer is truly a a connected signer
  * @param signer an ethers signer
@@ -34,3 +34,4 @@ export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrPr
  * @returns the populated TransactionRequest object
  */
 export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumberish, signerOrProvider: Signer | providers.Provider): Promise<providers.TransactionRequest>;
+export declare function getContractsByChainId(chainId: number): ContractAddresses;

package/dist/cjs/utils.js

@@ -8,9 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.increaseAllowance = exports.getSymbolFromTokenAddress = exports.getBrokerAddressFromRegistry = exports.validateSignerOrProvider = exports.validateSigner = void 0;
+exports.getContractsByChainId = exports.increaseAllowance = exports.getSymbolFromTokenAddress = exports.getBrokerAddressFromRegistry = exports.validateSignerOrProvider = exports.validateSigner = void 0;
 const ethers_1 = require("ethers");
+const contracts_json_1 = __importDefault(require("./contracts.json"));
 /**
  * Ensures that given signer is truly a a connected signer
  * @param signer an ethers signer
@@ -96,3 +100,12 @@ function increaseAllowance(tokenAddr, spender, amount, signerOrProvider) {
     });
 }
 exports.increaseAllowance = increaseAllowance;
+function getContractsByChainId(chainId) {
+    const addresses = contracts_json_1.default;
+    const contracts = addresses[chainId];
+    if (!contracts) {
+        throw new Error(`No contracts found for chainId ${chainId}`);
+    }
+    return contracts;
+}
+exports.getContractsByChainId = getContractsByChainId;

package/dist/esm/ChainClient.d.ts

@@ -0,0 +1,9 @@
+import { PopulatedTransaction, ethers, providers } from "ethers";
+import { IChainClient } from "./types";
+export declare class ChainClient implements IChainClient {
+    private readonly signerOrProvider;
+    constructor(signerOrProvider: ethers.Signer | providers.Provider);
+    getSigner(): Promise<ethers.Signer | providers.Provider>;
+    getChainId(): Promise<number>;
+    populateTransaction(tx: PopulatedTransaction): Promise<providers.TransactionRequest>;
+}

package/dist/esm/ChainClient.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Signer, providers } from "ethers";
+import { validateSignerOrProvider } from "./utils";
+export class ChainClient {
+    constructor(signerOrProvider) {
+        validateSignerOrProvider(signerOrProvider);
+        this.signerOrProvider = signerOrProvider;
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.signerOrProvider;
+        });
+    }
+    getChainId() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let chainId = 0;
+            if (Signer.isSigner(this.signerOrProvider)) {
+                const network = yield ((_a = this.signerOrProvider.provider) === null || _a === void 0 ? void 0 : _a.getNetwork());
+                if (network) {
+                    chainId = network.chainId;
+                }
+            }
+            else if (providers.Provider.isProvider(this.signerOrProvider)) {
+                const network = yield this.signerOrProvider.getNetwork();
+                if (network) {
+                    chainId = network.chainId;
+                }
+            }
+            if (chainId === 0) {
+                throw new Error('Could not get chainId from signer or provider');
+            }
+            return chainId;
+        });
+    }
+    populateTransaction(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Signer.isSigner(this.signerOrProvider)) {
+                return this.signerOrProvider.populateTransaction(tx);
+            }
+            else {
+                return tx;
+            }
+        });
+    }
+}

package/dist/esm/TestChainClient.d.ts

@@ -0,0 +1,7 @@
+import { PopulatedTransaction, ethers, providers } from 'ethers';
+import { IChainClient } from './types';
+export declare class TestChainClient implements IChainClient {
+    getSigner(): Promise<ethers.Signer | providers.Provider>;
+    getChainId(): Promise<number>;
+    populateTransaction(tx: PopulatedTransaction): Promise<providers.TransactionRequest>;
+}

package/dist/esm/TestChainClient.js

@@ -0,0 +1,37 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class TestChainClient {
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fakeProvider = {};
+            return fakeProvider;
+        });
+    }
+    getChainId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return 1;
+        });
+    }
+    populateTransaction(tx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fakeTx = {
+                to: tx.to,
+                from: tx.from,
+                data: tx.data,
+                value: tx.value,
+                nonce: 0,
+                gasLimit: 0,
+                gasPrice: 0,
+                chainId: 1,
+            };
+            return fakeTx;
+        });
+    }
+}

package/dist/esm/contracts.json

@@ -0,0 +1,26 @@
+{
+    "42220": {
+        "Airgrab": "",
+        "Emission": "",
+        "MentoGovernor": "",
+        "MentoToken": "",
+        "TimelockController": "",
+        "Locking": ""
+    },
+    "62320": {
+        "Airgrab": "0x349aa8910577A6fE16cA7b98b5A135d14CE4dF9f",
+        "Emission": "0xcd427DDB27D835E5353312e7897bb9ad35F0E214",
+        "MentoGovernor": "0x5dFE8CC7743C636a86bED8F8d0de982d502E22fC",
+        "MentoToken": "0xD2f4f160BAF7D88a7A9189b03D0B3AA6A5D9775B",
+        "TimelockController": "0xb5977b1d208ef35FAf97A9534Dd849c356F362C5",
+        "Locking": "0x831DAfC0912e1c2aBa2Da90668c0856d48a8C06b"
+    },
+    "44787": {
+        "Airgrab": "0x281fA47f59456fA04DF699539fA4b1F25e7769A3",
+        "Emission": "0x8D1267bFf3f8166AEB2B58217b74188d1fe326f3",
+        "MentoGovernor": "0x84382a356c1Dc6ada21997E64dc72e5a7AcF5826",
+        "MentoToken": "0x53De3F938c64baB8C621c8A3C5000b385afE2404",
+        "TimelockController": "0x2AFC4a1e7928Fb3bfC81076740d3142FF8B1DE05",
+        "Locking": "0x65a1271ce7B2ec8D564A4Bc752E13A36a46e81B8"
+    }
+}

package/dist/esm/governance.d.ts

@@ -0,0 +1,62 @@
+import { BigNumberish, Signer, providers } from 'ethers';
+import { MentoGovernor } from '@mento-protocol/mento-core-ts';
+import { IChainClient } from './types';
+export declare class Governance {
+    private chainClient;
+    constructor(chainClient: IChainClient);
+    constructor(signerOrProvider: Signer | providers.Provider);
+    /**
+     * This function retrieves the MentoGovernor contract.
+     * @returns The MentoGovernor contract.
+     */
+    getGovernorContract(): Promise<MentoGovernor>;
+    /**
+     * Generates a transaction that submits a proposal to be created to the Mento Governor contract using the specified values.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     * @returns The transaction request.
+     */
+    createProposal(targets: string[], values: BigNumberish[], calldatas: string[], description: string): Promise<providers.TransactionRequest>;
+    /**
+     * Generates a transaction that will queue the proposal with the specified id to be executed.
+     * @param proposalId The id of the proposal to queue.
+     * @returns The transaction request.
+     */
+    queueProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Executes the proposal with the specified id.
+     * @param proposalId The id of the proposal to execute.
+     * @returns The transaction request.
+     */
+    executeProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Submits a vote to the Mento Governor contract for the specified proposal.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    castVote(proposalId: BigNumberish, support: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Cancels the proposal with the specified id.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    cancelProposal(proposalId: BigNumberish): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the state of the proposal with the specified id.
+     * @param proposalId The id of the proposal to get the state of.
+     * @returns The state of the proposal.
+     */
+    getProposalState(proposalId: BigNumberish): Promise<string>;
+    /**
+     * This function validates the args that are to be used in the createProposal function.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values  The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     */
+    private validateProposalArgs;
+}

package/dist/esm/governance.js

@@ -0,0 +1,143 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Signer, providers } from 'ethers';
+import { getContractsByChainId } from './utils';
+import { MentoGovernor__factory, } from '@mento-protocol/mento-core-ts';
+import { ProposalState } from './types';
+import { ChainClient } from './ChainClient';
+import { TestChainClient } from './TestChainClient';
+export class Governance {
+    constructor(arg) {
+        // TODO: Remove use of TestChainClient in future this is only meant for testing
+        if (arg instanceof ChainClient || arg instanceof TestChainClient) {
+            this.chainClient = arg;
+        }
+        else if (Signer.isSigner(arg) || providers.Provider.isProvider(arg)) {
+            this.chainClient = new ChainClient(arg);
+        }
+        else {
+            throw new Error('Invalid constructor argument');
+        }
+    }
+    /**
+     * This function retrieves the MentoGovernor contract.
+     * @returns The MentoGovernor contract.
+     */
+    getGovernorContract() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contracts = getContractsByChainId(yield this.chainClient.getChainId());
+            const mentoGovernorAddress = contracts.MentoGovernor;
+            return MentoGovernor__factory.connect(mentoGovernorAddress, yield this.chainClient.getSigner());
+        });
+    }
+    /**
+     * Generates a transaction that submits a proposal to be created to the Mento Governor contract using the specified values.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     * @returns The transaction request.
+     */
+    createProposal(targets, values, calldatas, description) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.validateProposalArgs(targets, values, calldatas, description);
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['propose(address[],uint256[],bytes[],string)'](targets, values, calldatas, description);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Generates a transaction that will queue the proposal with the specified id to be executed.
+     * @param proposalId The id of the proposal to queue.
+     * @returns The transaction request.
+     */
+    queueProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['queue(uint256)'](proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Executes the proposal with the specified id.
+     * @param proposalId The id of the proposal to execute.
+     * @returns The transaction request.
+     */
+    executeProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction['execute(uint256)'](proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Submits a vote to the Mento Governor contract for the specified proposal.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    castVote(proposalId, support) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction.castVote(proposalId, support);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Cancels the proposal with the specified id.
+     * @param proposalId The id of the proposal to vote on.
+     * @param support Whether or not to support the proposal.
+     * @returns The transaction request.
+     */
+    cancelProposal(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const tx = yield governor.populateTransaction.cancel(proposalId);
+            return yield this.chainClient.populateTransaction(tx);
+        });
+    }
+    /**
+     * Returns the state of the proposal with the specified id.
+     * @param proposalId The id of the proposal to get the state of.
+     * @returns The state of the proposal.
+     */
+    getProposalState(proposalId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const governor = yield this.getGovernorContract();
+            const state = (yield governor.functions.state(proposalId))[0];
+            return ProposalState[state];
+        });
+    }
+    /**
+     * This function validates the args that are to be used in the createProposal function.
+     * @param targets The addresses of the contracts to be called during proposal execution.
+     * @param values  The values to be passed to the calls to the target contracts.
+     * @param calldatas The calldata to be passed to the calls to the target contracts.
+     * @param description A human readable description of the proposal.
+     */
+    validateProposalArgs(targets, values, calldatas, description) {
+        if (!targets || targets.length === 0) {
+            throw new Error('Targets must be specified');
+        }
+        if (!values || values.length === 0) {
+            throw new Error('Values must be specified');
+        }
+        if (!calldatas || calldatas.length === 0) {
+            throw new Error('Calldatas must be specified');
+        }
+        if (!description) {
+            throw new Error('Description must be specified');
+        }
+        if (targets.length !== values.length ||
+            targets.length !== calldatas.length) {
+            throw new Error('Targets, values, and calldatas must all have the same length');
+        }
+    }
+}

package/dist/esm/index.d.ts

@@ -1 +1,3 @@
 export * from './mento';
+export * from './governance';
+export * from './utils';

package/dist/esm/index.js

@@ -1,2 +1,4 @@
 /* istanbul ignore file */
 export * from './mento';
+export * from './governance';
+export * from './utils';

package/dist/esm/limits.d.ts

@@ -0,0 +1,33 @@
+import { Address, TradingLimit, TradingLimitsConfig, TradingLimitsState } from './types';
+import { Broker } from '@mento-protocol/mento-core-ts';
+/**
+ * Returns the limit configuration in the broker for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the limited asset
+ * @returns the limit configuration
+ */
+export declare function getLimitsConfig(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimitsConfig>;
+/**
+ * Returns the limit state in the broker for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the limited asset
+ * @returns the limit state
+ */
+export declare function getLimitsState(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimitsState>;
+/**
+ * Returns a human-friendly representation of the limits for the given exchange and asset
+ * @param broker an instance of the broker
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the asset with the limit
+ * @returns a list of TradingLimit objects
+ */
+export declare function getLimits(broker: Broker, exchangeId: string, asset: Address): Promise<TradingLimit[]>;
+/**
+ * Returns the limit id for the given exchange and asset
+ * @param exchangeId the id of the exchange
+ * @param asset the address of the asset with the limit
+ * @returns the limit id
+ */
+export declare function getLimitId(exchangeId: string, asset: Address): string;