@aurigami/sdk 0.1.5 → 0.2.2

package/src/abis/Oracle.json

@@ -0,0 +1,247 @@
+{
+    "abi": [
+        {
+            "inputs": [],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "constructor"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "feed",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "string",
+                    "name": "symbol",
+                    "type": "string"
+                }
+            ],
+            "name": "FeedSet",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "oldAdmin",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "newAdmin",
+                    "type": "address"
+                }
+            ],
+            "name": "NewAdmin",
+            "type": "event"
+        },
+        {
+            "anonymous": false,
+            "inputs": [
+                {
+                    "indexed": false,
+                    "internalType": "address",
+                    "name": "asset",
+                    "type": "address"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "previousPriceMantissa",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "requestedPriceMantissa",
+                    "type": "uint256"
+                },
+                {
+                    "indexed": false,
+                    "internalType": "uint256",
+                    "name": "newPriceMantissa",
+                    "type": "uint256"
+                }
+            ],
+            "name": "PricePosted",
+            "type": "event"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "admin",
+            "outputs": [
+                {
+                    "internalType": "address",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "asset",
+                    "type": "address"
+                }
+            ],
+            "name": "assetPrices",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "internalType": "string",
+                    "name": "symbol",
+                    "type": "string"
+                }
+            ],
+            "name": "getFeed",
+            "outputs": [
+                {
+                    "internalType": "contract AggregatorV2V3Interface",
+                    "name": "",
+                    "type": "address"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [
+                {
+                    "internalType": "contract QiToken",
+                    "name": "qiToken",
+                    "type": "address"
+                }
+            ],
+            "name": "getUnderlyingPrice",
+            "outputs": [
+                {
+                    "internalType": "uint256",
+                    "name": "",
+                    "type": "uint256"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "constant": true,
+            "inputs": [],
+            "name": "isPriceOracle",
+            "outputs": [
+                {
+                    "internalType": "bool",
+                    "name": "",
+                    "type": "bool"
+                }
+            ],
+            "payable": false,
+            "stateMutability": "view",
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "newAdmin",
+                    "type": "address"
+                }
+            ],
+            "name": "setAdmin",
+            "outputs": [],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "internalType": "address",
+                    "name": "asset",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "price",
+                    "type": "uint256"
+                }
+            ],
+            "name": "setDirectPrice",
+            "outputs": [],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "internalType": "string",
+                    "name": "symbol",
+                    "type": "string"
+                },
+                {
+                    "internalType": "address",
+                    "name": "feed",
+                    "type": "address"
+                }
+            ],
+            "name": "setFeed",
+            "outputs": [],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "function"
+        },
+        {
+            "constant": false,
+            "inputs": [
+                {
+                    "internalType": "contract QiToken",
+                    "name": "qiToken",
+                    "type": "address"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "underlyingPriceMantissa",
+                    "type": "uint256"
+                }
+            ],
+            "name": "setUnderlyingPrice",
+            "outputs": [],
+            "payable": false,
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ]
+}

package/src/abis/dummy.json

@@ -0,0 +1,3 @@
+{
+    "abi": []
+}

package/src/constants.ts

@@ -1,11 +1,7 @@
-import { Token } from './token';
+import BigNumber from 'bignumber.js';
 // import ethers from 'ethers';
 const ethers = require('ethers');
 import { Signer } from 'ethers';
-export const DOLLAR = new Token(
-   '0x0000000000000000000000000000000000000001', 2
-);
-
 export const AVAX_DEFAULT_PROVIDER_URL =
   'https://api.avax.network/ext/bc/C/rpc';
 
@@ -13,6 +9,78 @@ export const AVAX_DEFAULT_PROVIDER = new ethers.providers.JsonRpcProvider(
   AVAX_DEFAULT_PROVIDER_URL
 );
 
+export const dummyAddress: string = "0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE";
+export const ETHAddress: string = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+
 const dummyPrivateKey =
   '1111111111111111111111111111111111111111111111111111111111111111';
 export const AVAX_DEFAULT_SIGNER: Signer = new ethers.Wallet(dummyPrivateKey);
+
+export const AURORA_CHAINID = 1313161554;
+
+export const DECIMAL_PRECISION = 6;
+
+export type NetworkAddresses = {
+  auTokens: {
+    address: string,
+    underlying: string
+  }[],
+  misc: Record<string, string>,
+  tokens: Record<string, string>
+}
+export const networkAddresses: NetworkAddresses = {
+  auTokens: [
+    {
+      address: '0x7967532568bef9ec96cfad6badea4c63add5888a',
+      underlying: '0x9738319d4b8a95a9b3cfd99419dbf859904f23d8'
+    },
+    {
+      address: '0x96AAD2c3fde982627d531f45D1Bebd8bE3b86f60',
+      underlying: ETHAddress
+    },
+    {
+      address: '0xccf005cfc3669d806a03f0617885648c397c456e',
+      underlying: '0x959bf9bf41062e9cac0e60cacbaa441fbc8946c6'
+    },
+    {
+      address: '0x55a4c111c007f39326edf22cfd63bbbb21a35b35',
+      underlying: '0x1c67cb984abdf7f0a6bce2fd5d5e662e0b983369'
+    },
+    {
+      address: '0x77b088236c071ab5bd4e0bd21240b093275adffc',
+      underlying: '0x675c7e1d48f88329c6b4cd3867db5f10a69cda18'
+    },
+    {
+      address: '0xaa68274f87fd9ae940f1dec31b643486838481c1',
+      underlying: '0x7a80df8230c5aa711e2702a275ab31aeb32754bf'
+    },
+    {
+      address: '0x6970167dfaa2aaa67404204102cbbd18b405eca9',
+      underlying: '0x1dc7d4990b1edb9a88f3fa7d899864b69ee2c428',
+    },
+    {
+      address: '0x9630a6c5b729194972199805075fd76707a9713a',
+      underlying: '0x6f8a1daa158e08f75711a64e5a3073e959d688a6'
+    }
+  ],
+  misc: {
+    COMPTROLLER: "0xb51028d4f3fc69e3f9e3118ce067a4562c595aad",
+    oracle: "0xf1ebfaa2af93f4d82215fd7817c1835853c62fb8",
+    AURIFAIRLAUNCH: "0x7942874a9ef8059c5de259625a883dc61f03320d",
+    AURILENS: '0xa2635a23a7688cd3acdd07713c4943b2f0f9082c'
+  },
+  tokens: {
+    AURORA: "0x7a80df8230c5aa711e2702a275ab31aeb32754bf",
+    PLY: "0x6f8a1daa158e08f75711a64e5a3073e959d688a6",
+    AURPLY: dummyAddress
+  }
+}
+
+export const BORROW_LIMIT_BUFFER = new BigNumber(0.95);
+
+export const REWARDCLAIMSTART = 1673280000;
+
+export const ONE_DAY = 86400;
+
+export const AurPlyPid = 1;
+

package/src/decimals.ts

@@ -0,0 +1,18 @@
+export const decimalRecords: Record<string, number> = {
+    '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
+    '0x9738319d4b8a95a9b3cfd99419dbf859904f23d8': 18,
+    '0x1dc7d4990b1edb9a88f3fa7d899864b69ee2c428': 18,
+    '0x1c67cb984abdf7f0a6bce2fd5d5e662e0b983369': 18,
+    '0x675c7e1d48f88329c6b4cd3867db5f10a69cda18': 18,
+    '0xaa68274f87fd9ae940f1dec31b643486838481c1': 8,
+    '0x96AAD2c3fde982627d531f45D1Bebd8bE3b86f60': 8,
+    '0x6970167dfaa2aaa67404204102cbbd18b405eca9': 8,
+    '0x6f8a1daa158e08f75711a64e5a3073e959d688a6': 18,
+    '0xccf005cfc3669d806a03f0617885648c397c456e': 8,
+    '0x959bf9bf41062e9cac0e60cacbaa441fbc8946c6': 18,
+    '0x7a80df8230c5aa711e2702a275ab31aeb32754bf': 18,
+    '0x9630a6c5b729194972199805075fd76707a9713a': 8,
+    '0x77b088236c071ab5bd4e0bd21240b093275adffc': 8,
+    '0x7967532568bef9ec96cfad6badea4c63add5888a': 8,
+    '0x55a4c111c007f39326edf22cfd63bbbb21a35b35': 8
+}

package/src/helpers.ts

@@ -1,18 +1,40 @@
-import { BigNumber as BN, utils } from "ethers";
+import BigNumber from "bignumber.js";
+import { BigNumber as BN, providers, utils } from "ethers";
+import { decimalRecords } from "./decimals";
+import { Address } from "./types";
+
 export function formatObject(object: Object) {
   return JSON.stringify(object, null, '  ');
 }
 
-export const decimalFactor = (decimal: number): string => {
-  return BN.from(10)
-    .pow(decimal)
-    .toString();
-};
+export function decimalFactor(decimal: number) {
+  return BN.from(10).pow(decimal).toString();
+}
+
+export const isSameAddress = (address1: Address, address2: Address): boolean => {
+  return address1.toLowerCase() == address2.toLowerCase()
+}
+
+export const getCurrentTimestamp = async (provider: providers.Provider): Promise<number> => {
+  const latestBlockNumber = await provider.getBlockNumber();
+  const currentTime: number = (await provider.getBlock(latestBlockNumber)).timestamp;
+  return currentTime;
+}
 
-export function validateAndParseAddress(address: string): string {
+export function validateAndParseAddress(address: Address): Address {
   try {
     return utils.getAddress(address);
   } catch (error) {
-    throw new Error("Invalid address " + address);
+    throw new Error("Invalid address: " + address);
+  }
+}
+
+export function getDecimal(address: Address): number {
+  return decimalRecords[address.toLowerCase()];
+}
+export function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNumber, frequencyPerYear: number): BigNumber {
+  if (totalStakeValue.lte(0)) { // avoid division by zero when there is no stake
+      return new BigNumber('999999999');
   }
+  return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
 }

package/src/index.ts

@@ -5,7 +5,7 @@ export * from './BlockchainEntity';
 export * from './helpers';
 export * from './constants';
 export * from './dummy';
-
-export function sum(a: number, b: number): number {
-  return a + b;
-}
+export * from './priceFetcher';
+export * from './token';
+export * from './tokenAmount';
+export * from './types';

package/src/priceFetcher.ts

@@ -0,0 +1,108 @@
+import BigNumber from "bignumber.js";
+import { Contract, providers, BigNumber as BN } from "ethers";
+import { networkAddresses } from "./constants";
+import OracleABI from "./abis/Oracle.json";
+import { isSameAddress, decimalFactor, getDecimal } from "./helpers";
+import { PriceOracle } from "@aurigami/contracts/typechain";
+import { TokenAmount } from "./tokenAmount";
+import { Address } from "./types";
+import IUniswapV2PairABI from './abis/IUniswapV2Pair.json';
+import dummyABI from "./abis/dummy.json";
+
+const axios = require('axios')
+
+export async function fetchPriceFromCoingecko(id: string): Promise<BigNumber> {
+    const price = await axios.get(
+      `https://api.coingecko.com/api/v3/simple/price?ids=${id}&vs_currencies=usd`
+    ).then((res: any) => {
+      return res.data
+    })
+  
+    return new BigNumber(price[id].usd)
+}
+
+export async function fetchBasicTokenPrice(address: Address): Promise<BigNumber> {
+    if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
+        return fetchPriceFromCoingecko('aurora-near');
+    } else {
+        throw Error(`Unknown token ${address} in fetchBasicTokenPrice`);
+    }
+}
+
+export async function fetchLPPositions(LPAddress: Address, provider: providers.Provider): Promise<{
+    token0: Address,
+    token1: Address,
+    reserve0: BN,
+    reserve1: BN,
+    totalSupply: BN
+}> {
+    var promises = [];
+    const LPContract = new Contract(LPAddress, IUniswapV2PairABI.abi, provider);
+    promises.push(LPContract.token0());
+    promises.push(LPContract.toekn1());
+    promises.push(LPContract.getReserves());
+    promises.push(LPContract.totalSupply());
+    const values = await Promise.all(promises);
+    return {
+        token0: values[0],
+        token1: values[1],
+        reserve0: values[2]._reserve0,
+        reserve1: values[2]._reserve1,
+        totalSupply: values[3]
+    }
+}
+
+export async function fetchLPPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
+    var LPInfo = await fetchLPPositions(address, provider);
+    try {
+      const token0Price: BigNumber = await fetchPrice(LPInfo.token0, provider);
+      const reserveUSD: BigNumber = token0Price.multipliedBy(LPInfo.reserve0.toString()).multipliedBy(2);
+      return reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString()));
+    } catch {
+      try {
+        const token1Price: BigNumber = await fetchPrice(LPInfo.token1, provider);
+        const reserveUSD: BigNumber = token1Price.multipliedBy(LPInfo.reserve1.toString()).multipliedBy(2);
+        return reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString()));
+    } catch {
+        throw Error(`Unable to fetch price for both tokens of LP ${address}`);
+      }
+    }
+  }
+
+function processPriceFromOracle(rawPrice: BN, underlyingDecimal: number) {
+    return new BigNumber(rawPrice.toString()).div(decimalFactor(36 - underlyingDecimal));
+}
+export async function fetchPriceFromOracle(auTokenAddress: Address, underlyingDecimal: number, provider: providers.Provider): Promise<BigNumber> {
+    const oracleContract: PriceOracle = new Contract(networkAddresses.misc.oracle, OracleABI.abi, provider) as PriceOracle;
+    const rawPrice = await oracleContract.getUnderlyingPrice(auTokenAddress);
+    return processPriceFromOracle(rawPrice, underlyingDecimal)
+}
+
+export async function fetchUnderlyingTokensPrices(provider: providers.Provider) {
+    const auriLens: Contract = new Contract(networkAddresses.misc.AURILENS, dummyABI.abi, provider);
+    const auTokenAddresses = networkAddresses.auTokens.map((auToken) => auToken.address);
+    const underlyingDecimals = networkAddresses.auTokens.map((auToken) => getDecimal(auToken.underlying));
+    const rawPrices = await auriLens.auTokenUnderlyingPriceAll(auTokenAddresses);
+    return rawPrices.map((res: any, ind: number) => {
+        return {
+            auToken: res.auToken,
+            underlyingPrice: processPriceFromOracle(res.underlyingPrice, underlyingDecimals[ind])
+        }
+    })
+}
+
+export async function fetchPrice(address: Address, provider: providers.Provider): Promise<BigNumber> {
+    const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
+        return isSameAddress(auToken.underlying, address)
+    });
+    if (matchingAuToken !== undefined) {
+        return fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider);
+    } else if (isSameAddress(address, networkAddresses.misc.AUPLYLP)) {
+        return fetchLPPrice(address, provider);
+    } else {
+        return fetchBasicTokenPrice(address);
+    }
+}
+export async function fetchValuation(tokenAmount: TokenAmount, provider: providers.Provider, price?: BigNumber): Promise<BigNumber> {
+    return new BigNumber(0)
+}

package/src/token.ts

@@ -1,11 +1,21 @@
+import { getDecimal } from "./helpers";
+import { networkAddresses } from "./constants";
+
 export class Token {
     public readonly address: string;
-    public readonly decimals: number;
-    public readonly expiry?: number;
-  
-    public constructor(address: string, decimals: number, expiry?: number) {
+    public readonly decimals: number;  
+    public constructor(address: string, decimals: number) {
       this.address = address.toLowerCase();
       this.decimals = decimals;
-      this.expiry = expiry;
     }  
-}
+}
+
+export const PLYToken = new Token(
+    networkAddresses.tokens.PLY,
+    getDecimal(networkAddresses.tokens.PLY)
+)
+    
+export const AURPLYToken = new Token(
+    networkAddresses.tokens.AURPLY,
+    getDecimal(networkAddresses.tokens.AURPLY)
+)

package/src/types.ts

@@ -1,12 +1,22 @@
 import type { providers, Signer } from 'ethers';
-import { CurrencyAmount } from '@pendle/sdk-core';
+import { TokenAmount } from './tokenAmount';
 
-export type ProviderOrSigner = providers.Provider | Signer;
+export type NetworkConnection = {
+  provider: providers.Provider,
+  signer?: Signer
+}
+
+export type Address = string;
+
+export type CurrencyAmount = {
+  currency: string,
+  amount: string
+};
 
 export type MoneyMarketDetails = {
   auTokenAddress: string;
-  totalTokenDeposited: CurrencyAmount;
-  totalTokenBorrowed: CurrencyAmount;
+  totalTokenDeposited: TokenAmount;
+  totalTokenBorrowed: TokenAmount;
   depositApy: number;
   depositPlyApy: number;
   borrowApy: number;
@@ -17,8 +27,8 @@ export type MoneyMarketDetails = {
 export type UserDetails = {
   markets: UserMarketDetails[];
   borrowLimit: CurrencyAmount;
-  accruedPly: CurrencyAmount;
-  lockedPly: CurrencyAmount;
+  accruedPly: TokenAmount;
+  lockedPly: TokenAmount;
   borrowableAmount: CurrencyAmount;
 };
 
@@ -35,13 +45,13 @@ export type PlyAuroraPool = {
 
 export type UserMarketDetails = {
   market: string;
-  depositBalance: CurrencyAmount;
-  borrowBalance: CurrencyAmount;
+  depositBalance: TokenAmount;
+  borrowBalance: TokenAmount;
   isCollateral: boolean;
-  maxWithdrawableAmount: CurrencyAmount;
+  maxWithdrawableAmount: TokenAmount;
 };
 
 export type PlyAuroraPoolDetails = {
-  totalStakedLiquidity: CurrencyAmount;
-  apy: number;
-};
+  totalStakedLiquidity: TokenAmount;
+  apy: string;
+};