@imtbl/checkout-widgets 2.4.13 → 2.4.14-alpha.0

package/dist/browser/{index-C52OgfPn.js → index-CxVwwdjo.js}

@@ -1,4 +1,4 @@
-import { e4 as __awaiter, e5 as __generator, e6 as loadScript, e7 as getNextIntegrationsURL, e8 as unloadScript, e9 as __spreadArray, ea as isOffline, eb as __assign, ec as ContextCancelation, ed as applyDestinationMiddleware, ee as dist, ef as isServer, eg as mergedOptions, eh as isPlainObject, ei as pWhile, ej as PriorityQueue, ek as PersistedPriorityQueue, el as attempt, em as isOnline, en as Context } from './index-Co43S-f8.js';
+import { e5 as __awaiter, e6 as __generator, e7 as loadScript, e8 as getNextIntegrationsURL, e9 as unloadScript, ea as __spreadArray, eb as isOffline, ec as __assign, ed as ContextCancelation, ee as applyDestinationMiddleware, ef as dist, eg as isServer, eh as mergedOptions, ei as isPlainObject, ej as pWhile, ek as PriorityQueue, el as PersistedPriorityQueue, em as attempt, en as isOnline, eo as Context } from './index-CYSUCb_r.js';
 import { i as isPlanEventEnabled } from './is-plan-event-enabled-mXX0dwl-.js';
 
 function normalizeName(name) {

package/dist/browser/{index-iCexzEAZ.js → index-DfqbSiW-.js}

@@ -1,4 +1,4 @@
-import { dW as se$1, dX as T$2, dY as oe$1, dZ as R$1, d_ as a$2, d$ as te$1, e0 as p$1, e1 as ne$1, e2 as y$1 } from './index-Co43S-f8.js';
+import { dX as se$1, dY as T$2, dZ as oe$1, d_ as R$1, d$ as a$2, e0 as te$1, e1 as p$1, e2 as ne$1, e3 as y$1 } from './index-CYSUCb_r.js';
 
 /**
  * @license

package/dist/browser/{index-C7zLn4CO.js → index-DhJhrEPT.js}

@@ -1,4 +1,4 @@
-import { ep as gracefulDecodeURIComponent, eh as isPlainObject } from './index-Co43S-f8.js';
+import { eq as gracefulDecodeURIComponent, ei as isPlainObject } from './index-CYSUCb_r.js';
 
 /**
  * Returns an object containing only the properties prefixed by the input

package/dist/browser/{index-B6adB8ks.js → index-DkUaawBA.js}

@@ -1,4 +1,4 @@
-import { e4 as __awaiter, e5 as __generator, ef as isServer, e7 as getNextIntegrationsURL, e6 as loadScript } from './index-Co43S-f8.js';
+import { e5 as __awaiter, e6 as __generator, eg as isServer, e8 as getNextIntegrationsURL, e7 as loadScript } from './index-CYSUCb_r.js';
 
 function remoteMiddlewares(ctx, settings, obfuscate) {
     var _a;

package/dist/browser/{index-COIl8mga.js → index-_E9_8iXP.js}

@@ -1,4 +1,4 @@
-import { eb as __assign } from './index-Co43S-f8.js';
+import { ec as __assign } from './index-CYSUCb_r.js';
 import { i as isPlanEventEnabled } from './is-plan-event-enabled-mXX0dwl-.js';
 
 function disabledActionDestinations(plan, settings) {

package/dist/browser/index.js

@@ -1 +1 @@
-export { eq as WidgetsFactory } from './index-Co43S-f8.js';
+export { er as WidgetsFactory } from './index-CYSUCb_r.js';

package/dist/browser/{index.umd-ENtuIC6R.js → index.umd-C_C0lXQh.js}

@@ -1,4 +1,4 @@
-import { ay as getDefaultExportFromCjs } from './index-Co43S-f8.js';
+import { ay as getDefaultExportFromCjs } from './index-CYSUCb_r.js';
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {

package/dist/browser/{useInterval-BaXQ-Cl5.js → useInterval-BjJWflew.js}

@@ -1,4 +1,4 @@
-import { r as reactExports, dV as useBrowserLayoutEffect } from './index-Co43S-f8.js';
+import { r as reactExports, dW as useBrowserLayoutEffect } from './index-CYSUCb_r.js';
 
 // Inspired by https://usehooks-ts.com/react-hook/use-interval
 function useInterval(callback, delay) {

package/dist/types/lib/squid/functions/execute.d.ts

@@ -0,0 +1,8 @@
+import { EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { Flow } from '@imtbl/metrics';
+import { ethers, TransactionReceipt } from 'ethers';
+import { RouteResponse } from '@0xsquid/squid-types';
+import { Squid } from '@0xsquid/sdk';
+export declare const waitForReceipt: (provider: WrappedBrowserProvider, txHash: string, maxAttempts?: number) => Promise<ethers.TransactionReceipt>;
+export declare const callApprove: (flow: Flow, fromProviderInfo: EIP6963ProviderInfo, provider: WrappedBrowserProvider, routeResponse: RouteResponse) => Promise<TransactionReceipt>;
+export declare const callExecute: (flow: Flow, squid: Squid, fromProviderInfo: EIP6963ProviderInfo, provider: WrappedBrowserProvider, routeResponse: RouteResponse) => Promise<TransactionReceipt>;

package/dist/types/lib/squid/functions/routeCalculation.d.ts

@@ -0,0 +1,22 @@
+import { TokenBalance } from '@0xsquid/sdk/dist/types';
+import { WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { FromAmountData, Token } from '../types';
+/**
+ * Functions to handle route amount calculations.
+ */
+/**
+ * Calculate the fromAmount based on USD prices and slippage.
+ */
+export declare const calculateFromAmount: (fromToken: Token, toToken: Token, toAmount: string, additionalBuffer?: number) => string;
+/**
+ * Calculate the fromAmount using exchange rate returned from the route.
+ */
+export declare const calculateFromAmountFromRoute: (exchangeRate: string, toAmount: string, toAmountUSD?: string) => string;
+/**
+ * Convert a string amount to a formatted amount with the specified number of decimals.
+ */
+export declare const convertToFormattedFromAmount: (amount: string, decimals: number) => string;
+export declare const getFromAmountData: (tokens: Token[], balance: TokenBalance, toAmount: string, toChainId: string, toTokenAddress: string, additionalBuffer?: number) => FromAmountData | undefined;
+export declare const getSufficientFromAmounts: (tokens: Token[], balances: TokenBalance[], toChainId: string, toTokenAddress: string, toAmount: string) => FromAmountData[];
+export declare const hasSufficientBalance: (balances: TokenBalance[], toTokenAddress: string, toChainId: string, toAmount: string) => boolean;
+export declare const hasSufficientGas: (balances: TokenBalance[], selectedChainId: string | number, provider: WrappedBrowserProvider | undefined) => boolean;

package/dist/types/lib/squid/functions/slippage.d.ts

@@ -0,0 +1 @@
+export declare const calculateAdjustedAmount: (baseAmount: number, usdAmount: number, additionalBuffer?: number) => number;

package/dist/types/lib/squid/hooks/useExecute.d.ts

@@ -1,6 +1,6 @@
 import { RouteResponse } from '@0xsquid/squid-types';
 import { Squid } from '@0xsquid/sdk';
-import { ethers, TransactionReceipt } from 'ethers';
+import { TransactionReceipt } from 'ethers';
 import { StatusResponse } from '@0xsquid/sdk/dist/types';
 import { EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
 import { UserJourney } from '../../../context/analytics-provider/SegmentAnalyticsProvider';
@@ -9,5 +9,4 @@ export declare const useExecute: (userJourney: UserJourney, onTransactionError?:
     approve: (fromProviderInfo: EIP6963ProviderInfo, provider: WrappedBrowserProvider, routeResponse: RouteResponse) => Promise<TransactionReceipt | undefined>;
     execute: (squid: Squid, fromProviderInfo: EIP6963ProviderInfo, provider: WrappedBrowserProvider, routeResponse: RouteResponse) => Promise<TransactionReceipt | undefined>;
     getStatus: (squid: Squid, transactionHash: string) => Promise<StatusResponse | undefined>;
-    waitForReceipt: (provider: WrappedBrowserProvider, txHash: string, maxAttempts?: number) => Promise<ethers.TransactionReceipt>;
 };

package/dist/types/lib/squid/hooks/useRoutes.d.ts

@@ -1,12 +1,8 @@
 import { TokenBalance } from '@0xsquid/sdk/dist/types';
 import { Squid } from '@0xsquid/sdk';
-import { WrappedBrowserProvider } from '@imtbl/checkout-sdk';
-import { FromAmountData, RouteData, RouteResponseData, Token } from '../types';
+import { RouteData, RouteResponseData, Token } from '../types';
 import { SquidPostHook } from '../../primary-sales';
 export declare const useRoutes: () => {
-    hasSufficientBalance: (balances: TokenBalance[], toTokenAddress: string, toChainId: string, toAmount: string) => boolean;
-    hasSufficientGas: (balances: TokenBalance[], selectedChainId: string | number, provider: WrappedBrowserProvider | undefined) => boolean;
     fetchRoutes: (squid: Squid, tokens: Token[], balances: TokenBalance[], toChainId: string, toTokenAddress: string, toAmount: string, bulkNumber?: number, delayMs?: number, isSwapAllowed?: boolean) => Promise<RouteData[]>;
-    getFromAmountData: (tokens: Token[], balance: TokenBalance, toAmount: string, toChainId: string, toTokenAddress: string, additionalBuffer?: number) => FromAmountData | undefined;
     getRoute: (squid: Squid, fromToken: Token, toToken: Token, toAddress: string, fromAmount: string, toAmount: string, fromAddress?: string, quoteOnly?: boolean, postHook?: SquidPostHook) => Promise<RouteResponseData>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imtbl/checkout-widgets",
-  "version": "2.4.13",
+  "version": "2.4.14-alpha.0",
   "browserslist": {
     "production": [
       ">0.2%",
@@ -18,12 +18,12 @@
     "@biom3/design-tokens": "^0.4.5",
     "@biom3/react": "^0.29.4",
     "@emotion/react": "^11.11.3",
-    "@imtbl/bridge-sdk": "2.4.13",
-    "@imtbl/checkout-sdk": "2.4.13",
-    "@imtbl/config": "2.4.13",
-    "@imtbl/cryptofiat": "2.4.13",
-    "@imtbl/dex-sdk": "2.4.13",
-    "@imtbl/passport": "2.4.13",
+    "@imtbl/bridge-sdk": "2.4.14-alpha.0",
+    "@imtbl/checkout-sdk": "2.4.14-alpha.0",
+    "@imtbl/config": "2.4.14-alpha.0",
+    "@imtbl/cryptofiat": "2.4.14-alpha.0",
+    "@imtbl/dex-sdk": "2.4.14-alpha.0",
+    "@imtbl/passport": "2.4.14-alpha.0",
     "@imtbl/react-analytics": "0.3.2-alpha",
     "@rive-app/react-canvas-lite": "^4.9.0",
     "@walletconnect/ethereum-provider": "^2.11.1",

package/src/lib/squid/functions/execute.ts

@@ -0,0 +1,88 @@
+import { EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { Flow } from '@imtbl/metrics';
+import { ethers, TransactionReceipt, TransactionResponse } from 'ethers';
+import { RouteResponse } from '@0xsquid/squid-types';
+import { Squid } from '@0xsquid/sdk';
+import { EvmWallet } from '@0xsquid/sdk/dist/types';
+import { retry } from '../../retry';
+
+export const waitForReceipt = async (
+  provider: WrappedBrowserProvider,
+  txHash: string,
+  maxAttempts = 120,
+) => {
+  const result = await retry(
+    async () => {
+      const receipt = await provider.getTransactionReceipt(txHash);
+      if (!receipt) {
+        throw new Error('receipt not found');
+      }
+      if (receipt.status === 0) {
+        throw new Error('status failed');
+      }
+      return receipt;
+    },
+    {
+      retries: maxAttempts,
+      retryIntervalMs: 1000,
+      nonRetryable: (error) => error.message === 'status failed',
+    },
+  );
+
+  if (!result) {
+    throw new Error(
+      `Transaction receipt not found after ${maxAttempts} attempts`,
+    );
+  }
+
+  return result;
+};
+
+export const callApprove = async (
+  flow: Flow,
+  fromProviderInfo: EIP6963ProviderInfo,
+  provider: WrappedBrowserProvider,
+  routeResponse: RouteResponse,
+): Promise<TransactionReceipt> => {
+  flow.addEvent(`provider_${fromProviderInfo.name}`);
+  const erc20Abi = [
+    'function approve(address spender, uint256 amount) public returns (bool)',
+  ];
+  const fromToken = routeResponse?.route.params.fromToken;
+  const signer = await provider.getSigner();
+  const tokenContract = new ethers.Contract(fromToken, erc20Abi, signer);
+
+  const fromAmount = routeResponse?.route.params.fromAmount;
+  if (!fromAmount) {
+    throw new Error('fromAmount is undefined');
+  }
+
+  const transactionRequestTarget = routeResponse?.route?.transactionRequest?.target;
+  if (!transactionRequestTarget) {
+    throw new Error('transactionRequest target is undefined');
+  }
+
+  const tx = await tokenContract.approve(
+    transactionRequestTarget,
+    fromAmount,
+  );
+  flow.addEvent('transactionSent');
+
+  return await waitForReceipt(provider, tx.hash);
+};
+
+export const callExecute = async (
+  flow: Flow,
+  squid: Squid,
+  fromProviderInfo: EIP6963ProviderInfo,
+  provider: WrappedBrowserProvider,
+  routeResponse: RouteResponse,
+): Promise<TransactionReceipt> => {
+  flow.addEvent(`provider_${fromProviderInfo.name}`);
+  const tx = (await squid.executeRoute({
+    signer: await provider.getSigner() as unknown as EvmWallet,
+    route: routeResponse.route,
+  })) as unknown as TransactionResponse;
+  flow.addEvent('transactionSent');
+  return await waitForReceipt(provider, tx.hash);
+};

package/src/lib/squid/functions/routeCalculation.ts

@@ -0,0 +1,162 @@
+import { formatUnits, parseUnits } from 'ethers';
+import { TokenBalance } from '@0xsquid/sdk/dist/types';
+import { WrappedBrowserProvider } from '@imtbl/checkout-sdk';
+import { calculateAdjustedAmount } from './slippage';
+import { FromAmountData, Token } from '../types';
+import { findToken } from './findToken';
+import { isPassportProvider } from '../../provider/utils';
+import { SQUID_NATIVE_TOKEN } from '../config';
+
+const INSUFFICIENT_GAS_THRESHOLD = 0.1;
+
+/**
+ * Functions to handle route amount calculations.
+ */
+
+/**
+ * Calculate the fromAmount based on USD prices and slippage.
+ */
+export const calculateFromAmount = (
+  fromToken: Token,
+  toToken: Token,
+  toAmount: string,
+  additionalBuffer: number = 0,
+) => {
+  const toAmountNumber = parseFloat(toAmount);
+  // Calculate the USD value of the toAmount
+  const toAmountInUsd = toAmountNumber * toToken.usdPrice;
+  // Calculate the amount of fromToken needed to match this USD value
+  const baseFromAmount = toAmountInUsd / fromToken.usdPrice;
+  // Add a buffer for price fluctuations and fees
+  const fromAmountWithBuffer = calculateAdjustedAmount(baseFromAmount, toAmountInUsd, additionalBuffer);
+
+  return fromAmountWithBuffer.toString();
+};
+
+/**
+ * Calculate the fromAmount using exchange rate returned from the route.
+ */
+export const calculateFromAmountFromRoute = (
+  exchangeRate: string,
+  toAmount: string,
+  toAmountUSD?: string,
+) => {
+  const toAmountUSDNumber = toAmountUSD ? parseFloat(toAmountUSD) : 0;
+  const fromAmount = parseFloat(toAmount) / parseFloat(exchangeRate);
+  const fromAmountWithBuffer = calculateAdjustedAmount(fromAmount, toAmountUSDNumber);
+  return fromAmountWithBuffer.toString();
+};
+
+/**
+ * Convert a string amount to a formatted amount with the specified number of decimals.
+ */
+export const convertToFormattedFromAmount = (amount: string, decimals: number) => {
+  const parsedFromAmount = parseFloat(amount).toFixed(decimals);
+  const formattedFromAmount = parseUnits(parsedFromAmount, decimals);
+  return formattedFromAmount.toString();
+};
+
+export const getFromAmountData = (
+  tokens: Token[],
+  balance: TokenBalance,
+  toAmount: string,
+  toChainId: string,
+  toTokenAddress: string,
+  additionalBuffer: number = 0,
+): FromAmountData | undefined => {
+  const fromToken = findToken(
+    tokens,
+    balance.address,
+    balance.chainId.toString(),
+  );
+  const toToken = findToken(tokens, toTokenAddress, toChainId);
+
+  if (!fromToken || !toToken) {
+    return undefined;
+  }
+
+  return {
+    fromToken,
+    fromAmount: calculateFromAmount(
+      fromToken,
+      toToken,
+      toAmount,
+      additionalBuffer,
+    ),
+    toToken,
+    toAmount,
+    balance,
+    additionalBuffer,
+  };
+};
+
+export const getSufficientFromAmounts = (
+  tokens: Token[],
+  balances: TokenBalance[],
+  toChainId: string,
+  toTokenAddress: string,
+  toAmount: string,
+): FromAmountData[] => {
+  const filteredBalances = balances.filter(
+    (balance) => !(
+      balance.address.toLowerCase() === toTokenAddress.toLowerCase()
+        && balance.chainId === toChainId
+    ),
+  );
+
+  const fromAmountDataArray: FromAmountData[] = filteredBalances
+    .map((balance) => getFromAmountData(tokens, balance, toAmount, toChainId, toTokenAddress))
+    .filter((value) => value !== undefined);
+
+  return fromAmountDataArray.filter((data: FromAmountData) => {
+    const formattedBalance = formatUnits(
+      data.balance.balance,
+      data.balance.decimals,
+    );
+    return (
+      parseFloat(formattedBalance.toString()) > parseFloat(data.fromAmount)
+    );
+  });
+};
+
+export const hasSufficientBalance = (
+  balances: TokenBalance[],
+  toTokenAddress: string,
+  toChainId: string,
+  toAmount: string,
+): boolean => {
+  const matchingTokens = balances.filter(
+    (balance) => balance.address.toLowerCase() === toTokenAddress.toLowerCase()
+      && balance.chainId.toString() === toChainId.toString(),
+  );
+
+  if (matchingTokens.length > 0) {
+    return matchingTokens.some((balance) => {
+      const tokenAmount = parseFloat(formatUnits(balance.balance, balance.decimals));
+      return tokenAmount >= parseFloat(toAmount);
+    });
+  }
+
+  return false;
+};
+
+export const hasSufficientGas = (
+  balances: TokenBalance[],
+  selectedChainId: string | number,
+  provider: WrappedBrowserProvider | undefined,
+): boolean => {
+  if (!provider) return false;
+  if (isPassportProvider(provider)) return true;
+
+  const nativeCurrencyBalance = balances.find(
+    (balance) => balance.address.toLowerCase() === SQUID_NATIVE_TOKEN.toLowerCase()
+      && balance.chainId.toString() === selectedChainId.toString(),
+  );
+  if (!nativeCurrencyBalance) return false;
+
+  const nativeCurrencyBalanceAmount = parseFloat(
+    formatUnits(nativeCurrencyBalance.balance, nativeCurrencyBalance.decimals),
+  );
+  if (nativeCurrencyBalanceAmount < INSUFFICIENT_GAS_THRESHOLD) return false;
+  return true;
+};

package/src/lib/squid/functions/slippage.ts

@@ -0,0 +1,36 @@
+const BASE_SLIPPAGE_HIGH_TIER = 0.005;
+const BASE_SLIPPAGE_MEDIUM_TIER = 0.01;
+const BASE_SLIPPAGE_LOW_TIER = 0.015;
+
+const SLIPPAGE_TIERS = {
+  high: {
+    threshold: 999,
+    value: BASE_SLIPPAGE_HIGH_TIER,
+  },
+  medium: {
+    threshold: 99,
+    value: BASE_SLIPPAGE_MEDIUM_TIER,
+  },
+  low: {
+    threshold: 0,
+    value: BASE_SLIPPAGE_LOW_TIER,
+  },
+} as const;
+
+/**
+ * Functions to calculate slippage based on thresholds
+ */
+const getSlippageTier = (usdAmount: number): number => {
+  if (usdAmount >= SLIPPAGE_TIERS.high.threshold) return SLIPPAGE_TIERS.high.value;
+  if (usdAmount >= SLIPPAGE_TIERS.medium.threshold) return SLIPPAGE_TIERS.medium.value;
+  return SLIPPAGE_TIERS.low.value;
+};
+
+export const calculateAdjustedAmount = (
+  baseAmount: number,
+  usdAmount: number,
+  additionalBuffer: number = 0,
+): number => {
+  const slippage = getSlippageTier(usdAmount);
+  return baseAmount * (1 + slippage + additionalBuffer);
+};

package/src/lib/squid/hooks/useExecute.ts

@@ -1,17 +1,17 @@
 import { RouteResponse } from '@0xsquid/squid-types';
 import { Squid } from '@0xsquid/sdk';
 import {
-  ethers, MaxUint256, TransactionReceipt, TransactionResponse,
+  ethers, MaxUint256, TransactionReceipt,
 } from 'ethers';
 
-import { StatusResponse, EvmWallet } from '@0xsquid/sdk/dist/types';
-import { Flow } from '@imtbl/metrics';
+import { StatusResponse } from '@0xsquid/sdk/dist/types';
 import { EIP6963ProviderInfo, WrappedBrowserProvider } from '@imtbl/checkout-sdk';
 import { isSquidNativeToken } from '../functions/isSquidNativeToken';
 import { retry } from '../../retry';
 import { withMetricsAsync } from '../../metrics';
 import { useAnalytics, UserJourney } from '../../../context/analytics-provider/SegmentAnalyticsProvider';
 import { isRejectedError } from '../../../functions/errorType';
+import { callApprove, callExecute } from '../functions/execute';
 
 const TRANSACTION_NOT_COMPLETED = 'transaction not completed';
 
@@ -21,38 +21,6 @@ export const useExecute = (
 ) => {
   const { user } = useAnalytics();
 
-  const waitForReceipt = async (
-    provider: WrappedBrowserProvider,
-    txHash: string,
-    maxAttempts = 120,
-  ) => {
-    const result = await retry(
-      async () => {
-        const receipt = await provider.getTransactionReceipt(txHash);
-        if (!receipt) {
-          throw new Error('receipt not found');
-        }
-        if (receipt.status === 0) {
-          throw new Error('status failed');
-        }
-        return receipt;
-      },
-      {
-        retries: maxAttempts,
-        retryIntervalMs: 1000,
-        nonRetryable: (error) => error.message === 'status failed',
-      },
-    );
-
-    if (!result) {
-      throw new Error(
-        `Transaction receipt not found after ${maxAttempts} attempts`,
-      );
-    }
-
-    return result;
-  };
-
   const getAllowance = async (
     provider: WrappedBrowserProvider,
     routeResponse: RouteResponse,
@@ -86,39 +54,6 @@ export const useExecute = (
     }
   };
 
-  const callApprove = async (
-    flow:Flow,
-    fromProviderInfo: EIP6963ProviderInfo,
-    provider: WrappedBrowserProvider,
-    routeResponse: RouteResponse,
-  ): Promise<TransactionReceipt> => {
-    flow.addEvent(`provider_${fromProviderInfo.name}`);
-    const erc20Abi = [
-      'function approve(address spender, uint256 amount) public returns (bool)',
-    ];
-    const fromToken = routeResponse?.route.params.fromToken;
-    const signer = await provider.getSigner();
-    const tokenContract = new ethers.Contract(fromToken, erc20Abi, signer);
-
-    const fromAmount = routeResponse?.route.params.fromAmount;
-    if (!fromAmount) {
-      throw new Error('fromAmount is undefined');
-    }
-
-    const transactionRequestTarget = routeResponse?.route?.transactionRequest?.target;
-    if (!transactionRequestTarget) {
-      throw new Error('transactionRequest target is undefined');
-    }
-
-    const tx = await tokenContract.approve(
-      transactionRequestTarget,
-      fromAmount,
-    );
-    flow.addEvent('transactionSent');
-
-    return await waitForReceipt(provider, tx.hash);
-  };
-
   const getAnonymousId = async () => {
     try {
       const userData = await user();
@@ -149,22 +84,6 @@ export const useExecute = (
     }
   };
 
-  const callExecute = async (
-    flow: Flow,
-    squid: Squid,
-    fromProviderInfo: EIP6963ProviderInfo,
-    provider: WrappedBrowserProvider,
-    routeResponse: RouteResponse,
-  ): Promise<TransactionReceipt> => {
-    flow.addEvent(`provider_${fromProviderInfo.name}`);
-    const tx = (await squid.executeRoute({
-      signer: await provider.getSigner() as unknown as EvmWallet,
-      route: routeResponse.route,
-    })) as unknown as TransactionResponse;
-    flow.addEvent('transactionSent');
-    return await waitForReceipt(provider, tx.hash);
-  };
-
   const execute = async (
     squid: Squid,
     fromProviderInfo: EIP6963ProviderInfo,
@@ -234,6 +153,5 @@ export const useExecute = (
     approve,
     execute,
     getStatus,
-    waitForReceipt,
   };
 };