@mento-protocol/mento-sdk 0.1.2 → 0.1.4

package/README.md

@@ -2,57 +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)
+
+  // 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)
+}
+
+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, BigNumberish, 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}]
@@ -43,7 +56,7 @@ export declare class Mento {
      * @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>;
+    getAmountIn(tokenIn: Address, tokenOut: Address, amountOut: BigNumberish): Promise<BigNumber>;
     /**
      * Returns the amount of tokenOut to be bought by selling amountIn of tokenIn
      * @param tokenIn the token to be sold
@@ -51,14 +64,14 @@ export declare class Mento {
      * @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>;
+    getAmountOut(tokenIn: Address, tokenOut: Address, amountIn: BigNumberish): 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>;
+    increaseTradingAllowance(token: Address, amount: BigNumberish): 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
@@ -68,7 +81,7 @@ export declare class Mento {
      * @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>;
+    swapIn(tokenIn: Address, tokenOut: Address, amountIn: BigNumberish, amountOutMin: BigNumberish): 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
@@ -78,18 +91,27 @@ export declare class Mento {
      * @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>;
+    swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumberish, amountInMax: BigNumberish): 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,22 +10,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mento = void 0;
-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.
@@ -35,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
@@ -125,13 +117,15 @@ class Mento {
      */
     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);
+            if (ethers_1.Signer.isSigner(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);
+            }
+            else {
+                return tx;
+            }
         });
     }
     /**
@@ -145,13 +139,15 @@ class Mento {
      */
     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);
+            if (ethers_1.Signer.isSigner(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);
+            }
+            else {
+                return tx;
+            }
         });
     }
     /**
@@ -165,15 +161,24 @@ class Mento {
      */
     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);
+            if (ethers_1.Signer.isSigner(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);
+            }
+            else {
+                return 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
@@ -183,29 +188,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 { BigNumberish, 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
@@ -18,7 +30,7 @@ export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrPr
  * @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
+ * @param signerOrProvider an ethers signer or provider
  * @returns the populated TransactionRequest object
  */
-export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumber, signer: Signer): Promise<providers.TransactionRequest>;
+export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumberish, signerOrProvider: Signer | providers.Provider): Promise<providers.TransactionRequest>;

package/dist/cjs/utils.js

@@ -9,8 +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;
+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
@@ -51,15 +81,17 @@ exports.getSymbolFromTokenAddress = getSymbolFromTokenAddress;
  * @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
+ * @param signerOrProvider an ethers signer or provider
  * @returns the populated TransactionRequest object
  */
-function increaseAllowance(tokenAddr, spender, amount, signer) {
+function increaseAllowance(tokenAddr, spender, amount, signerOrProvider) {
     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);
+        // TODO, not all ERC-20 contracts support increaseAllowance
+        // Add a check for that here
+        const contract = new ethers_1.Contract(tokenAddr, abi, signerOrProvider);
         return yield contract.populateTransaction.increaseAllowance(spender, amount);
     });
 }

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, BigNumberish, 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}]
@@ -43,7 +56,7 @@ export declare class Mento {
      * @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>;
+    getAmountIn(tokenIn: Address, tokenOut: Address, amountOut: BigNumberish): Promise<BigNumber>;
     /**
      * Returns the amount of tokenOut to be bought by selling amountIn of tokenIn
      * @param tokenIn the token to be sold
@@ -51,14 +64,14 @@ export declare class Mento {
      * @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>;
+    getAmountOut(tokenIn: Address, tokenOut: Address, amountIn: BigNumberish): 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>;
+    increaseTradingAllowance(token: Address, amount: BigNumberish): 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
@@ -68,7 +81,7 @@ export declare class Mento {
      * @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>;
+    swapIn(tokenIn: Address, tokenOut: Address, amountIn: BigNumberish, amountOutMin: BigNumberish): 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
@@ -78,18 +91,27 @@ export declare class Mento {
      * @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>;
+    swapOut(tokenIn: Address, tokenOut: Address, amountOut: BigNumberish, amountInMax: BigNumberish): 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,22 +7,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-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.
@@ -32,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
@@ -122,13 +114,15 @@ export class Mento {
      */
     increaseTradingAllowance(token, amount) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!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 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);
+            if (Signer.isSigner(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);
+            }
+            else {
+                return tx;
+            }
         });
     }
     /**
@@ -142,13 +136,15 @@ export class Mento {
      */
     swapIn(tokenIn, tokenOut, amountIn, amountOutMin) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!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);
+            if (Signer.isSigner(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);
+            }
+            else {
+                return tx;
+            }
         });
     }
     /**
@@ -162,15 +158,24 @@ export class Mento {
      */
     swapOut(tokenIn, tokenOut, amountOut, amountInMax) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!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);
+            if (Signer.isSigner(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);
+            }
+            else {
+                return 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
@@ -180,29 +185,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* () {

package/dist/esm/utils.d.ts

@@ -1,5 +1,17 @@
-import { BigNumber, Signer, providers } from 'ethers';
+import { BigNumberish, 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
@@ -18,7 +30,7 @@ export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrPr
  * @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
+ * @param signerOrProvider an ethers signer or provider
  * @returns the populated TransactionRequest object
  */
-export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumber, signer: Signer): Promise<providers.TransactionRequest>;
+export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumberish, signerOrProvider: Signer | providers.Provider): Promise<providers.TransactionRequest>;

package/dist/esm/utils.js

@@ -7,7 +7,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Contract, constants } from 'ethers';
+import { constants, Contract, providers, Signer } from 'ethers';
+/**
+ * Ensures that given signer is truly a a connected signer
+ * @param signer an ethers signer
+ * @throws if signer is invalid or not connected
+ */
+export function validateSigner(signer) {
+    if (!Signer.isSigner(signer)) {
+        throw new Error('A valid signer must be provided');
+    }
+    if (!providers.Provider.isProvider(signer.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
+/**
+ * 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 function validateSignerOrProvider(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 && !providers.Provider.isProvider(signerOrProvider.provider)) {
+        throw new Error('Signer must be connected to a provider');
+    }
+}
 /**
  * Returns the broker address from the Celo registry
  * @param signerOrProvider an ethers provider or signer
@@ -46,15 +74,17 @@ export function getSymbolFromTokenAddress(tokenAddr, signerOrProvider) {
  * @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
+ * @param signerOrProvider an ethers signer or provider
  * @returns the populated TransactionRequest object
  */
-export function increaseAllowance(tokenAddr, spender, amount, signer) {
+export function increaseAllowance(tokenAddr, spender, amount, signerOrProvider) {
     return __awaiter(this, void 0, void 0, function* () {
         const abi = [
             'function increaseAllowance(address spender, uint256 value) external returns (bool)',
         ];
-        const contract = new Contract(tokenAddr, abi, signer);
+        // TODO, not all ERC-20 contracts support increaseAllowance
+        // Add a check for that here
+        const contract = new Contract(tokenAddr, abi, signerOrProvider);
         return yield contract.populateTransaction.increaseAllowance(spender, amount);
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [
@@ -17,14 +17,16 @@
   "module": "dist/esm/index.js",
   "typings": "dist/esm/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.test.*"
   ],
   "scripts": {
     "analyze": "size-limit --why",
     "build": "yarn build:cjs && yarn build:esm",
     "build:cjs": "tsc --project ./tsconfig.json",
     "build:esm": "tsc --project ./tsconfig.esm.json",
-    "lint": "eslint --config ./.eslintrc.json **/*.{json,ts}",
+    "clean": "rm -rf ./dist",
+    "lint": "eslint --config ./.eslintrc.json src/**/*.ts",
     "prettier": "prettier --config ./.prettierrc.json --write **/*.{json,md,js,ts,yml}",
     "size": "size-limit",
     "test": "jest --runInBand --verbose",
@@ -61,21 +63,24 @@
     "@tsconfig/recommended": "^1.0.1",
     "@types/jest": "^29.4.0",
     "@types/node": "^18.13.0",
-    "@typescript-eslint/eslint-plugin": "^5.51.0",
-    "@typescript-eslint/parser": "^5.51.0",
-    "eslint": "^8.33.0",
+    "@typescript-eslint/eslint-plugin": "^5.53.0",
+    "@typescript-eslint/parser": "^5.53.0",
+    "eslint": "^8.34.0",
+    "eslint-config-prettier": "^8.6.0",
     "ethers": "^5.7.2",
     "husky": "^8.0.2",
     "jest": "^29.4.2",
     "prettier": "^2.8.4",
     "size-limit": "^8.1.0",
     "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
     "typescript": "^4.9.5"
   },
   "dependencies": {
     "@mento-protocol/mento-core-ts": "^0.1.0"
   },
   "peerDependencies": {
-    "ethers": "^5.7.2"
-  }
+    "ethers": "^5.7"
+  },
+  "packageManager": "yarn@3.3.1"
 }