@aurigami/sdk 1.24.0 → 1.24.2

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;
-//   };
-// }

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);
-}