@aurigami/sdk 0.1.6 → 0.2.3

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,14 +1,7 @@
-import { Token } from '@pendle/sdk-core';
+import BigNumber from 'bignumber.js';
 // import ethers from 'ethers';
 const ethers = require('ethers');
 import { Signer } from 'ethers';
-export const DOLLAR = new Token({
-  chainId: 43114,
-  decimal: 2,
-  symbol: 'USDC',
-  address: '0x0000000000000000000000000000000000000001',
-});
-
 export const AVAX_DEFAULT_PROVIDER_URL =
   'https://api.avax.network/ext/bc/C/rpc';
 
@@ -16,6 +9,80 @@ 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 ONE_YEAR = ONE_DAY * 365;
+
+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/dummy.ts

@@ -1,49 +1,35 @@
-import { Token, CurrencyAmount } from '@pendle/sdk-core';
+import { Token } from './token';
+import { TokenAmount } from './tokenAmount';
 import { UserMarketDetails } from './types';
 
-export const dummyToken = new Token({
-  chainId: 43114,
-  decimal: 6,
-  symbol: 'USDC',
-  address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-});
-
-export const dummyPly = new Token({
-  chainId: 43114,
-  decimal: 18,
-  symbol: 'QI',
-  address: '0x8729438eb15e2c8b576fcc6aecda6a148776c0f5',
-});
-
-export const dummyPlyAurora = new Token({
-  chainId: 43114,
-  decimal: 18,
-  symbol: 'QIWAVAX',
-  address: '0xE530dC2095Ef5653205CF5ea79F8979a7028065c',
-});
-
-export const dummyTokenAmount = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '123.456',
-  isRaw: false,
-});
-
-export const dummyZeroTokenAmount = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '0',
-});
-
-export const dummyTokenAmount2 = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '456.123',
-  isRaw: false,
-});
-
-export const dummyTokenAmount3 = new CurrencyAmount({
-  currency: dummyToken,
-  amount: '1000.123',
-  isRaw: false,
-});
+export const dummyToken = new Token('0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', 6);
+
+export const dummyPly = new Token('0x8729438eb15e2c8b576fcc6aecda6a148776c0f5', 18);
+
+export const dummyPlyAurora = new Token('0xE530dC2095Ef5653205CF5ea79F8979a7028065c', 18);
+
+export const dummyTokenAmount = new TokenAmount(
+  dummyToken,
+  '123.456',
+  false,
+);
+
+export const dummyZeroTokenAmount = new TokenAmount(
+  dummyToken,
+   '0',
+);
+
+export const dummyTokenAmount2 = new TokenAmount(
+  dummyToken,
+  '456.123',
+ false,
+);
+
+export const dummyTokenAmount3 = new TokenAmount(
+  dummyToken,
+  '1000.123',
+  false,
+);
 
 export const dummyMarketAddress = '0xbeb5d47a3f720ec0a390d04b4d41ed7d9688bc7f'; // qiUSDC
 

package/src/helpers.ts

@@ -1,3 +1,40 @@
+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 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: Address): Address {
+  try {
+    return utils.getAddress(address);
+  } catch (error) {
+    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 fetchPriceFromCoingeckoAPI(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 fetchPriceFromCoingecko(address: Address): Promise<BigNumber> {
+    if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
+        return fetchPriceFromCoingeckoAPI('aurora-near');
+    } else {
+        throw Error(`Unknown token ${address} in fetchPriceFromCoingecko`);
+    }
+}
+
+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 fetchPriceFromCoingecko(address);
+    }
+}
+export async function fetchValuation(tokenAmount: TokenAmount, provider: providers.Provider, price?: BigNumber): Promise<BigNumber> {
+    return new BigNumber(0)
+}

package/src/token.ts

@@ -0,0 +1,21 @@
+import { getDecimal } from "./helpers";
+import { networkAddresses } from "./constants";
+
+export class Token {
+    public readonly address: string;
+    public readonly decimals: number;  
+    public constructor(address: string, decimals: number) {
+      this.address = address.toLowerCase();
+      this.decimals = decimals;
+    }  
+}
+
+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/tokenAmount.ts

@@ -0,0 +1,29 @@
+import { Token } from "./token";
+import BigNumber from 'bignumber.js';
+import { decimalFactor } from "./helpers";
+
+export class TokenAmount {
+    public readonly token: Token;
+    private rawAmnt: string;
+
+    public constructor(token: Token, amount: string, isRaw: boolean = true) {
+        if (isRaw) {
+            this.rawAmnt = amount;
+        } else {
+            this.rawAmnt = new BigNumber(amount)
+                .times(decimalFactor(token.decimals))
+                .toFixed(0);
+        }
+        this.token = token;
+    }
+
+    public formattedAmount(): string {
+        return new BigNumber(this.rawAmnt)
+            .div(decimalFactor(this.token.decimals))
+            .toString();
+    }
+
+    public rawAmount(): string {
+        return this.rawAmnt;
+    }
+}