@sabaaa1/common 0.0.1

package/src/functions/web3/oneInchAPI.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,156 @@
+/* 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/index.ts

@@ -0,0 +1,9 @@
+export * from './API';
+export * from './constants';
+export * from './crypto';
+export * from './data-structures';
+export * from './error-handling';
+export * from './externalABIs';
+export * from './functions';
+export * from './types';
+export * from './mutexes';

package/src/mutexes/index.ts

@@ -0,0 +1 @@
+export * from './mutex';

package/src/mutexes/mutex.ts

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

package/src/providers/EthersProviderAdapter.ts

@@ -0,0 +1,230 @@
+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

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