@mento-protocol/mento-sdk 0.1.4 → 0.2.0

package/README.md

@@ -2,72 +2,16 @@
 
 The official Mento Protocol SDK for interacting with Multi-Collateral Mento smart contracts on the Celo network.
 
-# Example Usage
+## Installation
 
-```javascript
-import { Wallet, providers, utils } from 'ethers'
+```sh
+# Install with npm
+npm install @mento-protocol/mento-sdk
 
-import { Mento } from '@mento-protocol/mento-sdk'
-
-async function main() {
-  const provider = new providers.JsonRpcProvider(
-    'https://baklava-forno.celo-testnet.org'
-  )
-  const pKey =
-    'b214fcf9673dc1a880f8041a8c8952c2dc7daff41fb64cf7715919df095c3fce'
-  const wallet = new Wallet(pKey, provider)
-
-  const mento = await Mento.create(wallet)
-  console.log('available pairs: ', await mento.getTradeablePairs())
-  /*
-          [
-        [
-          {
-            address: '0x62492A644A588FD904270BeD06ad52B9abfEA1aE',
-            symbol: 'cUSD'
-          },
-          {
-            address: '0xdDc9bE57f553fe75752D61606B94CBD7e0264eF8',
-            symbol: 'CELO'
-          }
-        ],
-        ...
-      ]
-      */
-
-  // swap 1 CELO for cUSD
-  const one = 1
-  const tokenIn = '0xdDc9bE57f553fe75752D61606B94CBD7e0264eF8' // CELO
-  const tokenOut = '0x62492A644A588FD904270BeD06ad52B9abfEA1aE' // cUSD
-  const amountIn = utils.parseUnits(one.toString(), 18)
-  const expectedAmountOut = await mento.getAmountOut(
-    tokenIn,
-    tokenOut,
-    utils.parseUnits(one.toString(), 18)
-  )
-  // 95% of the quote to allow some slippage
-  const minAmountOut = expectedAmountOut.mul(95).div(100)
-
-  // allow the broker contract to spend CELO on behalf of the wallet
-  const allowanceTxObj = await mento.increaseTradingAllowance(tokenIn, amountIn)
-  const allowanceTx = await wallet.sendTransaction(allowanceTxObj)
-  const allowanceReceipt = await allowanceTx.wait()
-  console.log('increaseAllowance receipt', allowanceReceipt)
-
-  // execute the swap
-  const swapTxObj = await mento.swapIn(
-    tokenIn,
-    tokenOut,
-    amountIn,
-    minAmountOut
-  )
-  const swapTx = await wallet.sendTransaction(swapTxObj)
-  const swapReceipt = await swapTx.wait()
+# Or install with yarn
+yarn add @mento-protocol/mento-sdk
+```
 
-  console.log('swapIn receipt', swapReceipt)
-}
+# Learn more
 
-main()
-  .then(() => console.log('Done'))
-  .catch((e) => console.error('Error:', e))
-```
+You can find example usages of the SDK in the [mento-sdk-examples](https://github.com/mento-protocol/mento-sdk-examples) repository. For in-depth documentation and walk through explanations please see the [SDK section](https://docs.mento.org/mento/developers/mento-sdk) of the Mento docs.

package/dist/cjs/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/cjs/ChainClient.js

@@ -0,0 +1,58 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainClient = void 0;
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+class ChainClient {
+    constructor(signerOrProvider) {
+        (0, utils_1.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 (ethers_1.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 (ethers_1.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 (ethers_1.Signer.isSigner(this.signerOrProvider)) {
+                return this.signerOrProvider.populateTransaction(tx);
+            }
+            else {
+                return tx;
+            }
+        });
+    }
+}
+exports.ChainClient = ChainClient;

package/dist/cjs/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/cjs/TestChainClient.js

@@ -0,0 +1,41 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestChainClient = void 0;
+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;
+        });
+    }
+}
+exports.TestChainClient = TestChainClient;

package/dist/cjs/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/cjs/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/cjs/governance.js

@@ -0,0 +1,147 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Governance = void 0;
+const ethers_1 = require("ethers");
+const utils_1 = require("./utils");
+const mento_core_ts_1 = require("@mento-protocol/mento-core-ts");
+const types_1 = require("./types");
+const ChainClient_1 = require("./ChainClient");
+const TestChainClient_1 = require("./TestChainClient");
+class Governance {
+    constructor(arg) {
+        // TODO: Remove use of TestChainClient in future this is only meant for testing
+        if (arg instanceof ChainClient_1.ChainClient || arg instanceof TestChainClient_1.TestChainClient) {
+            this.chainClient = arg;
+        }
+        else if (ethers_1.Signer.isSigner(arg) || ethers_1.providers.Provider.isProvider(arg)) {
+            this.chainClient = new ChainClient_1.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 = (0, utils_1.getContractsByChainId)(yield this.chainClient.getChainId());
+            const mentoGovernorAddress = contracts.MentoGovernor;
+            return mento_core_ts_1.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 types_1.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');
+        }
+    }
+}
+exports.Governance = Governance;

package/dist/cjs/index.d.ts

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

package/dist/cjs/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./mento"), exports);
+__exportStar(require("./governance"), exports);
+__exportStar(require("./utils"), exports);

package/dist/cjs/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;

package/dist/cjs/limits.js

@@ -0,0 +1,122 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimitId = exports.getLimits = exports.getLimitsState = exports.getLimitsConfig = void 0;
+const assert_1 = require("assert");
+const ethers_1 = require("ethers");
+/**
+ * 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
+ */
+function getLimitsConfig(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limitId = getLimitId(exchangeId, asset);
+        const cfg = yield broker.tradingLimitsConfig(limitId);
+        return {
+            timestep0: cfg['timestep0'],
+            timestep1: cfg['timestep1'],
+            limit0: cfg['limit0'],
+            limit1: cfg['limit1'],
+            limitGlobal: cfg['limitGlobal'],
+            flags: cfg['flags'],
+        };
+    });
+}
+exports.getLimitsConfig = getLimitsConfig;
+/**
+ * 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
+ */
+function getLimitsState(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const limitId = getLimitId(exchangeId, asset);
+        const [cfg, state] = yield Promise.all([
+            getLimitsConfig(broker, exchangeId, asset),
+            broker.tradingLimitsState(limitId),
+        ]);
+        const isL0Enabled = cfg.timestep0 > 0;
+        const isL1Enabled = cfg.timestep1 > 0;
+        const nowEpoch = Math.floor(Date.now() / 1000);
+        const isL0Outdated = isL0Enabled && nowEpoch > state['lastUpdated0'] + cfg.timestep0;
+        const isL1Outdated = isL1Enabled && nowEpoch > state['lastUpdated1'] + cfg.timestep1;
+        return {
+            lastUpdated0: isL0Outdated ? nowEpoch : state['lastUpdated0'],
+            lastUpdated1: isL1Outdated ? nowEpoch : state['lastUpdated1'],
+            netflow0: isL0Outdated ? 0 : state['netflow0'],
+            netflow1: isL1Outdated ? 0 : state['netflow1'],
+            netflowGlobal: state['netflowGlobal'],
+        };
+    });
+}
+exports.getLimitsState = getLimitsState;
+/**
+ * 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
+ */
+function getLimits(broker, exchangeId, asset) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [cfg, state] = yield Promise.all([
+            getLimitsConfig(broker, exchangeId, asset),
+            getLimitsState(broker, exchangeId, asset),
+        ]);
+        const limits = [];
+        if (cfg.limit0 > 0) {
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limit0 - state.netflow0,
+                maxOut: cfg.limit0 + state.netflow0,
+                until: state.lastUpdated0 + cfg.timestep0,
+            });
+        }
+        if (cfg.limit1 > 0) {
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limit1 - state.netflow1,
+                maxOut: cfg.limit1 + state.netflow1,
+                until: state.lastUpdated1 + cfg.timestep1,
+            });
+        }
+        if (cfg.limitGlobal > 0) {
+            const timestampIn2030 = 1893456000; // a far away timestamp
+            limits.push({
+                asset: asset,
+                maxIn: cfg.limitGlobal - state.netflowGlobal,
+                maxOut: cfg.limitGlobal + state.netflowGlobal,
+                until: timestampIn2030,
+            });
+        }
+        return limits;
+    });
+}
+exports.getLimits = getLimits;
+/**
+ * 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
+ */
+function getLimitId(exchangeId, asset) {
+    const assetBytes32 = ethers_1.utils.zeroPad(asset, 32);
+    const exchangeIdBytes = ethers_1.utils.arrayify(exchangeId);
+    const assetBytes = ethers_1.utils.arrayify(assetBytes32);
+    (0, assert_1.strict)(exchangeIdBytes.length === assetBytes.length, 'exchangeId and asset0 must be the same length');
+    return ethers_1.utils.hexlify(exchangeIdBytes.map((b, i) => b ^ assetBytes[i]));
+}
+exports.getLimitId = getLimitId;

package/dist/cjs/mento.d.ts

@@ -1,6 +1,6 @@
+import { Address, TradingLimit, TradingLimitsConfig, TradingLimitsState } from './types';
 import { IBroker } from '@mento-protocol/mento-core-ts';
-import { BigNumber, BigNumberish, providers, Signer } from 'ethers';
-import { Address } from './types';
+import { BigNumber, BigNumberish, Signer, providers } from 'ethers';
 export interface Exchange {
     providerAddr: Address;
     id: string;
@@ -109,9 +109,44 @@ export declare class Mento {
     getExchangesForProvider(exchangeProviderAddr: Address): Promise<Exchange[]>;
     /**
      * 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: Address, token1: Address): Promise<Exchange>;
+    /**
+     * 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: string): Promise<Exchange>;
+    /**
+     * 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: string): Promise<boolean>;
+    /**
+     * 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: string): Promise<TradingLimit[]>;
+    /**
+     * Returns the trading limits configuration for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @returns the trading limits configuration
+     */
+    getTradingLimitConfig(exchangeId: string): Promise<TradingLimitsConfig>;
+    /**
+     * Returns the trading limits state for a given exchange id
+     * @param exchangeId the id of the exchange
+     * @returns the trading limits state
+     */
+    getTradingLimitState(exchangeId: string): Promise<TradingLimitsState>;
 }