@mento-protocol/mento-sdk 0.1.4 → 0.2.0

package/dist/esm/limits.js

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

package/dist/esm/mento.js

@@ -7,9 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { IBroker__factory, IExchangeProvider__factory, } from '@mento-protocol/mento-core-ts';
+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 {
     /**
@@ -211,8 +212,8 @@ export class Mento {
     }
     /**
      * Returns the Mento exchange (if any) for a given pair of tokens
-     * @param token0 the first token
-     * @param token1 the second token
+     * @param token0 the address of the first token
+     * @param token1 the address of the second token
      * @returns exchange
      */
     getExchangeForTokens(token0, token1) {
@@ -225,4 +226,82 @@ export class Mento {
             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 assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return getLimits(broker, exchangeId, assetWithLimit);
+        });
+    }
+    /**
+     * Returns the trading limits configuration 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 assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return getLimitsConfig(broker, exchangeId, assetWithLimit);
+        });
+    }
+    /**
+     * 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 exchange = yield this.getExchangeById(exchangeId);
+            const broker = Broker__factory.connect(this.broker.address, this.signerOrProvider);
+            const assetWithLimit = exchange.assets[0]; // currently limits are configured only on asset0
+            return getLimitsState(broker, exchangeId, assetWithLimit);
+        });
+    }
 }

package/dist/esm/types.d.ts

@@ -1 +1,49 @@
+import { ethers, providers } from "ethers";
 export type Address = string;
+export interface TradingLimit {
+    asset: Address;
+    maxIn: number;
+    maxOut: number;
+    until: number;
+}
+export interface TradingLimitsConfig {
+    timestep0: number;
+    timestep1: number;
+    limit0: number;
+    limit1: number;
+    limitGlobal: number;
+    flags: number;
+}
+export interface TradingLimitsState {
+    lastUpdated0: number;
+    lastUpdated1: number;
+    netflow0: number;
+    netflow1: number;
+    netflowGlobal: number;
+}
+export interface ContractAddressMap {
+    [chainId: string]: ContractAddresses;
+}
+export interface ContractAddresses {
+    Airgrab: string;
+    Emission: string;
+    MentoGovernor: string;
+    MentoToken: string;
+    TimelockController: string;
+    Locking: string;
+}
+export declare enum ProposalState {
+    PENDING = 0,
+    ACTIVE = 1,
+    CANCELED = 2,
+    DEFEATED = 3,
+    SUCCEEDED = 4,
+    QUEUED = 5,
+    EXPIRED = 6,
+    EXECUTED = 7
+}
+export interface IChainClient {
+    getSigner(): Promise<ethers.Signer | providers.Provider>;
+    getChainId(): Promise<number>;
+    populateTransaction(tx: ethers.PopulatedTransaction): Promise<providers.TransactionRequest>;
+}

package/dist/esm/types.js

@@ -1 +1,11 @@
-export {};
+export var ProposalState;
+(function (ProposalState) {
+    ProposalState[ProposalState["PENDING"] = 0] = "PENDING";
+    ProposalState[ProposalState["ACTIVE"] = 1] = "ACTIVE";
+    ProposalState[ProposalState["CANCELED"] = 2] = "CANCELED";
+    ProposalState[ProposalState["DEFEATED"] = 3] = "DEFEATED";
+    ProposalState[ProposalState["SUCCEEDED"] = 4] = "SUCCEEDED";
+    ProposalState[ProposalState["QUEUED"] = 5] = "QUEUED";
+    ProposalState[ProposalState["EXPIRED"] = 6] = "EXPIRED";
+    ProposalState[ProposalState["EXECUTED"] = 7] = "EXECUTED";
+})(ProposalState || (ProposalState = {}));

package/dist/esm/utils.d.ts

@@ -1,5 +1,5 @@
 import { BigNumberish, providers, Signer } from 'ethers';
-import { Address } from './types';
+import { Address, ContractAddresses } from './types';
 /**
  * Ensures that given signer is truly a a connected signer
  * @param signer an ethers signer
@@ -34,3 +34,4 @@ export declare function getSymbolFromTokenAddress(tokenAddr: Address, signerOrPr
  * @returns the populated TransactionRequest object
  */
 export declare function increaseAllowance(tokenAddr: string, spender: string, amount: BigNumberish, signerOrProvider: Signer | providers.Provider): Promise<providers.TransactionRequest>;
+export declare function getContractsByChainId(chainId: number): ContractAddresses;

package/dist/esm/utils.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { constants, Contract, providers, Signer } from 'ethers';
+import contractAddresses from './contracts.json';
 /**
  * Ensures that given signer is truly a a connected signer
  * @param signer an ethers signer
@@ -88,3 +89,11 @@ export function increaseAllowance(tokenAddr, spender, amount, signerOrProvider)
         return yield contract.populateTransaction.increaseAllowance(spender, amount);
     });
 }
+export function getContractsByChainId(chainId) {
+    const addresses = contractAddresses;
+    const contracts = addresses[chainId];
+    if (!contracts) {
+        throw new Error(`No contracts found for chainId ${chainId}`);
+    }
+    return contracts;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [
@@ -77,7 +77,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@mento-protocol/mento-core-ts": "^0.1.0"
+    "@mento-protocol/mento-core-ts": "^0.2.0"
   },
   "peerDependencies": {
     "ethers": "^5.7"