@sabaaa1/common 0.0.7 → 0.0.8

package/src/functions/pre-transaction/process-gas-estimates.ts

@@ -1,36 +0,0 @@
-import { getGasEstimates } from '../../API/getGasEstimates';
-import { logError } from '../../error-handling/logError';
-import { CallInfo, ERC20Token, ExternalActionId } from '../../types';
-import { getValueFirstNDigit } from '../utils/amounts.utils';
-import { getAmountInWei } from '../web3/etherFunctions';
-
-export const processGasEstimates = async (
-  chainId: number,
-  tokenForGasFee: ERC20Token,
-  externalActionId: ExternalActionId,
-  erc20TokenAddressLength: number,
-  gasAmount?: number,
-  calls: CallInfo<bigint>[] = [],
-) => {
-  let priceOfTransactionInUSD;
-  let priceOfTransactionInTokenEstimate;
-
-  try {
-    ({ priceOfTransactionInUSD, priceOfTransactionInToken: priceOfTransactionInTokenEstimate } = await getGasEstimates(
-      chainId,
-      tokenForGasFee.erc20TokenAddress,
-      externalActionId,
-      erc20TokenAddressLength,
-      calls.map(({ from, to, calldata, value }) => ({ from, to, calldata, value: `${value}` })),
-      gasAmount,
-    ));
-  } catch (error: unknown) {
-    logError('processGasEstimates error:', error);
-  }
-
-  const priceOfTransactionInToken = priceOfTransactionInTokenEstimate
-    ? getAmountInWei(tokenForGasFee, getValueFirstNDigit(priceOfTransactionInTokenEstimate, tokenForGasFee.decimals))
-    : undefined; // in wei
-
-  return { priceOfTransactionInUSD, priceOfTransactionInToken };
-};

package/src/functions/pre-transaction/shouldPatchAccessTokenMerkleTree.ts

@@ -1,15 +0,0 @@
-import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
-
-export const shouldPatchAccessTokenMerkleTree = async (
-  hinkal: IHinkal,
-  erc20Addresses: string[],
-  amountChanges: bigint[],
-) => {
-  const kycRequired = await hinkal.checkTokenRegistry(erc20Addresses, amountChanges);
-
-  const hasAccessToken = await hinkal.checkAccessToken();
-
-  // Note: we return hasAccessToken and kycRequired here as performance optimization
-  // so we don't have to fetch it again later and waste a network request
-  return { patchAccessTokenMerkleTree: kycRequired && !hasAccessToken, hasAccessToken, kycRequired };
-};

package/src/functions/private-wallet/emporium.helpers.ts

@@ -1,296 +0,0 @@
-import { BigNumber, Contract, ContractTransaction, ethers, utils } from 'ethers';
-import { zeroAddress } from '../../constants/protocol.constants';
-import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
-import { ContractType } from '../../types/ethereum-network.types';
-import { caseInsensitiveEqual, createTorRpcProvider, replaceAllInstances } from '../utils';
-import { replaceAddressesInCalldata } from '../utils/replaceAddressInCalldata';
-import { UserKeys } from '../../data-structures/crypto-keys/keys';
-import { Logger } from '../../error-handling/logger';
-import { type AuthorizationData } from '../../types/hinkal.types';
-import { chainIds, networkRegistry } from '../../constants/chains.constants';
-import { ethers as ethersV6 } from 'ethers-v6h';
-
-export const emporiumOp = <
-  ContractInstance extends Contract,
-  ContractFunctions extends ContractInstance['functions'],
-  ExactFunction extends {
-    [K in keyof ContractFunctions]: ReturnType<ContractFunctions[K]> extends Promise<ContractTransaction> ? K : never;
-  }[keyof ContractFunctions],
-  FunctionArguments extends Parameters<ContractFunctions[ExactFunction]>,
->({
-  contract,
-  func,
-  args,
-  callDataString,
-  invokeWallet,
-  value,
-}: {
-  contract: ContractInstance | string;
-  func?: ExactFunction;
-  args?: FunctionArguments extends [] ? [] : FunctionArguments;
-  callDataString?: string;
-  invokeWallet?: boolean;
-  value?: bigint;
-}): string => {
-  let endpointBytes: Uint8Array = new Uint8Array();
-  let callDataBytes = callDataString ? utils.arrayify(callDataString) : new Uint8Array();
-
-  if (typeof contract === 'object' && 'address' in contract) {
-    endpointBytes = utils.arrayify(contract.address);
-
-    if (callDataString?.length && callDataString?.length > 0) {
-      throw Error('If function and args are providedm no calldata is needed');
-    }
-    if (func && args && !callDataString) {
-      callDataBytes = utils.arrayify(contract.interface.encodeFunctionData(func as string, args));
-    }
-  } else {
-    endpointBytes = utils.arrayify(contract);
-  }
-  const invokeWalletByte = utils.arrayify([invokeWallet ? 1 : 0]);
-  const valueBytes = utils.zeroPad(utils.arrayify(BigNumber.from(value ?? 0n)), 16);
-
-  const dataBytes = utils.concat([endpointBytes, invokeWalletByte, valueBytes, callDataBytes]);
-  return utils.hexlify(dataBytes);
-};
-
-export const encodeEmporiumMetadata = async (
-  chainId: number,
-  emporiumAddress: string,
-  privateKey: string | undefined,
-  ops: string[],
-  message?: bigint,
-  signerAddress?: string,
-) => {
-  const signature = privateKey
-    ? await UserKeys.signTypedDataFromPrivateKey(
-        privateKey,
-        { name: 'Emporium', version: '1.0.0', chainId, verifyingContract: emporiumAddress },
-        { EmporiumSignature: [{ name: 'message', type: 'uint256' }] },
-        { message },
-      )
-    : undefined;
-
-  const { v, r, s } = signature ? utils.splitSignature(signature) : { v: 0, r: '0x', s: '0x' };
-
-  return utils.defaultAbiCoder.encode(
-    ['tuple(uint8 v,bytes32 r, bytes32 s, uint256 message, address signerAddress, bytes[] ops)'],
-    [
-      {
-        v,
-        r,
-        s,
-        message: message ?? 0n,
-        signerAddress: signerAddress ?? zeroAddress,
-        ops,
-      },
-    ],
-  );
-};
-
-export const createTransferToEmporiumOp = (
-  tokenContract: ethers.Contract | undefined,
-  to: string,
-  amount: bigint,
-  invokeWallet: boolean,
-) => {
-  if (!tokenContract) {
-    return emporiumOp({ contract: to, value: amount, invokeWallet });
-  }
-  return emporiumOp({
-    contract: tokenContract,
-    func: 'transfer',
-    args: [to, amount],
-    invokeWallet,
-  });
-};
-
-export const createTransaferEmporiumOpsBatch = (
-  hinkal: IHinkal,
-  erc20TokenAddresses: string[],
-  amounts: bigint[],
-  to?: string,
-) => {
-  const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-
-  return erc20TokenAddresses.map((erc20Address, index) => {
-    const tokenContract = caseInsensitiveEqual(erc20Address, zeroAddress)
-      ? undefined
-      : hinkal.getContractWithFetcher(ContractType.ERC20Contract, erc20Address);
-
-    return createTransferToEmporiumOp(tokenContract, to ?? hinkalContract.address, amounts[index], true);
-  });
-};
-
-export const createApproveEmporiumOp = (
-  tokenContract: ethers.Contract,
-  to: string,
-  amount: bigint,
-  invokeWallet: boolean,
-): string => {
-  return emporiumOp({
-    contract: tokenContract,
-    func: 'approve',
-    args: [to, amount],
-    invokeWallet,
-  });
-};
-
-export const modifyDataForProxy = (hinkal: IHinkal, userAddress: string, data: string) => {
-  const hinkalAddress = hinkal.getSelectedNetwork()?.contractData.hinkalAddress;
-  if (!hinkalAddress) {
-    throw Error('No Hinkal Address Provided to modifyDataForProxy');
-  }
-  return replaceAllInstances(data, hinkalAddress.slice(2), userAddress.slice(2));
-};
-
-export const modifyDataForProxyWithPrivateKey = (hinkal: IHinkal, privateKey: string | undefined, data: string) => {
-  if (!privateKey) {
-    throw Error('No private key provided to modifyDataForProxy');
-  }
-  const userAddress = UserKeys.getSignerAddressFromPrivateKey(privateKey);
-
-  return modifyDataForProxy(hinkal, userAddress, data);
-};
-
-export const generateFundAndApproveOps = (
-  hinkal: IHinkal,
-  erc20AddressesToFund: string[],
-  fundAmounts: bigint[],
-  approveTokenAddresses: string[],
-  approveAmounts: bigint[],
-  walletAddress: string,
-  spenderAddress: string | undefined,
-) => {
-  const emporiumOps = [];
-
-  for (let i = 0; i < erc20AddressesToFund.length; i += 1) {
-    const tokenAddress = erc20AddressesToFund[i];
-    const tokenContract = caseInsensitiveEqual(tokenAddress, zeroAddress)
-      ? undefined
-      : hinkal.getContractWithFetcher(ContractType.ERC20Contract, tokenAddress);
-
-    emporiumOps.push(createTransferToEmporiumOp(tokenContract, walletAddress, fundAmounts[i], false));
-  }
-
-  if (spenderAddress) {
-    for (let i = 0; i < approveTokenAddresses.length; i += 1) {
-      const tokenAddress = approveTokenAddresses[i];
-      if (!caseInsensitiveEqual(tokenAddress, zeroAddress)) {
-        const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, tokenAddress);
-        emporiumOps.push(createApproveEmporiumOp(tokenContract, spenderAddress, approveAmounts[i], true));
-      }
-    }
-  }
-
-  return emporiumOps;
-};
-
-export const generateFundApproveAndTransactOps = (
-  hinkal: IHinkal,
-  erc20AddressesToFund: string[],
-  fundAmounts: bigint[],
-  approveTokenAddresses: string[],
-  approveAmounts: bigint[],
-  walletAddress: string,
-  spenderAddress: string | undefined,
-  to?: string,
-  callDataString?: string,
-  value?: bigint,
-) => {
-  const emporiumOps = generateFundAndApproveOps(
-    hinkal,
-    erc20AddressesToFund,
-    fundAmounts,
-    approveTokenAddresses,
-    approveAmounts,
-    walletAddress,
-    spenderAddress,
-  );
-
-  const isWithTransact = !!to && !!callDataString;
-
-  if (isWithTransact) {
-    const hinkalContract = hinkal.getContractWithFetcher(ContractType.HinkalContract);
-
-    emporiumOps.push(
-      emporiumOp({
-        contract: to,
-        callDataString: replaceAddressesInCalldata(callDataString, hinkalContract.address, walletAddress),
-        value,
-        invokeWallet: true,
-      }),
-    );
-  }
-
-  return emporiumOps;
-};
-
-// EIP-7702 delegation marker - the bytecode starts with this prefix
-const EIP_7702_MAGIC = '0xef0100'; // EF01 (magic) + 00 (version)
-
-export const checkEOAWithDelegation = async (chainId: number, eoaAddress: string) => {
-  try {
-    const { fetchRpcUrl } = networkRegistry[chainId];
-    if (!fetchRpcUrl) throw new Error('RPC URL not found for the specified chain ID');
-
-    const provider = createTorRpcProvider(fetchRpcUrl);
-    const code: string | undefined = await provider.getCode(eoaAddress);
-
-    // No code = no designation
-    if (code === '0x' || !code) return { delegated: false, implementation: undefined, nonce: undefined };
-
-    // 7702 stub is exactly 23 bytes (0xef0100 + 20-byte address)
-    if (code.toLowerCase().startsWith(EIP_7702_MAGIC) && code.length === 2 + 46) {
-      const impl = `0x${code.slice(8)}`; // drop 0x ef0100
-      const nonce = await provider.getTransactionCount(eoaAddress);
-      return { delegated: true, implementation: utils.getAddress(impl), nonce };
-    } else {
-      throw Error('checkEOAWithDelegation: It is a contract');
-    }
-  } catch (error) {
-    Logger.error('checkEOAWithDelegation error', { error });
-    throw error;
-  }
-};
-
-const getHinkalWalletImplementation = (chainId: number) => {
-  const { hinkalWalletAddress } = networkRegistry[chainId].contractData;
-  if (!hinkalWalletAddress || caseInsensitiveEqual(hinkalWalletAddress, zeroAddress)) {
-    throw Error('Hinkal Wallet Address is not set');
-  }
-
-  return hinkalWalletAddress;
-};
-
-export const getAuthorizationDataIfNeeded = async (chainId: number, privateKey: string | undefined) => {
-  // useful for tests, hardhat network doesn't support EIP7702
-  // in tests we use setCode to emulate EIP7702 behaviour
-  if (chainId === chainIds.localhost) return undefined;
-  if (!privateKey) return undefined;
-  const eoaAddress = UserKeys.getSignerAddressFromPrivateKey(privateKey);
-  const { delegated, implementation: oldImplementation } = await checkEOAWithDelegation(chainId, eoaAddress);
-  const implementation = getHinkalWalletImplementation(chainId);
-  if (!delegated || !caseInsensitiveEqual(oldImplementation, implementation)) {
-    const auth = await UserKeys.authorizeDelegationFromPrivateKey(privateKey, chainId, implementation);
-    const authData: AuthorizationData = {
-      v: auth.signature.v.toString(),
-      r: auth.signature.r,
-      s: auth.signature.s,
-      nonce: auth.nonce.toString(),
-      address: implementation,
-      chainId: String(chainId),
-    };
-    return authData;
-  }
-  return undefined;
-};
-
-export const recoverAuthorizationData = (
-  authorizationData: AuthorizationData | undefined,
-): ethersV6.Authorization | undefined => {
-  if (!authorizationData) return undefined;
-  const { v, r, s, nonce, chainId, address } = authorizationData;
-  const signature = ethersV6.Signature.from({ v, r, s });
-  return { signature, nonce: BigInt(nonce), chainId: BigInt(chainId), address };
-};

package/src/functions/private-wallet/emporium.swap.helpers.ts

@@ -1,284 +0,0 @@
-import { BigNumber, ethers } from 'ethers';
-import { createApproveEmporiumOp, emporiumOp } from './emporium.helpers';
-import {
-  NATIVE_TOKEN_WRAPPER_ADDRESSES,
-  SWAP_FEE_TAKER_ADDRESSES,
-  WRAPPER_TOKEN_EXCHANGE_ADDRESSES,
-} from '../../constants/addresses.constants';
-import { IHinkal } from '../../data-structures/Hinkal/IHinkal';
-import { ExternalActionId } from '../../types/external-action.types';
-import { ContractType } from '../../types/ethereum-network.types';
-import { getExternalSwapAddress } from '../pre-transaction/getExternalSwapAddress';
-import { replaceAllInstances } from '../utils/string.utils';
-import { HINKAL_SWAP_VARIABLE_RATE, zeroAddress } from '../../constants/protocol.constants';
-import { getERC20Registry } from '../../constants/token-data';
-import { caseInsensitiveEqual } from '../utils/caseInsensitive.utils';
-import { Logger } from '../../error-handling/logger';
-
-export const createSwapToEmporiumOpForUniswap = (
-  routerAddress: string,
-  inputTokenAddress: string,
-  positiveAmountInput: bigint,
-  outputTokenAddress: string,
-  recipient: string,
-  data: string,
-  invokeWallet = false,
-) => {
-  const fee = BigNumber.from(data).toBigInt();
-  const exactInputSingleParams = {
-    tokenIn: inputTokenAddress,
-    tokenOut: outputTokenAddress,
-    fee,
-    recipient,
-    amountIn: positiveAmountInput,
-    amountOutMinimum: 0,
-    sqrtPriceLimitX96: 0,
-  };
-
-  const routerAbi = [
-    'function exactInputSingle(tuple(address tokenIn,address tokenOut,uint24 fee,address recipient,uint256 amountIn,uint256 amountOutMinimum,uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
-  ];
-
-  const uniswap = new ethers.Contract(routerAddress, routerAbi);
-  return emporiumOp({
-    contract: uniswap,
-    func: 'exactInputSingle',
-    args: [exactInputSingleParams],
-    invokeWallet,
-  });
-};
-
-export const createSwapToEmporiumOpFromData = (
-  hinkal: IHinkal,
-  externalActionId: ExternalActionId,
-  routerAddress: string,
-  data: string,
-  walletAddress: string,
-  value?: bigint,
-  invokeWallet = false,
-) => {
-  const externalAddress = getExternalSwapAddress(hinkal, externalActionId);
-  const modifiedData = replaceAllInstances(data, externalAddress.slice(2), walletAddress.slice(2));
-
-  return emporiumOp({
-    contract: routerAddress,
-    callDataString: modifiedData,
-    value,
-    invokeWallet,
-  });
-};
-
-export const nullifyApprovalBeforeSwap = async (
-  hinkal: IHinkal,
-  ops: string[],
-  tokenContract: ethers.Contract,
-  walletAddress: string,
-  routerAddress: string,
-  invokeWallet: boolean,
-) => {
-  const tokenAddress = tokenContract.address;
-  const tokenRegistry = getERC20Registry(hinkal.getCurrentChainId());
-  const usdtToken = tokenRegistry.find((token) => token.symbol === 'USDT');
-
-  if (!usdtToken) return;
-  if (caseInsensitiveEqual(tokenAddress, usdtToken.erc20TokenAddress)) {
-    try {
-      const allowance: BigNumber = await tokenContract['allowance'](walletAddress, routerAddress);
-      if (allowance.toBigInt() > 0n) {
-        ops.push(createApproveEmporiumOp(tokenContract, routerAddress, 0n, invokeWallet));
-      }
-    } catch (error) {
-      Logger.error('Error in nullifyApprovalBeforeSwap', error);
-    }
-  }
-};
-
-const takeSwapFee = async (
-  hinkal: IHinkal,
-  outputTokenAddress: string,
-  walletAddress: string,
-  relay: string,
-  ops: string[],
-  invokeWallet: boolean,
-  outputAmount: bigint,
-) => {
-  if (outputTokenAddress !== zeroAddress) {
-    // we want to apply some variable fee to the swap
-    const swapFeeTakerAddress = SWAP_FEE_TAKER_ADDRESSES[hinkal.getCurrentChainId()];
-    const outputTokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, outputTokenAddress);
-    const balanceOfOutputTokenBefore: BigNumber = await outputTokenContract['balanceOf'](walletAddress);
-
-    ops.push(createApproveEmporiumOp(outputTokenContract, swapFeeTakerAddress, 2n ** 256n - 1n, invokeWallet));
-
-    const swapFeeTakerAbi = [
-      'function takeSwapFee(address token, uint256 beforeBalance, uint256 variableRate, address relay) external payable',
-    ];
-    const swapFeeTakerContract = new ethers.Contract(swapFeeTakerAddress, swapFeeTakerAbi);
-    const receiver = relay;
-    ops.push(
-      emporiumOp({
-        contract: swapFeeTakerContract,
-        func: 'takeSwapFee',
-        args: [outputTokenAddress, balanceOfOutputTokenBefore, HINKAL_SWAP_VARIABLE_RATE, receiver],
-        invokeWallet,
-      }),
-    );
-  } else {
-    // Here we want to transfer the swapped native ETH output to the relayer
-    const receiver = relay;
-    ops.push(
-      emporiumOp({
-        contract: receiver,
-        value: (outputAmount * HINKAL_SWAP_VARIABLE_RATE) / 10000n,
-        invokeWallet,
-      }),
-    );
-  }
-};
-
-// OneInch and Lifi can deal with native Eth
-// Uniswap and Odos needs wrapping
-export const createSwapToEmporiumOps = async (
-  hinkal: IHinkal,
-  externalActionId: ExternalActionId,
-  routerAddress: string,
-  data: string,
-  inputTokenAddress: string,
-  inputAmount: bigint,
-  outputAmount: bigint | undefined,
-  outputTokenAddress: string | undefined,
-  isTheSameChainSwap: boolean,
-  walletAddress: string,
-  relay: string,
-  invokeWallet = false,
-) => {
-  const positiveAmountInput = inputAmount < 0n ? -1n * inputAmount : inputAmount;
-  const chainId = hinkal.getCurrentChainId();
-
-  const ops: string[] = [];
-  const wrapperAddress = NATIVE_TOKEN_WRAPPER_ADDRESSES[chainId];
-  let shouldUnwrap = false;
-  let swapOp;
-
-  // OneInch and Lifi
-  if (externalActionId === ExternalActionId.OneInch || externalActionId === ExternalActionId.Lifi) {
-    if (inputTokenAddress !== zeroAddress) {
-      const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, inputTokenAddress);
-      ops.push(createApproveEmporiumOp(tokenContract, routerAddress, positiveAmountInput, invokeWallet));
-    }
-
-    // During bridging, LiFi may request an additional native token amount stored in outputAmount.
-    // Any native token required on either side input or output is accumulated into value.
-    let value = 0n;
-
-    if (inputTokenAddress === zeroAddress) {
-      value += positiveAmountInput;
-    }
-
-    if (outputAmount && outputTokenAddress === zeroAddress && outputAmount < 0n) {
-      value += -1n * outputAmount;
-    }
-
-    const finalValue = value > 0n ? value : undefined;
-
-    swapOp = createSwapToEmporiumOpFromData(
-      hinkal,
-      externalActionId,
-      routerAddress,
-      data,
-      walletAddress,
-      finalValue,
-      invokeWallet,
-    );
-    ops.push(swapOp);
-
-    if (
-      (externalActionId === ExternalActionId.OneInch ||
-        (isTheSameChainSwap && externalActionId === ExternalActionId.Lifi)) &&
-      outputTokenAddress &&
-      outputAmount !== undefined
-    ) {
-      await takeSwapFee(hinkal, outputTokenAddress, walletAddress, relay, ops, invokeWallet, outputAmount);
-    }
-
-    return ops;
-  }
-
-  if (!outputTokenAddress || !outputAmount) throw Error('There should be output token for UniSwap and Odos');
-
-  // Uniswap and ODOS case
-  if (inputTokenAddress === zeroAddress) {
-    const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, wrapperAddress);
-    ops.push(
-      emporiumOp({
-        contract: tokenContract,
-        func: 'deposit',
-        value: positiveAmountInput,
-        invokeWallet,
-      }),
-    );
-    inputTokenAddress = wrapperAddress;
-  }
-
-  let wrappedTokenBalanceBefore = 0n;
-
-  if (outputTokenAddress === zeroAddress) {
-    outputTokenAddress = wrapperAddress;
-    shouldUnwrap = true;
-    const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, wrapperAddress);
-    wrappedTokenBalanceBefore = await tokenContract['balanceOf'](walletAddress);
-  }
-
-  if (inputTokenAddress !== zeroAddress) {
-    const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, inputTokenAddress);
-    // USDT needs to set approval to 0, before you increase it. If you already have positive approval to Odos and then you try to increase it, it will fail
-    await nullifyApprovalBeforeSwap(hinkal, ops, tokenContract, walletAddress, routerAddress, invokeWallet);
-    ops.push(createApproveEmporiumOp(tokenContract, routerAddress, positiveAmountInput, invokeWallet));
-  }
-
-  if (externalActionId === ExternalActionId.Uniswap) {
-    swapOp = createSwapToEmporiumOpForUniswap(
-      routerAddress,
-      inputTokenAddress,
-      positiveAmountInput,
-      outputTokenAddress,
-      walletAddress,
-      data,
-      invokeWallet,
-    );
-  } else {
-    swapOp = createSwapToEmporiumOpFromData(
-      hinkal,
-      externalActionId,
-      routerAddress,
-      data,
-      walletAddress,
-      undefined,
-      invokeWallet,
-    );
-  }
-  ops.push(swapOp);
-
-  await takeSwapFee(hinkal, outputTokenAddress, walletAddress, relay, ops, invokeWallet, outputAmount);
-
-  // finally we unwrap the wrapped eth to native
-  if (shouldUnwrap) {
-    const wrapperExchangeContract = WRAPPER_TOKEN_EXCHANGE_ADDRESSES[chainId];
-
-    const tokenContract = hinkal.getContractWithFetcher(ContractType.ERC20Contract, wrapperAddress);
-    ops.push(createApproveEmporiumOp(tokenContract, wrapperExchangeContract, 2n ** 256n - 1n, invokeWallet));
-
-    const withdrawAbi = ['function withdrawBalanceDifference(uint256 beforeBalance) external'];
-    const withdrawContract = new ethers.Contract(wrapperExchangeContract, withdrawAbi);
-    ops.push(
-      emporiumOp({
-        contract: withdrawContract,
-        func: 'withdrawBalanceDifference',
-        args: [wrappedTokenBalanceBefore],
-        invokeWallet,
-      }),
-    );
-  }
-
-  return ops;
-};

package/src/functions/private-wallet/opProducer.ts

@@ -1,33 +0,0 @@
-import { ERC20ABI, ISwapRouterABI } from '../../externalABIs';
-import { ethers } from 'ethers';
-import { emporiumOp } from './emporium.helpers';
-
-export enum OpType {
-  Erc20Token,
-  Uniswap,
-}
-
-export const produceOp = (
-  opType: OpType,
-  contractAddress: string,
-  func?: string,
-  args?: any[],
-  invokeWallet?: boolean,
-  value?: bigint,
-): string => {
-  let abi: ethers.ContractInterface = '';
-  switch (opType) {
-    case OpType.Erc20Token:
-      abi = ERC20ABI;
-      break;
-    case OpType.Uniswap:
-      abi = ISwapRouterABI;
-      break;
-    default:
-      break;
-  }
-  if (!abi) throw Error('No ABI match in produceOp');
-
-  const contract = new ethers.Contract(contractAddress, abi);
-  return emporiumOp({ contract, func, args, invokeWallet, value });
-};