@defisaver/positions-sdk 0.0.198 → 0.0.199-dev-1

package/esm/liquityV2/index.js

@@ -0,0 +1,175 @@
+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 Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import { createContractWrapper, LiquityV2ViewContract } from '../contracts';
+import { LIQUITY_V2_TROVE_STATUS_ENUM, } from '../types';
+import { getStakingApy, STAKING_ASSETS } from '../staking';
+import { getLiquityV2AggregatedPositionData } from '../helpers/liquityV2Helpers';
+import { compareAddresses, ethToWeth } from '../services/utils';
+import { ZERO_ADDRESS } from '../constants';
+export const getLiquityV2MarketData = (web3, network, selectedMarket, mainnetWeb3) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const { marketAddress, debtToken, collateralToken } = selectedMarket;
+    const data = yield viewContract.methods.getMarketData(marketAddress).call();
+    const hintHelperAddress = data.hintHelpers;
+    const troveNFTAddress = data.troveNFT;
+    const borrowerOperationsAddress = data.borrowerOperations;
+    const troveManagerAddress = data.troveManager;
+    const stabilityPoolAddress = data.stabilityPool;
+    const collSurplusPoolAddress = data.collSurplusPool;
+    const activePoolAddress = data.activePool;
+    const minCollRatio = new Dec(data.MCR).div(1e16).toString();
+    const criticalCollRatio = new Dec(data.CCR).div(1e18).toString();
+    const totalMarketBorrow = assetAmountInEth(data.entireSystemDebt);
+    const totalMarketSupply = assetAmountInEth(data.entireSystemColl);
+    const collPrice = assetAmountInEth(data.collPrice);
+    const totalCollRatio = new Dec(totalMarketSupply).mul(collPrice).div(totalMarketBorrow).toString();
+    const leftToBorrowGlobal = new Dec(totalMarketSupply).mul(collPrice).div(criticalCollRatio).sub(totalMarketBorrow)
+        .toString();
+    const minCollAmountForCurrentBorrow = new Dec(totalMarketBorrow).mul(criticalCollRatio).div(collPrice).toString();
+    const leftToWithdrawGlobal = new Dec(totalMarketSupply).sub(minCollAmountForCurrentBorrow).toString();
+    const assetsData = {};
+    assetsData[debtToken] = {
+        symbol: debtToken,
+        address: getAssetInfo(debtToken, network).address,
+        price: '1',
+        totalSupply: '0',
+        totalBorrow: totalMarketBorrow,
+        canBeSupplied: false,
+        canBeBorrowed: true,
+        leftToBorrowGlobal,
+        leftToWithdrawGlobal: '0',
+    };
+    assetsData[collateralToken] = {
+        symbol: collateralToken,
+        address: getAssetInfo(ethToWeth(collateralToken), network).address,
+        price: collPrice,
+        totalSupply: totalMarketSupply,
+        totalBorrow: '0',
+        canBeSupplied: true,
+        canBeBorrowed: false,
+        leftToBorrowGlobal: '0',
+        leftToWithdrawGlobal,
+    };
+    if (STAKING_ASSETS.includes(collateralToken)) {
+        assetsData[collateralToken].incentiveSupplyApy = yield getStakingApy(collateralToken, mainnetWeb3);
+        assetsData[collateralToken].incentiveSupplyToken = collateralToken;
+    }
+    return {
+        assetsData,
+        marketData: {
+            minCollRatio,
+            totalCollRatio: new Dec(totalCollRatio).mul(100).toString(),
+            criticalCollRatio: new Dec(criticalCollRatio).mul(100).toString(),
+            isUnderCollateralized: new Dec(totalCollRatio).lt(criticalCollRatio),
+            hintHelperAddress,
+            troveNFTAddress,
+            borrowerOperationsAddress,
+            troveManagerAddress,
+            stabilityPoolAddress,
+            collSurplusPoolAddress,
+            activePoolAddress,
+        },
+    };
+});
+const _getUserTroves = (viewContract, account, marketAddress, startIndex = 0, endIndex = 100) => __awaiter(void 0, void 0, void 0, function* () { return viewContract.methods.getUserTroves(account, marketAddress, startIndex, endIndex).call(); });
+const getUserTroves = (viewContract, account, marketAddress, startIndex = 0, endIndex = 100, troves = []) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield _getUserTroves(viewContract, account, marketAddress, startIndex, endIndex);
+    const newStartIndex = endIndex + 1;
+    const nextFreeTroveIndex = result.nextFreeTroveIndex;
+    const existingTroves = [...troves, ...result.troves];
+    if (nextFreeTroveIndex !== '-1')
+        return { troves: existingTroves.filter((trove) => trove.ownedByUser), nextFreeTroveIndex };
+    return getUserTroves(viewContract, account, marketAddress, newStartIndex, newStartIndex + 100, existingTroves);
+});
+const TransferEventSig = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+const getTransferredTroves = (web3, network, troveNFTAddress, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const nftContract = createContractWrapper(web3, network, 'LiquityV2TroveNFT', troveNFTAddress);
+    const currentBlock = yield web3.eth.getBlockNumber();
+    const events = yield nftContract.getPastEvents(TransferEventSig, {
+        fromBlock: currentBlock - 1000,
+    });
+    const userTransferredTroves = events.filter((event) => !compareAddresses(event.returnValues.from, ZERO_ADDRESS) && compareAddresses(event.returnValues.to, account));
+    // check if the last know transfer address is the user
+    userTransferredTroves.forEach((event, index) => {
+        const otherTransfers = events.filter((e) => event.blockNumber < e.blockNumber && e.returnValues.tokenId === event.returnValues.tokenId);
+        // @ts-ignore
+        userTransferredTroves[index].invalid = !!otherTransfers.length;
+    });
+    // @ts-ignore
+    return userTransferredTroves.filter((event) => !event.invalid).map((event) => ({ troveId: event.returnValues.tokenId }));
+});
+export const getLiquityV2UserTroveIds = (web3, network, selectedMarket, troveNFTAddress, account) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const [{ troves: userTroves, nextFreeTroveIndex }, userTransferredTroves] = yield Promise.all([
+        getUserTroves(viewContract, account, selectedMarket.marketAddress),
+        getTransferredTroves(web3, network, troveNFTAddress, account),
+    ]);
+    const troves = [...userTroves.map(({ troveId }) => ({ troveId })), ...userTransferredTroves];
+    const filteredTroves = troves.filter((value, index, self) => index === self.findIndex((t) => (t.troveId === value.troveId)));
+    return { troves: filteredTroves, nextFreeTroveIndex };
+});
+const _getDebtInFront = (viewContract, marketAddress, troveId, accumulatedSum = '0', iterations = 2000) => __awaiter(void 0, void 0, void 0, function* () { return viewContract.methods.getDebtInFront(marketAddress, troveId, accumulatedSum, iterations).call(); });
+export const getDebtInFrontLiquityV2 = (viewContract, marketAddress, troveId, accumulatedSum = '0', iterations = 2000) => __awaiter(void 0, void 0, void 0, function* () {
+    const { debt, next } = yield _getDebtInFront(viewContract, marketAddress, troveId, accumulatedSum, iterations);
+    if (next === '0')
+        return assetAmountInEth(debt);
+    return getDebtInFrontLiquityV2(viewContract, marketAddress, next, debt, iterations);
+});
+export const getLiquityV2TroveData = (web3, network, { selectedMarket, assetsData, marketData, troveId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const viewContract = LiquityV2ViewContract(web3, network);
+    const { minCollRatio } = marketData;
+    const { collateralToken, marketAddress, debtToken } = selectedMarket;
+    const [data, debtInFront] = yield Promise.all([
+        viewContract.methods.getTroveInfo(marketAddress, troveId).call(),
+        getDebtInFrontLiquityV2(viewContract, marketAddress, troveId),
+    ]);
+    const usedAssets = {};
+    const debtAssetData = assetsData[debtToken];
+    const borrowed = assetAmountInEth(data.debtAmount);
+    usedAssets[debtToken] = {
+        symbol: debtToken,
+        supplied: '0',
+        suppliedUsd: '0',
+        borrowed,
+        borrowedUsd: new Dec(borrowed).mul(debtAssetData.price).toString(),
+        isBorrowed: true,
+        isSupplied: false,
+    };
+    const collAssetData = assetsData[collateralToken];
+    const suppliedColl = assetAmountInEth(data.collAmount);
+    usedAssets[collateralToken] = {
+        symbol: collateralToken,
+        supplied: suppliedColl,
+        suppliedUsd: new Dec(suppliedColl).mul(collAssetData.price).toString(),
+        borrowed: '0',
+        borrowedUsd: '0',
+        isBorrowed: false,
+        isSupplied: true,
+        collateral: true,
+    };
+    const collRatio = new Dec(data.TCRatio).div(1e16).toString();
+    const interestRate = new Dec(data.annualInterestRate).div(1e16).toString();
+    const interestBatchManager = data.interestBatchManager;
+    const payload = Object.assign(Object.assign({ usedAssets,
+        troveId,
+        interestRate,
+        interestBatchManager,
+        debtInFront, troveStatus: LIQUITY_V2_TROVE_STATUS_ENUM[parseInt(data.status, 10)] }, getLiquityV2AggregatedPositionData({
+        usedAssets, assetsData, minCollRatio, interestRate,
+    })), { collRatio });
+    return payload;
+});
+export const getLiquityV2ClaimableCollateral = (collSurplusPoolAddress, account, web3, network) => __awaiter(void 0, void 0, void 0, function* () {
+    const collSurplusPoolContract = createContractWrapper(web3, network, 'LiquityV2CollSurplusPool', collSurplusPoolAddress);
+    const claimableCollateral = yield collSurplusPoolContract.methods.getCollateral(account).call();
+    return claimableCollateral;
+});

package/esm/markets/aave/marketAssets.js

@@ -11,10 +11,8 @@ export const aaveV3AssetsDefaultMarketEth = ['ETH', 'wstETH', 'WBTC', 'USDC', 'D
 export const aaveV3AssetsDefaultMarketOpt = [
     'DAI', 'USDC.e', 'USDT', 'SUSD', 'AAVE', 'LINK', 'WBTC', 'ETH', 'OP', 'wstETH', 'LUSD', 'MAI', 'rETH', 'USDC',
 ];
-export const aaveV3AssetsDefaultMarketArb = [
-    'ETH', 'DAI', 'EURS', 'USDC', 'USDT', 'AAVE', 'LINK', 'WBTC', 'wstETH', 'MAI', 'rETH', 'LUSD', 'USDC.e', 'FRAX', 'ARB', 'weETH', 'GHO',
-];
-export const aaveV3AssetsDefaultMarketBase = ['ETH', 'cbETH', 'USDbC', 'wstETH', 'USDC', 'weETH', 'cbBTC'];
+export const aaveV3AssetsDefaultMarketArb = ['DAI', 'LINK', 'USDC.e', 'WBTC', 'ETH', 'USDT', 'AAVE', 'EURS', 'wstETH', 'MAI', 'rETH', 'LUSD', 'USDC', 'FRAX', 'ARB', 'weETH', 'GHO', 'ezETH'];
+export const aaveV3AssetsDefaultMarketBase = ['ETH', 'cbETH', 'USDbC', 'wstETH', 'USDC', 'weETH', 'cbBTC', 'ezETH'];
 // @dev Keep assets in array, do not assign directly, so we can parse it and edit it programmatically with `scripts/updateMarkets`
 export const aaveV3AssetsDefaultMarket = {
     [NetworkNumber.Eth]: aaveV3AssetsDefaultMarketEth,

package/esm/markets/index.d.ts

@@ -4,4 +4,5 @@ export { SparkMarkets } from './spark';
 export { CrvUsdMarkets } from './curveUsd';
 export { MorphoBlueMarkets, findMorphoBlueMarket } from './morphoBlue';
 export { LlamaLendMarkets } from './llamaLend';
+export { LiquityV2Markets } from './liquityV2';
 export { EulerV2Markets } from './euler';

package/esm/markets/index.js

@@ -4,4 +4,5 @@ export { SparkMarkets } from './spark';
 export { CrvUsdMarkets } from './curveUsd';
 export { MorphoBlueMarkets, findMorphoBlueMarket } from './morphoBlue';
 export { LlamaLendMarkets } from './llamaLend';
+export { LiquityV2Markets } from './liquityV2';
 export { EulerV2Markets } from './euler';

package/esm/markets/liquityV2/index.d.ts

@@ -0,0 +1,10 @@
+import { NetworkNumber } from '../../types/common';
+import { LiquityV2MarketInfo } from '../../types/liquityV2';
+export declare const LIQUITY_V2_ETH_MARKET: (networkId?: NetworkNumber) => LiquityV2MarketInfo;
+export declare const LIQUITY_V2_WSTETH_MARKET: (networkId?: NetworkNumber) => LiquityV2MarketInfo;
+export declare const LIQUITY_V2_RETH_MARKET: (networkId?: NetworkNumber) => LiquityV2MarketInfo;
+export declare const LiquityV2Markets: (networkId: NetworkNumber) => {
+    readonly liquityv2eth: LiquityV2MarketInfo;
+    readonly liquityv2wsteth: LiquityV2MarketInfo;
+    readonly liquityv2reth: LiquityV2MarketInfo;
+};

package/esm/markets/liquityV2/index.js

@@ -0,0 +1,40 @@
+import { NetworkNumber } from '../../types/common';
+import { LiquityV2Versions } from '../../types/liquityV2';
+export const LIQUITY_V2_ETH_MARKET = (networkId = NetworkNumber.Eth) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Liquity V2 ETH',
+    shortLabel: 'ETH',
+    value: LiquityV2Versions.LiquityV2Eth,
+    url: 'eth',
+    debtToken: 'BOLD',
+    collateralToken: 'ETH',
+    marketAddress: '0xc3fe668b43439525f70fe860f89882f0be312504',
+    protocolName: 'liquity-v2',
+});
+export const LIQUITY_V2_WSTETH_MARKET = (networkId = NetworkNumber.Eth) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Liquity V2 wstETH',
+    shortLabel: 'wstETH',
+    value: LiquityV2Versions.LiquityV2WstEth,
+    url: 'wsteth',
+    debtToken: 'BOLD',
+    collateralToken: 'wstETH',
+    marketAddress: '0x9b27787ff66aa3cea8dbc47772328459a1fa05ac',
+    protocolName: 'liquity-v2',
+});
+export const LIQUITY_V2_RETH_MARKET = (networkId = NetworkNumber.Eth) => ({
+    chainIds: [NetworkNumber.Eth],
+    label: 'Liquity V2 rETH',
+    shortLabel: 'rETH',
+    value: LiquityV2Versions.LiquityV2REth,
+    url: 'reth',
+    debtToken: 'BOLD',
+    collateralToken: 'rETH',
+    marketAddress: '0xde524be191de806011e98c8d36d50d7a88391a3e',
+    protocolName: 'liquity-v2',
+});
+export const LiquityV2Markets = (networkId) => ({
+    [LiquityV2Versions.LiquityV2Eth]: LIQUITY_V2_ETH_MARKET(networkId),
+    [LiquityV2Versions.LiquityV2WstEth]: LIQUITY_V2_WSTETH_MARKET(networkId),
+    [LiquityV2Versions.LiquityV2REth]: LIQUITY_V2_RETH_MARKET(networkId),
+});

package/esm/moneymarket/moneymarketCommonService.js

@@ -16,7 +16,7 @@ export const calcLeverageLiqPrice = (leverageType, assetPrice, borrowedUsd, borr
     return '0';
 };
 export const calculateBorrowingAssetLimit = (assetBorrowedUsd, borrowLimitUsd) => new Dec(assetBorrowedUsd).div(borrowLimitUsd).times(100).toString();
-export const STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI', 'crvUSD'];
+export const STABLE_ASSETS = ['DAI', 'USDC', 'USDT', 'TUSD', 'USDP', 'GUSD', 'BUSD', 'SUSD', 'FRAX', 'LUSD', 'USDC.e', 'GHO', 'sDAI', 'crvUSD', 'BOLD'];
 export const isLeveragedPos = (usedAssets, dustLimit = 5) => {
     let borrowUnstable = 0;
     let supplyStable = 0;

package/esm/types/contracts/generated/LiquityV2CollSurplusPool.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export type BorrowerOperationsAddressChanged = ContractEventLog<{
+    _newBorrowerOperationsAddress: string;
+    0: string;
+}>;
+export type CollBalanceUpdated = ContractEventLog<{
+    _account: string;
+    _newBalance: string;
+    0: string;
+    1: string;
+}>;
+export type CollSent = ContractEventLog<{
+    _to: string;
+    _amount: string;
+    0: string;
+    1: string;
+}>;
+export type TroveManagerAddressChanged = ContractEventLog<{
+    _newTroveManagerAddress: string;
+    0: string;
+}>;
+export interface LiquityV2CollSurplusPool extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): LiquityV2CollSurplusPool;
+    clone(): LiquityV2CollSurplusPool;
+    methods: {
+        NAME(): NonPayableTransactionObject<string>;
+        accountSurplus(_account: string, _amount: number | string | BN): NonPayableTransactionObject<void>;
+        borrowerOperationsAddress(): NonPayableTransactionObject<string>;
+        claimColl(_account: string): NonPayableTransactionObject<void>;
+        collToken(): NonPayableTransactionObject<string>;
+        getCollBalance(): NonPayableTransactionObject<string>;
+        getCollateral(_account: string): NonPayableTransactionObject<string>;
+        troveManagerAddress(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        BorrowerOperationsAddressChanged(cb?: Callback<BorrowerOperationsAddressChanged>): EventEmitter;
+        BorrowerOperationsAddressChanged(options?: EventOptions, cb?: Callback<BorrowerOperationsAddressChanged>): EventEmitter;
+        CollBalanceUpdated(cb?: Callback<CollBalanceUpdated>): EventEmitter;
+        CollBalanceUpdated(options?: EventOptions, cb?: Callback<CollBalanceUpdated>): EventEmitter;
+        CollSent(cb?: Callback<CollSent>): EventEmitter;
+        CollSent(options?: EventOptions, cb?: Callback<CollSent>): EventEmitter;
+        TroveManagerAddressChanged(cb?: Callback<TroveManagerAddressChanged>): EventEmitter;
+        TroveManagerAddressChanged(options?: EventOptions, cb?: Callback<TroveManagerAddressChanged>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "BorrowerOperationsAddressChanged", cb: Callback<BorrowerOperationsAddressChanged>): void;
+    once(event: "BorrowerOperationsAddressChanged", options: EventOptions, cb: Callback<BorrowerOperationsAddressChanged>): void;
+    once(event: "CollBalanceUpdated", cb: Callback<CollBalanceUpdated>): void;
+    once(event: "CollBalanceUpdated", options: EventOptions, cb: Callback<CollBalanceUpdated>): void;
+    once(event: "CollSent", cb: Callback<CollSent>): void;
+    once(event: "CollSent", options: EventOptions, cb: Callback<CollSent>): void;
+    once(event: "TroveManagerAddressChanged", cb: Callback<TroveManagerAddressChanged>): void;
+    once(event: "TroveManagerAddressChanged", options: EventOptions, cb: Callback<TroveManagerAddressChanged>): void;
+}

package/esm/types/contracts/generated/LiquityV2CollSurplusPool.js

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export {};

package/esm/types/contracts/generated/LiquityV2TroveNFT.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export type Approval = ContractEventLog<{
+    owner: string;
+    approved: string;
+    tokenId: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export type ApprovalForAll = ContractEventLog<{
+    owner: string;
+    operator: string;
+    approved: boolean;
+    0: string;
+    1: string;
+    2: boolean;
+}>;
+export type Transfer = ContractEventLog<{
+    from: string;
+    to: string;
+    tokenId: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export interface LiquityV2TroveNFT extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): LiquityV2TroveNFT;
+    clone(): LiquityV2TroveNFT;
+    methods: {
+        approve(to: string, tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        balanceOf(owner: string): NonPayableTransactionObject<string>;
+        burn(_troveId: number | string | BN): NonPayableTransactionObject<void>;
+        getApproved(tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        isApprovedForAll(owner: string, operator: string): NonPayableTransactionObject<boolean>;
+        metadataNFT(): NonPayableTransactionObject<string>;
+        mint(_owner: string, _troveId: number | string | BN): NonPayableTransactionObject<void>;
+        name(): NonPayableTransactionObject<string>;
+        ownerOf(tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        "safeTransferFrom(address,address,uint256)"(from: string, to: string, tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        "safeTransferFrom(address,address,uint256,bytes)"(from: string, to: string, tokenId: number | string | BN, data: string | number[]): NonPayableTransactionObject<void>;
+        setApprovalForAll(operator: string, approved: boolean): NonPayableTransactionObject<void>;
+        supportsInterface(interfaceId: string | number[]): NonPayableTransactionObject<boolean>;
+        symbol(): NonPayableTransactionObject<string>;
+        tokenURI(_tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        transferFrom(from: string, to: string, tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        troveManager(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        Approval(cb?: Callback<Approval>): EventEmitter;
+        Approval(options?: EventOptions, cb?: Callback<Approval>): EventEmitter;
+        ApprovalForAll(cb?: Callback<ApprovalForAll>): EventEmitter;
+        ApprovalForAll(options?: EventOptions, cb?: Callback<ApprovalForAll>): EventEmitter;
+        Transfer(cb?: Callback<Transfer>): EventEmitter;
+        Transfer(options?: EventOptions, cb?: Callback<Transfer>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "Approval", cb: Callback<Approval>): void;
+    once(event: "Approval", options: EventOptions, cb: Callback<Approval>): void;
+    once(event: "ApprovalForAll", cb: Callback<ApprovalForAll>): void;
+    once(event: "ApprovalForAll", options: EventOptions, cb: Callback<ApprovalForAll>): void;
+    once(event: "Transfer", cb: Callback<Transfer>): void;
+    once(event: "Transfer", options: EventOptions, cb: Callback<Transfer>): void;
+}

package/esm/types/contracts/generated/LiquityV2TroveNFT.js

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export {};

package/esm/types/contracts/generated/LiquityV2View.d.ts

@@ -0,0 +1,244 @@
+/// <reference types="node" />
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type { Callback, NonPayableTransactionObject, BlockType, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare namespace LiquityV2View {
+    type MarketDataStruct = [
+        string,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        number | string | BN,
+        boolean
+    ] | {
+        market: string;
+        CCR: number | string | BN;
+        MCR: number | string | BN;
+        SCR: number | string | BN;
+        LIQUIDATION_PENALTY_SP: number | string | BN;
+        LIQUIDATION_PENALTY_REDISTRIBUTION: number | string | BN;
+        entireSystemColl: number | string | BN;
+        entireSystemDebt: number | string | BN;
+        collToken: string;
+        troveNFT: string;
+        borrowerOperations: string;
+        troveManager: string;
+        stabilityPool: string;
+        sortedTroves: string;
+        collSurplusPool: string;
+        activePool: string;
+        hintHelpers: string;
+        priceFeed: string;
+        collPrice: number | string | BN;
+        isShutDown: boolean;
+    };
+    type MarketDataStructOutputArray = [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        boolean
+    ];
+    type MarketDataStructOutputStruct = {
+        market: string;
+        CCR: string;
+        MCR: string;
+        SCR: string;
+        LIQUIDATION_PENALTY_SP: string;
+        LIQUIDATION_PENALTY_REDISTRIBUTION: string;
+        entireSystemColl: string;
+        entireSystemDebt: string;
+        collToken: string;
+        troveNFT: string;
+        borrowerOperations: string;
+        troveManager: string;
+        stabilityPool: string;
+        sortedTroves: string;
+        collSurplusPool: string;
+        activePool: string;
+        hintHelpers: string;
+        priceFeed: string;
+        collPrice: string;
+        isShutDown: boolean;
+    };
+    type MarketDataStructOutput = MarketDataStructOutputArray & MarketDataStructOutputStruct;
+    type TroveDataStruct = [
+        number | string | BN,
+        string,
+        string,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        number | string | BN,
+        string,
+        number | string | BN
+    ] | {
+        troveId: number | string | BN;
+        owner: string;
+        collToken: string;
+        status: number | string | BN;
+        collAmount: number | string | BN;
+        debtAmount: number | string | BN;
+        collPrice: number | string | BN;
+        TCRatio: number | string | BN;
+        annualInterestRate: number | string | BN;
+        interestBatchManager: string;
+        batchDebtShares: number | string | BN;
+    };
+    type TroveDataStructOutputArray = [
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+    type TroveDataStructOutputStruct = {
+        troveId: string;
+        owner: string;
+        collToken: string;
+        status: string;
+        collAmount: string;
+        debtAmount: string;
+        collPrice: string;
+        TCRatio: string;
+        annualInterestRate: string;
+        interestBatchManager: string;
+        batchDebtShares: string;
+    };
+    type TroveDataStructOutput = TroveDataStructOutputArray & TroveDataStructOutputStruct;
+    type ExistingTroveStruct = [number | string | BN, boolean] | {
+        troveId: number | string | BN;
+        ownedByUser: boolean;
+    };
+    type ExistingTroveStructOutputArray = [string, boolean];
+    type ExistingTroveStructOutputStruct = {
+        troveId: string;
+        ownedByUser: boolean;
+    };
+    type ExistingTroveStructOutput = ExistingTroveStructOutputArray & ExistingTroveStructOutputStruct;
+}
+export interface LiquityV2View extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): LiquityV2View;
+    clone(): LiquityV2View;
+    methods: {
+        findInsertPosition(_market: string, _interestRate: number | string | BN, _prevId: number | string | BN, _nextId: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            prevId: string;
+            nextId: string;
+        }>;
+        getApproxHint(_market: string, _collIndex: number | string | BN, _interestRate: number | string | BN, _numTrials: number | string | BN, _inputRandomSeed: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string,
+            string
+        ] & {
+            hintId: string;
+            diff: string;
+            latestRandomSeed: string;
+        }>;
+        getDebtInFront(_market: string, _troveId: number | string | BN, _acc: number | string | BN, _iterations: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            next: string;
+            debt: string;
+        }>;
+        getDebtInFrontByInterestRate(_market: string, _troveId: number | string | BN, _acc: number | string | BN, _iterations: number | string | BN, _targetIR: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            next: string;
+            debt: string;
+        }>;
+        getDebtInFrontByTroveNum(_market: string, _numTroves: number | string | BN): NonPayableTransactionObject<string>;
+        getDepositorInfo(_market: string, _depositor: string): NonPayableTransactionObject<[
+            string,
+            string,
+            string
+        ] & {
+            compoundedBOLD: string;
+            collGain: string;
+            boldGain: string;
+        }>;
+        getInsertPosition(_market: string, _collIndex: number | string | BN, _interestRate: number | string | BN, _numTrials: number | string | BN, _inputRandomSeed: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            prevId: string;
+            nextId: string;
+        }>;
+        getMarketData(_market: string): NonPayableTransactionObject<LiquityV2View.MarketDataStructOutput>;
+        getNumOfTrovesInFrontOfTrove(_market: string, _troveId: number | string | BN, _iterations: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            next: string;
+            numTroves: string;
+        }>;
+        getTroveInfo(_market: string, _troveId: number | string | BN): NonPayableTransactionObject<LiquityV2View.TroveDataStructOutput>;
+        getTrovePosition(_market: string, _collIndex: number | string | BN, _troveId: number | string | BN, _numTrials: number | string | BN, _inputRandomSeed: number | string | BN): NonPayableTransactionObject<[
+            string,
+            string
+        ] & {
+            prevId: string;
+            nextId: string;
+        }>;
+        getUserTroves(_user: string, _market: string, _startIndex: number | string | BN, _endIndex: number | string | BN): NonPayableTransactionObject<[
+            LiquityV2View.ExistingTroveStructOutput[],
+            string
+        ] & {
+            troves: LiquityV2View.ExistingTroveStructOutput[];
+            nextFreeTroveIndex: string;
+        }>;
+        isShutDown(_market: string): NonPayableTransactionObject<boolean>;
+        predictAdjustTroveUpfrontFee(_market: string, _collIndex: number | string | BN, _troveId: number | string | BN, _debtIncrease: number | string | BN): NonPayableTransactionObject<string>;
+    };
+    events: {
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+}

package/esm/types/contracts/generated/LiquityV2View.js

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export {};