@mento-protocol/mento-sdk 0.1.0

package/README.md

@@ -0,0 +1,62 @@
+# Mento SDK
+
+The official Mento Protocol SDK for interacting with Multi-Collateral Mento smart contracts on the Celo network.
+
+# Sample Usage
+
+```javascript
+const provider = new providers.JsonRpcProvider(
+  'https://baklava-forno.celo-testnet.org'
+)
+const pKey = 'privateKey'
+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()
+
+console.log('swapIn receipt', swapReceipt)
+```
+
+# In depth docs
+
+- [ ] TODO: Adds docs link

package/dist/cjs/index.d.ts

@@ -0,0 +1 @@
+export * from './mento';

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/* istanbul ignore file */
+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("./mento"), exports);

package/dist/cjs/mento.d.ts

@@ -0,0 +1,94 @@
+import { BigNumber, Signer, providers } from 'ethers';
+interface Asset {
+    address: Address;
+    symbol: string;
+}
+export declare class Mento {
+    private readonly signerOrProvider;
+    private readonly broker;
+    private exchanges;
+    /**
+     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * to create a new Mento instance
+     * @param brokerAddress the address of the broker contract
+     * @param provider an ethers provider
+     * @param signer an optional ethers signer to execute swaps (must be connected to a provider)
+     */
+    private constructor();
+    /**
+     * Creates a new Mento object instance.
+     * When constructed with only a Provider only read-only operations are supported
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static create(signerOrProvider: Signer | providers.Provider): Promise<Mento>;
+    /**
+     * Create a new Mento object instance given a specific broker address
+     * When constructed with only a Provider only read-only operations are supported
+     * @param brokerAddr the address of the broker contract
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static createWithBrokerAddress(brokerAddr: Address, signerOrProvider: Signer | providers.Provider): Mento;
+    /**
+     * Returns a list of all the pairs that can be traded on Mento
+     * @returns The list of tradeable pairs in the form of [{address, symbol}]
+     */
+    getTradeablePairs(): Promise<[Asset, Asset][]>;
+    /**
+     * Returns the amount of tokenIn to be sold to buy amountOut of tokenOut
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @returns the amount of tokenIn to be sold
+     */
+    getAmountIn(tokenIn: Address, tokenOut: Address, amountOut: BigNumber): Promise<BigNumber>;
+    /**
+     * Returns the amount of tokenOut to be bought by selling amountIn of tokenIn
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @returns the amount of tokenOut to be bought
+     */
+    getAmountOut(tokenIn: Address, tokenOut: Address, amountIn: BigNumber): Promise<BigNumber>;
+    /**
+     * Increases the broker's trading allowance for the given token
+     * @param token the token to increase the allowance for
+     * @param amount the amount to increase the allowance by
+     * @returns the populated TransactionRequest object
+     */
+    increaseTradingAllowance(token: Address, amount: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns a token swap populated tx object with a fixed amount of tokenIn and a minimum amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @param amountOutMin the minimum amount of tokenOut to be bought
+     * @returns the populated TransactionRequest object
+     */
+    swapIn(tokenIn: Address, tokenOut: Address, amountIn: BigNumber, amountOutMin: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns a token swap populated tx object with a maximum amount of tokenIn and a fixed amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @param amountInMax the maximum amount of tokenIn to be sold
+     * @returns the populated TransactionRequest object
+     */
+    swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumber, amountInMax: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the list of exchanges available in Mento (cached)
+     * @returns the list of exchanges
+     */
+    private getExchanges;
+    /**
+     * Returns the Mento exchange (if any) for a given pair of tokens
+     * @param token0 the first token
+     * @param token1 the second token
+     * @returns
+     */
+    private getExchangeForTokens;
+}
+export {};

package/dist/cjs/mento.js

@@ -0,0 +1,222 @@
+"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.Mento = void 0;
+// SPDX-License-Identifier: GPL-3.0-or-later
+const ethers_1 = require("ethers");
+const mento_core_ts_1 = require("@mento-protocol/mento-core-ts");
+const utils_1 = require("./utils");
+const assert_1 = require("assert");
+class Mento {
+    /**
+     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * to create a new Mento instance
+     * @param brokerAddress the address of the broker contract
+     * @param provider an ethers provider
+     * @param signer an optional ethers signer to execute swaps (must be connected to a provider)
+     */
+    constructor(brokerAddress, signerOrProvider) {
+        this.broker = mento_core_ts_1.IBroker__factory.connect(brokerAddress, signerOrProvider);
+        this.signerOrProvider = signerOrProvider;
+        this.exchanges = new Array();
+    }
+    /**
+     * Creates a new Mento object instance.
+     * When constructed with only a Provider only read-only operations are supported
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static create(signerOrProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSigner = ethers_1.Signer.isSigner(signerOrProvider);
+            const isProvider = ethers_1.providers.Provider.isProvider(signerOrProvider);
+            if (!isSigner && !isProvider) {
+                throw new Error('A valid signer or provider must be provided');
+            }
+            if (isSigner) {
+                if (!ethers_1.providers.Provider.isProvider(signerOrProvider.provider)) {
+                    throw new Error('Signer must be connected to a provider');
+                }
+            }
+            return new Mento(yield (0, utils_1.getBrokerAddressFromRegistry)(signerOrProvider), signerOrProvider);
+        });
+    }
+    /**
+     * Create a new Mento object instance given a specific broker address
+     * When constructed with only a Provider only read-only operations are supported
+     * @param brokerAddr the address of the broker contract
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static createWithBrokerAddress(brokerAddr, signerOrProvider) {
+        const isSigner = ethers_1.Signer.isSigner(signerOrProvider);
+        const isProvider = ethers_1.providers.Provider.isProvider(signerOrProvider);
+        if (!isSigner && !isProvider) {
+            throw new Error('A valid signer or provider must be provided');
+        }
+        if (isSigner) {
+            if (!ethers_1.providers.Provider.isProvider(signerOrProvider.provider)) {
+                throw new Error('Signer must be connected to a provider');
+            }
+        }
+        return new Mento(brokerAddr, signerOrProvider);
+    }
+    /**
+     * Returns a list of all the pairs that can be traded on Mento
+     * @returns The list of tradeable pairs in the form of [{address, symbol}]
+     */
+    getTradeablePairs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchanges = yield this.getExchanges();
+            const pairs = [];
+            for (const exchange of exchanges) {
+                const asset0 = exchange.assets[0];
+                const asset1 = exchange.assets[1];
+                const symbols = yield Promise.all([
+                    (0, utils_1.getSymbolFromTokenAddress)(asset0, this.signerOrProvider),
+                    (0, utils_1.getSymbolFromTokenAddress)(asset1, this.signerOrProvider),
+                ]);
+                pairs.push([
+                    { address: asset0, symbol: symbols[0] },
+                    { address: asset1, symbol: symbols[1] },
+                ]);
+            }
+            return pairs;
+        });
+    }
+    /**
+     * Returns the amount of tokenIn to be sold to buy amountOut of tokenOut
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @returns the amount of tokenIn to be sold
+     */
+    getAmountIn(tokenIn, tokenOut, amountOut) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
+            return this.broker.getAmountIn(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountOut);
+        });
+    }
+    /**
+     * Returns the amount of tokenOut to be bought by selling amountIn of tokenIn
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @returns the amount of tokenOut to be bought
+     */
+    getAmountOut(tokenIn, tokenOut, amountIn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
+            return this.broker.getAmountOut(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountIn);
+        });
+    }
+    /**
+     * Increases the broker's trading allowance for the given token
+     * @param token the token to increase the allowance for
+     * @param amount the amount to increase the allowance by
+     * @returns the populated TransactionRequest object
+     */
+    increaseTradingAllowance(token, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ethers_1.Signer.isSigner(this.signerOrProvider)) {
+                throw new Error('A signer is required to populate the increaseAllowance tx object');
+            }
+            const spender = this.broker.address;
+            const tx = yield (0, utils_1.increaseAllowance)(token, spender, amount, this.signerOrProvider);
+            // The contract call doesn't populate all of the signer fields, so we need an extra call for the signer
+            return this.signerOrProvider.populateTransaction(tx);
+        });
+    }
+    /**
+     * Returns a token swap populated tx object with a fixed amount of tokenIn and a minimum amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @param amountOutMin the minimum amount of tokenOut to be bought
+     * @returns the populated TransactionRequest object
+     */
+    swapIn(tokenIn, tokenOut, amountIn, amountOutMin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ethers_1.Signer.isSigner(this.signerOrProvider)) {
+                throw new Error('A signer is required to populate the swapIn tx object');
+            }
+            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
+            const tx = yield this.broker.populateTransaction.swapIn(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountIn, amountOutMin);
+            // The broker's call doesn't populate all of the signer fields, so we need an extra call for the signer
+            return this.signerOrProvider.populateTransaction(tx);
+        });
+    }
+    /**
+     * Returns a token swap populated tx object with a maximum amount of tokenIn and a fixed amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @param amountInMax the maximum amount of tokenIn to be sold
+     * @returns the populated TransactionRequest object
+     */
+    swapOut(tokenIn, tokenOut, amountOut, amountInMax) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ethers_1.Signer.isSigner(this.signerOrProvider)) {
+                throw new Error('A signer is required to populate the swapOut tx object');
+            }
+            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
+            const tx = yield this.broker.populateTransaction.swapOut(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountOut, amountInMax);
+            // The broker's call doesn't populate all of the signer fields, so we need an extra call for the signer
+            return this.signerOrProvider.populateTransaction(tx);
+        });
+    }
+    /**
+     * Returns the list of exchanges available in Mento (cached)
+     * @returns the list of exchanges
+     */
+    getExchanges() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.exchanges.length > 0) {
+                return this.exchanges;
+            }
+            const exchanges = [];
+            const exchangeProvidersAddresses = yield this.broker.getExchangeProviders();
+            for (const exchangeProviderAddr of exchangeProvidersAddresses) {
+                const exchangeManager = mento_core_ts_1.IExchangeProvider__factory.connect(exchangeProviderAddr, this.signerOrProvider);
+                const exchangesInManager = yield exchangeManager.getExchanges();
+                for (const exchange of exchangesInManager) {
+                    (0, assert_1.strict)(exchange.assets.length === 2, 'Exchange must have 2 assets');
+                    exchanges.push({
+                        providerAddr: exchangeProviderAddr,
+                        id: exchange.exchangeId,
+                        assets: exchange.assets,
+                    });
+                }
+            }
+            this.exchanges = exchanges;
+            return exchanges;
+        });
+    }
+    /**
+     * Returns the Mento exchange (if any) for a given pair of tokens
+     * @param token0 the first token
+     * @param token1 the second token
+     * @returns
+     */
+    getExchangeForTokens(token0, token1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchanges = (yield this.getExchanges()).filter((e) => e.assets.includes(token0) && e.assets.includes(token1));
+            if (exchanges.length === 0) {
+                throw Error(`No exchange found for ${token0} and ${token1}`);
+            }
+            (0, assert_1.strict)(exchanges.length === 1, `More than one exchange found for ${token0} and ${token1}`);
+            return exchanges[0];
+        });
+    }
+}
+exports.Mento = Mento;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,23 @@
+import { BigNumber, Signer, providers } from 'ethers';
+/**
+ * Returns the broker address from the Celo registry
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the broker address
+ */
+export declare function getBrokerAddressFromRegistry(signerOrProvider: Signer | providers.Provider): Promise<Address>;
+/**
+ * Returns the symbol of an erc20 token
+ * @param tokenAddr the address of the erc20 token
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the symbol of the erc20 token
+ */
+export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrProvider: Signer | providers.Provider): Promise<string>;
+/**
+ * Returns a populated tx obj for increasing the allowance of a spender for a given erc20 token by a given amount
+ * @param tokenAddr the address of the erc20 token
+ * @param spender the address of the spender
+ * @param amount the amount to increase the allowance by
+ * @param signer an ethers signer
+ * @returns the populated TransactionRequest object
+ */
+export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumber, signer: Signer): Promise<providers.TransactionRequest>;

package/dist/cjs/utils.js

@@ -0,0 +1,67 @@
+"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.increaseAllowance = exports.getSymbolFromTokenAddress = exports.getBrokerAddressFromRegistry = void 0;
+// SPDX-License-Identifier: GPL-3.0-or-later
+const ethers_1 = require("ethers");
+/**
+ * Returns the broker address from the Celo registry
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the broker address
+ */
+function getBrokerAddressFromRegistry(signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const celoRegistryAddress = '0x000000000000000000000000000000000000ce10';
+        const brokerIdentifier = 'Broker';
+        const registryAbi = [
+            'function getAddressForString(string calldata identifier) external view returns (address)',
+        ];
+        const contract = new ethers_1.Contract(celoRegistryAddress, registryAbi, signerOrProvider);
+        const brokerAddress = yield contract.getAddressForString(brokerIdentifier);
+        if (brokerAddress === ethers_1.constants.AddressZero) {
+            throw Error('Broker address not found in the registry');
+        }
+        return brokerAddress;
+    });
+}
+exports.getBrokerAddressFromRegistry = getBrokerAddressFromRegistry;
+/**
+ * Returns the symbol of an erc20 token
+ * @param tokenAddr the address of the erc20 token
+ * @param signerOrProvider an ethers provider or signer
+ * @returns the symbol of the erc20 token
+ */
+function getSymbolFromTokenAddress(tokenAddr, signerOrProvider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const erc20Abi = ['function symbol() external view returns (string memory)'];
+        const contract = new ethers_1.Contract(tokenAddr, erc20Abi, signerOrProvider);
+        return contract.symbol();
+    });
+}
+exports.getSymbolFromTokenAddress = getSymbolFromTokenAddress;
+/**
+ * Returns a populated tx obj for increasing the allowance of a spender for a given erc20 token by a given amount
+ * @param tokenAddr the address of the erc20 token
+ * @param spender the address of the spender
+ * @param amount the amount to increase the allowance by
+ * @param signer an ethers signer
+ * @returns the populated TransactionRequest object
+ */
+function increaseAllowance(tokenAddr, spender, amount, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const abi = [
+            'function increaseAllowance(address spender, uint256 value) external returns (bool)',
+        ];
+        const contract = new ethers_1.Contract(tokenAddr, abi, signer);
+        return yield contract.populateTransaction.increaseAllowance(spender, amount);
+    });
+}
+exports.increaseAllowance = increaseAllowance;

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export * from './mento';

package/dist/esm/index.js

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

package/dist/esm/mento.d.ts

@@ -0,0 +1,94 @@
+import { BigNumber, Signer, providers } from 'ethers';
+interface Asset {
+    address: Address;
+    symbol: string;
+}
+export declare class Mento {
+    private readonly signerOrProvider;
+    private readonly broker;
+    private exchanges;
+    /**
+     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * to create a new Mento instance
+     * @param brokerAddress the address of the broker contract
+     * @param provider an ethers provider
+     * @param signer an optional ethers signer to execute swaps (must be connected to a provider)
+     */
+    private constructor();
+    /**
+     * Creates a new Mento object instance.
+     * When constructed with only a Provider only read-only operations are supported
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static create(signerOrProvider: Signer | providers.Provider): Promise<Mento>;
+    /**
+     * Create a new Mento object instance given a specific broker address
+     * When constructed with only a Provider only read-only operations are supported
+     * @param brokerAddr the address of the broker contract
+     * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @returns a new Mento object instance
+     */
+    static createWithBrokerAddress(brokerAddr: Address, signerOrProvider: Signer | providers.Provider): Mento;
+    /**
+     * Returns a list of all the pairs that can be traded on Mento
+     * @returns The list of tradeable pairs in the form of [{address, symbol}]
+     */
+    getTradeablePairs(): Promise<[Asset, Asset][]>;
+    /**
+     * Returns the amount of tokenIn to be sold to buy amountOut of tokenOut
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @returns the amount of tokenIn to be sold
+     */
+    getAmountIn(tokenIn: Address, tokenOut: Address, amountOut: BigNumber): Promise<BigNumber>;
+    /**
+     * Returns the amount of tokenOut to be bought by selling amountIn of tokenIn
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @returns the amount of tokenOut to be bought
+     */
+    getAmountOut(tokenIn: Address, tokenOut: Address, amountIn: BigNumber): Promise<BigNumber>;
+    /**
+     * Increases the broker's trading allowance for the given token
+     * @param token the token to increase the allowance for
+     * @param amount the amount to increase the allowance by
+     * @returns the populated TransactionRequest object
+     */
+    increaseTradingAllowance(token: Address, amount: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns a token swap populated tx object with a fixed amount of tokenIn and a minimum amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountIn the amount of tokenIn to be sold
+     * @param amountOutMin the minimum amount of tokenOut to be bought
+     * @returns the populated TransactionRequest object
+     */
+    swapIn(tokenIn: Address, tokenOut: Address, amountIn: BigNumber, amountOutMin: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns a token swap populated tx object with a maximum amount of tokenIn and a fixed amount of tokenOut
+     * Submitting the transaction to execute the swap is left to the consumer
+     * @param tokenIn the token to be sold
+     * @param tokenOut the token to be bought
+     * @param amountOut the amount of tokenOut to be bought
+     * @param amountInMax the maximum amount of tokenIn to be sold
+     * @returns the populated TransactionRequest object
+     */
+    swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumber, amountInMax: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the list of exchanges available in Mento (cached)
+     * @returns the list of exchanges
+     */
+    private getExchanges;
+    /**
+     * Returns the Mento exchange (if any) for a given pair of tokens
+     * @param token0 the first token
+     * @param token1 the second token
+     * @returns
+     */
+    private getExchangeForTokens;
+}
+export {};