@mento-protocol/mento-sdk 0.1.1 → 0.1.3

package/README.md

@@ -2,61 +2,72 @@
 
 The official Mento Protocol SDK for interacting with Multi-Collateral Mento smart contracts on the Celo network.
 
-# Sample Usage
+# Example Usage
 
 ```javascript
-const provider = new providers.JsonRpcProvider(
-  'https://baklava-forno.celo-testnet.org'
-)
-const pKey = 'privateKey'
-const wallet = new Wallet(pKey, provider)
+import { Wallet, providers, utils } from 'ethers'
 
-const mento = await Mento.create(wallet)
+import { Mento } from '@mento-protocol/mento-sdk'
 
-console.log('available pairs: ', await mento.getTradeablePairs())
-/*
+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()
-
-console.log('swapIn receipt', swapReceipt)
-```
+          {
+            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)
 
-# In depth docs
+  // 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)
 
-- [ ] TODO: Adds docs link
+  // 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)
+}
+
+main()
+  .then(() => console.log('Done'))
+  .catch((e) => console.error('Error:', e))
+```

package/dist/cjs/mento.d.ts

@@ -1,6 +1,12 @@
-import { BigNumber, Signer, providers } from 'ethers';
+import { IBroker } from '@mento-protocol/mento-core-ts';
+import { BigNumber, providers, Signer } from 'ethers';
 import { Address } from './types';
-interface Asset {
+export interface Exchange {
+    providerAddr: Address;
+    id: string;
+    assets: Address[];
+}
+export interface Asset {
     address: Address;
     symbol: string;
 }
@@ -9,11 +15,11 @@ export declare class Mento {
     private readonly broker;
     private exchanges;
     /**
-     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * This constructor is private, use the static create or createWithParams methods
      * to create a new Mento instance
+     * @param signerOrProvider an ethers provider or connected signer
      * @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)
+     * @param exchanges exchange data for the broker
      */
     private constructor();
     /**
@@ -24,13 +30,20 @@ export declare class Mento {
      */
     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
+     * Create a new Mento object instance given a broker address and optional exchanges data
+     * When constructed with a Provider, only read-only operations are supported
      * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @param brokerAddr the address of the broker contract
+     * @param exchanges the exchanges data for the broker
      * @returns a new Mento object instance
      */
-    static createWithBrokerAddress(brokerAddr: Address, signerOrProvider: Signer | providers.Provider): Mento;
+    static createWithParams(signerOrProvider: Signer | providers.Provider, brokerAddr: Address, exchanges?: Exchange[]): Mento;
+    /**
+     * Returns a new Mento instance connected to the given signer
+     * @param signer an ethers signer
+     * @returns new Mento object instance
+     */
+    connectSigner(signer: Signer): 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}]
@@ -79,17 +92,26 @@ export declare class Mento {
      * @returns the populated TransactionRequest object
      */
     swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumber, amountInMax: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the mento instance's broker contract
+     * @returns broker contract
+     */
+    getBroker(): IBroker;
     /**
      * Returns the list of exchanges available in Mento (cached)
      * @returns the list of exchanges
      */
-    private getExchanges;
+    getExchanges(): Promise<Exchange[]>;
+    /**
+     * Returns the list of exchanges for a given exchange provider address
+     * @returns list of exchanges
+     */
+    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
-     * @returns
+     * @returns exchange
      */
-    private getExchangeForTokens;
+    getExchangeForTokens(token0: Address, token1: Address): Promise<Exchange>;
 }
-export {};

package/dist/cjs/mento.js

@@ -10,23 +10,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 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 ethers_1 = require("ethers");
 const utils_1 = require("./utils");
 const assert_1 = require("assert");
 class Mento {
     /**
-     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * This constructor is private, use the static create or createWithParams methods
      * to create a new Mento instance
+     * @param signerOrProvider an ethers provider or connected signer
      * @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)
+     * @param exchanges exchange data for the broker
      */
-    constructor(brokerAddress, signerOrProvider) {
-        this.broker = mento_core_ts_1.IBroker__factory.connect(brokerAddress, signerOrProvider);
+    constructor(signerOrProvider, brokerAddress, exchanges) {
         this.signerOrProvider = signerOrProvider;
-        this.exchanges = new Array();
+        this.broker = mento_core_ts_1.IBroker__factory.connect(brokerAddress, signerOrProvider);
+        this.exchanges = exchanges || [];
     }
     /**
      * Creates a new Mento object instance.
@@ -36,38 +35,30 @@ class Mento {
      */
     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);
+            (0, utils_1.validateSignerOrProvider)(signerOrProvider);
+            return new Mento(signerOrProvider, yield (0, utils_1.getBrokerAddressFromRegistry)(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
+     * Create a new Mento object instance given a broker address and optional exchanges data
+     * When constructed with a Provider, only read-only operations are supported
      * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @param brokerAddr the address of the broker contract
+     * @param exchanges the exchanges data for the broker
      * @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);
+    static createWithParams(signerOrProvider, brokerAddr, exchanges) {
+        (0, utils_1.validateSignerOrProvider)(signerOrProvider);
+        return new Mento(signerOrProvider, brokerAddr, exchanges);
+    }
+    /**
+     * Returns a new Mento instance connected to the given signer
+     * @param signer an ethers signer
+     * @returns new Mento object instance
+     */
+    connectSigner(signer) {
+        (0, utils_1.validateSigner)(signer);
+        return new Mento(signer, this.broker.address, this.exchanges);
     }
     /**
      * Returns a list of all the pairs that can be traded on Mento
@@ -175,6 +166,13 @@ class Mento {
             return this.signerOrProvider.populateTransaction(tx);
         });
     }
+    /**
+     * Returns the mento instance's broker contract
+     * @returns broker contract
+     */
+    getBroker() {
+        return this.broker;
+    }
     /**
      * Returns the list of exchanges available in Mento (cached)
      * @returns the list of exchanges
@@ -184,29 +182,35 @@ class Mento {
             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,
-                    });
-                }
-            }
+            const exchanges = (yield Promise.all(exchangeProvidersAddresses.map((a) => this.getExchangesForProvider(a)))).flat();
             this.exchanges = exchanges;
             return exchanges;
         });
     }
+    /**
+     * Returns the list of exchanges for a given exchange provider address
+     * @returns list of exchanges
+     */
+    getExchangesForProvider(exchangeProviderAddr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchangeProvider = mento_core_ts_1.IExchangeProvider__factory.connect(exchangeProviderAddr, this.signerOrProvider);
+            const exchangesInProvider = yield exchangeProvider.getExchanges();
+            return exchangesInProvider.map((e) => {
+                (0, assert_1.strict)(e.assets.length === 2, 'Exchange must have 2 assets');
+                return {
+                    providerAddr: exchangeProviderAddr,
+                    id: e.exchangeId,
+                    assets: e.assets,
+                };
+            });
+        });
+    }
     /**
      * Returns the Mento exchange (if any) for a given pair of tokens
      * @param token0 the first token
      * @param token1 the second token
-     * @returns
+     * @returns exchange
      */
     getExchangeForTokens(token0, token1) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/cjs/utils.d.ts

@@ -1,5 +1,17 @@
-import { BigNumber, Signer, providers } from 'ethers';
+import { BigNumber, providers, Signer } from 'ethers';
 import { Address } from './types';
+/**
+ * Ensures that given signer is truly a a connected signer
+ * @param signer an ethers signer
+ * @throws if signer is invalid or not connected
+ */
+export declare function validateSigner(signer: Signer): void;
+/**
+ * Ensures that given signerOrProvider is truly a provider or a connected signer
+ * @param signerOrProvider an ethers provider or signer
+ * @throws if signerOrProvider is invalid or not connected
+ */
+export declare function validateSignerOrProvider(signerOrProvider: Signer | providers.Provider): void;
 /**
  * Returns the broker address from the Celo registry
  * @param signerOrProvider an ethers provider or signer

package/dist/cjs/utils.js

@@ -9,9 +9,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.increaseAllowance = exports.getSymbolFromTokenAddress = exports.getBrokerAddressFromRegistry = void 0;
-// SPDX-License-Identifier: GPL-3.0-or-later
+exports.increaseAllowance = exports.getSymbolFromTokenAddress = exports.getBrokerAddressFromRegistry = exports.validateSignerOrProvider = exports.validateSigner = void 0;
 const ethers_1 = require("ethers");
+/**
+ * Ensures that given signer is truly a a connected signer
+ * @param signer an ethers signer
+ * @throws if signer is invalid or not connected
+ */
+function validateSigner(signer) {
+    if (!ethers_1.Signer.isSigner(signer)) {
+        throw new Error('A valid signer must be provided');
+    }
+    if (!ethers_1.providers.Provider.isProvider(signer.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
+exports.validateSigner = validateSigner;
+/**
+ * Ensures that given signerOrProvider is truly a provider or a connected signer
+ * @param signerOrProvider an ethers provider or signer
+ * @throws if signerOrProvider is invalid or not connected
+ */
+function validateSignerOrProvider(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 && !ethers_1.providers.Provider.isProvider(signerOrProvider.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
+exports.validateSignerOrProvider = validateSignerOrProvider;
 /**
  * Returns the broker address from the Celo registry
  * @param signerOrProvider an ethers provider or signer

package/dist/esm/mento.d.ts

@@ -1,6 +1,12 @@
-import { BigNumber, Signer, providers } from 'ethers';
+import { IBroker } from '@mento-protocol/mento-core-ts';
+import { BigNumber, providers, Signer } from 'ethers';
 import { Address } from './types';
-interface Asset {
+export interface Exchange {
+    providerAddr: Address;
+    id: string;
+    assets: Address[];
+}
+export interface Asset {
     address: Address;
     symbol: string;
 }
@@ -9,11 +15,11 @@ export declare class Mento {
     private readonly broker;
     private exchanges;
     /**
-     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * This constructor is private, use the static create or createWithParams methods
      * to create a new Mento instance
+     * @param signerOrProvider an ethers provider or connected signer
      * @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)
+     * @param exchanges exchange data for the broker
      */
     private constructor();
     /**
@@ -24,13 +30,20 @@ export declare class Mento {
      */
     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
+     * Create a new Mento object instance given a broker address and optional exchanges data
+     * When constructed with a Provider, only read-only operations are supported
      * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @param brokerAddr the address of the broker contract
+     * @param exchanges the exchanges data for the broker
      * @returns a new Mento object instance
      */
-    static createWithBrokerAddress(brokerAddr: Address, signerOrProvider: Signer | providers.Provider): Mento;
+    static createWithParams(signerOrProvider: Signer | providers.Provider, brokerAddr: Address, exchanges?: Exchange[]): Mento;
+    /**
+     * Returns a new Mento instance connected to the given signer
+     * @param signer an ethers signer
+     * @returns new Mento object instance
+     */
+    connectSigner(signer: Signer): 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}]
@@ -79,17 +92,26 @@ export declare class Mento {
      * @returns the populated TransactionRequest object
      */
     swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumber, amountInMax: BigNumber): Promise<providers.TransactionRequest>;
+    /**
+     * Returns the mento instance's broker contract
+     * @returns broker contract
+     */
+    getBroker(): IBroker;
     /**
      * Returns the list of exchanges available in Mento (cached)
      * @returns the list of exchanges
      */
-    private getExchanges;
+    getExchanges(): Promise<Exchange[]>;
+    /**
+     * Returns the list of exchanges for a given exchange provider address
+     * @returns list of exchanges
+     */
+    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
-     * @returns
+     * @returns exchange
      */
-    private getExchangeForTokens;
+    getExchangeForTokens(token0: Address, token1: Address): Promise<Exchange>;
 }
-export {};

package/dist/esm/mento.js

@@ -7,23 +7,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-// SPDX-License-Identifier: GPL-3.0-or-later
-import { Signer, providers } from 'ethers';
 import { IBroker__factory, IExchangeProvider__factory, } from '@mento-protocol/mento-core-ts';
-import { getBrokerAddressFromRegistry, getSymbolFromTokenAddress, increaseAllowance, } from './utils';
+import { Signer } from 'ethers';
+import { getBrokerAddressFromRegistry, getSymbolFromTokenAddress, increaseAllowance, validateSigner, validateSignerOrProvider, } from './utils';
 import { strict as assert } from 'assert';
 export class Mento {
     /**
-     * This constructor is private, use the static create or createWithBrokerAddress methods
+     * This constructor is private, use the static create or createWithParams methods
      * to create a new Mento instance
+     * @param signerOrProvider an ethers provider or connected signer
      * @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)
+     * @param exchanges exchange data for the broker
      */
-    constructor(brokerAddress, signerOrProvider) {
-        this.broker = IBroker__factory.connect(brokerAddress, signerOrProvider);
+    constructor(signerOrProvider, brokerAddress, exchanges) {
         this.signerOrProvider = signerOrProvider;
-        this.exchanges = new Array();
+        this.broker = IBroker__factory.connect(brokerAddress, signerOrProvider);
+        this.exchanges = exchanges || [];
     }
     /**
      * Creates a new Mento object instance.
@@ -33,38 +32,30 @@ export class Mento {
      */
     static create(signerOrProvider) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isSigner = Signer.isSigner(signerOrProvider);
-            const isProvider = providers.Provider.isProvider(signerOrProvider);
-            if (!isSigner && !isProvider) {
-                throw new Error('A valid signer or provider must be provided');
-            }
-            if (isSigner) {
-                if (!providers.Provider.isProvider(signerOrProvider.provider)) {
-                    throw new Error('Signer must be connected to a provider');
-                }
-            }
-            return new Mento(yield getBrokerAddressFromRegistry(signerOrProvider), signerOrProvider);
+            validateSignerOrProvider(signerOrProvider);
+            return new Mento(signerOrProvider, yield getBrokerAddressFromRegistry(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
+     * Create a new Mento object instance given a broker address and optional exchanges data
+     * When constructed with a Provider, only read-only operations are supported
      * @param signerOrProvider an ethers signer or provider. A signer is required to execute swaps
+     * @param brokerAddr the address of the broker contract
+     * @param exchanges the exchanges data for the broker
      * @returns a new Mento object instance
      */
-    static createWithBrokerAddress(brokerAddr, signerOrProvider) {
-        const isSigner = Signer.isSigner(signerOrProvider);
-        const isProvider = providers.Provider.isProvider(signerOrProvider);
-        if (!isSigner && !isProvider) {
-            throw new Error('A valid signer or provider must be provided');
-        }
-        if (isSigner) {
-            if (!providers.Provider.isProvider(signerOrProvider.provider)) {
-                throw new Error('Signer must be connected to a provider');
-            }
-        }
-        return new Mento(brokerAddr, signerOrProvider);
+    static createWithParams(signerOrProvider, brokerAddr, exchanges) {
+        validateSignerOrProvider(signerOrProvider);
+        return new Mento(signerOrProvider, brokerAddr, exchanges);
+    }
+    /**
+     * Returns a new Mento instance connected to the given signer
+     * @param signer an ethers signer
+     * @returns new Mento object instance
+     */
+    connectSigner(signer) {
+        validateSigner(signer);
+        return new Mento(signer, this.broker.address, this.exchanges);
     }
     /**
      * Returns a list of all the pairs that can be traded on Mento
@@ -172,6 +163,13 @@ export class Mento {
             return this.signerOrProvider.populateTransaction(tx);
         });
     }
+    /**
+     * Returns the mento instance's broker contract
+     * @returns broker contract
+     */
+    getBroker() {
+        return this.broker;
+    }
     /**
      * Returns the list of exchanges available in Mento (cached)
      * @returns the list of exchanges
@@ -181,29 +179,35 @@ export class Mento {
             if (this.exchanges.length > 0) {
                 return this.exchanges;
             }
-            const exchanges = [];
             const exchangeProvidersAddresses = yield this.broker.getExchangeProviders();
-            for (const exchangeProviderAddr of exchangeProvidersAddresses) {
-                const exchangeManager = IExchangeProvider__factory.connect(exchangeProviderAddr, this.signerOrProvider);
-                const exchangesInManager = yield exchangeManager.getExchanges();
-                for (const exchange of exchangesInManager) {
-                    assert(exchange.assets.length === 2, 'Exchange must have 2 assets');
-                    exchanges.push({
-                        providerAddr: exchangeProviderAddr,
-                        id: exchange.exchangeId,
-                        assets: exchange.assets,
-                    });
-                }
-            }
+            const exchanges = (yield Promise.all(exchangeProvidersAddresses.map((a) => this.getExchangesForProvider(a)))).flat();
             this.exchanges = exchanges;
             return exchanges;
         });
     }
+    /**
+     * Returns the list of exchanges for a given exchange provider address
+     * @returns list of exchanges
+     */
+    getExchangesForProvider(exchangeProviderAddr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchangeProvider = IExchangeProvider__factory.connect(exchangeProviderAddr, this.signerOrProvider);
+            const exchangesInProvider = yield exchangeProvider.getExchanges();
+            return exchangesInProvider.map((e) => {
+                assert(e.assets.length === 2, 'Exchange must have 2 assets');
+                return {
+                    providerAddr: exchangeProviderAddr,
+                    id: e.exchangeId,
+                    assets: e.assets,
+                };
+            });
+        });
+    }
     /**
      * Returns the Mento exchange (if any) for a given pair of tokens
      * @param token0 the first token
      * @param token1 the second token
-     * @returns
+     * @returns exchange
      */
     getExchangeForTokens(token0, token1) {
         return __awaiter(this, void 0, void 0, function* () {