@mento-protocol/mento-sdk 1.0.0 → 2.0.0-beta.1

package/dist/esm/limits.d.ts

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

package/dist/esm/limits.js

@@ -1,123 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { strict as assert } from 'assert';
-import { utils } from 'ethers';
-/**
- * Returns the limit configuration in the broker for the given exchange and asset
- * @param broker an instance of the broker
- * @param exchangeId the id of the exchange
- * @param asset the address of the limited asset
- * @returns the limit configuration
- */
-export function getLimitsConfig(broker, exchangeId, asset) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const limitId = getLimitId(exchangeId, asset);
-        const cfg = yield broker.tradingLimitsConfig(limitId);
-        return {
-            asset,
-            timestep0: cfg['timestep0'],
-            timestep1: cfg['timestep1'],
-            limit0: cfg['limit0'],
-            limit1: cfg['limit1'],
-            limitGlobal: cfg['limitGlobal'],
-            flags: cfg['flags'],
-        };
-    });
-}
-/**
- * Returns the limit state in the broker for the given exchange and asset
- * @param broker an instance of the broker
- * @param exchangeId the id of the exchange
- * @param asset the address of the limited asset
- * @returns the limit state
- */
-export function getLimitsState(broker, exchangeId, asset) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const limitId = getLimitId(exchangeId, asset);
-        const [cfg, state] = yield Promise.all([
-            getLimitsConfig(broker, exchangeId, asset),
-            broker.tradingLimitsState(limitId),
-        ]);
-        const isL0Enabled = cfg.timestep0 > 0;
-        const isL1Enabled = cfg.timestep1 > 0;
-        const nowEpoch = Math.floor(Date.now() / 1000);
-        const isL0Outdated = isL0Enabled && nowEpoch > state['lastUpdated0'] + cfg.timestep0;
-        const isL1Outdated = isL1Enabled && nowEpoch > state['lastUpdated1'] + cfg.timestep1;
-        return {
-            asset,
-            lastUpdated0: isL0Outdated ? nowEpoch : state['lastUpdated0'],
-            lastUpdated1: isL1Outdated ? nowEpoch : state['lastUpdated1'],
-            netflow0: isL0Outdated ? 0 : state['netflow0'],
-            netflow1: isL1Outdated ? 0 : state['netflow1'],
-            netflowGlobal: state['netflowGlobal'],
-        };
-    });
-}
-/**
- * Returns a human-friendly representation of the limits for the given exchange and asset
- * @param broker an instance of the broker
- * @param exchangeId the id of the exchange
- * @param asset the address of the asset with the limit
- * @returns a list of TradingLimit objects
- */
-export function getLimits(broker, exchangeId, asset) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const [cfg, state] = yield Promise.all([
-            getLimitsConfig(broker, exchangeId, asset),
-            getLimitsState(broker, exchangeId, asset),
-        ]);
-        const limits = [];
-        if (cfg.limit0 > 0) {
-            limits.push({
-                asset: asset,
-                maxIn: cfg.limit0 - state.netflow0,
-                maxOut: cfg.limit0 + state.netflow0,
-                until: state.lastUpdated0 + cfg.timestep0,
-            });
-        }
-        if (cfg.limit1 > 0) {
-            limits.push({
-                asset: asset,
-                maxIn: cfg.limit1 - state.netflow1,
-                maxOut: cfg.limit1 + state.netflow1,
-                until: state.lastUpdated1 + cfg.timestep1,
-            });
-        }
-        if (cfg.limitGlobal > 0) {
-            const timestampIn2030 = 1893456000; // a far away timestamp
-            limits.push({
-                asset: asset,
-                maxIn: cfg.limitGlobal - state.netflowGlobal,
-                maxOut: cfg.limitGlobal + state.netflowGlobal,
-                until: timestampIn2030,
-            });
-        }
-        // Limits with a smaller timeframe are restricted by the ones with a larger one
-        // e.g: if maxIn is 0 in LG, it should also be 0 in L1 and L0
-        for (let i = limits.length - 1; i > 0; i--) {
-            limits[i - 1].maxIn = Math.min(limits[i - 1].maxIn, limits[i].maxIn);
-            limits[i - 1].maxOut = Math.min(limits[i - 1].maxOut, limits[i].maxOut);
-        }
-        return limits;
-    });
-}
-/**
- * Returns the limit id for the given exchange and asset
- * @param exchangeId the id of the exchange
- * @param asset the address of the asset with the limit
- * @returns the limit id
- */
-export function getLimitId(exchangeId, asset) {
-    const assetBytes32 = utils.zeroPad(asset, 32);
-    const exchangeIdBytes = utils.arrayify(exchangeId);
-    const assetBytes = utils.arrayify(assetBytes32);
-    assert(exchangeIdBytes.length === assetBytes.length, 'exchangeId and asset0 must be the same length');
-    return utils.hexlify(exchangeIdBytes.map((b, i) => b ^ assetBytes[i]));
-}

package/dist/esm/mento.d.ts

@@ -1,152 +0,0 @@
-import { Address, TradingLimit, TradingLimitsConfig, TradingLimitsState } from './interfaces';
-import { IBroker } from '@mento-protocol/mento-core-ts';
-import { BigNumber, BigNumberish, Signer, providers } from 'ethers';
-export interface Exchange {
-    providerAddr: Address;
-    id: string;
-    assets: Address[];
-}
-export 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 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 exchanges exchange data for the broker
-     */
-    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 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 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}]
-     */
-    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: BigNumberish): 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: 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: 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
-     * @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: 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
-     * @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: 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
-     */
-    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 address of the first token
-     * @param token1 the address of the second token
-     * @returns exchange
-     */
-    getExchangeForTokens(token0: Address, token1: Address): Promise<Exchange>;
-    /**
-     * Returns the Mento exchange for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the exchange with the given id
-     */
-    getExchangeById(exchangeId: string): Promise<Exchange>;
-    /**
-     * Returns whether trading is enabled in the given mode for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @param mode the trading mode
-     * @returns true if trading is enabled in the given mode, false otherwise
-     */
-    isTradingEnabled(exchangeId: string): Promise<boolean>;
-    /**
-     * Return the trading limits for a given exchange id. Each limit is an object with the following fields:
-     * asset: the address of the asset with the limit
-     * maxIn: the maximum amount of the asset that can be sold
-     * maxOut: the maximum amount of the asset that can be bought
-     * until: the timestamp until which the limit is valid
-     * @param exchangeId the id of the exchange
-     * @returns the list of trading limits
-     */
-    getTradingLimits(exchangeId: string): Promise<TradingLimit[]>;
-    /**
-     * Returns the trading limits configurations for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the trading limits configuration
-     */
-    getTradingLimitConfig(exchangeId: string): Promise<TradingLimitsConfig[]>;
-    /**
-     * Returns the trading limits state for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the trading limits state
-     */
-    getTradingLimitState(exchangeId: string): Promise<TradingLimitsState[]>;
-}

package/dist/esm/mento.js

@@ -1,314 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { BiPoolManager__factory, Broker__factory, IBreakerBox__factory, IBroker__factory, IExchangeProvider__factory, } from '@mento-protocol/mento-core-ts';
-import { Signer } from 'ethers';
-import { getBrokerAddressFromRegistry, getSymbolFromTokenAddress, increaseAllowance, validateSigner, validateSignerOrProvider, } from './utils';
-import { getLimits, getLimitsConfig, getLimitsState } from './limits';
-import { strict as assert } from 'assert';
-export class Mento {
-    /**
-     * 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 exchanges exchange data for the broker
-     */
-    constructor(signerOrProvider, brokerAddress, exchanges) {
-        this.signerOrProvider = signerOrProvider;
-        this.broker = IBroker__factory.connect(brokerAddress, signerOrProvider);
-        this.exchanges = exchanges || [];
-    }
-    /**
-     * 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* () {
-            validateSignerOrProvider(signerOrProvider);
-            return new Mento(signerOrProvider, yield getBrokerAddressFromRegistry(signerOrProvider));
-        });
-    }
-    /**
-     * 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 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
-     * @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([
-                    getSymbolFromTokenAddress(asset0, this.signerOrProvider),
-                    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* () {
-            const spender = this.broker.address;
-            const tx = yield increaseAllowance(token, spender, amount, this.signerOrProvider);
-            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 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* () {
-            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
-            const tx = yield this.broker.populateTransaction.swapIn(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountIn, amountOutMin);
-            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 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* () {
-            const exchange = yield this.getExchangeForTokens(tokenIn, tokenOut);
-            const tx = yield this.broker.populateTransaction.swapOut(exchange.providerAddr, exchange.id, tokenIn, tokenOut, amountOut, amountInMax);
-            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
-     */
-    getExchanges() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.exchanges.length > 0) {
-                return this.exchanges;
-            }
-            const exchangeProvidersAddresses = yield this.broker.getExchangeProviders();
-            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 address of the first token
-     * @param token1 the address of the second token
-     * @returns exchange
-     */
-    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}`);
-            }
-            assert(exchanges.length === 1, `More than one exchange found for ${token0} and ${token1}`);
-            return exchanges[0];
-        });
-    }
-    /**
-     * Returns the Mento exchange for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the exchange with the given id
-     */
-    getExchangeById(exchangeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exchanges = (yield this.getExchanges()).filter((e) => e.id === exchangeId);
-            if (exchanges.length === 0) {
-                throw Error(`No exchange found for id ${exchangeId}`);
-            }
-            assert(exchanges.length === 1, `More than one exchange found with id ${exchangeId}`);
-            return exchanges[0];
-        });
-    }
-    /**
-     * Returns whether trading is enabled in the given mode for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @param mode the trading mode
-     * @returns true if trading is enabled in the given mode, false otherwise
-     */
-    isTradingEnabled(exchangeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exchange = yield this.getExchangeById(exchangeId);
-            const biPoolManager = BiPoolManager__factory.connect(exchange.providerAddr, this.signerOrProvider);
-            const [breakerBoxAddr, exchangeConfig] = yield Promise.all([
-                biPoolManager.breakerBox(),
-                biPoolManager.getPoolExchange(exchangeId),
-            ]);
-            const breakerBox = IBreakerBox__factory.connect(breakerBoxAddr, this.signerOrProvider);
-            const currentMode = yield breakerBox.getRateFeedTradingMode(exchangeConfig.config.referenceRateFeedID);
-            const BI_DIRECTIONAL_TRADING_MODE = 0;
-            return currentMode == BI_DIRECTIONAL_TRADING_MODE;
-        });
-    }
-    /**
-     * Return the trading limits for a given exchange id. Each limit is an object with the following fields:
-     * asset: the address of the asset with the limit
-     * maxIn: the maximum amount of the asset that can be sold
-     * maxOut: the maximum amount of the asset that can be bought
-     * until: the timestamp until which the limit is valid
-     * @param exchangeId the id of the exchange
-     * @returns the list of trading limits
-     */
-    getTradingLimits(exchangeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exchange = yield this.getExchangeById(exchangeId);
-            const broker = Broker__factory.connect(this.broker.address, this.signerOrProvider);
-            const asset0Limits = yield getLimits(broker, exchangeId, exchange.assets[0]);
-            const asset1Limits = yield getLimits(broker, exchangeId, exchange.assets[1]);
-            return asset0Limits.concat(asset1Limits);
-        });
-    }
-    /**
-     * Returns the trading limits configurations for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the trading limits configuration
-     */
-    getTradingLimitConfig(exchangeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const exchange = yield this.getExchangeById(exchangeId);
-            const broker = Broker__factory.connect(this.broker.address, this.signerOrProvider);
-            const cfgs = [];
-            for (const asset of exchange.assets) {
-                const limitCfg = yield getLimitsConfig(broker, exchangeId, asset);
-                const isLimitConfigured = limitCfg.flags > 0;
-                if (isLimitConfigured) {
-                    cfgs.push(limitCfg);
-                }
-            }
-            return cfgs;
-        });
-    }
-    /**
-     * Returns the trading limits state for a given exchange id
-     * @param exchangeId the id of the exchange
-     * @returns the trading limits state
-     */
-    getTradingLimitState(exchangeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const broker = Broker__factory.connect(this.broker.address, this.signerOrProvider);
-            const configuredLimitCfgs = yield this.getTradingLimitConfig(exchangeId);
-            return yield Promise.all(configuredLimitCfgs.map((cfg) => __awaiter(this, void 0, void 0, function* () { return yield getLimitsState(broker, exchangeId, cfg.asset); })));
-        });
-    }
-}

package/dist/esm/types/contractAddressMap.d.ts

@@ -1,4 +0,0 @@
-import { ContractAddresses } from '.';
-export type ContractAddressMap = {
-    [chainId: number]: ContractAddresses;
-};

package/dist/esm/types/contractAddressMap.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/types/contractAddresses.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './contractAddresses';
-export * from './contractAddressMap';

package/dist/esm/types/index.js

@@ -1,2 +0,0 @@
-export * from './contractAddresses';
-export * from './contractAddressMap';

package/dist/esm/utils.d.ts

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