@curvefi/llamalend-api 1.0.23 → 1.0.25

package/README.md

@@ -807,6 +807,44 @@ import llamalend from "@curvefi/llamalend-api";
 })()
 ```
 
+### Partial self-liquidation for lendMarket
+```ts
+(async () => {
+    await llamalend.init('JsonRpc', {});
+
+    const lendMarket = llamalend.getLendMarket('one-way-market-0');
+
+    // Wallet balances: {
+    //     borrowed: '301.533523886491869218',
+    //     collateral: '0.860611976623971606'
+    // }
+    // State: {
+    //     collateral: '0.139388023376028394',
+    //     borrowed: '2751.493405530582315609',
+    //     debt: '3053.026929417074184827'
+    // }
+    
+    await lendMarket.tokensToLiquidate();
+    // 301.533523886491869218
+
+    const fraction = await lendMarket.calcPartialFrac(140); // <- 140 - amount (should be less then lendMarket.tokensToLiquidate)
+    // {frac: '472880873283878292', fracDecimal: '0.47288087328387829207', amount: 140}
+    // 
+
+    
+    await lendMarket.partialSelfLiquidateIsApproved(fraction);
+    // false
+    await lendMarket.partialSelfLiquidateApprove(fraction);
+    // []
+    await lendMarket.partialSelfLiquidateIsApproved(fraction);
+    // true
+    await lendMarket.partialSelfLiquidate(fraction, 0.1); // slippage = 0.1 %
+
+    // Wallet balances: { borrowed: '0', collateral: '0.7' }
+    // State: { collateral: '0.6', borrowed: '1300', debt: '1500' }
+})()
+```
+
 ### Liquidation for lendMarket
 ```ts
 (async () => {

package/lib/external-api.d.ts

@@ -16,4 +16,5 @@ export declare const _getMarketsData: ((network: INetworkName) => Promise<IMarke
 export declare function _getQuoteOdos(this: Llamalend, fromToken: string, toToken: string, _amount: bigint, blacklist: string, pathVizImage: boolean, slippage?: number): Promise<IQuoteOdos>;
 export declare function _getExpectedOdos(this: Llamalend, fromToken: string, toToken: string, _amount: bigint, blacklist: string): Promise<string>;
 export declare function _assembleTxOdos(this: Llamalend, pathId: string): Promise<string>;
+export declare const _getHiddenPools: (() => Promise<any>) & memoize.Memoized<() => Promise<any>>;
 export {};

package/lib/external-api.js

@@ -188,3 +188,10 @@ export function _assembleTxOdos(pathId) {
         return _assembleTxOdosMemoized(this.constants.ALIASES.leverage_zap, pathId);
     });
 }
+export const _getHiddenPools = memoize(() => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(`https://api.curve.finance/api/getHiddenPools`);
+    return (yield response.json()).data;
+}), {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});

package/lib/interfaces.d.ts

@@ -14,6 +14,11 @@ export interface ICurveContract {
 }
 export type TAmount = number | string;
 export type TGas = number | number[];
+export interface IPartialFrac {
+    frac: string;
+    fracDecimal: string;
+    amount: string;
+}
 export interface ILlamma {
     amm_address: string;
     controller_address: string;

package/lib/lendMarkets/LendMarketTemplate.d.ts

@@ -1,6 +1,6 @@
 import memoize from "memoizee";
 import type { Llamalend } from "../llamalend.js";
-import { IDict, TGas, TAmount, IReward, IQuoteOdos, IOneWayMarket } from "../interfaces.js";
+import { IDict, TGas, TAmount, IReward, IQuoteOdos, IOneWayMarket, IPartialFrac } from "../interfaces.js";
 export declare class LendMarketTemplate {
     private llamalend;
     id: string;
@@ -50,6 +50,8 @@ export declare class LendMarketTemplate {
         liquidate: (address: string, slippage?: number) => Promise<TGas>;
         selfLiquidateApprove: () => Promise<TGas>;
         selfLiquidate: (slippage?: number) => Promise<TGas>;
+        partialSelfLiquidateApprove: (partialFrac: IPartialFrac) => Promise<TGas>;
+        partialSelfLiquidate: (partialFrac: IPartialFrac, slippage?: number) => Promise<TGas>;
     };
     stats: {
         parameters: () => Promise<{
@@ -441,10 +443,12 @@ export declare class LendMarketTemplate {
     swapEstimateGas(i: number, j: number, amount: number | string, slippage?: number): Promise<TGas>;
     swap(i: number, j: number, amount: number | string, slippage?: number): Promise<string>;
     tokensToLiquidate(address?: string): Promise<string>;
+    calcPartialFrac(amount: TAmount, address?: string): Promise<IPartialFrac>;
     liquidateIsApproved(address?: string): Promise<boolean>;
     private liquidateApproveEstimateGas;
     liquidateApprove(address?: string): Promise<string[]>;
     private _liquidate;
+    private _partialLiquidate;
     liquidateEstimateGas(address: string, slippage?: number): Promise<TGas>;
     liquidate(address: string, slippage?: number): Promise<string>;
     selfLiquidateIsApproved(): Promise<boolean>;
@@ -452,6 +456,11 @@ export declare class LendMarketTemplate {
     selfLiquidateApprove(): Promise<string[]>;
     selfLiquidateEstimateGas(slippage?: number): Promise<TGas>;
     selfLiquidate(slippage?: number): Promise<string>;
+    partialSelfLiquidateIsApproved(partialFrac: IPartialFrac): Promise<boolean>;
+    private partialSelfLiquidateApproveEstimateGas;
+    partialSelfLiquidateApprove(partialFrac: IPartialFrac): Promise<string[]>;
+    partialSelfLiquidateEstimateGas(partialFrac: IPartialFrac, slippage?: number): Promise<TGas>;
+    partialSelfLiquidate(partialFrac: IPartialFrac, slippage?: number): Promise<string>;
     private hasLeverage;
     private _checkLeverageZap;
     private _get_k_effective_BN;

package/lib/lendMarkets/LendMarketTemplate.js

@@ -508,6 +508,8 @@ export class LendMarketTemplate {
             liquidate: this.liquidateEstimateGas.bind(this),
             selfLiquidateApprove: this.selfLiquidateApproveEstimateGas.bind(this),
             selfLiquidate: this.selfLiquidateEstimateGas.bind(this),
+            partialSelfLiquidateApprove: this.partialSelfLiquidateApproveEstimateGas.bind(this),
+            partialSelfLiquidate: this.partialSelfLiquidateEstimateGas.bind(this),
         };
         this.stats = {
             parameters: this.statsParameters.bind(this),
@@ -2007,6 +2009,27 @@ export class LendMarketTemplate {
             return formatUnits(_tokens, this.borrowed_token.decimals);
         });
     }
+    calcPartialFrac(amount_1) {
+        return __awaiter(this, arguments, void 0, function* (amount, address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            const tokensToLiquidate = yield this.tokensToLiquidate(address);
+            const amountBN = BN(amount);
+            const tokensToLiquidateBN = BN(tokensToLiquidate);
+            if (amountBN.gt(tokensToLiquidateBN))
+                throw Error("Amount cannot be greater than total tokens to liquidate");
+            if (amountBN.lte(0))
+                throw Error("Amount must be greater than 0");
+            // Calculate frac = amount / tokensToLiquidate * 10**18
+            // 100% = 10**18
+            const fracDecimalBN = amountBN.div(tokensToLiquidateBN);
+            const frac = fromBN(fracDecimalBN);
+            return {
+                frac: frac.toString(),
+                fracDecimal: fracDecimalBN.toString(),
+                amount: amountBN.toString(),
+            };
+        });
+    }
     liquidateIsApproved() {
         return __awaiter(this, arguments, void 0, function* (address = "") {
             const tokensToLiquidate = yield this.tokensToLiquidate(address);
@@ -2047,6 +2070,32 @@ export class LendMarketTemplate {
             return (yield contract.liquidate(address, _minAmount, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
         });
     }
+    _partialLiquidate(address, partialFrac, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { borrowed, debt: currentDebt } = yield this.userState(address);
+            if (slippage <= 0)
+                throw Error("Slippage must be > 0");
+            if (slippage > 100)
+                throw Error("Slippage must be <= 100");
+            if (Number(currentDebt) === 0)
+                throw Error(`Loan for ${address} does not exist`);
+            if (Number(borrowed) === 0)
+                throw Error(`User ${address} is not in liquidation mode`);
+            const frac = partialFrac.frac;
+            const fracBN = BN(partialFrac.fracDecimal);
+            const borrowedBN = BN(borrowed);
+            const expectedBorrowedBN = borrowedBN.times(fracBN);
+            const minAmountBN = expectedBorrowedBN.times(100 - slippage).div(100);
+            const _minAmount = fromBN(minAmountBN);
+            const contract = this.llamalend.contracts[this.addresses.controller].contract;
+            const gas = (yield contract.liquidate_extended.estimateGas(address, _minAmount, frac, this.llamalend.constants.ZERO_ADDRESS, [], this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.liquidate_extended(address, _minAmount, frac, this.llamalend.constants.ZERO_ADDRESS, [], Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
     liquidateEstimateGas(address_1) {
         return __awaiter(this, arguments, void 0, function* (address, slippage = 0.1) {
             if (!(yield this.liquidateIsApproved(address)))
@@ -2089,6 +2138,35 @@ export class LendMarketTemplate {
             return yield this._liquidate(this.llamalend.signerAddress, slippage, false);
         });
     }
+    // ---------------- PARTIAL SELF-LIQUIDATE ----------------
+    partialSelfLiquidateIsApproved(partialFrac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield hasAllowance.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.llamalend.signerAddress, this.addresses.controller);
+        });
+    }
+    partialSelfLiquidateApproveEstimateGas(partialFrac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.addresses.controller);
+        });
+    }
+    partialSelfLiquidateApprove(partialFrac) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield ensureAllowance.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.addresses.controller);
+        });
+    }
+    partialSelfLiquidateEstimateGas(partialFrac_1) {
+        return __awaiter(this, arguments, void 0, function* (partialFrac, slippage = 0.1) {
+            if (!(yield this.partialSelfLiquidateIsApproved(partialFrac)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._partialLiquidate(this.llamalend.signerAddress, partialFrac, slippage, true);
+        });
+    }
+    partialSelfLiquidate(partialFrac_1) {
+        return __awaiter(this, arguments, void 0, function* (partialFrac, slippage = 0.1) {
+            yield this.partialSelfLiquidateApprove(partialFrac);
+            return yield this._partialLiquidate(this.llamalend.signerAddress, partialFrac, slippage, false);
+        });
+    }
     _checkLeverageZap() {
         if (!this.hasLeverage()) {
             throw Error("This market does not support leverage");

package/lib/llamalend.d.ts

@@ -64,6 +64,7 @@ declare class Llamalend implements ILlamalend {
         maxFeePerGas?: number;
         maxPriorityFeePerGas?: number;
     }): void;
+    _filterHiddenMarkets(markets: IDict<IOneWayMarket>): Promise<IDict<IOneWayMarket>>;
     getLendMarketList: () => string[];
     getMintMarketList: () => string[];
     getFactoryMarketData: () => Promise<Record<string, any>>;

package/lib/llamalend.js

@@ -42,7 +42,7 @@ import { LLAMMAS } from "./constants/llammas";
 import { L2Networks } from "./constants/L2Networks.js";
 import { createCall, handleMultiCallResponse } from "./utils.js";
 import { cacheKey, cacheStats } from "./cache/index.js";
-import { _getMarketsData } from "./external-api.js";
+import { _getMarketsData, _getHiddenPools } from "./external-api.js";
 import { extractDecimals } from "./constants/utils.js";
 export const NETWORK_CONSTANTS = {
     1: {
@@ -296,6 +296,7 @@ class Llamalend {
                     collateral_token: COIN_DATA[collateral_tokens[index]],
                 };
             });
+            this.constants.ONE_WAY_MARKETS = yield this._filterHiddenMarkets(this.constants.ONE_WAY_MARKETS);
             yield this.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens);
         });
         this._fetchOneWayMarketsByAPI = () => __awaiter(this, void 0, void 0, function* () {
@@ -341,6 +342,7 @@ class Llamalend {
                     collateral_token: COIN_DATA[collateral_tokens[index]],
                 };
             });
+            this.constants.ONE_WAY_MARKETS = yield this._filterHiddenMarkets(this.constants.ONE_WAY_MARKETS);
         });
         this.address = '00000';
         this.crvUsdAddress = COINS_ETHEREUM.crvusd;
@@ -649,6 +651,12 @@ class Llamalend {
     setCustomFeeData(customFeeData) {
         this.feeData = Object.assign(Object.assign({}, this.feeData), customFeeData);
     }
+    _filterHiddenMarkets(markets) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hiddenMarkets = (yield _getHiddenPools())[this.constants.NETWORK_NAME] || [];
+            return Object.fromEntries(Object.entries(markets).filter(([id]) => !hiddenMarkets.includes(id)));
+        });
+    }
     formatUnits(value, unit) {
         return ethers.formatUnits(value, unit);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/llamalend-api",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "JavaScript library for Curve Lending",
   "main": "lib/index.js",
   "author": "Macket",

package/src/external-api.ts

@@ -209,3 +209,15 @@ const _assembleTxOdosMemoized = memoize(
 export async function _assembleTxOdos(this: Llamalend, pathId: string): Promise<string> {
     return _assembleTxOdosMemoized(this.constants.ALIASES.leverage_zap, pathId);
 }
+
+export const _getHiddenPools = memoize(
+    async () => {
+        const response = await fetch(`https://api.curve.finance/api/getHiddenPools`)
+
+        return (await response.json() as any).data
+    },
+    {
+        promise: true,
+        maxAge: 5 * 60 * 1000, // 5m
+    }
+)

package/src/interfaces.ts

@@ -18,6 +18,12 @@ export interface ICurveContract {
 export type TAmount = number | string
 export type TGas = number | number[]
 
+export interface IPartialFrac {
+    frac: string;
+    fracDecimal: string;
+    amount: string;
+}
+
 export interface ILlamma {
     amm_address: string,
     controller_address: string,

package/src/lendMarkets/LendMarketTemplate.ts

@@ -22,7 +22,7 @@ import {
     DIGas,
     smartNumber,
 } from "../utils.js";
-import {IDict, TGas, TAmount, IReward, IQuoteOdos, IOneWayMarket} from "../interfaces.js";
+import {IDict, TGas, TAmount, IReward, IQuoteOdos, IOneWayMarket, IPartialFrac} from "../interfaces.js";
 import { _getExpectedOdos, _getQuoteOdos, _assembleTxOdos, _getUserCollateral, _getMarketsData } from "../external-api.js";
 import ERC20Abi from '../constants/abis/ERC20.json' with {type: 'json'};
 import {cacheKey, cacheStats} from "../cache/index.js";
@@ -82,6 +82,8 @@ export class LendMarketTemplate {
         liquidate: (address: string, slippage?: number) => Promise<TGas>,
         selfLiquidateApprove: () => Promise<TGas>,
         selfLiquidate: (slippage?: number) => Promise<TGas>,
+        partialSelfLiquidateApprove: (partialFrac: IPartialFrac) => Promise<TGas>,
+        partialSelfLiquidate: (partialFrac: IPartialFrac, slippage?: number) => Promise<TGas>,
     };
     stats: {
         parameters: () => Promise<{
@@ -265,6 +267,8 @@ export class LendMarketTemplate {
             liquidate: this.liquidateEstimateGas.bind(this),
             selfLiquidateApprove: this.selfLiquidateApproveEstimateGas.bind(this),
             selfLiquidate: this.selfLiquidateEstimateGas.bind(this),
+            partialSelfLiquidateApprove: this.partialSelfLiquidateApproveEstimateGas.bind(this),
+            partialSelfLiquidate: this.partialSelfLiquidateEstimateGas.bind(this),
         }
         this.stats = {
             parameters: this.statsParameters.bind(this),
@@ -2043,10 +2047,31 @@ export class LendMarketTemplate {
     public async tokensToLiquidate(address = ""): Promise<string> {
         address = _getAddress.call(this.llamalend, address);
         const _tokens = await this.llamalend.contracts[this.addresses.controller].contract.tokens_to_liquidate(address, this.llamalend.constantOptions) as bigint;
-
         return formatUnits(_tokens, this.borrowed_token.decimals)
     }
 
+    public async calcPartialFrac(amount: TAmount, address = ""): Promise<IPartialFrac> {
+        address = _getAddress.call(this.llamalend, address);
+        const tokensToLiquidate = await this.tokensToLiquidate(address);
+        
+        const amountBN = BN(amount);
+        const tokensToLiquidateBN = BN(tokensToLiquidate);
+        
+        if (amountBN.gt(tokensToLiquidateBN)) throw Error("Amount cannot be greater than total tokens to liquidate");
+        if (amountBN.lte(0)) throw Error("Amount must be greater than 0");
+        
+        // Calculate frac = amount / tokensToLiquidate * 10**18
+        // 100% = 10**18
+        const fracDecimalBN = amountBN.div(tokensToLiquidateBN);
+        const frac = fromBN(fracDecimalBN);
+        return {
+            frac: frac.toString(),
+            fracDecimal: fracDecimalBN.toString(),
+            amount: amountBN.toString(),
+        };
+    }
+
+
     public async liquidateIsApproved(address = ""): Promise<boolean> {
         const tokensToLiquidate = await this.tokensToLiquidate(address);
         return await hasAllowance.call(this.llamalend, [this.addresses.borrowed_token], [tokensToLiquidate], this.llamalend.signerAddress, this.addresses.controller);
@@ -2080,6 +2105,45 @@ export class LendMarketTemplate {
         return (await contract.liquidate(address, _minAmount, { ...this.llamalend.options, gasLimit })).hash
     }
 
+    private async _partialLiquidate(address: string, partialFrac: IPartialFrac, slippage: number, estimateGas: boolean): Promise<string | TGas> {
+        const { borrowed, debt: currentDebt } = await this.userState(address);
+        if (slippage <= 0) throw Error("Slippage must be > 0");
+        if (slippage > 100) throw Error("Slippage must be <= 100");
+        if (Number(currentDebt) === 0) throw Error(`Loan for ${address} does not exist`);
+        if (Number(borrowed) === 0) throw Error(`User ${address} is not in liquidation mode`);
+        
+        const frac = partialFrac.frac;
+        const fracBN = BN(partialFrac.fracDecimal);
+        
+        const borrowedBN = BN(borrowed);
+        const expectedBorrowedBN = borrowedBN.times(fracBN);
+        const minAmountBN = expectedBorrowedBN.times(100 - slippage).div(100);
+        const _minAmount = fromBN(minAmountBN);
+        
+        const contract = this.llamalend.contracts[this.addresses.controller].contract;
+        const gas = (await contract.liquidate_extended.estimateGas(
+            address, 
+            _minAmount, 
+            frac, 
+            this.llamalend.constants.ZERO_ADDRESS,
+            [],
+            this.llamalend.constantOptions
+        ));
+        
+        if (estimateGas) return smartNumber(gas);
+
+        await this.llamalend.updateFeeData();
+        const gasLimit = _mulBy1_3(DIGas(gas));
+        return (await contract.liquidate_extended(
+            address, 
+            _minAmount, 
+            frac, 
+            this.llamalend.constants.ZERO_ADDRESS,
+            [],
+            { ...this.llamalend.options, gasLimit }
+        )).hash;
+    }
+
     public async liquidateEstimateGas(address: string, slippage = 0.1): Promise<TGas> {
         if (!(await this.liquidateIsApproved(address))) throw Error("Approval is needed for gas estimation");
         return await this._liquidate(address, slippage, true) as TGas;
@@ -2114,6 +2178,30 @@ export class LendMarketTemplate {
         return await this._liquidate(this.llamalend.signerAddress, slippage, false) as string;
     }
 
+    // ---------------- PARTIAL SELF-LIQUIDATE ----------------
+
+    public async partialSelfLiquidateIsApproved(partialFrac: IPartialFrac): Promise<boolean> {
+        return await hasAllowance.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.llamalend.signerAddress, this.addresses.controller);
+    }
+
+    private async partialSelfLiquidateApproveEstimateGas(partialFrac: IPartialFrac): Promise<TGas> {
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.addresses.controller);
+    }
+
+    public async partialSelfLiquidateApprove(partialFrac: IPartialFrac): Promise<string[]> {
+        return await ensureAllowance.call(this.llamalend, [this.addresses.borrowed_token], [partialFrac.amount], this.addresses.controller);
+    }
+
+    public async partialSelfLiquidateEstimateGas(partialFrac: IPartialFrac, slippage = 0.1): Promise<TGas> {
+        if (!(await this.partialSelfLiquidateIsApproved(partialFrac))) throw Error("Approval is needed for gas estimation");
+        return await this._partialLiquidate(this.llamalend.signerAddress, partialFrac, slippage, true) as TGas;
+    }
+
+    public async partialSelfLiquidate(partialFrac: IPartialFrac, slippage = 0.1): Promise<string> {
+        await this.partialSelfLiquidateApprove(partialFrac);
+        return await this._partialLiquidate(this.llamalend.signerAddress, partialFrac, slippage, false) as string;
+    }
+
     // ---------------- LEVERAGE CREATE LOAN ----------------
 
     private hasLeverage = (): boolean => {

package/src/llamalend.ts

@@ -79,7 +79,7 @@ import {LLAMMAS} from "./constants/llammas";
 import {L2Networks} from "./constants/L2Networks.js";
 import {createCall, handleMultiCallResponse} from "./utils.js";
 import {cacheKey, cacheStats} from "./cache/index.js";
-import {_getMarketsData} from "./external-api.js";
+import {_getMarketsData, _getHiddenPools} from "./external-api.js";
 import {extractDecimals} from "./constants/utils.js";
 
 export const NETWORK_CONSTANTS: { [index: number]: any } = {
@@ -529,6 +529,11 @@ class Llamalend implements ILlamalend {
         this.feeData = { ...this.feeData, ...customFeeData };
     }
 
+    async _filterHiddenMarkets(markets: IDict<IOneWayMarket>): Promise<IDict<IOneWayMarket>> {
+        const hiddenMarkets = (await _getHiddenPools() as any)[this.constants.NETWORK_NAME] || [];
+        return Object.fromEntries(Object.entries(markets).filter(([id]) => !hiddenMarkets.includes(id))) as IDict<IOneWayMarket>;
+    }
+
     getLendMarketList = () => Object.keys(this.constants.ONE_WAY_MARKETS);
 
     getMintMarketList = () => Object.keys(this.constants.LLAMMAS);
@@ -720,6 +725,8 @@ class Llamalend implements ILlamalend {
             }
         })
 
+        this.constants.ONE_WAY_MARKETS = await this._filterHiddenMarkets(this.constants.ONE_WAY_MARKETS);
+
         await this.fetchStats(amms, controllers, vaults, borrowed_tokens, collateral_tokens);
     }
 
@@ -767,6 +774,8 @@ class Llamalend implements ILlamalend {
                 collateral_token: COIN_DATA[collateral_tokens[index]],
             }
         })
+
+        this.constants.ONE_WAY_MARKETS = await this._filterHiddenMarkets(this.constants.ONE_WAY_MARKETS);
     }
 
     formatUnits(value: BigNumberish, unit?: string | Numeric): string {