@aurigami/sdk 1.19.0 → 1.19.2

package/dist/types/index.d.ts

@@ -178,3 +178,23 @@ export declare type UserNotification = {
         liquidation: boolean;
     }[];
 };
+export declare type UserLiquidationHistorySubgraph = {
+    liquidationEvents: LiquidationEventSubgraph[];
+};
+export declare type LiquidationEventSubgraph = {
+    auTokenSymbol: string;
+    amount: number;
+    blockTime: number;
+    from: string;
+    id: string;
+    underlyingRepayAmount: number;
+    underlyingRepayAmountUSD: number;
+    underlyingSymbol: string;
+};
+export declare type LiquidationDetail = {
+    liquidationTime: Timestamp;
+    tokenAmount: TokenAmount;
+    value: CurrencyAmount;
+    transactionId: string;
+};
+export declare type Timestamp = number;

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.19.0",
+  "version": "1.19.2",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/SDK.ts

@@ -1,11 +1,18 @@
 import { TransactionResponse } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
-import { ALL_STAKING_POOLS, SD_INCENTIVE_IN_SD } from './consts';
+import {
+  ALL_STAKING_POOLS,
+  AURIGAMI_SUBGRAPH_URL,
+  SD_INCENTIVE_IN_SD,
+  networkAddresses,
+} from './consts';
 import { AuriEnv, BlockchainEntity, BlockchainEntityRead, Token, TokenAmount } from './entities';
 import { MiscRead, StakingRead, StakingReadWrite } from './interactors';
 import * as types from './types';
 import * as NotificationApi from './helpers/notification-api';
 import { BigNumber as BN } from 'ethers';
+import { getDecimal, queryGraphQL } from './helpers';
+import { getLiquidationEventsQuery } from './helpers/subgraphQuery';
 
 export class SdkRead extends BlockchainEntityRead {
   protected env: AuriEnv;
@@ -94,14 +101,16 @@ export class SdkRead extends BlockchainEntityRead {
     return this._misc.sneakAccounts(accounts, tokenAddresses, dust);
   }
 
+  public async getLTVAndLiquidationThreshold(userAddr: types.Address) {
+    return this._misc.getLTVAndLiquidationThreshold(userAddr);
+  }
+
   public async getNetApyWithoutIncentive(userAddress: types.Address): Promise<BigNumber> {
-    const miscRead = new MiscRead(this._networkConnection);
-    return miscRead.getNetApyWithoutIncentive(userAddress);
+    return this._misc.getNetApyWithoutIncentive(userAddress);
   }
 
   public async getNetApyWithIncentive(userAddress: types.Address): Promise<BigNumber> {
-    const miscRead = new MiscRead(this._networkConnection);
-    return miscRead.getNetApyWithIncentive(userAddress);
+    return this._misc.getNetApyWithIncentive(userAddress);
   }
 
   public async setUserNotificationSettings(
@@ -147,6 +156,36 @@ export class SdkRead extends BlockchainEntityRead {
     const response = await NotificationApi.postApi('alert-setting/get-user-setting', body);
     return response;
   }
+
+  public async getLiquidationHistory(address: string): Promise<types.LiquidationDetail[]> {
+    const liquidationHistorySubgraph = (await queryGraphQL(
+      getLiquidationEventsQuery(address, 100),
+      AURIGAMI_SUBGRAPH_URL
+    )) as types.UserLiquidationHistorySubgraph;
+    const liquidationEvents = liquidationHistorySubgraph.liquidationEvents.map((event) => {
+      const value: types.CurrencyAmount = {
+        amount: event.underlyingRepayAmountUSD.toString(),
+        currency: 'USD',
+      };
+      const underlyingAddress = networkAddresses.auTokens.find(
+        (auToken) => auToken.name.slice(2).toLowerCase() === event.underlyingSymbol.toLowerCase()
+      )!.underlying;
+      const decimal = getDecimal(underlyingAddress);
+      const token = new Token(underlyingAddress, decimal);
+      const tokenAmount = new TokenAmount(token, event.underlyingRepayAmount.toString(), false);
+      return {
+        liquidationTime: event.blockTime,
+        tokenAmount,
+        value,
+        transactionId: event.id.split('-')[0],
+      };
+    }) as types.LiquidationDetail[];
+    return liquidationEvents;
+  }
+
+  public calculateBorrowPower(tokenAmount: TokenAmount): Promise<types.CurrencyAmount> {
+    return this._misc.calcBorrowPower(tokenAmount);
+  }
 }
 
 export class SdkReadWrite extends SdkRead {

package/src/consts/constants.ts

@@ -190,3 +190,8 @@ export const SD_INCENTIVE_IN_SD = 83.35;
 export const STADER_ETH = '0x30D20208d987713f46DFD34EF128Bb16C404D10f'.toLowerCase();
 
 export const USDT_ETH = '0xdAC17F958D2ee523a2206206994597C13D831ec7'.toLowerCase();
+
+export const AURIGAMI_SUBGRAPH_URL =
+  'https://api.thegraph.com/subgraphs/name/takao-aurigami/aurigami-feb-27';
+
+export const GRAPHQL_URL = 'https://explorer.mainnet.aurora.dev/graphiql';

package/src/helpers/graphql-helpers.ts

@@ -1,9 +1,7 @@
 import axios from 'axios';
 
-const GRAPHQL_URL = 'https://explorer.mainnet.aurora.dev/graphiql';
-
-export async function queryGraphQL(query: string): Promise<any> {
-  let resp = await axios.post(GRAPHQL_URL, {
+export async function queryGraphQL(query: string, graphqlUrl: string): Promise<any> {
+  let resp = await axios.post(graphqlUrl, {
     query: query,
   });
   return resp.data.data!;

package/src/helpers/helpers.ts

@@ -3,7 +3,7 @@ import { Provider } from '@ethersproject/abstract-provider';
 import BigNumber from 'bignumber.js';
 import { BigNumber as BN, utils } from 'ethers';
 import { Result } from 'ethers/lib/utils';
-import { CACHE_TIMEOUT, networkAddresses } from '../consts/constants';
+import { CACHE_TIMEOUT, GRAPHQL_URL, networkAddresses } from '../consts/constants';
 import { decimalRecords } from '../consts/decimals';
 import { symbolRecords } from '../consts/symbols';
 import { Address } from '../types';
@@ -129,7 +129,7 @@ export async function getBlocksTimestamp(
 
   for (let i = 0; i < lines.length; i += CHUNK_SIZE) {
     let query = `{ ${lines.slice(i, i + CHUNK_SIZE).join('\n')} }`;
-    promises.push(queryGraphQL(query));
+    promises.push(queryGraphQL(query, GRAPHQL_URL));
   }
 
   // merge all the json objects

package/src/helpers/subgraphQuery.ts

@@ -0,0 +1,17 @@
+export function getLiquidationEventsQuery(address: string, limit: number) {
+  return `{
+    liquidationEvents(
+      first: ${limit},
+      where: {from: "${address.toLowerCase()}"}
+    ) {
+      amount
+      auTokenSymbol
+      blockTime
+      from
+      id
+      underlyingRepayAmountUSD
+      underlyingSymbol
+      underlyingRepayAmount
+    }
+  }`;
+}

package/src/interactors/MoneyMarket.ts

@@ -326,6 +326,20 @@ export class MoneyMarketRead extends BlockchainEntityRead {
     );
   }
 
+  public async getDepositBorrowValue(userAddress: Address) {
+    const [price, depositBalance, borrowBalance] = await Promise.all([
+      this.getUnderlyingPrice(),
+      this.getUserDepositBalance(userAddress),
+      this.getUserBorrowBalance(userAddress),
+    ]);
+    const suppliedValue = price.multipliedBy(depositBalance.formattedAmount());
+    const borrowedValue = price.multipliedBy(borrowBalance.formattedAmount());
+    return {
+      suppliedValue,
+      borrowedValue,
+    };
+  }
+
   public async getApyWithoutIncentive(userAddress: Address): Promise<Apy> {
     const [price, depositApy, borrowApy, depositBalance, borrowBalance] = await Promise.all([
       this.getUnderlyingPrice(),

package/src/interactors/misc.ts

@@ -145,6 +145,29 @@ export class MiscRead extends BlockchainEntityRead {
     };
   }
 
+  public async calcBorrowPower(tokenAmount: TokenAmount) {
+    const autoken = consts.networkAddresses.auTokens.find((auToken) =>
+      isSameAddress(auToken.underlying, tokenAmount.token.address)
+    )!;
+    const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
+      this._networkConnection,
+      autoken.address,
+      autoken.underlying
+    );
+    const collateralRatio = await moneyMarket.getCollateralRatio();
+    const underlyingPrice = await fetchPrice(
+      tokenAmount.token.address,
+      this._networkConnection.provider
+    );
+    const borrowPower = calcValuation(tokenAmount!, new BigNumber(underlyingPrice))
+      .multipliedBy(collateralRatio)
+      .multipliedBy(consts.BORROW_LIMIT_BUFFER);
+    return {
+      currency: 'USD',
+      amount: borrowPower.toFixed(consts.DECIMAL_PRECISION),
+    };
+  }
+
   public calcHypotheticalStats({
     userMarketDetail,
     currentBorrowLimit,
@@ -309,6 +332,47 @@ export class MiscRead extends BlockchainEntityRead {
     return res;
   }
 
+  public async getLTVAndLiquidationThreshold(userAddr: types.Address) {
+    let totalSuppliedValue = new BigNumber(0);
+    let totalBorrowedValue = new BigNumber(0);
+    let collateralValue = new BigNumber(0);
+    const assetsIn = await this.env.comptroller.getAssetsIn(userAddr);
+    const marketValues = await Promise.all(
+      consts.networkAddresses.auTokens.map(async (auToken) => {
+        const moneyMarket: MoneyMarketRead = new MoneyMarketRead(
+          this._networkConnection,
+          auToken.address,
+          auToken.underlying
+        );
+        return Promise.all([
+          moneyMarket.getCollateralRatio(),
+          moneyMarket.getDepositBorrowValue(userAddr),
+        ]);
+      })
+    );
+    consts.networkAddresses.auTokens.forEach(async (auToken, i) => {});
+    for (var i = 0; i < marketValues.length; i++) {
+      const auToken = consts.networkAddresses.auTokens[i];
+      const [collateralRatio, depositBorrowValue] = marketValues[i];
+      if (
+        assetsIn!.find((auAddress: types.Address) => isSameAddress(auToken.address, auAddress)) !==
+        undefined
+      ) {
+        totalSuppliedValue = totalSuppliedValue.plus(depositBorrowValue.suppliedValue);
+        collateralValue = collateralValue.plus(
+          depositBorrowValue.suppliedValue.times(collateralRatio)
+        );
+      }
+      totalBorrowedValue = totalBorrowedValue.plus(depositBorrowValue.borrowedValue);
+    }
+    const ltv = totalBorrowedValue.div(totalSuppliedValue);
+    const liquidationThreshold = collateralValue.div(totalSuppliedValue);
+    return {
+      ltv,
+      liquidationThreshold,
+    };
+  }
+
   public async getNetApyWithoutIncentive(userAddress: types.Address): Promise<BigNumber> {
     let sum = new BigNumber(0);
     let totalSuppliedValue = new BigNumber(0);

package/src/types/index.ts

@@ -200,3 +200,27 @@ export type UserNotification = {
     liquidation: boolean;
   }[];
 };
+
+export type UserLiquidationHistorySubgraph = {
+  liquidationEvents: LiquidationEventSubgraph[];
+};
+
+export type LiquidationEventSubgraph = {
+  auTokenSymbol: string;
+  amount: number;
+  blockTime: number;
+  from: string;
+  id: string;
+  underlyingRepayAmount: number;
+  underlyingRepayAmountUSD: number;
+  underlyingSymbol: string;
+};
+
+export type LiquidationDetail = {
+  liquidationTime: Timestamp;
+  tokenAmount: TokenAmount;
+  value: CurrencyAmount;
+  transactionId: string;
+};
+
+export type Timestamp = number;