@defisaver/positions-sdk 0.0.1

package/esm/types/curveUsd.d.ts

@@ -0,0 +1,101 @@
+import { NetworkNumber } from './common';
+export declare enum CrvUSDVersions {
+    'wstETH' = "wstETH",
+    'WBTC' = "WBTC",
+    'ETH' = "ETH"
+}
+export declare enum CrvUSDStatus {
+    Nonexistant = "Nonexistant",
+    Safe = "Safe",
+    Risk = "Risk",
+    SoftLiquidating = "SoftLiquidating",
+    SoftLiquidated = "SoftLiquidated"
+}
+export interface CrvUSDMarketData {
+    chainIds: NetworkNumber[];
+    label: string;
+    shortLabel: string;
+    value: CrvUSDVersions;
+    collAsset: string;
+    baseAsset: string;
+    controllerAddress: string;
+    ammAddress: string;
+    createCollAssets: string[];
+}
+export interface BandData {
+    id: string;
+    collAmount: string;
+    debtAmount: string;
+    lowPrice: string;
+    highPrice: string;
+}
+export interface UserBandData {
+    id: string;
+    collAmount: string;
+    debtAmount: string;
+    lowPrice: string;
+    highPrice: string;
+    userDebtAmount: string;
+    userCollAmount: string;
+}
+export interface CrvUSDGlobalMarketData {
+    collateral: string;
+    decimals: string;
+    activeBand: string;
+    totalDebt: string;
+    ammPrice: string;
+    basePrice: string;
+    oraclePrice: string;
+    minted: string;
+    redeemed: string;
+    monetaryPolicyRate: string;
+    ammRate: string;
+    minBand: string;
+    maxBand: string;
+    debtCeiling: string;
+    borrowRate: string;
+    futureBorrowRate: string;
+    leftToBorrow: string;
+    bands: BandData[];
+}
+export interface CrvUSDAggregatedPositionData {
+    ratio: string;
+    supplied: string;
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowed: string;
+    safetyRatio: string;
+}
+export interface CrvUSDUsedAsset {
+    isSupplied: boolean;
+    supplied: string;
+    suppliedUsd: string;
+    borrowed: string;
+    borrowedUsd: string;
+    isBorrowed: boolean;
+    symbol: string;
+    collateral: boolean;
+    price: string;
+    interestRate?: string;
+}
+export interface CrvUSDUsedAssets {
+    [key: string]: CrvUSDUsedAsset;
+}
+export interface CrvUSDUserData {
+    debtAmount: string;
+    health: string;
+    healthPercent: string;
+    priceHigh: string;
+    priceLow: string;
+    liquidationDiscount: string;
+    numOfBands: string;
+    usedAssets: CrvUSDUsedAssets;
+    status: CrvUSDStatus;
+    ratio: string;
+    supplied: string;
+    suppliedUsd: string;
+    borrowedUsd: string;
+    borrowed: string;
+    safetyRatio: string;
+    userBands: UserBandData[];
+}

package/esm/types/curveUsd.js

@@ -0,0 +1,14 @@
+export var CrvUSDVersions;
+(function (CrvUSDVersions) {
+    CrvUSDVersions["wstETH"] = "wstETH";
+    CrvUSDVersions["WBTC"] = "WBTC";
+    CrvUSDVersions["ETH"] = "ETH";
+})(CrvUSDVersions || (CrvUSDVersions = {}));
+export var CrvUSDStatus;
+(function (CrvUSDStatus) {
+    CrvUSDStatus["Nonexistant"] = "Nonexistant";
+    CrvUSDStatus["Safe"] = "Safe";
+    CrvUSDStatus["Risk"] = "Risk";
+    CrvUSDStatus["SoftLiquidating"] = "SoftLiquidating";
+    CrvUSDStatus["SoftLiquidated"] = "SoftLiquidated";
+})(CrvUSDStatus || (CrvUSDStatus = {}));

package/esm/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './aave';
+export * from './compound';
+export * from './spark';
+export * from './curveUsd';
+export * from './liquity';
+export * from './maker';

package/esm/types/index.js

@@ -0,0 +1,6 @@
+export * from './aave';
+export * from './compound';
+export * from './spark';
+export * from './curveUsd';
+export * from './liquity';
+export * from './maker';

package/esm/types/liquity.d.ts

@@ -0,0 +1,28 @@
+export declare enum LIQUITY_TROVE_STATUS_ENUM {
+    nonExistent = 0,
+    active = 1,
+    closedByOwner = 2,
+    closedByLiquidation = 3,
+    closedByRedemption = 4
+}
+export declare const LIQUITY_STATUS_MAPPING: {
+    nonExistent: string;
+    active: string;
+    closedByOwner: string;
+    closedByLiquidation: string;
+    closedByRedemption: string;
+};
+export interface LiquityTroveInfo {
+    troveStatus: string;
+    collateral: string;
+    debtInAsset: string;
+    TCRatio: string;
+    recoveryMode: boolean;
+    claimableCollateral: string;
+    borrowingRateWithDecay: string;
+    assetPrice: string;
+    totalETH: string;
+    totalLUSD: string;
+    minCollateralRatio: number;
+    priceForRecovery: string;
+}

package/esm/types/liquity.js

@@ -0,0 +1,15 @@
+export var LIQUITY_TROVE_STATUS_ENUM;
+(function (LIQUITY_TROVE_STATUS_ENUM) {
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["nonExistent"] = 0] = "nonExistent";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["active"] = 1] = "active";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByOwner"] = 2] = "closedByOwner";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByLiquidation"] = 3] = "closedByLiquidation";
+    LIQUITY_TROVE_STATUS_ENUM[LIQUITY_TROVE_STATUS_ENUM["closedByRedemption"] = 4] = "closedByRedemption";
+})(LIQUITY_TROVE_STATUS_ENUM || (LIQUITY_TROVE_STATUS_ENUM = {}));
+export const LIQUITY_STATUS_MAPPING = {
+    nonExistent: 'Non existent',
+    active: 'Active',
+    closedByOwner: 'Closed',
+    closedByLiquidation: 'Liquidated',
+    closedByRedemption: 'Redeemed',
+};

package/esm/types/maker.d.ts

@@ -0,0 +1,49 @@
+import { EthAddress } from './common';
+export interface IlkInfo {
+    ilkLabel: string;
+    currentRate: string;
+    futureRate: string;
+    minDebt: string;
+    globalDebtCeiling: string;
+    globalDebtCurrent: string;
+    assetPrice: string;
+    liqRatio: string;
+    liqPercent: number;
+    stabilityFee: number;
+    liquidationFee: string;
+    creatableDebt: string;
+}
+export interface CdpData {
+    owner: EthAddress;
+    userAddress: EthAddress;
+    id: string;
+    urn: EthAddress;
+    type: string;
+    ilk: string;
+    ilkLabel: string;
+    asset: string;
+    collateral: string;
+    collateralUsd: string;
+    futureDebt: string;
+    debtDai: string;
+    debtUsd: string;
+    debtInAsset: string;
+    debtAssetPrice: string;
+    debtAssetMarketPrice: string;
+    liquidationPrice: string;
+    ratio: string;
+    liqRatio: string;
+    liqPercent: number;
+    assetPrice: string;
+    daiLabel: string;
+    debtAsset: string;
+    unclaimedCollateral: string;
+    debtTooLow: boolean;
+    minDebt: string;
+    stabilityFee: number;
+    creatableDebt: string;
+    globalDebtCeiling: string;
+    globalDebtCurrent: string;
+    liquidationFee: string;
+    lastUpdated: number;
+}

package/esm/types/maker.js

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

package/esm/types/spark.d.ts

@@ -0,0 +1,100 @@
+import { EModeCategoryData, EModeCategoryDataMapping } from './aave';
+import { MMAssetData, MMPositionData, MMUsedAsset, NetworkNumber } from './common';
+export declare enum SparkVersions {
+    SparkV1 = "v1default"
+}
+export interface SparkMarketData {
+    chainIds: NetworkNumber[];
+    label: string;
+    shortLabel: string;
+    url: string;
+    value: SparkVersions;
+    assets: readonly string[];
+    provider: '' | 'SparkPoolAddressesProvider';
+    providerAddress: string;
+    lendingPool: 'SparkLendingPool';
+    lendingPoolAddress: string;
+    protocolData: '' | 'SparkProtocolDataProvider';
+    protocolDataAddress: string;
+    subVersionLabel?: string;
+    protocolName: string;
+    disabled?: boolean;
+}
+export interface SparkAssetData extends MMAssetData {
+    totalBorrowVar: string;
+    sortIndex?: number;
+    usageAsCollateralEnabled: boolean;
+    isIsolated: boolean;
+    eModeCategory: number;
+    eModeCategoryData: EModeCategoryData;
+    liquidationRatio: string;
+}
+export interface SparkAssetsData {
+    [token: string]: SparkAssetData;
+}
+export type SparkMarketsData = {
+    assetsData: SparkAssetsData;
+};
+export interface SparkUsedAsset extends MMUsedAsset {
+    stableBorrowRate: string;
+    borrowedStable: string;
+    borrowedVariable: string;
+    borrowedUsdStable: string;
+    borrowedUsdVariable: string;
+    stableLimit: string;
+    variableLimit: string;
+    limit: string;
+    eModeCategory: number;
+}
+export interface SparkUsedAssets {
+    [token: string]: SparkUsedAsset;
+}
+export interface SparkHelperCommon {
+    usedAssets: SparkUsedAssets;
+    eModeCategory: number;
+    eModeCategories?: {
+        [key: number]: EModeCategoryDataMapping;
+    };
+    assetsData: SparkAssetsData;
+    selectedMarket?: SparkMarketData;
+    network?: NetworkNumber;
+}
+export interface SparkAggregatedPositionData {
+    suppliedUsd: string;
+    suppliedCollateralUsd: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    liquidationLimitUsd: string;
+    leftToBorrowUsd: string;
+    ratio: string;
+    collRatio: string;
+    netApy: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    liqRatio: string;
+    liqPercent: string;
+    leveragedType: string;
+    leveragedAsset?: string;
+    leveragedLsdAssetRatio?: string;
+    liquidationPrice?: string;
+}
+export interface SparkPositionData extends MMPositionData {
+    ratio: string;
+    minRatio: string;
+    collRatio: string;
+    borrowedUsd: string;
+    borrowLimitUsd: string;
+    suppliedCollateralUsd: string;
+    incentiveUsd: string;
+    totalInterestUsd: string;
+    isSubscribedToAutomation?: boolean;
+    automationResubscribeRequired?: boolean;
+    totalSupplied: string;
+    usedAssets: SparkUsedAssets;
+    eModeCategory: number;
+    isInIsolationMode: boolean;
+    isInSiloedMode: boolean;
+    eModeCategories: {
+        [key: number]: EModeCategoryDataMapping;
+    };
+}

package/esm/types/spark.js

@@ -0,0 +1,4 @@
+export var SparkVersions;
+(function (SparkVersions) {
+    SparkVersions["SparkV1"] = "v1default";
+})(SparkVersions || (SparkVersions = {}));

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@defisaver/positions-sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./cjs/index.js",
+  "module": "./esm/src/index.js",
+  "types": "./esm/src/index.d.ts",
+  "scripts": {
+    "build:esm": "rm -rf esm && tsc -p tsconfig.json",
+    "build:cjs": "rm -rf cjs && tsc -p tsconfig.cjs.json",
+    "build": "npm run generate-contracts && npm run build:cjs && npm run build:esm",
+    "dev": "npm run generate-contracts && tsc -p tsconfig.cjs.json --watch",
+    "lint": "eslint src/ --fix",
+    "generate-contracts": "node scripts/generateContracts.js",
+    "test": "mocha tests/*",
+    "build-test": "npm run build && mocha tests/*"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@defisaver/tokens": "^1.4.57",
+    "decimal.js": "^10.4.3",
+    "@morpho-org/morpho-aave-v3-sdk": "^1.5.3",
+    "@ethersproject/bignumber": "^5.7.0"
+  },
+  "devDependencies": {
+    "@defisaver/eslint-config": "^1.0.1",
+    "chai": "^4.3.8",
+    "dotenv": "^16.3.1",
+    "eslint": "^8.49.0",
+    "mocha": "^10.2.0",
+    "typechain": "^8.3.1",
+    "typechain-target-web3-v1-3mihai3": "^6.0.2",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "web3": "^1.10.2"
+  }
+}

package/src/aaveV2/index.ts

@@ -0,0 +1,219 @@
+import Web3 from 'web3';
+import Dec from 'decimal.js';
+import { assetAmountInEth, getAssetInfo } from '@defisaver/tokens';
+import * as net from 'net';
+import {
+  Blockish, EthAddress, NetworkNumber, PositionBalances,
+} from '../types/common';
+import { calculateNetApy, getStETHApr } from '../staking';
+import { ethToWeth, wethToEth } from '../services/utils';
+import { AaveLoanInfoV2Contract } from '../contracts';
+import { calculateBorrowingAssetLimit } from '../moneymarket';
+import {
+  AaveMarketInfo, AaveV2AssetData, AaveV2AssetsData, AaveV2PositionData, AaveV2UsedAsset, AaveV2UsedAssets,
+} from '../types';
+import { EMPTY_AAVE_DATA } from '../aaveV3';
+import { AAVE_V2 } from '../markets/aave';
+import { aaveAnyGetAggregatedPositionData } from '../helpers/aaveHelpers';
+
+export const getAaveV2MarketsData = async (web3: Web3, network: NetworkNumber, selectedMarket: AaveMarketInfo, ethPrice: string, mainnetWeb3: Web3) => {
+  const _addresses = selectedMarket.assets.map(a => getAssetInfo(ethToWeth(a)).address);
+  const loanInfoContract = AaveLoanInfoV2Contract(web3, network);
+  const marketAddress = selectedMarket.providerAddress;
+  const loanInfo = await loanInfoContract.methods.getFullTokensInfo(marketAddress, _addresses).call();
+  const markets = loanInfo
+    .map((market, i) => ({
+      symbol: selectedMarket.assets[i],
+      underlyingTokenAddress: market.underlyingTokenAddress,
+      supplyRate: new Dec(market.supplyRate.toString()).div(1e25).toString(),
+      borrowRate: new Dec(market.borrowRateVariable.toString()).div(1e25).toString(),
+      borrowRateStable: new Dec(market.borrowRateStable.toString()).div(1e25).toString(),
+      collateralFactor: new Dec(market.collateralFactor.toString()).div(10000).toString(),
+      liquidationRatio: new Dec(market.liquidationRatio.toString()).div(10000).toString(),
+      marketLiquidity: assetAmountInEth(new Dec(market.totalSupply.toString())
+        .sub(market.totalBorrow.toString())
+        .toString(), selectedMarket.assets[i]),
+      utilization: new Dec(market.totalBorrow.toString())
+        .div(new Dec(market.totalSupply.toString()))
+        .times(100)
+        .toString(),
+      usageAsCollateralEnabled: market.usageAsCollateralEnabled,
+      supplyCap: '0',
+      borrowCap: '0', // v2 doesnt have borrow cap but adding it for compatability with v3
+      totalSupply: assetAmountInEth(market.totalSupply.toString(), selectedMarket.assets[i]),
+      isInactive: !market.isActive,
+      isFrozen: market.isFrozen,
+      canBeBorrowed: market.isActive && market.borrowingEnabled && !market.isFrozen,
+      canBeSupplied: market.isActive && !market.isFrozen,
+      canBeWithdrawn: market.isActive,
+      canBePayBacked: market.isActive,
+      disabledStableBorrowing: !market.stableBorrowRateEnabled,
+      totalBorrow: assetAmountInEth(market.totalBorrow.toString(), selectedMarket.assets[i]),
+      totalBorrowVar: assetAmountInEth(market.totalBorrowVar.toString(), selectedMarket.assets[i]),
+      priceInEth: new Dec(market.price.toString()).div(1e18).toString(),
+      incentiveSupplyToken: 'AAVE',
+      incentiveBorrowToken: 'AAVE',
+      incentiveSupplyApy: '0',
+      price: new Dec(market.price.toString()).div(1e18).mul(ethPrice).toString(),
+    }));
+
+  const stEthMarket = markets.find(({ symbol }) => symbol === 'stETH');
+  if (stEthMarket) {
+    stEthMarket.incentiveSupplyApy = await getStETHApr(mainnetWeb3);
+    stEthMarket.incentiveSupplyToken = 'stETH';
+  }
+
+  const payload: AaveV2AssetsData = {};
+  // Sort by market size
+  markets
+    .sort((a, b) => {
+      const aMarket = new Dec(a.price).times(a.totalSupply).toString();
+      const bMarket = new Dec(b.price).times(b.totalSupply).toString();
+
+      return new Dec(bMarket).minus(aMarket).toNumber();
+    })
+    .forEach((assetData: AaveV2AssetData, i) => {
+      payload[assetData.symbol] = { ...assetData, sortIndex: i };
+    });
+
+  return { assetsData: payload };
+};
+
+export const getAaveV2AccountBalances = async (web3: Web3, network: NetworkNumber, block: Blockish, addressMapping: boolean, address: EthAddress): Promise<PositionBalances> => {
+  let balances: PositionBalances = {
+    collateral: {},
+    debt: {},
+  };
+
+  if (!address) {
+    return balances;
+  }
+
+  const market = AAVE_V2;
+
+  const loanInfoContract = AaveLoanInfoV2Contract(web3, network, block);
+
+  const marketAddress = market.providerAddress;
+  const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a), network).address);
+  const loanInfo = await loanInfoContract.methods.getTokenBalances(marketAddress, address, _addresses).call({}, block);
+
+  loanInfo.forEach((_tokenInfo: any, i: number) => {
+    const asset = wethToEth(market.assets[i]);
+    const tokenInfo = { ..._tokenInfo };
+
+    // known bug: stETH leaves 1 wei on every transfer
+    if (asset === 'stETH' && tokenInfo.balance.toString() === '1') {
+      tokenInfo.balance = '0';
+    }
+
+    balances = {
+      collateral: {
+        ...balances.collateral,
+        [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: tokenInfo.balance.toString(),
+      },
+      debt: {
+        ...balances.debt,
+        [addressMapping ? getAssetInfo(asset, network).address.toLowerCase() : asset]: new Dec(tokenInfo.borrowsStable.toString()).add(tokenInfo.borrowsVariable.toString()).toString(),
+      },
+    };
+  });
+
+  return balances;
+};
+
+export const getAaveV2AccountData = async (web3: Web3, network: NetworkNumber, address: string, assetsData: AaveV2AssetsData, market: AaveMarketInfo): Promise<AaveV2PositionData> => {
+  if (!address) throw new Error('Address is required');
+
+  let payload: AaveV2PositionData = {
+    ...EMPTY_AAVE_DATA,
+    lastUpdated: Date.now(),
+  };
+
+  const loanInfoContract = AaveLoanInfoV2Contract(web3, network);
+  const marketAddress = market.providerAddress;
+  const _addresses = market.assets.map(a => getAssetInfo(ethToWeth(a)).address);
+  const loanInfo = await loanInfoContract.methods.getTokenBalances(marketAddress, address, _addresses).call();
+  const usedAssets = {} as AaveV2UsedAssets;
+  loanInfo.forEach((_tokenInfo, i) => {
+    const asset = market.assets[i];
+    const tokenInfo = { ..._tokenInfo };
+
+    // known bug: stETH leaves 1 wei on every transfer
+    if (asset === 'stETH' && tokenInfo.balance.toString() === '1') tokenInfo.balance = '0';
+
+    const isSupplied = tokenInfo.balance.toString() !== '0';
+    const isBorrowed = tokenInfo.borrowsStable.toString() !== '0' || tokenInfo.borrowsVariable.toString() !== '0';
+    if (!isSupplied && !isBorrowed) return;
+
+    const supplied = assetAmountInEth(tokenInfo.balance.toString(), asset);
+    const borrowedStable = assetAmountInEth(tokenInfo.borrowsStable.toString(), asset);
+    const borrowedVariable = assetAmountInEth(tokenInfo.borrowsVariable.toString(), asset);
+    const enabledAsCollateral = assetsData[asset].usageAsCollateralEnabled ? tokenInfo.enabledAsCollateral : false;
+    let interestMode;
+    if (borrowedVariable === '0' && borrowedStable !== '0') {
+      interestMode = '1';
+    } else if (borrowedVariable !== '0' && borrowedStable === '0') {
+      interestMode = '2';
+    } else {
+      interestMode = 'both';
+    }
+    if (!usedAssets[asset]) usedAssets[asset] = {} as AaveV2UsedAsset;
+    usedAssets[asset] = {
+      ...usedAssets[asset],
+      symbol: asset,
+      supplied,
+      suppliedUsd: new Dec(supplied).mul(assetsData[asset].price).toString(),
+      isSupplied,
+      collateral: enabledAsCollateral,
+      stableBorrowRate: new Dec(tokenInfo.stableBorrowRate).div(1e25).toString(),
+      borrowedStable,
+      borrowedVariable,
+      borrowedUsdStable: new Dec(borrowedStable).mul(assetsData[asset].price).toString(),
+      borrowedUsdVariable: new Dec(borrowedVariable).mul(assetsData[asset].price).toString(),
+      borrowed: new Dec(borrowedStable).add(borrowedVariable).toString(),
+      borrowedUsd: new Dec(new Dec(borrowedVariable).add(borrowedStable)).mul(assetsData[asset].price).toString(),
+      isBorrowed,
+      interestMode,
+    };
+  });
+  payload = {
+    ...payload,
+    usedAssets,
+    ...aaveAnyGetAggregatedPositionData({
+      usedAssets, assetsData, eModeCategory: 0, selectedMarket: market,
+    }),
+  };
+
+  payload.ratio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+    ? new Dec(payload.borrowLimitUsd).div(payload.borrowedUsd).mul(100).toString()
+    : '0';
+  payload.minRatio = '100';
+  payload.collRatio = payload.borrowedUsd && payload.borrowedUsd !== '0'
+    ? new Dec(payload.suppliedCollateralUsd).div(payload.borrowedUsd).mul(100).toString()
+    : '0';
+
+  // Calculate borrow limits per asset
+  Object.values(payload.usedAssets).forEach((item) => {
+    if (item.isBorrowed) {
+      // eslint-disable-next-line no-param-reassign
+      item.stableLimit = calculateBorrowingAssetLimit(item.borrowedUsdStable, payload.borrowLimitUsd);
+      // eslint-disable-next-line no-param-reassign
+      item.variableLimit = calculateBorrowingAssetLimit(item.borrowedUsdVariable, payload.borrowLimitUsd);
+      // eslint-disable-next-line no-param-reassign
+      item.limit = calculateBorrowingAssetLimit(item.borrowedUsd, payload.borrowLimitUsd);
+    }
+  });
+
+  const { netApy, incentiveUsd, totalInterestUsd } = calculateNetApy(usedAssets, assetsData);
+  payload.netApy = netApy;
+  payload.incentiveUsd = incentiveUsd;
+  payload.totalInterestUsd = totalInterestUsd;
+
+  return payload;
+};
+
+export const getAaveV2FullPositionData = async (web3: Web3, network: NetworkNumber, address: string, market: AaveMarketInfo, ethPrice: string, mainnetWeb3: Web3): Promise<AaveV2PositionData> => {
+  const marketData = await getAaveV2MarketsData(web3, network, market, ethPrice, mainnetWeb3);
+  const positionData = await getAaveV2AccountData(web3, network, address, marketData.assetsData, market);
+  return positionData;
+};