@aurigami/sdk 1.18.3 → 1.18.4

package/package.json

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

package/src/consts/constants.ts

@@ -186,3 +186,7 @@ export const REFERRAL_CAMPAIGNS: { [k: string]: { start: number; end: number } }
 export const CACHE_TIMEOUT = 10 * 1000; // 10 seconds
 
 export const SD_INCENTIVE_IN_SD = 83.35;
+
+export const STADER_ETH = '0x30D20208d987713f46DFD34EF128Bb16C404D10f'.toLowerCase();
+
+export const USDT_ETH = '0xdAC17F958D2ee523a2206206994597C13D831ec7'.toLowerCase();

package/src/helpers/kyber-aggregator-api.ts

@@ -0,0 +1,37 @@
+import axios from 'axios';
+
+const KYBER_AGGREGATOR_AURORA_API_END_POINT =
+  'https://aggregator-api.kyberswap.com/aurora/route/encode';
+
+const KYBER_AGGREGATOR_ETH_API_END_POINT =
+  'https://aggregator-api.kyberswap.com/ethereum/route/encode';
+
+export async function getSwapInfo(
+  tokenIn: string,
+  tokenOut: string,
+  amountIn: string,
+  onAurora = true
+): Promise<KyberApiResponse> {
+  const params = {
+    tokenIn,
+    tokenOut,
+    amountIn,
+    to: '0x0000000000000000000000000000000000000000',
+    useMeta: '1',
+    saveGas: '1',
+    gasInclude: '1',
+  };
+  const endpoint = onAurora
+    ? KYBER_AGGREGATOR_AURORA_API_END_POINT
+    : KYBER_AGGREGATOR_ETH_API_END_POINT;
+  const resp = await axios.get(endpoint + '?' + new URLSearchParams(params), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  return resp.data;
+}
+
+export type KyberApiResponse = {
+  inputAmount: string;
+  outputAmount: string;
+};

package/src/helpers/one-inch-aggregator-api.ts

@@ -0,0 +1,45 @@
+// https://api.1inch.io/v5.0/1313161554/quote?fromTokenAddress=0x8bec47865ade3b172a928df8f990bc7f2a3b9f79&toTokenAddress=0x4988a896b1227218e4a686fde5eabdcabd91571f&amount=1000000000000000000
+
+import axios from 'axios';
+
+const ONEINCH_AGGREGATOR_API_END_POINT = 'https://api.1inch.io/v5.0/1313161554/quote';
+
+export async function getQuoteOneInch(
+  fromTokenAddress: string,
+  toTokenAddress: string,
+  amount: string
+): Promise<OneInchApiResponse> {
+  const params = {
+    fromTokenAddress,
+    toTokenAddress,
+    amount,
+  };
+  const resp = await axios.get(
+    ONEINCH_AGGREGATOR_API_END_POINT + '?' + new URLSearchParams(params),
+    {
+      headers: { 'Content-Type': 'application/json' },
+    }
+  );
+  return resp.data;
+}
+
+export type OneInchApiResponse = {
+  fromToken: {
+    symbol: string;
+    name: string;
+    decimals: number;
+    address: string;
+    logoURI: string;
+    tags: string[];
+  };
+  toToken: {
+    symbol: string;
+    name: string;
+    decimals: number;
+    address: string;
+    logoURI: string;
+    tags: string[];
+  };
+  toTokenAmount: string;
+  fromTokenAmount: string;
+};

package/src/helpers/priceFetcher.ts

@@ -1,18 +1,63 @@
 import AuriLensABI from '@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json';
-import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
+import { ERC20, IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
 import axios from 'axios';
 import BigNumber from 'bignumber.js';
-import { BigNumber as BN, Contract, providers } from 'ethers';
-import { AuriOracleABI, IUniswapV2PairABI } from '../abis';
+import { BigNumber as BN, Contract, ethers, providers } from 'ethers';
+import { AuriOracleABI, EIP20InterfaceABI, IUniswapV2PairABI } from '../abis';
 import {
   DECIMAL_PRECISION,
   HARDCODE_PRICE_TOKENS,
   networkAddresses,
   PRICE_WHITELISTED,
+  STADER_ETH,
+  USDT_ETH,
 } from '../consts/constants';
 import { TokenAmount } from '../entities/tokenAmount';
 import { Address, TokenValuation } from '../types';
 import { assert, decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
+import { getSwapInfo } from './kyber-aggregator-api';
+import { getQuoteOneInch } from './one-inch-aggregator-api';
+
+export async function prepareParamsAggregator(address: string, provider: providers.Provider) {
+  const tokenInErc20 = new Contract(address, EIP20InterfaceABI.abi, provider) as ERC20;
+  const tokenInDecimal = await tokenInErc20.decimals();
+  const tokenInQuantity = BN.from(10).pow(tokenInDecimal).toString();
+  const usdtAddress =
+    networkAddresses.auTokens.find((autoken) => autoken.name == 'auUSDT')?.underlying ?? '';
+  const usdtDecimal = getDecimal(usdtAddress);
+  return {
+    tokenInQuantity,
+    usdtAddress,
+    usdtDecimal,
+  };
+}
+
+export async function fetchPriceFromOneInch(address: string, provider: providers.Provider) {
+  const { tokenInQuantity, usdtAddress, usdtDecimal } = await prepareParamsAggregator(
+    address,
+    provider
+  );
+  const info = await getQuoteOneInch(address, usdtAddress, tokenInQuantity);
+  const outputAmount = info.toTokenAmount;
+  return new BigNumber(outputAmount).dividedBy(10 ** usdtDecimal);
+}
+
+export async function fetchPriceFromKyberSwap(
+  address: string,
+  provider: providers.Provider,
+  onAurora = true
+) {
+  let { tokenInQuantity, usdtAddress, usdtDecimal } = await prepareParamsAggregator(
+    address,
+    provider
+  );
+  if (!onAurora) {
+    usdtAddress = USDT_ETH;
+  }
+  const info = await getSwapInfo(address, usdtAddress, tokenInQuantity, onAurora);
+  const outputAmount = info.outputAmount;
+  return new BigNumber(outputAmount).dividedBy(10 ** usdtDecimal);
+}
 
 export async function fetchPriceFromDefiLlamaAPI(id: string): Promise<BigNumber> {
   const price = await axios
@@ -225,7 +270,7 @@ export async function fetchUnderlyingTokensPrices(provider: providers.Provider):
   });
 }
 
-function shouldFetchFromCoingeckoOrDefiLlama(address: string) {
+function shouldFetchFromKyberSwap(address: string) {
   address = address.toLowerCase();
   return (
     address == networkAddresses.tokens.AURORA ||
@@ -243,12 +288,13 @@ async function _fetchPrice(address: Address, provider: providers.Provider): Prom
     PRICE_WHITELISTED.has(address.toLocaleLowerCase()),
     `Address ${address} is not whitelisted for price fetching`
   );
-  if (shouldFetchFromCoingeckoOrDefiLlama(address)) {
-    try {
-      return await fetchPriceFromCoingecko(address);
-    } catch (err) {
-      return fetchPriceFromDefiLlama(address);
+  if (shouldFetchFromKyberSwap(address)) {
+    if (address == networkAddresses.tokens.STADER) {
+      const ETH_PROVIDER = new ethers.providers.JsonRpcProvider('https://rpc.ankr.com/eth');
+
+      return fetchPriceFromKyberSwap(STADER_ETH, ETH_PROVIDER, false);
     }
+    return fetchPriceFromKyberSwap(address, provider);
   }
   const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
     return isSameAddress(auToken.underlying, address);