@sabaaa1/common 0.0.1 → 0.0.2

package/src/functions/web3/oneInchAPI.ts

@@ -1,47 +0,0 @@
-import { callOneInchAPI, OneInchRequest } from '../../API/callOneInchAPI';
-import { oneInchZeroAddress, zeroAddress } from '../../constants';
-import { Logger, transactionErrorCodes } from '../../error-handling';
-import { ContractType, ERC20Token } from '../../types';
-import { getAmountInWei } from './etherFunctions';
-import { getContractMetadata } from './getContractMetadata';
-
-export const getOneInchPrice = async (
-  chainId: number,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
-  inSwapAmount: string,
-  slippagePercentage = 0.7,
-) => {
-  try {
-    const request: OneInchRequest = {
-      fromTokenAddress:
-        inSwapToken.erc20TokenAddress !== zeroAddress ? inSwapToken.erc20TokenAddress : oneInchZeroAddress,
-      toTokenAddress:
-        outSwapToken.erc20TokenAddress !== zeroAddress ? outSwapToken.erc20TokenAddress : oneInchZeroAddress,
-      fromAddress: zeroAddress, // we user zero address here because this paramater is not relevant to us, only destReceiver is
-      destReceiver: getContractMetadata(ContractType.OneInchExternalActionContract, chainId).address,
-      amount: getAmountInWei(inSwapToken, inSwapAmount),
-      slippage: slippagePercentage,
-      disableEstimate: true, // disable gas estimation, we don't need it
-      // disable partial filling:
-      // if slippage tolerance isn't satisfied 1inch will try to swap less amount of input tokens
-      // and returning leftover tokens to fromAddress
-      // this is not what we want
-      allowPartialFill: false,
-    };
-
-    const response = await callOneInchAPI(chainId, request);
-
-    if (!response || !response.tx) {
-      throw Error('OneInch API price fetch error');
-    }
-
-    return {
-      outSwapAmountValue: BigInt(response.toAmount),
-      oneInchDataValue: response.tx.data, // calldata to use
-    };
-  } catch (error: unknown) {
-    Logger.log({ error });
-    throw Error(transactionErrorCodes.NO_ONEINCH_PRICE);
-  }
-};

package/src/functions/web3/runContractFunction.ts

@@ -1,116 +0,0 @@
-import { BigNumber, ethers } from 'ethers';
-import { getErrorMessage, transactionErrorCodes, UserFriendlyErrorCodes } from '../../error-handling';
-
-const defaultWaitTime = 50000;
-const defaultConfirmations = 1;
-const initialGasPremium = 11;
-const secondaryGasPremium = 15;
-
-enum GasPremiumType {
-  Initial,
-  Secondary,
-}
-
-interface IRunTransaction {
-  contractFunction: ethers.ContractFunction;
-  args: unknown[];
-  gasLimit?: number;
-  gasPrice?: BigNumber;
-  confirmations?: number;
-  waitTime?: number;
-  nonce?: number;
-}
-
-interface IRunContractFunction extends IRunTransaction {
-  provider: ethers.providers.Provider;
-}
-
-const getGasPrice = async (
-  provider: ethers.providers.Provider,
-  gasPremiumType: GasPremiumType,
-): Promise<BigNumber | undefined> => {
-  try {
-    const feeData = await provider.getFeeData();
-    const gasPremium = gasPremiumType === GasPremiumType.Initial ? initialGasPremium : secondaryGasPremium;
-    const gasPrice = feeData.gasPrice?.mul(gasPremium).div(10) ?? undefined;
-    return gasPrice;
-  } catch (err: unknown) {
-    console.log('getGasPrice error: ', { err });
-    return undefined;
-  }
-};
-
-const waitTransaction = (
-  transactionResponse: ethers.ContractTransaction,
-  confirmations: number,
-  waitTime: number,
-): Promise<ethers.ContractReceipt> =>
-  new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      reject(new Error(transactionErrorCodes.TRANSACTION_TIMEOUT));
-    }, waitTime);
-
-    transactionResponse
-      .wait(confirmations)
-      .then((tx) => {
-        clearTimeout(timeoutId);
-        resolve(tx);
-      })
-      .catch((err: unknown) => {
-        clearTimeout(timeoutId);
-        reject(err);
-      });
-  });
-
-const runTransaction = async ({
-  contractFunction,
-  args,
-  gasPrice,
-  gasLimit,
-  nonce,
-  confirmations,
-  waitTime,
-}: IRunTransaction) => {
-  const transactionResponse: ethers.ContractTransaction = await contractFunction(...args, {
-    type: 0,
-    gasLimit,
-    gasPrice,
-    nonce,
-  });
-  const tx = await waitTransaction(
-    transactionResponse,
-    confirmations ?? defaultConfirmations,
-    waitTime ?? defaultWaitTime,
-  );
-  return tx;
-};
-
-// Note: this function should only be used on the backend
-export const runContractFunction = async ({
-  provider,
-  contractFunction,
-  args,
-  gasLimit,
-  nonce,
-  confirmations,
-}: IRunContractFunction): Promise<ethers.ContractReceipt> => {
-  try {
-    const gasPrice = await getGasPrice(provider, GasPremiumType.Initial);
-    const tx = await runTransaction({ contractFunction, args, gasPrice, gasLimit, nonce, confirmations });
-    return tx;
-  } catch (err: any) {
-    const errMessage = getErrorMessage(err);
-    // Case 1. Transaction was underpriced
-    // Case 2. Transaction is stuck in the mem-pool and we need to replace it with higher gas price
-    if (
-      errMessage === UserFriendlyErrorCodes.MAX_FEE_GAS_ERROR ||
-      errMessage === transactionErrorCodes.TRANSACTION_TIMEOUT
-    ) {
-      console.log('Timeout Hit: Increase gas');
-      const gasPrice = await getGasPrice(provider, GasPremiumType.Secondary);
-      const tx = await runTransaction({ contractFunction, args, gasPrice, gasLimit, nonce, confirmations });
-      return tx;
-    }
-    throw err;
-  }
-};

package/src/functions/web3/uniswapAPI.ts

@@ -1,156 +0,0 @@
-/* eslint-disable @typescript-eslint/dot-notation */
-import { Contract, utils } from 'ethers';
-import { networkRegistry, zeroAddress } from '../../constants';
-import { logError, transactionErrorCodes } from '../../error-handling';
-import { ContractType, ERC20Token } from '../../types';
-import { getAmountInWei } from './etherFunctions';
-import { IHinkal } from '@hinkal/common/data-structures/Hinkal/IHinkal';
-
-interface PoolAndFee {
-  poolAddress: string;
-  fee: number;
-  token1Balance: bigint;
-}
-
-export const searchPoolAndFee = async (
-  token1Contract: Contract,
-  factory: Contract,
-  token0Address: string,
-  token1Address: string,
-): Promise<PoolAndFee> => {
-  // Finding all the pools of given pair of tokens
-  const poolArray = (
-    await Promise.all(
-      [100, 500, 3000, 10000].map(async (fee) => {
-        return {
-          poolAddress: await factory['getPool'](token0Address, token1Address, fee),
-          fee,
-        };
-      }),
-    )
-  )
-    // intentionally filter out address(0), getPool returns zeroAddress when pool doesn't exist
-    // this may seem redundant since we check balances of the addresses below
-    // but some tokens do have balances for address(0), most notably WETH on mainnet
-    .filter(({ poolAddress }) => poolAddress !== zeroAddress);
-
-  // Finding maximum token1 balance
-  const poolsWithBalances = await Promise.all(
-    poolArray.map(async (pool) => ({
-      poolAddress: pool.poolAddress,
-      fee: pool.fee,
-      token1Balance: (await token1Contract['balanceOf'](pool.poolAddress)).toBigInt(),
-    })),
-  );
-
-  const token1Balances = poolsWithBalances.map((pool) => pool.token1Balance);
-  const maxBalance: bigint = token1Balances.reduce((prevValue: bigint, currentValue: bigint) => {
-    if (currentValue >= prevValue) {
-      return currentValue;
-    }
-    return prevValue;
-  }, 0n);
-
-  if (maxBalance === 0n) {
-    throw new Error(transactionErrorCodes.UNISWAP_NOT_ENOUGH_LIQUIDITY);
-  }
-
-  const bestPool = poolsWithBalances.find((pool) => pool.token1Balance === maxBalance) as PoolAndFee;
-  return bestPool;
-};
-
-export const getUniswapPriceHelper = async (
-  hinkal: IHinkal,
-  chainId: number,
-  token0: ERC20Token,
-  token1: ERC20Token,
-  fee: number,
-  inSwapAmount: bigint,
-): Promise<bigint> => {
-  try {
-    if (!networkRegistry[chainId].quoterV2Address) throw Error('No Quoter Contract Provided');
-    const quoter = hinkal.getContractWithFetcherByChainId(
-      chainId,
-      ContractType.UniswapV3QuoterContract,
-      networkRegistry[chainId].quoterV2Address,
-    );
-
-    const price = (
-      await quoter.callStatic['quoteExactInputSingle']({
-        tokenIn: token0.wrappedErc20TokenAddress ?? token0.erc20TokenAddress,
-        tokenOut: token1.wrappedErc20TokenAddress ?? token1.erc20TokenAddress,
-        fee,
-        amountIn: inSwapAmount,
-        sqrtPriceLimitX96: 0,
-      })
-    ).amountOut.toBigInt();
-    return price;
-  } catch (error) {
-    logError(error);
-    throw error;
-  }
-};
-
-export const getUniswapFee = async (
-  hinkal: IHinkal,
-  chainId: number,
-  token0: ERC20Token,
-  token1: ERC20Token,
-): Promise<number> => {
-  try {
-    const factory = hinkal.getContractWithFetcherByChainId(
-      chainId,
-      ContractType.UniswapV3FactoryContract,
-      networkRegistry[chainId].uniswapV3FactoryAddress,
-    ); // as IUniswapV3Factory;
-
-    // 100 = 0.01%, 500 = 0.05%, 3000 = 0.3%, 100000 = 1% -> different fee structures
-    const token1Contract = hinkal.getContractWithFetcherByChainId(
-      chainId,
-      ContractType.ERC20Contract,
-      token1.wrappedErc20TokenAddress ?? token1.erc20TokenAddress,
-    ); // as IERC20;
-
-    const { fee } = await searchPoolAndFee(
-      token1Contract,
-      factory,
-      token0.wrappedErc20TokenAddress ?? token0.erc20TokenAddress,
-      token1.wrappedErc20TokenAddress ?? token1.erc20TokenAddress,
-    );
-
-    return fee;
-  } catch (err) {
-    console.log('Error in getUniswapFee', err);
-    throw err;
-  }
-};
-
-export const getUniswapPrice = async (
-  hinkal: IHinkal,
-  chainId: number,
-  inSwapAmount: string,
-  inSwapToken: ERC20Token,
-  outSwapToken: ERC20Token,
-) => {
-  try {
-    // for some reason there are existing pools with aave tokens in them, despite the fact that
-    // volatile tokens aren't supported by uniswap
-    const feeNumber = await getUniswapFee(hinkal, chainId, inSwapToken, outSwapToken);
-    const poolFee = utils.defaultAbiCoder.encode(['uint24'], [feeNumber]);
-    const inSwapAmountInWei = getAmountInWei(inSwapToken, inSwapAmount);
-
-    // this is final price after fee deduction (does not include relayer fee)
-    const tokenPrice = await getUniswapPriceHelper(
-      hinkal,
-      chainId,
-      inSwapToken,
-      outSwapToken,
-      feeNumber,
-      inSwapAmountInWei,
-    );
-
-    return { tokenPrice, poolFee };
-  } catch (error: unknown) {
-    throw Error(transactionErrorCodes.NO_UNISWAP_PRICE);
-  }
-};

package/src/mutexes/mutex.ts

@@ -1,3 +0,0 @@
-import { Mutex } from 'async-mutex';
-
-export const resetStateMutex = new Mutex();

package/src/providers/EthersProviderAdapter.ts

@@ -1,230 +0,0 @@
-import { ChainEventListener, IProviderAdapter } from '../data-structures/provider-adapter/IProviderAdapter';
-import { chainIds, localhostNetwork, networkRegistry } from '../constants/chains.constants';
-import { ContractMetadata, ContractType, EthereumNetwork } from '../types/ethereum-network.types';
-import { transactionErrorCodes } from '../error-handling/error-codes.constants';
-import { ethers, providers, Signer, utils } from 'ethers';
-import {
-  getContract,
-  getContractMetadata,
-  getContractWithFetcherByChainId,
-} from '../functions/web3/getContractMetadata';
-import { createTorRpcProvider } from '../functions';
-import { httpClient } from '../data-structures/tor';
-
-export class EthersProviderAdapter implements IProviderAdapter<Signer> {
-  public signer: Signer | undefined;
-
-  public chainId: number | undefined;
-
-  private originalProvider: providers.Provider | undefined;
-
-  private fetchProvider: providers.Provider | undefined;
-
-  private chainEventListener?: ChainEventListener;
-
-  initConnector(): void {}
-
-  initSigner(signer: Signer): void {
-    this.signer = signer;
-  }
-
-  getSigner(): Signer {
-    if (!this.signer) throw new Error('No Signer In Provider Adapter');
-    return this.signer;
-  }
-
-  requireSigner() {
-    if (!this.signer) throw Error('No Connector In Provider Adapter');
-  }
-
-  async init(chainId?: number): Promise<void> {
-    this.requireSigner();
-    // init chainId
-    if (chainId) this.chainId = chainId;
-    // init providers
-    const signerProvider = this.signer!.provider;
-
-    const customFetchProvider = this.createFetchProvider();
-
-    const useTor = httpClient.getUseTor();
-
-    if (useTor && customFetchProvider) {
-      this.originalProvider = customFetchProvider;
-      this.fetchProvider = customFetchProvider;
-    } else {
-      this.originalProvider = signerProvider;
-      this.fetchProvider = customFetchProvider ?? signerProvider;
-    }
-
-    if (this.fetchProvider === signerProvider && !useTor) {
-      console.warn('fetchProvider not available, falling back to signer provider');
-    }
-  }
-
-  async disconnectFromConnector(): Promise<void> {
-    // do nothing
-  }
-
-  async connectToConnector(): Promise<number> {
-    // do nothing
-    return 0;
-  }
-
-  async waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean> {
-    const txReceipt = await this.fetchProvider?.waitForTransaction(transactionHash, confirmations);
-    if (txReceipt?.status) return true;
-    throw Error(transactionErrorCodes.TRANSACTION_NOT_CONFIRMED);
-  }
-
-  async signMessage(message: string): Promise<string> {
-    this.requireSigner();
-    const signature = await this.signer!.signMessage(message);
-    if (!signature) throw new Error(transactionErrorCodes.SIGNING_FAILED); // coinbase wallet returns undefined in some cases.
-    if (signature.includes('error')) throw new Error(transactionErrorCodes.SIGNATURE_UNSUPPORTED_PERSONAL_SIGN);
-    return signature;
-  }
-
-  async signTypedData(
-    domain: ethers.TypedDataDomain,
-    types: Record<string, ethers.TypedDataField[]>,
-    value: Record<string, unknown>,
-  ): Promise<string> {
-    // TODO: Avoid type casting
-    return (this.signer as providers.JsonRpcSigner)._signTypedData(domain, types, value);
-  }
-
-  getSelectedNetwork = (): EthereumNetwork | undefined => {
-    if (!this.chainId) throw new Error('Illegal state: no chaindId');
-    return networkRegistry[this.chainId];
-  };
-
-  async switchNetwork(network: EthereumNetwork): Promise<void> {
-    this.originalProvider = this.createFetchProvider(network) ?? this.originalProvider;
-    if (!this.originalProvider) throw new Error('switchNetwork illegal state: no provider');
-    this.signer = this.signer?.connect(this.originalProvider);
-    this.chainEventListener?.onChainChanged(network.chainId);
-  }
-
-  async switchAccount(newSigner: Signer): Promise<void> {
-    const newProvider = this.createFetchProvider();
-    if (!newProvider) throw new Error("can't create new fetch provider");
-    this.signer = newSigner.connect(newProvider);
-    await this.onAccountChanged();
-    this.chainEventListener?.onAccountChanged();
-  }
-
-  private createFetchProvider(network?: EthereumNetwork) {
-    try {
-      const finalNetwork = network ?? networkRegistry[this.chainId!];
-      const fetchRpcUrl = finalNetwork?.fetchRpcUrl;
-
-      if (!fetchRpcUrl) {
-        return undefined;
-      }
-
-      return createTorRpcProvider(fetchRpcUrl);
-    } catch (err: any) {
-      console.log('create Fetch Provider error', err);
-      return undefined;
-    }
-  }
-
-  async getAddress(): Promise<string> {
-    this.requireSigner();
-    const address = await this.signer!.getAddress();
-    if (!address) {
-      throw new Error('IllegalState');
-    }
-    return utils.getAddress(address);
-  }
-
-  setChainEventListener(chainEventListener: ChainEventListener): void {
-    this.chainEventListener = chainEventListener;
-  }
-
-  onAccountChanged(): Promise<unknown> {
-    return this.init();
-  }
-
-  onChainChanged(chainId?: number): Promise<unknown> {
-    return this.init(chainId);
-  }
-
-  release(): void {
-    this.removeListeners();
-  }
-
-  private removeListeners() {
-    this.chainEventListener = undefined;
-  }
-
-  private parseChainIdParam(chainId: number | undefined) {
-    const resultChainId = chainId ?? this.chainId;
-
-    if (!resultChainId) {
-      throw new Error('No chainId provided in context');
-    }
-    return resultChainId;
-  }
-
-  getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata {
-    const resultChainId = this.parseChainIdParam(chainId);
-
-    return getContractMetadata(contractType, resultChainId);
-  }
-
-  getContract(contractType: ContractType, contractAddress = undefined, chainId?: number): ethers.Contract {
-    const resultChainId = this.parseChainIdParam(chainId);
-
-    return getContract(contractType, resultChainId, contractAddress);
-  }
-
-  getContractWithSigner(contract: ContractType, contractAddress = undefined): ethers.Contract {
-    if (!this.signer) throw new Error('IllegalState: no signer');
-
-    return this.getContract(contract, contractAddress).connect(this.signer);
-  }
-
-  getContractWithFetcher(contract: ContractType, contractAddress = undefined): ethers.Contract {
-    if (!this.fetchProvider) throw new Error('fetchProvider not initialized');
-
-    return this.getContract(contract, contractAddress).connect(this.fetchProvider);
-  }
-
-  getContractWithFetcherForEthereum(contract: ContractType, contractAddress = undefined): ethers.Contract {
-    const chainIdForRpcUrl =
-      this.chainId === chainIds.localhost && localhostNetwork === chainIds.ethMainnet
-        ? chainIds.localhost
-        : chainIds.ethMainnet;
-
-    return getContractWithFetcherByChainId(chainIdForRpcUrl, contract, contractAddress);
-  }
-
-  async sendTransaction(tx: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionResponse> {
-    if (!this.signer) throw new Error('IllegalState: no signer');
-
-    const resp = await this.signer.sendTransaction(tx);
-
-    return resp;
-  }
-
-  async connectAndPatchProvider(): Promise<number> {
-    this.requireSigner();
-    const chainId = await this.signer!.getChainId();
-    return chainId;
-  }
-
-  isPermitterAvailable(): boolean {
-    return false;
-  }
-
-  async getGasPrice(): Promise<bigint> {
-    const price = await this.fetchProvider?.getGasPrice();
-    if (!price) throw Error('Could not fetch gas price in getGasPrice');
-    return price.toBigInt();
-  }
-}
-
-export const ethersProvierAdapter = new EthersProviderAdapter();
-
-export default <T = unknown>() => new EthersProviderAdapter() as any as IProviderAdapter<T>;

package/src/providers/TorExternalProvider.ts

@@ -1,36 +0,0 @@
-import { ExternalProvider } from '@ethersproject/providers';
-import { httpClient } from '../data-structures/tor/HttpClient';
-import { Logger } from '../error-handling/logger';
-
-export class TorExternalProvider implements ExternalProvider {
-  private rpcUrl: string;
-
-  private nextId = 1;
-
-  constructor(rpcUrl: string) {
-    this.rpcUrl = rpcUrl;
-  }
-
-  async request(request: { method: string; params?: Array<any> }): Promise<any> {
-    const payload = {
-      jsonrpc: '2.0',
-      id: this.nextId,
-      method: request.method,
-      params: request.params || [],
-    };
-    this.nextId += 1;
-
-    try {
-      const response = await httpClient.post(this.rpcUrl, payload);
-
-      if (response.error) {
-        throw new Error(response.error.message || 'RPC Error');
-      }
-
-      return response.result;
-    } catch (error) {
-      Logger.error('TorExternalProvider RPC error:', error);
-      throw error;
-    }
-  }
-}