@aurigami/sdk 1.24.0 → 1.24.1

package/src/helpers/historicalPriceFetcher.ts

@@ -1,200 +0,0 @@
-import { IUniswapV2Pair, PriceOracle } from '@aurigami/contracts/typechain';
-import BigNumber from 'bignumber.js';
-import { BigNumber as BN, providers } from 'ethers';
-import { AuriOracleABI, IUniswapV2PairABI } from '../abis';
-import { HARDCODE_PRICE_TOKENS, networkAddresses } from '../consts/constants';
-import { Address } from '../types';
-import { decimalFactor, devLog, getDecimal, isSameAddress } from './helpers';
-import { createContract } from './multicall';
-
-export async function fetchHistoricalLPPositions(
-  LPAddress: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<{
-  token0: Address;
-  token1: Address;
-  reserve0: BN;
-  reserve1: BN;
-  totalSupply: BN;
-}> {
-  const LPContract = createContract<IUniswapV2Pair>(LPAddress, IUniswapV2PairABI.abi, provider);
-  var promises: any[] = [];
-  promises.push(LPContract.callStatic.token0());
-  promises.push(LPContract.callStatic.token1());
-  promises.push(LPContract.callStatic.getReserves({ blockTag: block }));
-  promises.push(LPContract.callStatic.totalSupply({ blockTag: block }));
-  const values: any[] = await Promise.all(promises);
-
-  return {
-    token0: values[0] as string,
-    token1: values[1] as string,
-    reserve0: (values[2] as { reserve0: BN; reserve1: BN }).reserve0,
-    reserve1: (values[2] as { reserve0: BN; reserve1: BN }).reserve1,
-    totalSupply: values[3] as BN,
-  };
-}
-
-export async function fetchHistoricalLPPrice(
-  address: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  var LPInfo = await fetchHistoricalLPPositions(address, provider, block);
-  const LPDecimal = getDecimal(address);
-
-  async function fetchLPPriceBy(
-    tokenReverse: {
-      address: string;
-      reserve: BN;
-    },
-    block: number
-  ): Promise<BigNumber> {
-    if (tokenReverse.reserve.isZero()) return new BigNumber(0);
-
-    const tokenPrice: BigNumber = await fetchHistoricalPrice(tokenReverse.address, provider, block);
-    const tokenDecimal = getDecimal(tokenReverse.address);
-
-    // reserveUSD will be divided by 10^tokenDecimal later for more precision
-    const reserveUSD: BigNumber = tokenPrice
-      .multipliedBy(tokenReverse.reserve.toString())
-      .multipliedBy(2);
-    return reserveUSD
-      .multipliedBy(decimalFactor(LPDecimal))
-      .dividedBy(new BigNumber(LPInfo.totalSupply.toString()))
-      .dividedBy(decimalFactor(tokenDecimal));
-  }
-
-  try {
-    // MUST await here
-    const lpPrice = await fetchLPPriceBy(
-      {
-        address: LPInfo.token0,
-        reserve: LPInfo.reserve0,
-      },
-      block
-    );
-    if (lpPrice.isZero()) {
-      throw Error(`Price is zero`);
-    }
-    return lpPrice;
-  } catch (e) {
-    devLog(`fetchLPPriceBy ${LPInfo.token0} failed`, e);
-    try {
-      // MUST await here
-      return await fetchLPPriceBy(
-        {
-          address: LPInfo.token1,
-          reserve: LPInfo.reserve1,
-        },
-        block
-      );
-    } catch (e) {
-      devLog(`fetchLPPriceBy ${LPInfo.token1} failed`, e);
-      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 fetchHistoricalPriceFromOracle(
-  auTokenAddress: Address,
-  underlyingDecimal: number,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  // from this block, we switch to use pyth
-  // TODO: add to consts
-  const oracleAddress =
-    block < 102438637
-      ? networkAddresses.misc.DEPRECATED_OLD_ORACLE
-      : networkAddresses.misc.PYTH_ORACLE;
-
-  const oracleContract = createContract<PriceOracle>(oracleAddress, AuriOracleABI.abi, provider);
-  const rawPrice = await oracleContract.callStatic
-    .getUnderlyingPrice(auTokenAddress, { blockTag: block })
-    .catch((e: any) => {
-      console.log(`Unable to fetch price from oracle for ${auTokenAddress}`);
-      return BN.from(0);
-    });
-
-  return processPriceFromOracle(rawPrice, underlyingDecimal);
-}
-
-export async function fetchHistoricalPrice(
-  address: Address,
-  provider: providers.Provider,
-  block: number
-): Promise<BigNumber> {
-  if (address.toLowerCase() in HARDCODE_PRICE_TOKENS) {
-    return new BigNumber(HARDCODE_PRICE_TOKENS[address.toLowerCase()]);
-  } else if (
-    isSameAddress(address, networkAddresses.tokens.PLY_WNEAR) ||
-    isSameAddress(address, networkAddresses.tokens.WNEAR_TRI) ||
-    isSameAddress(address, networkAddresses.tokens.AURORA_WNEAR)
-  ) {
-    return fetchHistoricalLPPrice(address, provider, block);
-  } else if (isSameAddress(address, networkAddresses.tokens.PLY)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.PLY_WNEAR, provider, block);
-  } else if (isSameAddress(address, networkAddresses.tokens.TRI)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.WNEAR_TRI, provider, block, 1);
-  } else if (isSameAddress(address, networkAddresses.tokens.AURORA)) {
-    return fetchHistoricalPriceByLP(networkAddresses.tokens.AURORA_WNEAR, provider, block);
-  }
-
-  const matchingAuToken = networkAddresses.auTokens.find((auToken) => {
-    return isSameAddress(auToken.underlying, address);
-  });
-
-  if (matchingAuToken !== undefined) {
-    return fetchHistoricalPriceFromOracle(
-      matchingAuToken.address,
-      getDecimal(address),
-      provider,
-      block
-    );
-  } else {
-    throw Error(`Unable to fetch price for ${address}`);
-  }
-}
-
-export async function fetchHistoricalPULPPrice(provider: providers.Provider): Promise<BigNumber> {
-  //TODO: Calculate PULP price
-  return new BigNumber(0);
-}
-
-export async function fetchHistoricalPriceByLP(
-  LP: Address,
-  provider: providers.Provider,
-  block: number,
-  tokenNumber: 0 | 1 = 0
-): Promise<BigNumber> {
-  let LPInfo = await fetchHistoricalLPPositions(LP, provider, block);
-
-  if (tokenNumber === 1) {
-    LPInfo = {
-      token0: LPInfo.token1,
-      token1: LPInfo.token0,
-      reserve0: LPInfo.reserve1,
-      reserve1: LPInfo.reserve0,
-      totalSupply: LPInfo.totalSupply,
-    };
-  }
-
-  if (LPInfo.reserve1.isZero()) {
-    return new BigNumber(0);
-  }
-
-  const token0Decimal = getDecimal(LPInfo.token0);
-  const token1Decimal = getDecimal(LPInfo.token1);
-
-  // (token0Price * reserve0) / 10^decimal0 = (token1Price * reserve1) / 10^decimal1
-  // token0Price = (token1Price * reserve1) * 10^decimal0 / 10^decimal1  / reserve0
-  return (await fetchHistoricalPrice(LPInfo.token1, provider, block))
-    .multipliedBy(LPInfo.reserve1.toString())
-    .multipliedBy(decimalFactor(token0Decimal))
-    .dividedBy(decimalFactor(token1Decimal))
-    .dividedBy(LPInfo.reserve0.toString());
-}

package/src/helpers/index.ts

@@ -1,7 +0,0 @@
-export * from './aurigami-api';
-export * from './aurora-api-helpers';
-export * from './graphql-helpers';
-export * from './helpers';
-export * from './priceFetcher';
-export * from './transfer-event-query';
-export * from './historicalPriceFetcher';

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

@@ -1,37 +0,0 @@
-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/multicall.ts

@@ -1,251 +0,0 @@
-import type { BlockTag } from '@ethersproject/abstract-provider';
-import type { Provider } from '@ethersproject/providers';
-
-import { CallOverrides, Contract, ContractInterface, Signer } from 'ethers';
-import { FunctionFragment, Interface } from 'ethers/lib/utils';
-import { Multicall2ABI } from '../abis';
-import { MulticallOverrides, MulticallStatic } from '../types';
-
-// export const MULTICALL_ADDRESSES: Record<ChainId, Address> = {
-//     [CHAIN_ID_MAPPING.ETHEREUM]: toAddress('0x5ba1e12693dc8f9c48aad8770482f4739beed696'),
-//     [CHAIN_ID_MAPPING.FUJI]: toAddress('0x07e46d95cc98f0d7493d679e89e396ea99020185'),
-//     [CHAIN_ID_MAPPING.MUMBAI]: toAddress('0x7De28d05a0781122565F3b49aA60331ced983a19'),
-//     [CHAIN_ID_MAPPING.ARBITRUM]: toAddress('0xcA11bde05977b3631167028862bE2a173976CA11'),
-// } as const;
-
-/**
- * Multicall implementation, allowing to call function of contract.callStatic functions
- * using multicall with Promise (without overrides).
- *
- * Example usage:
- *     const multicall = new Multicall({
- *          chainId,
- *          provider,
- *     });
- *     const contract = new Contract(address, PendleERC20ABI, networkConnection.provider) as PendleERC20;
- *
- *     // very small interface changes
- *     const balance = await multicall.wrap(contract).callStatic.balanceOf(userAddress);
- *
- *     // multiple calls
- *     const users = [addr1, addr2, addr3];
- *     const balances = await Promise.all(user.map((addr) => multicall.wrap(contract).callStatic.balanceOf(addr)));
- *
- * ### Result caching
- * Multicall#wrap will cache the result right in the contract object. To access the cache result without
- * calling the wrap function, use
- *
- *      contract[multicall.multicallStaticSymbol]
- *
- * Note that the field `multicallStaticSymbol` is **not** static, but local to the multicall instance.
- */
-
-const TRANSFORMER = new Interface([]);
-export const DEFAULT_CALL_LIMIT = 32;
-
-class ContractCall {
-  fragment: FunctionFragment;
-  address: string;
-  params: any[];
-
-  constructor({
-    fragment,
-    address,
-    params,
-  }: {
-    fragment: FunctionFragment;
-    address: string;
-    params: any[];
-  }) {
-    this.fragment = fragment;
-    this.address = address;
-    this.params = params;
-  }
-}
-
-export class Multicall {
-  static isMulticallOverrides(
-    overrides?: CallOverrides
-  ): overrides is MulticallOverrides | undefined {
-    if (overrides === undefined) {
-      return true;
-    }
-    for (const key of Object.keys(overrides)) {
-      if (key !== 'blockTag' && (overrides as any)[key] != undefined) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  private multicallContract: Contract;
-  public readonly batchMap = new Map<BlockTag, MulticallBatch>();
-  readonly callLimit: number;
-
-  // Note: this symbol is unique for each Multicall instance
-  readonly multicallStaticSymbol = Symbol.for('multicallStatic');
-
-  /**
-   * Perform _soft_ wrapping. If muticall is presented, multicall.wrap(contract) will be returned.
-   * Otherwise the contract itself will be returned. Note that this function is also type-safe,
-   * that is, even if the contract is returned, the user is disallowed to call functions
-   * with overrides.
-   *
-   * This function is useful in case where the user when to choose whether to use multicall
-   * by themselves.
-   */
-  static wrap<T extends Contract>(
-    contract: T,
-    multicall: Multicall | undefined
-  ): MulticallStatic<T> {
-    return multicall ? multicall.wrap(contract) : (contract as unknown as MulticallStatic<T>);
-  }
-
-  constructor({
-    address,
-    provider,
-    callLimit,
-  }: {
-    address: string;
-    provider: Provider | Signer;
-    callLimit?: number;
-  }) {
-    this.multicallContract = new Contract(address, Multicall2ABI.abi, provider);
-    this.callLimit = callLimit ?? DEFAULT_CALL_LIMIT;
-  }
-
-  async doAggregateCalls(calls: readonly ContractCall[], blockTag: BlockTag) {
-    const callRequests = calls.map((call) => ({
-      target: call.address,
-      callData: TRANSFORMER.encodeFunctionData(call.fragment, call.params),
-    }));
-
-    const responses = await this.multicallContract.callStatic.tryAggregate(false, callRequests, {
-      blockTag: blockTag,
-    });
-
-    const result = calls.map((call, i) => {
-      const [success, returnData] = responses[i];
-
-      try {
-        const outputs: any[] = call.fragment.outputs!;
-        const params = TRANSFORMER.decodeFunctionResult(call.fragment, returnData);
-
-        // If we do the !success check before the decode, we cannot get the error message of
-        // decodeFunctionResult. So we always decode first, then check the success later.
-        if (!success) {
-          const callId = FunctionFragment.from(call.fragment).format();
-          throw new Error(`Call ${call.address}:${callId} failed`);
-        }
-
-        return outputs.length === 1 ? params[0] : params;
-      } catch (e: any) {
-        if (e.reason == null) {
-          e.reason = 'Call failed for unknown reason';
-        }
-        return e;
-      }
-    });
-
-    return result;
-  }
-
-  wrap<T extends Contract>(contract_: T): MulticallStatic<T> {
-    const contract = contract_ as T & { [key in symbol]: MulticallStatic<T> };
-    if (contract[this.multicallStaticSymbol]) {
-      return contract[this.multicallStaticSymbol];
-    }
-    const functions = contract_.interface.functions;
-    const funcs: Record<string, (...args: any[]) => Promise<any>> = {};
-
-    for (const [_, fn] of Object.entries(functions)) {
-      funcs[fn.name] = async (...params: any[]) => {
-        let blockTag: BlockTag = 'latest';
-        if (params.length === fn.inputs.length + 1) {
-          const overrides: MulticallOverrides = params.pop() ?? {};
-          if (!Multicall.isMulticallOverrides(overrides)) {
-            throw new Error('Overrides for multicall should contain only blockTag property');
-          }
-          blockTag = (await overrides.blockTag) ?? 'latest';
-        }
-
-        const contractCall = new ContractCall({
-          fragment: fn,
-          address: contract.address,
-          params,
-        });
-        const res = new Promise((resolve, reject) => {
-          let currentBatch = this.batchMap.get(blockTag);
-          if (currentBatch === undefined) {
-            currentBatch = new MulticallBatch(this, blockTag);
-            this.batchMap.set(blockTag, currentBatch);
-          }
-          const dataPos = currentBatch.pendingContractCalls.length;
-          currentBatch.pendingContractCalls.push(contractCall);
-          currentBatch.promise
-            .then((currentResult) =>
-              currentResult[dataPos] instanceof Error
-                ? reject(currentResult[dataPos])
-                : resolve(currentResult[dataPos])
-            )
-            .catch(reject);
-          if (currentBatch.pendingContractCalls.length >= this.callLimit) {
-            this.batchMap.delete(blockTag);
-          }
-        });
-
-        return res;
-      };
-    }
-
-    const res = {
-      callStatic: funcs,
-      address: contract.address,
-      raw: contract,
-    } as unknown as MulticallStatic<T>;
-
-    // Do this to avoid typescript error.
-    Object.assign(contract, { [this.multicallStaticSymbol]: res });
-
-    return res;
-  }
-}
-
-class MulticallBatch {
-  readonly pendingContractCalls: ContractCall[] = [];
-  readonly promise: Promise<any[]>;
-
-  constructor(
-    private readonly multicallInstance: Multicall,
-    readonly blockTag: BlockTag = 'latest'
-  ) {
-    this.promise = Promise.resolve().then(async () => {
-      // effects
-
-      // instance comparison
-      if (this.multicallInstance.batchMap.get(this.blockTag) === this) {
-        this.multicallInstance.batchMap.delete(this.blockTag);
-      }
-
-      // interactions
-      return this.multicallInstance.doAggregateCalls(this.pendingContractCalls, this.blockTag);
-    });
-  }
-}
-
-let multicall: Multicall | undefined;
-
-export function createContract<T extends Contract>(
-  addressOrName: string,
-  contractInterface: ContractInterface,
-  signerOrProvider: Signer | Provider
-) {
-  const contract = new Contract(addressOrName, contractInterface, signerOrProvider) as T;
-  if (!multicall) {
-    multicall = new Multicall({
-      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
-      provider: signerOrProvider,
-    });
-  }
-  return Multicall.wrap(contract, multicall);
-}

package/src/helpers/notification-api.ts

@@ -1,22 +0,0 @@
-import axios from 'axios';
-
-const NOTIFICATION_API_END_POINT = 'https://api.aurigami.finance/notification/';
-
-export async function getApi(url: string, params: Record<string, any> = {}): Promise<any> {
-  const resp = await axios.get(
-    NOTIFICATION_API_END_POINT + url + '?' + new URLSearchParams(params),
-    {
-      headers: { 'Content-Type': 'application/json' },
-    }
-  );
-
-  return resp.data;
-}
-
-export async function postApi(url: string, body: Record<string, any>): Promise<any> {
-  const resp = await axios.post(NOTIFICATION_API_END_POINT + url, body, {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data;
-}

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

@@ -1,45 +0,0 @@
-// 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;
-};