@sabaaa1/common 0.0.8 → 0.0.9

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

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

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

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

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

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