@aurigami/sdk 1.23.1 → 1.24.1

package/src/entities/auriEnv.ts

@@ -1,178 +0,0 @@
-import {
-  AuErc20,
-  AuriAirdrop,
-  AuriFairLaunch,
-  AuriInternalLens,
-  AuriLens,
-  AuriOracle,
-  Comptroller,
-  IERC20,
-  PULP,
-  PlyGame,
-  PlyTokenLock,
-  ReferralDirectoryV2,
-} from '@aurigami/contracts/typechain';
-import { Contract } from 'ethers';
-import * as abis from '../abis';
-import { networkAddresses } from '../consts/constants';
-import { assert } from '../helpers/helpers';
-import { AuTokenWithUnderlying } from '../types';
-import { BlockchainEntityRead } from './BlockchainEntity';
-
-export class AuriEnv extends BlockchainEntityRead {
-  private _comptroller: Comptroller | null = null;
-  private _auriFairLaunch: AuriFairLaunch | null = null;
-  private _auriLens: AuriLens | null = null;
-  private _ply: IERC20 | null = null;
-  private _pulp: PULP | null = null;
-  private _auriInternalLens: AuriInternalLens | null = null;
-  private _auriAirdrop: AuriAirdrop | null = null;
-  private _referralDirectoryV2: ReferralDirectoryV2 | null = null;
-  private _oracle: AuriOracle | null = null;
-  private _plygame: PlyGame | null = null;
-  private _plyTokenLock: PlyTokenLock | null = null;
-
-  public getContract<CType extends Contract>(address: string, abi: any) {
-    return new Contract(address, abi, this._networkConnection.provider) as CType;
-  }
-
-  public getAuTokenContracts(): AuTokenWithUnderlying[] {
-    return networkAddresses.auTokens.map((auToken) => {
-      const contract = this.getContract<AuTokenWithUnderlying>(
-        auToken.address,
-        abis.AuTokenABI.abi
-      );
-      contract.underlying = auToken.underlying;
-      return contract;
-    });
-  }
-
-  /**
-   * Get AuErc20 contract by its address or underlying name.
-   *
-   * Either address or underlyingName must be provided
-   *
-   */
-  public getAuErc20Contract({
-    address,
-    underlyingName,
-  }: {
-    address?: string;
-    underlyingName?: string;
-  }): AuErc20 {
-    assert(
-      address !== undefined || underlyingName !== undefined,
-      'Either address or underlyingName must be provided'
-    );
-
-    if (underlyingName) {
-      address = networkAddresses.auTokens.find(
-        (auToken) => auToken.name == 'au' + underlyingName
-      )?.address;
-      assert(address !== undefined, `AuToken with underlying ${underlyingName} not found`);
-    }
-
-    return this.getContract<AuErc20>(address!, abis.AuErc20ABI.abi);
-  }
-
-  get comptroller(): Comptroller {
-    if (!this._comptroller) {
-      this._comptroller = this.getContract<Comptroller>(
-        networkAddresses.misc.COMPTROLLER,
-        abis.ComptrollerABI.abi
-      );
-    }
-    return this._comptroller;
-  }
-
-  get auriFairLaunch(): AuriFairLaunch {
-    if (!this._auriFairLaunch) {
-      this._auriFairLaunch = this.getContract<AuriFairLaunch>(
-        networkAddresses.misc.AURIFAIRLAUNCH,
-        abis.AuriFairLaunchABI.abi
-      );
-    }
-    return this._auriFairLaunch;
-  }
-
-  get auriLens(): AuriLens {
-    if (!this._auriLens) {
-      this._auriLens = this.getContract<AuriLens>(
-        networkAddresses.misc.AURILENS,
-        abis.AuriLensABI.abi
-      );
-    }
-    return this._auriLens;
-  }
-
-  get ply(): IERC20 {
-    if (!this._ply) {
-      this._ply = this.getContract<IERC20>(networkAddresses.tokens.PLY, abis.EIP20InterfaceABI.abi);
-    }
-    return this._ply;
-  }
-
-  get pulp(): PULP {
-    if (!this._pulp) {
-      this._pulp = this.getContract<PULP>(networkAddresses.tokens.PULP, abis.PulpABI.abi);
-    }
-    return this._pulp;
-  }
-
-  get auriInternalLens(): AuriInternalLens {
-    if (!this._auriInternalLens) {
-      this._auriInternalLens = this.getContract<AuriInternalLens>(
-        networkAddresses.misc.AURI_INTERNAL_LENS,
-        abis.AuriInternalLensABI.abi
-      );
-    }
-    return this._auriInternalLens;
-  }
-
-  get auriAirdrop(): AuriAirdrop {
-    if (!this._auriAirdrop) {
-      this._auriAirdrop = this.getContract<AuriAirdrop>(
-        networkAddresses.misc.AURI_AIRDROP,
-        abis.AuriAirdropABI.abi
-      );
-    }
-    return this._auriAirdrop;
-  }
-
-  get referralDirectoryV2(): ReferralDirectoryV2 {
-    if (!this._referralDirectoryV2) {
-      this._referralDirectoryV2 = this.getContract<ReferralDirectoryV2>(
-        networkAddresses.misc.REFERRAL_V2,
-        abis.ReferralDirectoryV2ABI.abi
-      );
-    }
-    return this._referralDirectoryV2;
-  }
-
-  get oracle(): AuriOracle {
-    if (!this._oracle) {
-      this._oracle = this.getContract<AuriOracle>(
-        networkAddresses.misc.PYTH_ORACLE,
-        abis.AuriOracleABI.abi
-      );
-    }
-    return this._oracle;
-  }
-
-  get plygame(): PlyGame {
-    if (!this._plygame) {
-      this._plygame = this.getContract<PlyGame>(networkAddresses.misc.PLYGAME, abis.PlyGameABI.abi);
-    }
-    return this._plygame;
-  }
-
-  get plyTokenLock(): PlyTokenLock {
-    if (!this._plyTokenLock) {
-      this._plyTokenLock = this.getContract<PlyTokenLock>(
-        networkAddresses.misc.PLY_TOKEN_LOCK,
-        abis.PlyTokenLockABI.abi
-      );
-    }
-    return this._plyTokenLock;
-  }
-}

package/src/entities/index.ts

@@ -1,4 +0,0 @@
-export * from './auriEnv';
-export * from './BlockchainEntity';
-export * from './token';
-export * from './tokenAmount';

package/src/entities/token.ts

@@ -1,21 +0,0 @@
-import { networkAddresses } from '../consts/constants';
-import { getDecimal } from '../helpers/helpers';
-
-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 PLYWNEARToken = new Token(
-  networkAddresses.tokens.PLYWNEAR,
-  getDecimal(networkAddresses.tokens.PLYWNEAR)
-);

package/src/entities/tokenAmount.ts

@@ -1,48 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { decimalFactor, getDecimal, getSymbol } from '../helpers/helpers';
-import { Address } from '../types';
-import { Token } from './token';
-
-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(decimal?: number, fmt?: BigNumber.Format): string {
-    if (decimal !== undefined && fmt !== undefined) {
-      return new BigNumber(this.rawAmnt)
-        .div(decimalFactor(this.token.decimals))
-        .toFormat(decimal, fmt);
-    }
-
-    return new BigNumber(this.rawAmnt).div(decimalFactor(this.token.decimals)).toString();
-  }
-
-  public formattedAmountWithSymbol(decimal?: number, fmt?: BigNumber.Format): string {
-    return `${this.formattedAmount(decimal, fmt)} ${getSymbol(this.token.address)}`;
-  }
-
-  public rawAmount(): string {
-    return this.rawAmnt;
-  }
-
-  public compare(other: TokenAmount): number {
-    return new BigNumber(this.rawAmnt).comparedTo(new BigNumber(other.rawAmnt));
-  }
-
-  public static fromAddressAndAmount(
-    tokenAddress: Address,
-    amount: string,
-    isRaw: boolean = true
-  ): TokenAmount {
-    return new TokenAmount(new Token(tokenAddress, getDecimal(tokenAddress)), amount, isRaw);
-  }
-}

package/src/helpers/aurigami-api.ts

@@ -1,42 +0,0 @@
-import axios from 'axios';
-
-const AURIGAMI_API_END_POINT = 'https://api.aurigami.finance/app/';
-
-export async function getApi(url: string, params: Record<string, any> = {}): Promise<any> {
-  const resp = await axios.get(AURIGAMI_API_END_POINT + url + '?' + new URLSearchParams(params), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data;
-}
-
-export type MetaApiResponse = {
-  totalItems: number;
-  itemCount: number;
-  itemsPerPage: number;
-  totalPages: number;
-  currentPage: number;
-};
-
-export type PaginagedApiResponse<T> = {
-  items: T[];
-  meta: MetaApiResponse;
-};
-
-export async function getPaginatedApi<T = any>(
-  url: string,
-  params: Record<string, any> = {},
-  page: number = 1,
-  pageSize: number = 50
-): Promise<PaginagedApiResponse<T>> {
-  params = {
-    ...params,
-    page,
-    limit: pageSize,
-  };
-  const resp = await axios.get(AURIGAMI_API_END_POINT + url + '?' + new URLSearchParams(params), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data;
-}

package/src/helpers/aurora-api-helpers.ts

@@ -1,17 +0,0 @@
-import axios from 'axios';
-
-const AURORA_API_BASE_URL = 'https://explorer.mainnet.aurora.dev/api';
-
-export async function getQuery(
-  module: string,
-  action: string,
-  params: Record<string, any> = {}
-): Promise<any> {
-  params = { ...params, module: module, action: action };
-
-  let resp = await axios.get(AURORA_API_BASE_URL + '?' + new URLSearchParams(params), {
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  return resp.data.result!;
-}

package/src/helpers/graphql-helpers.ts

@@ -1,8 +0,0 @@
-import axios from 'axios';
-
-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

@@ -1,212 +0,0 @@
-import { TypedEvent } from '@aurigami/contracts/typechain/common';
-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 { GRAPHQL_URL, networkAddresses } from '../consts/constants';
-import { decimalRecords } from '../consts/decimals';
-import { symbolRecords } from '../consts/symbols';
-import { Address } from '../types';
-import { getQuery as getAuroraAPIQuery } from './aurora-api-helpers';
-import { queryGraphQL } from './graphql-helpers';
-
-export function assert(condition: boolean, message: string = ''): void {
-  if (!condition) {
-    message = 'Assertion failed' + (message ? ': ' + message : '');
-    throw new Error(message);
-  }
-}
-
-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 = (): number => {
-  return Math.trunc(Date.now() / 1000);
-};
-
-export async function sleep(duration: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, duration);
-  });
-}
-
-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 {
-  let addressLowercase = address.toLowerCase();
-  assert(decimalRecords[addressLowercase] != undefined, 'Decimal not found for ' + address);
-  return decimalRecords[addressLowercase];
-}
-
-export function getSymbol(address: Address): string {
-  let addressLowercase = address.toLowerCase();
-  assert(symbolRecords[addressLowercase] != undefined, 'Symbol not found for ' + address);
-  return symbolRecords[addressLowercase];
-}
-
-export function getUnderlying(address: Address): Address {
-  let addressLowercase = address.toLowerCase();
-  let matching = networkAddresses.auTokens.filter((e) => e.address == addressLowercase);
-  if (matching.length == 0) {
-    throw new Error('Underlying not found for ' + address);
-  }
-  return matching[0].underlying;
-}
-
-export function calcLMRewardApr(
-  rewardsValue: BigNumber,
-  totalStakeValue: BigNumber,
-  frequencyPerYear: number
-): BigNumber {
-  if (rewardsValue.isZero()) {
-    return new BigNumber(0);
-  }
-  if (totalStakeValue.lte(0)) {
-    // avoid division by zero when there is no stake
-    return rewardsValue;
-  }
-  return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
-}
-
-export function calcNetApy(
-  suppliedValue: BigNumber,
-  supplyApy: BigNumber,
-  borrowedValue: BigNumber,
-  borrowApy: BigNumber
-) {
-  return suppliedValue.multipliedBy(supplyApy).minus(borrowedValue.multipliedBy(borrowApy));
-}
-
-export async function getBlockTimestamp(provider: Provider, blockNumber: number): Promise<number> {
-  const block = await provider.getBlock(blockNumber);
-  return block.timestamp;
-}
-
-export async function getBlocksTimestampViaRPC(
-  provider: Provider,
-  blocksNumber: number[]
-): Promise<number[]> {
-  // Promise all 200 blocks at a time, using too many blocks at once will cause the RPC call timeout.
-  const CHUNK_SIZE = 200;
-  let results: number[] = [];
-  for (let i = 0; i < blocksNumber.length; i += CHUNK_SIZE) {
-    let slice = blocksNumber.slice(i, i + CHUNK_SIZE);
-    let promises = slice.map(async (blockNumber) => getBlockTimestamp(provider, blockNumber));
-    results = results.concat(await Promise.all(promises));
-  }
-  return results;
-}
-
-/**
- * Get timestamp of multiple blocks.
- * @note the getBlockTimestamp function is too slow because of the RPC call, even with Promise.all.
- * So I use the GraphQL endpoint of Aurora instead. You can check it here: https://explorer.mainnet.aurora.dev/graphiql
- */
-export async function getBlocksTimestamp(
-  provider: Provider,
-  blockNumbers: number[]
-): Promise<number[]> {
-  if (blockNumbers.length == 0) return [];
-  const CHUNK_SIZE = 100; // graphql query limit
-
-  let promises = [];
-  let lines: string[] = blockNumbers.map((x) => `b${x}: block(number: ${x}) { timestamp }`);
-
-  for (let i = 0; i < lines.length; i += CHUNK_SIZE) {
-    let query = `{ ${lines.slice(i, i + CHUNK_SIZE).join('\n')} }`;
-    promises.push(queryGraphQL(query, GRAPHQL_URL));
-  }
-
-  // merge all the json objects
-  let results = (await Promise.all(promises)).reduce((acc, cur) => {
-    return { ...acc, ...cur };
-  }, {});
-
-  let missingBlocks = blockNumbers.filter((blockNumber) => !results[`b${blockNumber}`]);
-  if (missingBlocks.length > 0) {
-    devLog(`These blocks are missing from Aurora GraphQL endpoint: ${missingBlocks.join(', ')}`);
-  }
-
-  let missingBlocksTimestamps = await getBlocksTimestampViaRPC(provider, missingBlocks);
-
-  missingBlocksTimestamps.forEach((timestamp, index) => {
-    results[`b${missingBlocks[index]}`] = { timestamp: new Date(timestamp * 1000).toISOString() };
-  });
-
-  return blockNumbers.map((blockNumber) =>
-    Math.trunc(new Date(results[`b${blockNumber}`]!.timestamp).getTime() / 1000)
-  );
-}
-
-/**
- * Get the block number of the last block that has a timestamp before the given timestamp
- * @param timestamp input timestamp
- * @returns return the last block that its timestamp <= the give timestamp
- * @note Check this API for more information: https://aurorascan.dev/apis#blocks
- *
- * This function is much faster than using binary search.
- */
-export async function getBlockBeforeTimestamp(provider: Provider, timestamp: number) {
-  let result = await getAuroraAPIQuery('block', 'getblocknobytime', {
-    timestamp: timestamp,
-    closest: 'before',
-  });
-
-  // In case the API return `Block timestamp too far in the future`
-  // use the last block number
-  return parseInt(result.blockNumber) || (await provider.getBlockNumber());
-}
-
-export function devLog(message?: any, ...optionalParams: any[]): void {
-  if ('production' !== process.env.NODE_ENV) {
-    console.log('[DEV LOG]', message, ...optionalParams);
-  }
-}
-
-/**
- * Sorts (in place) an array of Events by blocknumber.
- * This method mutates the array and returns a reference to the same array.
- **/
-export function sortEvents<T extends Result>(events: TypedEvent<T>[]): TypedEvent<T>[] {
-  return events.sort((a, b) => {
-    if (a.blockNumber == b.blockNumber) {
-      return a.logIndex - b.logIndex;
-    }
-    return a.blockNumber - b.blockNumber;
-  });
-}
-
-// export function Cache(cacheTimeout: number) {
-//   return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-//     const originalMethod = descriptor.value;
-//     let cache = new Map<string, any>();
-//     descriptor.value = function (...args: any[]) {
-//       let key = JSON.stringify(args);
-//       if (cache.has(key)) {
-//         let [timestamp, value] = cache.get(key);
-//         if (Date.now() - timestamp < cacheTimeout) {
-//           return value;
-//         }
-//       }
-//       let result = originalMethod.apply(this, args);
-//       cache.set(key, [Date.now(), result]);
-//       return result;
-//     };
-//     return descriptor;
-//   };
-// }