diff --git a/.changeset/twenty-sites-smile.md b/.changeset/twenty-sites-smile.md
new file mode 100644
index 0000000000..164b1d8092
--- /dev/null
+++ b/.changeset/twenty-sites-smile.md
@@ -0,0 +1,5 @@
+---
+"@venusprotocol/evm": minor
+---
+
+add base Boost tab
diff --git a/apps/evm/src/clients/api/__mocks__/index.ts b/apps/evm/src/clients/api/__mocks__/index.ts
index 65ed32216d..c552fe8a9f 100644
--- a/apps/evm/src/clients/api/__mocks__/index.ts
+++ b/apps/evm/src/clients/api/__mocks__/index.ts
@@ -613,6 +613,16 @@ export const useGetAccountTransactionHistory = vi.fn(() =>
   }),
 );
 
+export const getSwapQuote = vi.fn(async () => ({
+  swapQuote: undefined,
+}));
+export const useGetSwapQuote = vi.fn(() =>
+  useQuery({
+    queryKey: [FunctionKey.GET_SWAP_QUOTE],
+    queryFn: getSwapQuote,
+  }),
+);
+
 // Mutations
 export const useApproveToken = vi.fn((_variables: never, options?: MutationObserverOptions) =>
   useMutation({
@@ -677,6 +687,14 @@ export const useBorrow = vi.fn((_variables: never, options?: MutationObserverOpt
   }),
 );
 
+export const useOpenLeveragedPosition = vi.fn(
+  (_variables: never, options?: MutationObserverOptions) =>
+    useMutation({
+      mutationFn: vi.fn(),
+      ...options,
+    }),
+);
+
 export const withdrawXvs = vi.fn();
 export const useWithdrawXvs = (options?: MutationObserverOptions) =>
   useMutation({
diff --git a/apps/evm/src/clients/api/index.ts b/apps/evm/src/clients/api/index.ts
index 7961a01059..c4e05de09a 100644
--- a/apps/evm/src/clients/api/index.ts
+++ b/apps/evm/src/clients/api/index.ts
@@ -31,6 +31,7 @@ export * from './mutations/useSwapTokens';
 export * from './mutations/useWithdraw';
 export * from './mutations/useImportSupplyPosition';
 export * from './mutations/useSetEModeGroup';
+export * from './mutations/useOpenLeveragedPosition';
 
 // Queries
 export * from './queries/getVaiTreasuryPercentage';
@@ -226,3 +227,6 @@ export * from './queries/getAccountTransactionHistory/useGetAccountTransactionHi
 
 export * from './queries/getSimulatedPool';
 export * from './queries/getSimulatedPool/useGetSimulatedPool';
+
+export * from './queries/getSwapQuote';
+export * from './queries/getSwapQuote/useGetSwapQuote';
diff --git a/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/__snapshots__/index.spec.ts.snap b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/__snapshots__/index.spec.ts.snap
new file mode 100644
index 0000000000..b579c8c6d9
--- /dev/null
+++ b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/__snapshots__/index.spec.ts.snap
@@ -0,0 +1,54 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`useOpenLeveragedPosition > calls useSendTransaction with correct parameters 'with single asset' 1`] = `
+{
+  "abi": Any<Array>,
+  "address": "0xfakeLeverageManagerContractAddress",
+  "args": [
+    "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+    0n,
+    100000000n,
+  ],
+  "functionName": "enterSingleAssetLeverage",
+}
+`;
+
+exports[`useOpenLeveragedPosition > calls useSendTransaction with correct parameters 'with single asset' 2`] = `
+[
+  [
+    {
+      "queryKey": [
+        "GET_POOLS",
+      ],
+    },
+  ],
+]
+`;
+
+exports[`useOpenLeveragedPosition > calls useSendTransaction with correct parameters 'with swapQuote' 1`] = `
+{
+  "abi": Any<Array>,
+  "address": "0xfakeLeverageManagerContractAddress",
+  "args": [
+    "0x170d3b2da05cc2124334240fB34ad1359e34C562",
+    0n,
+    "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+    100000000n,
+    100000000n,
+    "0x",
+  ],
+  "functionName": "enterLeverage",
+}
+`;
+
+exports[`useOpenLeveragedPosition > calls useSendTransaction with correct parameters 'with swapQuote' 2`] = `
+[
+  [
+    {
+      "queryKey": [
+        "GET_POOLS",
+      ],
+    },
+  ],
+]
+`;
diff --git a/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/index.spec.ts b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/index.spec.ts
new file mode 100644
index 0000000000..2fc15876b0
--- /dev/null
+++ b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/index.spec.ts
@@ -0,0 +1,76 @@
+import { lisUsd, usdc } from '__mocks__/models/tokens';
+import { vLisUSD, vUsdc } from '__mocks__/models/vTokens';
+import { queryClient } from 'clients/api';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import { useSendTransaction } from 'hooks/useSendTransaction';
+import { renderHook } from 'testUtils/render';
+import type { ExactInSwapQuote } from 'types';
+import type { Mock } from 'vitest';
+import { useOpenLeveragedPosition } from '..';
+
+const fakeSwapQuote: ExactInSwapQuote = {
+  fromToken: usdc,
+  toToken: lisUsd,
+  direction: 'exact-in',
+  priceImpactPercentage: 0.1,
+  fromTokenAmountSoldMantissa: 100000000n,
+  expectedToTokenAmountReceivedMantissa: 100000000n,
+  minimumToTokenAmountReceivedMantissa: 100000000n,
+  callData: '0x',
+};
+
+vi.mock('libs/contracts');
+
+describe('useOpenLeveragedPosition', () => {
+  it.each([
+    {
+      label: 'with swapQuote',
+      input: {
+        borrowedVToken: vUsdc,
+        suppliedVToken: vLisUSD,
+        swapQuote: fakeSwapQuote,
+      },
+    },
+    {
+      label: 'with single asset',
+      input: {
+        vToken: vUsdc,
+        amountMantissa: 100000000n,
+      },
+    },
+  ])('calls useSendTransaction with correct parameters $label', async ({ input }) => {
+    renderHook(() => useOpenLeveragedPosition());
+
+    expect(useSendTransaction).toHaveBeenCalledWith({
+      fn: expect.any(Function),
+      onConfirmed: expect.any(Function),
+      options: undefined,
+    });
+
+    const { fn } = (useSendTransaction as jest.Mock).mock.calls[0][0];
+
+    expect(await fn(input)).toMatchSnapshot({
+      abi: expect.any(Array),
+    });
+
+    const { onConfirmed } = (useSendTransaction as jest.Mock).mock.calls[0][0];
+    await onConfirmed();
+
+    expect((queryClient.invalidateQueries as Mock).mock.calls).toMatchSnapshot();
+  });
+
+  it('throws error when LeverageManager contract address is not found', async () => {
+    (useGetContractAddress as Mock).mockImplementation(() => ({ address: undefined }));
+
+    renderHook(() => useOpenLeveragedPosition());
+
+    const { fn } = (useSendTransaction as Mock).mock.calls[0][0];
+
+    await expect(async () =>
+      fn({
+        vToken: vUsdc,
+        amountMantissa: 100000000n,
+      }),
+    ).rejects.toThrow('somethingWentWrong');
+  });
+});
diff --git a/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/index.tsx b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/index.tsx
new file mode 100644
index 0000000000..106c617920
--- /dev/null
+++ b/apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/index.tsx
@@ -0,0 +1,83 @@
+import type { Account, Address, Chain, Hex, WriteContractParameters } from 'viem';
+
+import { queryClient } from 'clients/api';
+import FunctionKey from 'constants/functionKey';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import { type UseSendTransactionOptions, useSendTransaction } from 'hooks/useSendTransaction';
+import { leverageManagerAbi } from 'libs/contracts';
+import { VError } from 'libs/errors';
+import type { ExactInSwapQuote, VToken } from 'types';
+
+type OpenLeveragedPositionWithSwapInput = {
+  swapQuote: ExactInSwapQuote;
+  borrowedVToken: VToken;
+  suppliedVToken: VToken;
+};
+
+type OpenLeveragedPositionWithSingleAssetInput = {
+  vToken: VToken;
+  amountMantissa: bigint;
+};
+
+type OpenLeveragedPositionInput =
+  | OpenLeveragedPositionWithSwapInput
+  | OpenLeveragedPositionWithSingleAssetInput;
+
+type Options = UseSendTransactionOptions<OpenLeveragedPositionInput>;
+
+export const useOpenLeveragedPosition = (options?: Partial<Options>) => {
+  const { address: leverageManagerContractAddress } = useGetContractAddress({
+    name: 'LeverageManager',
+  });
+
+  return useSendTransaction({
+    fn: (input: OpenLeveragedPositionInput) => {
+      if (!leverageManagerContractAddress) {
+        throw new VError({ type: 'unexpected', code: 'somethingWentWrong' });
+      }
+
+      if ('swapQuote' in input) {
+        return {
+          abi: leverageManagerAbi,
+          address: leverageManagerContractAddress,
+          functionName: 'enterLeverage',
+          args: [
+            input.suppliedVToken.address,
+            0n,
+            input.borrowedVToken.address,
+            input.swapQuote.fromTokenAmountSoldMantissa,
+            input.swapQuote.minimumToTokenAmountReceivedMantissa,
+            input.swapQuote.callData,
+          ],
+        } as WriteContractParameters<
+          typeof leverageManagerAbi,
+          'enterLeverage',
+          readonly [Address, bigint, Address, bigint, bigint, Hex],
+          Chain,
+          Account
+        >;
+      }
+
+      return {
+        abi: leverageManagerAbi,
+        address: leverageManagerContractAddress,
+        functionName: 'enterSingleAssetLeverage',
+        args: [input.vToken.address, 0n, input.amountMantissa],
+      } as WriteContractParameters<
+        typeof leverageManagerAbi,
+        'enterSingleAssetLeverage',
+        readonly [Address, bigint, bigint],
+        Chain,
+        Account
+      >;
+    },
+    onConfirmed: () => {
+      // TODO: send analytic event
+
+      queryClient.invalidateQueries({
+        queryKey: [FunctionKey.GET_POOLS],
+      });
+    },
+    options,
+  });
+};
diff --git a/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/__snapshots__/index.spec.ts.snap b/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/__snapshots__/index.spec.ts.snap
index 3eb8e35eed..37117c9d62 100644
--- a/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/__snapshots__/index.spec.ts.snap
+++ b/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/__snapshots__/index.spec.ts.snap
@@ -1366,6 +1366,689 @@ exports[`getSimulatedPool > returns simulated pool with updated asset balances w
 }
 `;
 
+exports[`getSimulatedPool > returns simulated pool with updated asset balances when mutations are provided, including enabling collateral 1`] = `
+{
+  "pool": {
+    "assets": [
+      {
+        "badDebtMantissa": 6789000000000000000n,
+        "borrowApyPercentage": "-2.3062487835658776",
+        "borrowBalanceCents": "70925716",
+        "borrowBalanceTokens": "1852935.597521220541385584",
+        "borrowCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "borrowPointDistributions": [
+          {
+            "description": "Fake point distribution description",
+            "extraInfoUrl": "https://fake.url",
+            "incentive": "3x points",
+            "logoUrl": "fake-xvs-asset",
+            "title": "Fake points",
+          },
+        ],
+        "borrowTokenDistributions": [
+          {
+            "apyPercentage": "4.17469243006608279",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+        ],
+        "borrowerCount": 10,
+        "cashTokens": "10",
+        "collateralFactor": 0.5,
+        "disabledTokenActions": [],
+        "exchangeRateVTokens": "49.589181233",
+        "isBorrowable": true,
+        "isBorrowableByUser": true,
+        "isCollateralOfUser": true,
+        "liquidationPenaltyPercentage": 4,
+        "liquidationThresholdPercentage": 50,
+        "liquidityCents": "8036465875",
+        "reserveFactor": 0.25,
+        "reserveTokens": "1000",
+        "supplierCount": 100,
+        "supplyApyPercentage": "0.05225450324405023",
+        "supplyBalanceCents": "278311516",
+        "supplyBalanceTokens": "19339683254955736",
+        "supplyCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "supplyPointDistributions": [
+          {
+            "description": "Fake point distribution description",
+            "extraInfoUrl": "https://fake.url",
+            "incentive": "3x points",
+            "logoUrl": "fake-xvs-asset",
+            "title": "Fake points",
+          },
+        ],
+        "supplyTokenDistributions": [
+          {
+            "apyPercentage": "0.11720675342484096",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+        ],
+        "tokenPriceCents": "127.86734",
+        "userBorrowBalanceCents": "0",
+        "userBorrowBalanceTokens": "0",
+        "userBorrowLimitSharePercentage": 0,
+        "userCollateralFactor": 0.5,
+        "userLiquidationThresholdPercentage": 50,
+        "userSupplyBalanceCents": "11508",
+        "userSupplyBalanceTokens": "90",
+        "userWalletBalanceCents": "12786",
+        "userWalletBalanceTokens": "100",
+        "vToken": {
+          "address": "0x6d6F697e34145Bb95c54E77482d97cc261Dc237E",
+          "decimals": 8,
+          "symbol": "vXVS",
+          "underlyingToken": {
+            "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+            "decimals": 18,
+            "iconSrc": "fake-xvs-asset",
+            "symbol": "XVS",
+          },
+        },
+      },
+      {
+        "badDebtMantissa": 0n,
+        "borrowApyPercentage": "-5.361233028654066",
+        "borrowBalanceCents": "858721657509635.98728",
+        "borrowBalanceTokens": "73128320.509651061457900627",
+        "borrowCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "borrowPointDistributions": [],
+        "borrowTokenDistributions": [
+          {
+            "apyPercentage": "1.670327607690572731",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "1.233105649796123742",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+              "decimals": 6,
+              "iconSrc": "fake-usdc-asset",
+              "symbol": "USDC",
+            },
+            "type": "primeSimulation",
+          },
+          {
+            "apyPercentage": "0.913105649796123742",
+            "isActive": true,
+            "token": {
+              "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+              "decimals": 6,
+              "iconSrc": "fake-usdc-asset",
+              "symbol": "USDC",
+            },
+            "type": "prime",
+          },
+        ],
+        "borrowerCount": 10,
+        "cashTokens": "10",
+        "collateralFactor": 0.8,
+        "disabledTokenActions": [
+          "borrow",
+          "supply",
+        ],
+        "exchangeRateVTokens": "1",
+        "isBorrowable": false,
+        "isBorrowableByUser": false,
+        "isCollateralOfUser": true,
+        "liquidationPenaltyPercentage": 4,
+        "liquidationThresholdPercentage": 80,
+        "liquidityCents": "1702951959",
+        "reserveFactor": 0.2,
+        "reserveTokens": "1000",
+        "supplierCount": 100,
+        "supplyApyPercentage": "3.887242555711379188",
+        "supplyBalanceCents": "1000183891888505.4276",
+        "supplyBalanceTokens": "4.717199913187927152720001092e+28",
+        "supplyCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "supplyPointDistributions": [],
+        "supplyTokenDistributions": [
+          {
+            "apyPercentage": "1.353105649796123742",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "0.953105649796123742",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+              "decimals": 6,
+              "iconSrc": "fake-usdc-asset",
+              "symbol": "USDC",
+            },
+            "type": "primeSimulation",
+          },
+          {
+            "apyPercentage": "0.753105649796123742",
+            "isActive": true,
+            "token": {
+              "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+              "decimals": 6,
+              "iconSrc": "fake-usdc-asset",
+              "symbol": "USDC",
+            },
+            "type": "prime",
+          },
+        ],
+        "tokenPriceCents": "99.99364",
+        "userBorrowBalanceCents": "199.98728",
+        "userBorrowBalanceTokens": "2",
+        "userBorrowLimitSharePercentage": 0.69,
+        "userCollateralFactor": 0.8,
+        "userLiquidationThresholdPercentage": 80,
+        "userSupplyBalanceCents": "18998.4276",
+        "userSupplyBalanceTokens": "190",
+        "userWalletBalanceCents": "0",
+        "userWalletBalanceTokens": "0",
+        "vToken": {
+          "address": "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+          "decimals": 8,
+          "symbol": "vUSDC",
+          "underlyingToken": {
+            "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+            "decimals": 6,
+            "iconSrc": "fake-usdc-asset",
+            "symbol": "USDC",
+          },
+        },
+      },
+      {
+        "badDebtMantissa": 0n,
+        "borrowApyPercentage": "-4.9748661428011145",
+        "borrowBalanceCents": "3158444721",
+        "borrowBalanceTokens": "232511166.920938849475104194",
+        "borrowCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "borrowPointDistributions": [
+          {
+            "description": "Fake point distribution description",
+            "extraInfoUrl": "https://fake.url",
+            "incentive": "3x points",
+            "logoUrl": "fake-xvs-asset",
+            "title": "Fake points",
+          },
+        ],
+        "borrowTokenDistributions": [
+          {
+            "apyPercentage": "0.522209972682294832",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "1.015310564979612374",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c",
+              "decimals": 6,
+              "iconSrc": "fake-usdt-asset",
+              "symbol": "USDT",
+            },
+            "type": "primeSimulation",
+          },
+        ],
+        "borrowerCount": 10,
+        "cashTokens": "10",
+        "collateralFactor": 0.8,
+        "disabledTokenActions": [
+          "swapAndSupply",
+        ],
+        "exchangeRateVTokens": "0.981982",
+        "isBorrowable": true,
+        "isBorrowableByUser": true,
+        "isCollateralOfUser": true,
+        "liquidationPenaltyPercentage": 4,
+        "liquidationThresholdPercentage": 80,
+        "liquidityCents": "5534102886",
+        "reserveFactor": 0.2,
+        "reserveTokens": "1000",
+        "supplierCount": 100,
+        "supplyApyPercentage": "3.593608909332766999",
+        "supplyBalanceCents": "1098041201011568",
+        "supplyBalanceTokens": "5.029972090817266864401527367893625e+33",
+        "supplyCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "supplyPointDistributions": [],
+        "supplyTokenDistributions": [
+          {
+            "apyPercentage": "0.421719501189155143",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "1.753105649796123742",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c",
+              "decimals": 6,
+              "iconSrc": "fake-usdt-asset",
+              "symbol": "USDT",
+            },
+            "type": "primeSimulation",
+          },
+        ],
+        "tokenPriceCents": "100.024602",
+        "userBorrowBalanceCents": "4000",
+        "userBorrowBalanceTokens": "40",
+        "userBorrowLimitSharePercentage": 13.81,
+        "userCollateralFactor": 0.8,
+        "userLiquidationThresholdPercentage": 80,
+        "userSupplyBalanceCents": "10000",
+        "userSupplyBalanceTokens": "100",
+        "userWalletBalanceCents": "90000",
+        "userWalletBalanceTokens": "900",
+        "vToken": {
+          "address": "0xb7526572FFE56AB9D7489838Bf2E18e3323b441A",
+          "decimals": 8,
+          "symbol": "vUSDT",
+          "underlyingToken": {
+            "address": "0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c",
+            "decimals": 6,
+            "iconSrc": "fake-usdt-asset",
+            "symbol": "USDT",
+          },
+        },
+      },
+      {
+        "badDebtMantissa": 0n,
+        "borrowApyPercentage": "-4.050271277344538",
+        "borrowBalanceCents": "83910350502",
+        "borrowBalanceTokens": "142662020.229587308931217432",
+        "borrowCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "borrowPointDistributions": [],
+        "borrowTokenDistributions": [
+          {
+            "apyPercentage": "0.852697602175970714",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "1.753105649796123742",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+              "decimals": 18,
+              "iconSrc": "fake-busd-asset",
+              "symbol": "BUSD",
+            },
+            "type": "primeSimulation",
+          },
+          {
+            "apyPercentage": "0.913105649796123742",
+            "isActive": true,
+            "token": {
+              "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+              "decimals": 18,
+              "iconSrc": "fake-busd-asset",
+              "symbol": "BUSD",
+            },
+            "type": "prime",
+          },
+        ],
+        "borrowerCount": 10,
+        "cashTokens": "10",
+        "collateralFactor": 0.8,
+        "disabledTokenActions": [
+          "supply",
+        ],
+        "exchangeRateVTokens": "1.000003",
+        "isBorrowable": true,
+        "isBorrowableByUser": true,
+        "isCollateralOfUser": false,
+        "liquidationPenaltyPercentage": 4,
+        "liquidationThresholdPercentage": 80,
+        "liquidityCents": "3654492935",
+        "reserveFactor": 0.2,
+        "reserveTokens": "1000",
+        "supplierCount": 100,
+        "supplyApyPercentage": "2.886396363044176106",
+        "supplyBalanceCents": "1054707853878",
+        "supplyBalanceTokens": "51881081291203672464",
+        "supplyCapTokens": "1.15792089237316195423570985008687907853269984665640564039457584007913129639935e+77",
+        "supplyPointDistributions": [
+          {
+            "description": "Fake point distribution description",
+            "extraInfoUrl": "https://fake.url",
+            "incentive": "3x points",
+            "logoUrl": "fake-xvs-asset",
+            "title": "Fake points",
+          },
+        ],
+        "supplyTokenDistributions": [
+          {
+            "apyPercentage": "0.678420831753642169",
+            "dailyDistributedTokens": "9999999.5",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "venus",
+          },
+          {
+            "apyPercentage": "1.753105649796123742",
+            "isActive": true,
+            "referenceValues": {
+              "userBorrowBalanceTokens": "1000",
+              "userSupplyBalanceTokens": "1000",
+              "userXvsStakedTokens": "1000",
+            },
+            "token": {
+              "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+              "decimals": 18,
+              "iconSrc": "fake-busd-asset",
+              "symbol": "BUSD",
+            },
+            "type": "primeSimulation",
+          },
+          {
+            "apyPercentage": "0",
+            "isActive": true,
+            "token": {
+              "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+              "decimals": 18,
+              "iconSrc": "fake-xvs-asset",
+              "symbol": "XVS",
+            },
+            "type": "prime",
+          },
+        ],
+        "tokenPriceCents": "100.000922",
+        "userBorrowBalanceCents": "5000",
+        "userBorrowBalanceTokens": "50",
+        "userBorrowLimitSharePercentage": 17.26,
+        "userCollateralFactor": 0.8,
+        "userLiquidationThresholdPercentage": 80,
+        "userSupplyBalanceCents": "0",
+        "userSupplyBalanceTokens": "0",
+        "userWalletBalanceCents": "11000",
+        "userWalletBalanceTokens": "110",
+        "vToken": {
+          "address": "0x08e0A5575De71037aE36AbfAfb516595fE68e5e4",
+          "decimals": 8,
+          "symbol": "vBUSD",
+          "underlyingToken": {
+            "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+            "decimals": 18,
+            "iconSrc": "fake-busd-asset",
+            "symbol": "BUSD",
+          },
+        },
+      },
+    ],
+    "comptrollerAddress": "0x94d1820b2d1c7c7452a163983dc888cec546b77d",
+    "eModeGroups": [
+      {
+        "assetSettings": [
+          {
+            "collateralFactor": 0.6,
+            "isBorrowable": true,
+            "liquidationPenaltyPercentage": 0,
+            "liquidationThresholdPercentage": 62,
+            "vToken": {
+              "address": "0x6d6F697e34145Bb95c54E77482d97cc261Dc237E",
+              "decimals": 8,
+              "symbol": "vXVS",
+              "underlyingToken": {
+                "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+                "decimals": 18,
+                "iconSrc": "fake-xvs-asset",
+                "symbol": "XVS",
+              },
+            },
+          },
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": false,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+              "decimals": 8,
+              "symbol": "vUSDC",
+              "underlyingToken": {
+                "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+                "decimals": 6,
+                "iconSrc": "fake-usdc-asset",
+                "symbol": "USDC",
+              },
+            },
+          },
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": true,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0xb7526572FFE56AB9D7489838Bf2E18e3323b441A",
+              "decimals": 8,
+              "symbol": "vUSDT",
+              "underlyingToken": {
+                "address": "0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c",
+                "decimals": 6,
+                "iconSrc": "fake-usdt-asset",
+                "symbol": "USDT",
+              },
+            },
+          },
+        ],
+        "id": 0,
+        "isActive": true,
+        "isIsolated": false,
+        "name": "Stablecoins",
+      },
+      {
+        "assetSettings": [
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": true,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0xb7526572FFE56AB9D7489838Bf2E18e3323b441A",
+              "decimals": 8,
+              "symbol": "vUSDT",
+              "underlyingToken": {
+                "address": "0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c",
+                "decimals": 6,
+                "iconSrc": "fake-usdt-asset",
+                "symbol": "USDT",
+              },
+            },
+          },
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": true,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0x08e0A5575De71037aE36AbfAfb516595fE68e5e4",
+              "decimals": 8,
+              "symbol": "vBUSD",
+              "underlyingToken": {
+                "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+                "decimals": 18,
+                "iconSrc": "fake-busd-asset",
+                "symbol": "BUSD",
+              },
+            },
+          },
+        ],
+        "id": 1,
+        "isActive": true,
+        "isIsolated": false,
+        "name": "DeFi",
+      },
+      {
+        "assetSettings": [
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": false,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+              "decimals": 8,
+              "symbol": "vUSDC",
+              "underlyingToken": {
+                "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+                "decimals": 6,
+                "iconSrc": "fake-usdc-asset",
+                "symbol": "USDC",
+              },
+            },
+          },
+        ],
+        "id": 2,
+        "isActive": true,
+        "isIsolated": true,
+        "name": "#ToTheMoon",
+      },
+      {
+        "assetSettings": [
+          {
+            "collateralFactor": 0.6,
+            "isBorrowable": true,
+            "liquidationPenaltyPercentage": 0,
+            "liquidationThresholdPercentage": 62,
+            "vToken": {
+              "address": "0x6d6F697e34145Bb95c54E77482d97cc261Dc237E",
+              "decimals": 8,
+              "symbol": "vXVS",
+              "underlyingToken": {
+                "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+                "decimals": 18,
+                "iconSrc": "fake-xvs-asset",
+                "symbol": "XVS",
+              },
+            },
+          },
+          {
+            "collateralFactor": 0.9,
+            "isBorrowable": false,
+            "liquidationPenaltyPercentage": 30,
+            "liquidationThresholdPercentage": 92,
+            "vToken": {
+              "address": "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+              "decimals": 8,
+              "symbol": "vUSDC",
+              "underlyingToken": {
+                "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+                "decimals": 6,
+                "iconSrc": "fake-usdc-asset",
+                "symbol": "USDC",
+              },
+            },
+          },
+        ],
+        "id": 3,
+        "isActive": false,
+        "isIsolated": false,
+        "name": "GameFi",
+      },
+    ],
+    "isIsolated": false,
+    "name": "Venus",
+    "userBorrowBalanceCents": "10199.98728",
+    "userBorrowLimitCents": "28952.74208",
+    "userHealthFactor": 2.83,
+    "userLiquidationThresholdCents": "28952.74208",
+    "userSupplyBalanceCents": "40506.4276",
+    "userYearlyEarningsCents": "2070",
+    "vai": {
+      "borrowAprPercentage": "1.34",
+      "token": {
+        "address": "0x5fFbE5302BadED40941A403228E6AD03f93752d9",
+        "decimals": 18,
+        "iconSrc": "fake-vai-asset",
+        "symbol": "VAI",
+      },
+      "tokenPriceCents": "100",
+      "userBorrowBalanceCents": "1000",
+      "userBorrowBalanceTokens": "10",
+    },
+  },
+}
+`;
+
 exports[`getSimulatedPool > returns undefined pool when no balance mutations are provided 1`] = `
 {
   "pool": undefined,
diff --git a/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/index.spec.ts b/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/index.spec.ts
index e42b4911a8..fc42fd31e2 100644
--- a/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/index.spec.ts
+++ b/apps/evm/src/clients/api/queries/getSimulatedPool/__tests__/index.spec.ts
@@ -12,13 +12,17 @@ import { getSimulatedPool } from '..';
 const fakeNonPrimeAsset = poolData[0].assets[0];
 const fakePrimeAsset = poolData[0].assets[1];
 
-const generateAssetBalanceMutations = ({ asset }: { asset: Asset }) => {
+const generateAssetBalanceMutations = ({
+  asset,
+  enableAsCollateralOfUser,
+}: { asset: Asset; enableAsCollateralOfUser?: boolean }) => {
   const balanceMutations: BalanceMutation[] = [
     {
       type: 'asset',
       action: 'supply',
       vTokenAddress: asset.vToken.address,
       amountTokens: new BigNumber(100),
+      enableAsCollateralOfUser,
     },
     {
       type: 'asset',
@@ -76,6 +80,21 @@ describe('getSimulatedPool', () => {
     expect(result).toMatchSnapshot();
   });
 
+  it('returns simulated pool with updated asset balances when mutations are provided, including enabling collateral', async () => {
+    const fakeBalanceMutations = generateAssetBalanceMutations({
+      asset: poolData[0].assets[1],
+      enableAsCollateralOfUser: true,
+    });
+
+    const result = await getSimulatedPool({
+      publicClient: {} as unknown as PublicClient,
+      pool: poolData[0],
+      balanceMutations: fakeBalanceMutations,
+    });
+
+    expect(result).toMatchSnapshot();
+  });
+
   it('recalculates Prime APYs when a Prime market is mutated and the user qualifies for Prime rewards', async () => {
     const readContractMock = vi.fn(async () => ({
       supplyAPR: 1000n,
diff --git a/apps/evm/src/clients/api/queries/getSimulatedPool/index.ts b/apps/evm/src/clients/api/queries/getSimulatedPool/index.ts
index cf401459d5..db1129882a 100644
--- a/apps/evm/src/clients/api/queries/getSimulatedPool/index.ts
+++ b/apps/evm/src/clients/api/queries/getSimulatedPool/index.ts
@@ -9,7 +9,12 @@ import type {
   PoolVai,
   VaiBalanceMutation,
 } from 'types';
-import { addUserBorrowLimitShares, calculateUserPoolValues, clampToZero } from 'utilities';
+import {
+  addUserBorrowLimitShares,
+  areAddressesEqual,
+  calculateUserPoolValues,
+  clampToZero,
+} from 'utilities';
 import { addUserPrimeApys } from './addUserPrimeApys';
 
 export interface GetSimulatedPoolInput {
@@ -71,9 +76,11 @@ export const getSimulatedPool = async ({
   const mutatedPrimeVTokenAddresses: Address[] = [];
 
   let simulatedAssets: Asset[] = pool.assets.map(asset => {
-    const lowerCasedVTokenAddress = asset.vToken.address.toLowerCase() as Address;
+    const assetBalanceMutations = assetMutations.filter(balanceMutation =>
+      areAddressesEqual(balanceMutation.vTokenAddress, asset.vToken.address),
+    );
 
-    if (!mutatedVTokenAddresses.includes(lowerCasedVTokenAddress)) {
+    if (assetBalanceMutations.length === 0) {
       return asset;
     }
 
@@ -83,7 +90,7 @@ export const getSimulatedPool = async ({
     ].some(d => d.type === 'prime' || d.type === 'primeSimulation');
 
     if (isAssetPrime) {
-      mutatedPrimeVTokenAddresses.push(lowerCasedVTokenAddress);
+      mutatedPrimeVTokenAddresses.push(asset.vToken.address.toLowerCase() as Address);
     }
 
     let supplyBalanceTokens = asset.supplyBalanceTokens;
@@ -96,9 +103,15 @@ export const getSimulatedPool = async ({
     let userBorrowBalanceTokens = asset.userBorrowBalanceTokens;
     let userBorrowBalanceCents = asset.userBorrowBalanceCents;
 
-    filteredBalanceMutations.forEach(({ action, amountTokens }) => {
+    let isCollateralOfUser = asset.isCollateralOfUser;
+
+    assetBalanceMutations.forEach(({ action, amountTokens, enableAsCollateralOfUser }) => {
       const amountCents = amountTokens.multipliedBy(asset.tokenPriceCents);
 
+      if (enableAsCollateralOfUser) {
+        isCollateralOfUser = true;
+      }
+
       switch (action) {
         case 'supply':
           supplyBalanceTokens = supplyBalanceTokens.plus(amountTokens);
@@ -149,6 +162,7 @@ export const getSimulatedPool = async ({
       userSupplyBalanceCents,
       userBorrowBalanceTokens,
       userBorrowBalanceCents,
+      isCollateralOfUser,
     };
 
     return simulatedAsset;
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/__ tests__/index.spec.ts b/apps/evm/src/clients/api/queries/getSwapQuote/__ tests__/index.spec.ts
new file mode 100644
index 0000000000..611be72df5
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/__ tests__/index.spec.ts	
@@ -0,0 +1,248 @@
+import BigNumber from 'bignumber.js';
+import type { Address } from 'viem';
+import type { Mock } from 'vitest';
+
+import fakeAddress from '__mocks__/models/address';
+import { busd, usdc } from '__mocks__/models/tokens';
+import { ChainId } from 'types';
+import { restService } from 'utilities';
+import { getSwapQuote } from '..';
+import type { SwapApiResponse } from '../types';
+
+vi.mock('utilities/restService');
+vi.mock('utilities/generateTransactionDeadline');
+
+const sharedProps = {
+  chainId: ChainId.BSC_MAINNET,
+  fromToken: usdc,
+  toToken: busd,
+  slippagePercentage: 0.5,
+  recipientAddress: fakeAddress as Address,
+};
+
+const fakeApiResponse: SwapApiResponse = {
+  quotes: [
+    {
+      amountIn: '1000000',
+      amountInMax: '1000000',
+      amountOut: '1000000000000000000',
+      amountOutMin: '9789746164978756079',
+      protocol: 'Fake Protocol',
+      priceImpact: 0.8,
+      swapHelperMulticall: {
+        target: '0xfakeSwapHelperMulticall',
+        calldata: {
+          encodedCall: '0xfakeEncodedCallData',
+        },
+      },
+    },
+  ],
+};
+
+describe('getSwapQuote', () => {
+  beforeEach(() => {
+    (restService as Mock).mockResolvedValue({ data: fakeApiResponse });
+  });
+
+  it('fetches and formats "exact-in" swap quote correctly', async () => {
+    const result = await getSwapQuote({
+      ...sharedProps,
+      direction: 'exact-in',
+      fromTokenAmountTokens: new BigNumber(1),
+    });
+
+    expect(restService).toHaveBeenCalledTimes(1);
+    expect((restService as Mock).mock.calls[0][0]).toMatchInlineSnapshot(`
+      {
+        "endpoint": "/find-swap/pcs",
+        "method": "GET",
+        "params": {
+          "chainId": 56,
+          "deadlineTimestampSecs": 1747386407,
+          "exactAmountInMantissa": "1000000",
+          "recipientAddress": "0x3d759121234cd36F8124C21aFe1c6852d2bEd848",
+          "shouldTransferToReceiver": true,
+          "slippagePercentage": 0.5,
+          "tokenInAddress": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+          "tokenOutAddress": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+          "type": "exact-in",
+        },
+      }
+    `);
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "swapQuote": {
+          "callData": "0xfakeEncodedCallData",
+          "direction": "exact-in",
+          "expectedToTokenAmountReceivedMantissa": 1000000000000000000n,
+          "fromToken": {
+            "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+            "decimals": 6,
+            "iconSrc": "fake-usdc-asset",
+            "symbol": "USDC",
+          },
+          "fromTokenAmountSoldMantissa": 1000000n,
+          "minimumToTokenAmountReceivedMantissa": 995000000000000000n,
+          "priceImpactPercentage": 0.8,
+          "toToken": {
+            "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+            "decimals": 18,
+            "iconSrc": "fake-busd-asset",
+            "symbol": "BUSD",
+          },
+        },
+      }
+    `);
+  });
+
+  it('fetches and formats "exact-out" swap quote correctly', async () => {
+    const result = await getSwapQuote({
+      ...sharedProps,
+      direction: 'exact-out',
+      toTokenAmountTokens: new BigNumber(1),
+    });
+
+    expect(restService).toHaveBeenCalledTimes(1);
+    expect((restService as Mock).mock.calls[0][0]).toMatchInlineSnapshot(`
+      {
+        "endpoint": "/find-swap/pcs",
+        "method": "GET",
+        "params": {
+          "chainId": 56,
+          "deadlineTimestampSecs": 1747386407,
+          "exactAmountOutMantissa": "1000000",
+          "recipientAddress": "0x3d759121234cd36F8124C21aFe1c6852d2bEd848",
+          "shouldTransferToReceiver": true,
+          "slippagePercentage": 0.5,
+          "tokenInAddress": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+          "tokenOutAddress": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+          "type": "exact-out",
+        },
+      }
+    `);
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "swapQuote": {
+          "callData": "0xfakeEncodedCallData",
+          "direction": "exact-out",
+          "expectedFromTokenAmountSoldMantissa": 1000000n,
+          "fromToken": {
+            "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+            "decimals": 6,
+            "iconSrc": "fake-usdc-asset",
+            "symbol": "USDC",
+          },
+          "maximumFromTokenAmountSoldMantissa": 995000n,
+          "priceImpactPercentage": 0.8,
+          "toToken": {
+            "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+            "decimals": 18,
+            "iconSrc": "fake-busd-asset",
+            "symbol": "BUSD",
+          },
+          "toTokenAmountReceivedMantissa": 1000000000000000000n,
+        },
+      }
+    `);
+  });
+
+  it('fetches and formats "approximate-out" swap quote correctly', async () => {
+    const result = await getSwapQuote({
+      ...sharedProps,
+      direction: 'approximate-out',
+      minToTokenAmountTokens: new BigNumber(1),
+    });
+
+    expect(restService).toHaveBeenCalledTimes(1);
+    expect((restService as Mock).mock.calls[0][0]).toMatchInlineSnapshot(`
+      {
+        "endpoint": "/find-swap/pcs",
+        "method": "GET",
+        "params": {
+          "chainId": 56,
+          "deadlineTimestampSecs": 1747386407,
+          "minAmountOutMantissa": "1000000",
+          "recipientAddress": "0x3d759121234cd36F8124C21aFe1c6852d2bEd848",
+          "shouldTransferToReceiver": true,
+          "slippagePercentage": 0.5,
+          "tokenInAddress": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+          "tokenOutAddress": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+          "type": "approximate-out",
+        },
+      }
+    `);
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "swapQuote": {
+          "callData": "0xfakeEncodedCallData",
+          "direction": "approximate-out",
+          "expectedToTokenAmountReceivedMantissa": 1000000000000000000n,
+          "fromToken": {
+            "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+            "decimals": 6,
+            "iconSrc": "fake-usdc-asset",
+            "symbol": "USDC",
+          },
+          "fromTokenAmountSoldMantissa": 1000000n,
+          "minimumToTokenAmountReceivedMantissa": 995000000000000000n,
+          "priceImpactPercentage": 0.8,
+          "toToken": {
+            "address": "0x8301F2213c0eeD49a7E28Ae4c3e91722919B8B47",
+            "decimals": 18,
+            "iconSrc": "fake-busd-asset",
+            "symbol": "BUSD",
+          },
+        },
+      }
+    `);
+  });
+
+  it('throws on error in payload', async () => {
+    (restService as Mock).mockResolvedValue({ data: { error: 'Some error' } });
+
+    await expect(
+      getSwapQuote({
+        ...sharedProps,
+        direction: 'approximate-out',
+        minToTokenAmountTokens: new BigNumber(1),
+      }),
+    ).rejects.toMatchObject({
+      code: 'somethingWentWrong',
+    });
+  });
+
+  it('throws on undefined payload', async () => {
+    (restService as Mock).mockResolvedValue({ data: undefined });
+
+    await expect(
+      getSwapQuote({
+        ...sharedProps,
+        direction: 'approximate-out',
+        minToTokenAmountTokens: new BigNumber(1),
+      }),
+    ).rejects.toMatchObject({
+      code: 'somethingWentWrong',
+    });
+  });
+
+  it('throws on empty quotes array', async () => {
+    (restService as Mock).mockResolvedValue({
+      data: {
+        quotes: [],
+      },
+    });
+
+    await expect(
+      getSwapQuote({
+        ...sharedProps,
+        direction: 'approximate-out',
+        minToTokenAmountTokens: new BigNumber(1),
+      }),
+    ).rejects.toMatchObject({
+      code: 'noSwapQuoteFound',
+    });
+  });
+});
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/index.ts b/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/index.ts
new file mode 100644
index 0000000000..409231c9ba
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/index.ts
@@ -0,0 +1,83 @@
+import type {
+  ApproximateOutSwapQuote,
+  ExactInSwapQuote,
+  ExactOutSwapQuote,
+  SwapQuoteDirection,
+  Token,
+} from 'types';
+import type { ApiSwapQuote } from '../types';
+import { subtractSlippagePercentage } from './subtractSlippagePercentage';
+
+export const formatSwapQuote = ({
+  direction,
+  fromToken,
+  toToken,
+  apiSwapQuote,
+  slippagePercentage,
+}: {
+  direction: SwapQuoteDirection;
+  fromToken: Token;
+  toToken: Token;
+  apiSwapQuote: ApiSwapQuote;
+  slippagePercentage: number;
+}) => {
+  const sharedProps = {
+    fromToken,
+    toToken,
+    priceImpactPercentage: apiSwapQuote.priceImpact,
+    callData: apiSwapQuote.swapHelperMulticall.calldata.encodedCall,
+  };
+
+  if (direction === 'exact-in') {
+    const expectedToTokenAmountReceivedMantissa = BigInt(apiSwapQuote.amountOut);
+    const minimumToTokenAmountReceivedMantissa = subtractSlippagePercentage({
+      amount: expectedToTokenAmountReceivedMantissa,
+      slippagePercentage,
+    });
+
+    const swapQuote: ExactInSwapQuote = {
+      ...sharedProps,
+      fromTokenAmountSoldMantissa: BigInt(apiSwapQuote.amountIn),
+      expectedToTokenAmountReceivedMantissa,
+      minimumToTokenAmountReceivedMantissa,
+      direction: 'exact-in',
+    };
+
+    return swapQuote;
+  }
+
+  if (direction === 'exact-out') {
+    const expectedFromTokenAmountSoldMantissa = BigInt(apiSwapQuote.amountIn);
+    const maximumFromTokenAmountSoldMantissa = subtractSlippagePercentage({
+      amount: expectedFromTokenAmountSoldMantissa,
+      slippagePercentage,
+    });
+
+    const swapQuote: ExactOutSwapQuote = {
+      ...sharedProps,
+      expectedFromTokenAmountSoldMantissa,
+      maximumFromTokenAmountSoldMantissa,
+      toTokenAmountReceivedMantissa: BigInt(apiSwapQuote.amountOut),
+      direction: 'exact-out',
+    };
+
+    return swapQuote;
+  }
+
+  // Approximate out swap
+  const expectedToTokenAmountReceivedMantissa = BigInt(apiSwapQuote.amountOut);
+  const minimumToTokenAmountReceivedMantissa = subtractSlippagePercentage({
+    amount: expectedToTokenAmountReceivedMantissa,
+    slippagePercentage,
+  });
+
+  const swapQuote: ApproximateOutSwapQuote = {
+    ...sharedProps,
+    fromTokenAmountSoldMantissa: BigInt(apiSwapQuote.amountIn),
+    expectedToTokenAmountReceivedMantissa,
+    minimumToTokenAmountReceivedMantissa,
+    direction: 'approximate-out',
+  };
+
+  return swapQuote;
+};
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/subtractSlippagePercentage/index.ts b/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/subtractSlippagePercentage/index.ts
new file mode 100644
index 0000000000..75df167096
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/formatSwapQuote/subtractSlippagePercentage/index.ts
@@ -0,0 +1,7 @@
+import BigNumber from 'bignumber.js';
+
+export const subtractSlippagePercentage = ({
+  amount,
+  slippagePercentage,
+}: { amount: bigint; slippagePercentage: number }) =>
+  BigInt(new BigNumber((Number(amount) * (100 - slippagePercentage)) / 100).toFixed(0));
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/index.ts b/apps/evm/src/clients/api/queries/getSwapQuote/index.ts
new file mode 100644
index 0000000000..4cd56c200a
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/index.ts
@@ -0,0 +1,82 @@
+import { VError } from 'libs/errors';
+import { convertTokensToMantissa, generateTransactionDeadline, restService } from 'utilities';
+import { formatSwapQuote } from './formatSwapQuote';
+import type { GetSwapQuoteInput, GetSwapQuoteOutput, SwapApiResponse } from './types';
+
+export * from './types';
+
+export const getSwapQuote = async ({
+  chainId,
+  fromToken,
+  toToken,
+  slippagePercentage,
+  recipientAddress,
+  ...swapSpecificProps
+}: GetSwapQuoteInput): Promise<GetSwapQuoteOutput> => {
+  const transactionDeadline = generateTransactionDeadline();
+
+  const params: Record<string, number | string | boolean> = {
+    chainId,
+    tokenInAddress: fromToken.address,
+    tokenOutAddress: toToken.address,
+    slippagePercentage,
+    recipientAddress,
+    deadlineTimestampSecs: Number(transactionDeadline),
+    type: swapSpecificProps.direction,
+    shouldTransferToReceiver: true,
+  };
+
+  if (swapSpecificProps.direction === 'exact-in') {
+    params.exactAmountInMantissa = convertTokensToMantissa({
+      value: swapSpecificProps.fromTokenAmountTokens,
+      token: fromToken,
+    }).toFixed();
+  } else if (swapSpecificProps.direction === 'exact-out') {
+    params.exactAmountOutMantissa = convertTokensToMantissa({
+      value: swapSpecificProps.toTokenAmountTokens,
+      token: fromToken,
+    }).toFixed();
+  } else {
+    // Approximate out swap
+    params.minAmountOutMantissa = convertTokensToMantissa({
+      value: swapSpecificProps.minToTokenAmountTokens,
+      token: fromToken,
+    }).toFixed();
+  }
+
+  const txsResponse = await restService<SwapApiResponse>({
+    endpoint: '/find-swap/pcs',
+    method: 'GET',
+    params,
+  });
+
+  if (txsResponse.data && 'error' in txsResponse.data) {
+    throw new VError({
+      type: 'unexpected',
+      code: 'somethingWentWrong',
+      data: { exception: txsResponse.data.error },
+    });
+  }
+
+  if (!txsResponse.data) {
+    throw new VError({ type: 'unexpected', code: 'somethingWentWrong' });
+  }
+
+  if (txsResponse.data.quotes.length === 0) {
+    throw new VError({ type: 'swapQuote', code: 'noSwapQuoteFound' });
+  }
+
+  const apiSwapQuote = txsResponse.data.quotes[0];
+
+  const swapQuote = formatSwapQuote({
+    apiSwapQuote,
+    direction: swapSpecificProps.direction,
+    slippagePercentage: Number(params.slippagePercentage),
+    fromToken,
+    toToken,
+  });
+
+  return {
+    swapQuote,
+  };
+};
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/types.ts b/apps/evm/src/clients/api/queries/getSwapQuote/types.ts
new file mode 100644
index 0000000000..53b682fd8c
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/types.ts
@@ -0,0 +1,55 @@
+import type { ChainId, Token } from '@venusprotocol/chains';
+import type { SwapQuote } from 'types';
+import type { Address, Hex } from 'viem';
+
+export interface ApiSwapQuote {
+  amountIn: string;
+  amountInMax: string;
+  amountOut: string;
+  amountOutMin: string;
+  protocol: string;
+  priceImpact: number;
+  swapHelperMulticall: {
+    target: Address;
+    calldata: {
+      encodedCall: Hex;
+    };
+  };
+}
+
+export interface SwapApiResponse {
+  quotes: ApiSwapQuote[];
+}
+
+interface GetSwapQuoteBase {
+  chainId: ChainId;
+  recipientAddress: Address;
+  fromToken: Token;
+  toToken: Token;
+  direction: SwapQuote['direction'];
+  slippagePercentage: number;
+}
+
+export interface GetExactInSwapQuoteInput extends GetSwapQuoteBase {
+  fromTokenAmountTokens: BigNumber;
+  direction: 'exact-in';
+}
+
+export interface GetExactOutSwapQuoteInput extends GetSwapQuoteBase {
+  toTokenAmountTokens: BigNumber;
+  direction: 'exact-out';
+}
+
+export interface GetApproximateOutSwapQuoteInput extends GetSwapQuoteBase {
+  minToTokenAmountTokens: BigNumber;
+  direction: 'approximate-out';
+}
+
+export type GetSwapQuoteInput =
+  | GetExactInSwapQuoteInput
+  | GetExactOutSwapQuoteInput
+  | GetApproximateOutSwapQuoteInput;
+
+export type GetSwapQuoteOutput = {
+  swapQuote: SwapQuote | undefined;
+};
diff --git a/apps/evm/src/clients/api/queries/getSwapQuote/useGetSwapQuote.ts b/apps/evm/src/clients/api/queries/getSwapQuote/useGetSwapQuote.ts
new file mode 100644
index 0000000000..0ce9b5ca55
--- /dev/null
+++ b/apps/evm/src/clients/api/queries/getSwapQuote/useGetSwapQuote.ts
@@ -0,0 +1,51 @@
+import { type QueryObserverOptions, useQuery } from '@tanstack/react-query';
+
+import FunctionKey from 'constants/functionKey';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import type { VError } from 'libs/errors';
+import { useChainId } from 'libs/wallet';
+import { callOrThrow, generatePseudoRandomRefetchInterval } from 'utilities';
+import {
+  type GetApproximateOutSwapQuoteInput,
+  type GetExactInSwapQuoteInput,
+  type GetExactOutSwapQuoteInput,
+  type GetSwapQuoteOutput,
+  getSwapQuote,
+} from '.';
+
+type TrimmedGetSwapQuoteInput =
+  | Omit<GetExactInSwapQuoteInput, 'chainId'>
+  | Omit<GetExactOutSwapQuoteInput, 'chainId'>
+  | Omit<GetApproximateOutSwapQuoteInput, 'chainId'>;
+
+type Options = QueryObserverOptions<
+  GetSwapQuoteOutput,
+  VError<'swapQuote' | 'interaction'>,
+  GetSwapQuoteOutput,
+  GetSwapQuoteOutput,
+  [FunctionKey.GET_SWAP_QUOTE, TrimmedGetSwapQuoteInput]
+>;
+
+const refetchInterval = generatePseudoRandomRefetchInterval();
+
+export const useGetSwapQuote = (input: TrimmedGetSwapQuoteInput, options?: Partial<Options>) => {
+  const { chainId } = useChainId();
+
+  const { address: leverageManagerContractAddress } = useGetContractAddress({
+    name: 'LeverageManager',
+  });
+
+  return useQuery({
+    queryKey: [FunctionKey.GET_SWAP_QUOTE, input],
+    queryFn: () =>
+      callOrThrow({ leverageManagerContractAddress }, params =>
+        getSwapQuote({
+          ...input,
+          chainId,
+          recipientAddress: params.leverageManagerContractAddress,
+        }),
+      ),
+    refetchInterval,
+    ...options,
+  });
+};
diff --git a/apps/evm/src/components/TextField/index.tsx b/apps/evm/src/components/TextField/index.tsx
index 213c4dd886..bcd986338f 100644
--- a/apps/evm/src/components/TextField/index.tsx
+++ b/apps/evm/src/components/TextField/index.tsx
@@ -82,7 +82,7 @@ export const TextField: React.FC<TextFieldProps> = forwardRef<HTMLInputElement,
     return (
       <div className={className}>
         {!!label && (
-          <label className="text-sm font-semibold text-grey" htmlFor={inputProps.id}>
+          <label className="text-sm text-grey block mb-1" htmlFor={inputProps.id}>
             {label}
           </label>
         )}
diff --git a/apps/evm/src/constants/functionKey.ts b/apps/evm/src/constants/functionKey.ts
index a147afcf78..620053fd9b 100644
--- a/apps/evm/src/constants/functionKey.ts
+++ b/apps/evm/src/constants/functionKey.ts
@@ -69,6 +69,7 @@ enum FunctionKey {
   GET_ENABLED_E_MODE_GROUP = 'GET_ENABLED_E_MODE_GROUP',
   GET_ACCOUNT_TRANSACTION_HISTORY = 'GET_ACCOUNT_TRANSACTION_HISTORY',
   GET_SIMULATED_POOL = 'GET_SIMULATED_POOL',
+  GET_SWAP_QUOTE = 'GET_SWAP_QUOTE',
 }
 
 export default FunctionKey;
diff --git a/apps/evm/src/containers/SwapDetails/index.tsx b/apps/evm/src/containers/SwapDetails/index.tsx
index 80f95fce85..fa0ccae691 100644
--- a/apps/evm/src/containers/SwapDetails/index.tsx
+++ b/apps/evm/src/containers/SwapDetails/index.tsx
@@ -5,6 +5,7 @@ import {
   DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE,
   HIGH_PRICE_IMPACT_THRESHOLD_PERCENTAGE,
 } from 'constants/swap';
+import { useGetUserSlippageTolerance } from 'hooks/useGetUserSlippageTolerance';
 import { useUserChainSettings } from 'hooks/useUserChainSettings';
 import { useTranslation } from 'libs/translations';
 import { useState } from 'react';
@@ -31,16 +32,14 @@ export const SwapDetails: React.FC<SwapDetailsProps> = ({
   const [userChainSettings, setUserChainSettings] = useUserChainSettings();
   const [isSlippageToleranceModalOpen, setIsSlippageToleranceModalOpen] = useState(false);
 
-  const readablePriceImpact = formatPercentageToReadableValue(priceImpactPercentage);
-
-  const userSlippageTolerancePercentage = userChainSettings.slippageTolerancePercentage
-    ? userChainSettings.slippageTolerancePercentage
-    : DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE;
+  const { userSlippageTolerancePercentage } = useGetUserSlippageTolerance();
 
   const readableUserSlippageTolerance = formatPercentageToReadableValue(
     userSlippageTolerancePercentage,
   );
 
+  const readablePriceImpact = formatPercentageToReadableValue(priceImpactPercentage);
+
   const openSlippageToleranceModal = () => setIsSlippageToleranceModalOpen(true);
   const closeSlippageToleranceModal = () => setIsSlippageToleranceModalOpen(false);
 
diff --git a/apps/evm/src/hooks/useDelegateApproval/index.ts b/apps/evm/src/hooks/useDelegateApproval/index.ts
index df44a4def2..39a91d1714 100644
--- a/apps/evm/src/hooks/useDelegateApproval/index.ts
+++ b/apps/evm/src/hooks/useDelegateApproval/index.ts
@@ -11,7 +11,7 @@ export interface UseDelegateApprovalInput {
 
 export interface UseDelegateApprovalOutput {
   updatePoolDelegateStatus: ({ approvedStatus }: { approvedStatus: boolean }) => Promise<unknown>;
-  isDelegateStatusLoading: boolean;
+  isUpdateDelegateStatusLoading: boolean;
   isDelegateApproved: boolean | undefined;
   isDelegateApprovedLoading: boolean;
 }
@@ -23,10 +23,12 @@ const useDelegateApproval = ({
 }: UseDelegateApprovalInput): UseDelegateApprovalOutput => {
   const { accountAddress } = useAccountAddress();
 
-  const { mutateAsync: updatePoolDelegateStatusMutation, isPending: isDelegateStatusLoading } =
-    useUpdatePoolDelegateStatus({
-      waitForConfirmation: true,
-    });
+  const {
+    mutateAsync: updatePoolDelegateStatusMutation,
+    isPending: isUpdateDelegateStatusLoading,
+  } = useUpdatePoolDelegateStatus({
+    waitForConfirmation: true,
+  });
 
   const updatePoolDelegateStatus = (input: { approvedStatus: boolean }) =>
     updatePoolDelegateStatusMutation({
@@ -51,7 +53,7 @@ const useDelegateApproval = ({
 
   return {
     updatePoolDelegateStatus,
-    isDelegateStatusLoading,
+    isUpdateDelegateStatusLoading,
     isDelegateApproved,
     isDelegateApprovedLoading,
   };
diff --git a/apps/evm/src/hooks/useGetUserSlippageTolerance/__tests__/index.spec.tsx b/apps/evm/src/hooks/useGetUserSlippageTolerance/__tests__/index.spec.tsx
new file mode 100644
index 0000000000..49966ca67c
--- /dev/null
+++ b/apps/evm/src/hooks/useGetUserSlippageTolerance/__tests__/index.spec.tsx
@@ -0,0 +1,34 @@
+import noop from 'noop-ts';
+import type { Mock } from 'vitest';
+
+import { DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE } from 'constants/swap';
+import { useUserChainSettings } from 'hooks/useUserChainSettings';
+import { renderHook } from 'testUtils/render';
+import { useGetUserSlippageTolerance } from '..';
+
+vi.mock('hooks/useUserChainSettings', () => ({
+  useUserChainSettings: vi.fn(() => [
+    {
+      slippageTolerancePercentage: 1,
+    },
+    noop,
+  ]),
+}));
+
+describe('useGetUserSlippageTolerance', () => {
+  it('returns the correct value', () => {
+    const { result } = renderHook(() => useGetUserSlippageTolerance());
+
+    expect(result.current.userSlippageTolerancePercentage).toEqual(1);
+  });
+
+  it('returns default value if user setting is undefined', () => {
+    (useUserChainSettings as Mock).mockImplementation(() => [{}, noop]);
+
+    const { result } = renderHook(() => useGetUserSlippageTolerance());
+
+    expect(result.current.userSlippageTolerancePercentage).toEqual(
+      DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE,
+    );
+  });
+});
diff --git a/apps/evm/src/hooks/useGetUserSlippageTolerance/index.tsx b/apps/evm/src/hooks/useGetUserSlippageTolerance/index.tsx
new file mode 100644
index 0000000000..2a36a3a758
--- /dev/null
+++ b/apps/evm/src/hooks/useGetUserSlippageTolerance/index.tsx
@@ -0,0 +1,14 @@
+import { DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE } from 'constants/swap';
+import { useUserChainSettings } from 'hooks/useUserChainSettings';
+
+export const useGetUserSlippageTolerance = () => {
+  const [userChainSettings] = useUserChainSettings();
+
+  const userSlippageTolerancePercentage = userChainSettings.slippageTolerancePercentage
+    ? Number(userChainSettings.slippageTolerancePercentage)
+    : DEFAULT_SLIPPAGE_TOLERANCE_PERCENTAGE;
+
+  return {
+    userSlippageTolerancePercentage,
+  };
+};
diff --git a/apps/evm/src/hooks/useIsFeatureEnabled/index.tsx b/apps/evm/src/hooks/useIsFeatureEnabled/index.tsx
index cd40d6e83f..9e3cbdcff9 100644
--- a/apps/evm/src/hooks/useIsFeatureEnabled/index.tsx
+++ b/apps/evm/src/hooks/useIsFeatureEnabled/index.tsx
@@ -141,16 +141,7 @@ export const featureFlags = {
     ChainId.UNICHAIN_SEPOLIA,
   ],
   transactionHistory: [ChainId.BSC_MAINNET, ChainId.ETHEREUM, ChainId.UNICHAIN_MAINNET],
-  leveragedPositions: [
-    ChainId.BSC_TESTNET,
-    ChainId.OPBNB_TESTNET,
-    ChainId.SEPOLIA,
-    ChainId.ARBITRUM_SEPOLIA,
-    ChainId.ZKSYNC_SEPOLIA,
-    ChainId.OPTIMISM_SEPOLIA,
-    ChainId.BASE_SEPOLIA,
-    ChainId.UNICHAIN_SEPOLIA,
-  ],
+  leveragedPositions: [ChainId.BSC_TESTNET],
 };
 
 export type FeatureFlag = keyof typeof featureFlags;
diff --git a/apps/evm/src/hooks/useSendTransaction/index.ts b/apps/evm/src/hooks/useSendTransaction/index.ts
index edd3ee2cce..a39b9b6ca6 100644
--- a/apps/evm/src/hooks/useSendTransaction/index.ts
+++ b/apps/evm/src/hooks/useSendTransaction/index.ts
@@ -80,7 +80,9 @@ export const useSendTransaction = <
   const tryGasless = options?.tryGasless ?? true;
 
   const { accountAddress } = useAccountAddress();
-  const { data: walletClient } = useWalletClient({ account: accountAddress });
+  const { data: walletClient } = useWalletClient({
+    account: accountAddress,
+  });
   const { publicClient } = usePublicClient();
   const { chainId } = useChainId();
 
diff --git a/apps/evm/src/libs/contracts/config/externalAbis/LeverageManager.json b/apps/evm/src/libs/contracts/config/externalAbis/LeverageManager.json
new file mode 100644
index 0000000000..09a5f4a74d
--- /dev/null
+++ b/apps/evm/src/libs/contracts/config/externalAbis/LeverageManager.json
@@ -0,0 +1,695 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "contract IComptroller",
+        "name": "_comptroller",
+        "type": "address"
+      },
+      {
+        "internalType": "contract IProtocolShareReserve",
+        "name": "_protocolShareReserve",
+        "type": "address"
+      },
+      {
+        "internalType": "contract SwapHelper",
+        "name": "_swapHelper",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "errorCode",
+        "type": "uint256"
+      }
+    ],
+    "name": "BorrowBehalfFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "err",
+        "type": "uint256"
+      }
+    ],
+    "name": "EnterMarketFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "FlashLoanAssetOrAmountMismatch",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InitiatorMismatch",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InsufficientFundsToRepayFlashloan",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidExecuteOperation",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "market",
+        "type": "address"
+      }
+    ],
+    "name": "MarketNotListed",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "errorCode",
+        "type": "uint256"
+      }
+    ],
+    "name": "MintBehalfFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NotAnApprovedDelegate",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OnBehalfMismatch",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "OperationCausesLiquidation",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "errorCode",
+        "type": "uint256"
+      }
+    ],
+    "name": "RedeemBehalfFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "errorCode",
+        "type": "uint256"
+      }
+    ],
+    "name": "RepayBehalfFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "SlippageExceeded",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "TokenSwapCallFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "UnauthorizedExecutor",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ZeroAddress",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ZeroFlashLoanAmount",
+    "type": "error"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "DustTransferred",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "version",
+        "type": "uint8"
+      }
+    ],
+    "name": "Initialized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "collateralMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "collateralAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "borrowedMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "borrowedAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "LeverageEntered",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "collateralMarket",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "borrowedMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "borrowedAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "borrowedAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "LeverageEnteredFromBorrow",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "collateralMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "collateralAmountToRedeemForSwap",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "borrowedMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "borrowedAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "LeverageExited",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "previousOwner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "OwnershipTransferStarted",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "previousOwner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "OwnershipTransferred",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "collateralMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "collateralAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "collateralAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "SingleAssetLeverageEntered",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "user",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "contract IVToken",
+        "name": "collateralMarket",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "collateralAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "SingleAssetLeverageExited",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "COMPTROLLER",
+    "outputs": [
+      {
+        "internalType": "contract IComptroller",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "acceptOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken",
+        "name": "_collateralMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_collateralAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "internalType": "contract IVToken",
+        "name": "_borrowedMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_borrowedAmountToFlashLoan",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_minAmountOutAfterSwap",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_swapData",
+        "type": "bytes"
+      }
+    ],
+    "name": "enterLeverage",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken",
+        "name": "_collateralMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "contract IVToken",
+        "name": "_borrowedMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_borrowedAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_borrowedAmountToFlashLoan",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_minAmountOutAfterSwap",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_swapData",
+        "type": "bytes"
+      }
+    ],
+    "name": "enterLeverageFromBorrow",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken",
+        "name": "_collateralMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_collateralAmountSeed",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_collateralAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "enterSingleAssetLeverage",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken[]",
+        "name": "vTokens",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "amounts",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "premiums",
+        "type": "uint256[]"
+      },
+      {
+        "internalType": "address",
+        "name": "initiator",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "onBehalf",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "param",
+        "type": "bytes"
+      }
+    ],
+    "name": "executeOperation",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "success",
+        "type": "bool"
+      },
+      {
+        "internalType": "uint256[]",
+        "name": "repayAmounts",
+        "type": "uint256[]"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken",
+        "name": "_collateralMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_collateralAmountToRedeemForSwap",
+        "type": "uint256"
+      },
+      {
+        "internalType": "contract IVToken",
+        "name": "_borrowedMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_borrowedAmountToFlashLoan",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_minAmountOutAfterSwap",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_swapData",
+        "type": "bytes"
+      }
+    ],
+    "name": "exitLeverage",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IVToken",
+        "name": "_collateralMarket",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_collateralAmountToFlashLoan",
+        "type": "uint256"
+      }
+    ],
+    "name": "exitSingleAssetLeverage",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "initialize",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "owner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "pendingOwner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "protocolShareReserve",
+    "outputs": [
+      {
+        "internalType": "contract IProtocolShareReserve",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "renounceOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "swapHelper",
+    "outputs": [
+      {
+        "internalType": "contract SwapHelper",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "transferOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]
diff --git a/apps/evm/src/libs/contracts/config/index.ts b/apps/evm/src/libs/contracts/config/index.ts
index 38e29af59f..a1eeabb541 100644
--- a/apps/evm/src/libs/contracts/config/index.ts
+++ b/apps/evm/src/libs/contracts/config/index.ts
@@ -116,6 +116,7 @@ import aavePoolAddressesProviderAbi from './externalAbis/AavePoolAddressesProvid
 import aaveUiPoolDataProviderAbi from './externalAbis/AaveUiPoolDataProvider.json';
 import aaveV3PoolAbi from './externalAbis/AaveV3Pool.json';
 import erc20Abi from './externalAbis/Erc20.json';
+import leverageManagerAbi from './externalAbis/LeverageManager.json'; // TODO: get from package
 import maximillionAbi from './externalAbis/Maximillion.json';
 import multicall3Abi from './externalAbis/Multicall3.json';
 import nexusAbi from './externalAbis/Nexus.json';
@@ -671,6 +672,13 @@ export const contracts: ContractConfig[] = [
       [ChainId.UNICHAIN_SEPOLIA]: '0x0000003eDf18913c01cBc482C978bBD3D6E8ffA3',
     },
   },
+  {
+    name: 'LeverageManager',
+    abi: leverageManagerAbi as Abi,
+    address: {
+      [ChainId.BSC_MAINNET]: '0x3Ee4F1474A1071c5fAC97bd881eabcA2Cf8F6085', // TODO: get from package
+    },
+  },
   // Generic Contracts
   {
     name: 'IsolatedPoolComptroller',
diff --git a/apps/evm/src/libs/errors/VError.ts b/apps/evm/src/libs/errors/VError.ts
index 6dfd1e164a..641d06bfab 100644
--- a/apps/evm/src/libs/errors/VError.ts
+++ b/apps/evm/src/libs/errors/VError.ts
@@ -1,5 +1,6 @@
 import type { importProposalErrorPhrases } from './importProposalErrorPhrases';
 import type { interactionErrorPhrases } from './interactionErrorPhrases';
+import type { swapQuoteErrorPhrases } from './swapQuoteErrorPhrases';
 import type { transactionErrorPhrases } from './transactionErrorPhrases';
 import type { unexpectedErrorPhrases } from './unexpectedErrorPhrases';
 
@@ -10,6 +11,7 @@ export interface VErrorParamMap {
   };
   unexpected: { exception?: unknown } | undefined;
   interaction: { assetName: string; exception?: unknown };
+  swapQuote: { exception?: unknown };
   proposal: {
     info?: string;
   };
@@ -20,6 +22,7 @@ export interface VErrorPhraseMap {
   unexpected: keyof typeof unexpectedErrorPhrases;
   interaction: keyof typeof interactionErrorPhrases;
   proposal: keyof typeof importProposalErrorPhrases;
+  swapQuote: keyof typeof swapQuoteErrorPhrases;
 }
 
 export type ErrorCodes = keyof VErrorParamMap;
diff --git a/apps/evm/src/libs/errors/swapQuoteErrorPhrases.ts b/apps/evm/src/libs/errors/swapQuoteErrorPhrases.ts
new file mode 100644
index 0000000000..06c65e3687
--- /dev/null
+++ b/apps/evm/src/libs/errors/swapQuoteErrorPhrases.ts
@@ -0,0 +1,5 @@
+import { t } from 'libs/translations';
+
+export const swapQuoteErrorPhrases = {
+  noSwapQuoteFound: t('errors.noSwapQuoteFound'),
+};
diff --git a/apps/evm/src/libs/translations/translations/en.json b/apps/evm/src/libs/translations/translations/en.json
index 2ac76a20d1..cbda9429c6 100644
--- a/apps/evm/src/libs/translations/translations/en.json
+++ b/apps/evm/src/libs/translations/translations/en.json
@@ -400,6 +400,7 @@
     "noMetaKey": "No metadata information is present in the file",
     "noParamsKey": "File does not contain the list of params",
     "noSignaturesKey": "There are no call signatures in the file",
+    "noSwapQuoteFound": "No swap found. Please update the form.",
     "noTargetsKey": "File does not contain the list of targets",
     "noTypeKey": "File does not indicate the proposal's type",
     "proposalNotFound": "Proposal not found",
@@ -676,6 +677,7 @@
       "higherThanWalletSpendingLimit": "You entered an amount that exceeds your spending limit for this asset. Please revoke your spending limit then set a new one in order to proceed with this transaction.",
       "insufficientSwapLiquidity": "Insufficient liquidity in PancakeSwap for this swap",
       "noCollateral": "You need to supply tokens and enable them as collateral before you can borrow {{tokenSymbol}} from this pool",
+      "noSwapQuoteFound": "No swap found. Please update the form.",
       "priceImpactTooHigh": "Price impact too high",
       "supplyCapReached": "The supply cap of {{assetSupplyCap}} has been reached for this pool. You can not supply to this market anymore until withdraws are made or its supply cap is increased.",
       "tooRisky": "This transaction would get your account liquidated",
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/SelectTokenField/index.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/SelectTokenField/index.tsx
index b28af2a736..c2693bf54b 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/SelectTokenField/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/SelectTokenField/index.tsx
@@ -1,13 +1,14 @@
 import { type ButtonProps, Icon, QuinaryButton, TokenIconWithSymbol, cn } from 'components';
+import { getTokenSelectButtonTestId } from 'components/SelectTokenTextField/testIdGetters';
 import type { Token } from 'types';
 
-export interface SelectTokenFieldProps {
+export interface SelectTokenFieldProps extends React.HTMLAttributes<HTMLDivElement> {
   onButtonClick: ButtonProps['onClick'];
   token: Token;
   isActive: boolean;
   label: string;
   disabled?: boolean;
-  className?: string;
+  'data-testid'?: string;
 }
 
 export const SelectTokenField: React.FC<SelectTokenFieldProps> = ({
@@ -17,9 +18,11 @@ export const SelectTokenField: React.FC<SelectTokenFieldProps> = ({
   disabled,
   label,
   className,
+  'data-testid': testId,
+  ...otherProps
 }) => (
-  <div className={className}>
-    <p className="text-sm font-semibold text-grey">{label}</p>
+  <div className={className} data-testid={testId} {...otherProps}>
+    <p className="text-sm text-grey mb-1">{label}</p>
 
     <QuinaryButton
       className={cn(
@@ -29,6 +32,12 @@ export const SelectTokenField: React.FC<SelectTokenFieldProps> = ({
       contentClassName="w-full justify-between disabled:bg-transparent"
       onClick={onButtonClick}
       disabled={disabled}
+      data-testid={
+        !!testId &&
+        getTokenSelectButtonTestId({
+          parentTestId: testId,
+        })
+      }
     >
       <div className="flex items-center gap-x-2">
         <TokenIconWithSymbol token={token} />
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/SubmitSection/index.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/SubmitSection/index.tsx
index f2571567dd..41c8d63981 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/SubmitSection/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/SubmitSection/index.tsx
@@ -1,23 +1,47 @@
 import { useMemo } from 'react';
 
 import { PrimaryButton } from 'components';
+import { NULL_ADDRESS } from 'constants/address';
 import { SwitchChain } from 'containers/SwitchChain';
+import useDelegateApproval from 'hooks/useDelegateApproval';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
 import { useTranslation } from 'libs/translations';
+import type { Address } from 'viem';
+import { ApproveDelegateSteps } from '../../ApproveDelegateSteps';
 import type { FormErrorCode } from '../useForm';
 
 export interface SubmitSectionProps {
   isFormValid: boolean;
-  isFormSubmitting: boolean;
+  isLoading: boolean;
+  poolComptrollerContractAddress: Address;
   formErrorCode?: FormErrorCode;
 }
 
 export const SubmitSection: React.FC<SubmitSectionProps> = ({
   isFormValid,
-  isFormSubmitting,
+  isLoading,
   formErrorCode,
+  poolComptrollerContractAddress,
 }) => {
   const { t } = useTranslation();
 
+  const { address: leverageManagerContractAddress } = useGetContractAddress({
+    name: 'LeverageManager',
+  });
+
+  const {
+    isDelegateApproved,
+    isDelegateApprovedLoading,
+    isUpdateDelegateStatusLoading,
+    updatePoolDelegateStatus,
+  } = useDelegateApproval({
+    delegateeAddress: leverageManagerContractAddress || NULL_ADDRESS,
+    poolComptrollerAddress: poolComptrollerContractAddress,
+    enabled: !!leverageManagerContractAddress,
+  });
+
+  const approveDelegate = () => updatePoolDelegateStatus({ approvedStatus: true });
+
   const submitButtonLabel = useMemo(() => {
     if (!isFormValid && formErrorCode !== 'REQUIRES_RISK_ACKNOWLEDGEMENT') {
       return t('operationForm.submitButtonLabel.enterValidAmount');
@@ -29,8 +53,8 @@ export const SubmitSection: React.FC<SubmitSectionProps> = ({
   let dom = (
     <PrimaryButton
       type="submit"
-      loading={isFormSubmitting}
-      disabled={!isFormValid || isFormSubmitting}
+      loading={isLoading}
+      disabled={!isFormValid || isLoading}
       className="w-full"
     >
       {submitButtonLabel}
@@ -38,10 +62,20 @@ export const SubmitSection: React.FC<SubmitSectionProps> = ({
   );
 
   if (isFormValid) {
-    dom = <SwitchChain>{dom}</SwitchChain>;
+    dom = (
+      <SwitchChain>
+        <ApproveDelegateSteps
+          approveDelegateeAction={approveDelegate}
+          isApproveDelegateeLoading={isUpdateDelegateStatusLoading}
+          isDelegateeApproved={isDelegateApproved}
+          isDelegateeApprovedLoading={isDelegateApprovedLoading}
+          secondStepButtonLabel={submitButtonLabel}
+        >
+          {dom}
+        </ApproveDelegateSteps>
+      </SwitchChain>
+    );
   }
 
   return dom;
 };
-
-export default SubmitSection;
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/TokenSelectField/index.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/TokenSelectField/index.tsx
new file mode 100644
index 0000000000..ee782cb07b
--- /dev/null
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/TokenSelectField/index.tsx
@@ -0,0 +1,47 @@
+import { type ButtonProps, Icon, QuinaryButton, TokenIconWithSymbol, cn } from 'components';
+import type { Token } from 'types';
+
+export interface TokenSelectFieldProps {
+  onButtonClick: ButtonProps['onClick'];
+  token: Token;
+  isActive: boolean;
+  label: string;
+  disabled?: boolean;
+  className?: string;
+}
+
+export const TokenSelectField: React.FC<TokenSelectFieldProps> = ({
+  token,
+  onButtonClick,
+  isActive,
+  disabled,
+  label,
+  className,
+}) => (
+  <div className={className}>
+    <p className="text-sm text-grey mb-1">{label}</p>
+
+    <QuinaryButton
+      className={cn(
+        'px-4 h-14 w-full rounded-xl active:bg-lightGrey active:border-blue disabled:bg-transparent disabled:border-lightGrey',
+        isActive && 'border-blue bg-lightGrey',
+      )}
+      contentClassName="w-full justify-between disabled:bg-transparent"
+      onClick={onButtonClick}
+      disabled={disabled}
+    >
+      <div className="flex items-center gap-x-2">
+        <TokenIconWithSymbol token={token} tokenIconClassName="h-5 w-5" />
+      </div>
+
+      <Icon
+        name="arrowUp"
+        className={cn(
+          'w-5 h-5',
+          !isActive && 'rotate-180',
+          disabled ? 'text-grey' : 'text-offWhite',
+        )}
+      />
+    </QuinaryButton>
+  </div>
+);
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/__testUtils__/fakeData.ts b/apps/evm/src/pages/Market/OperationForm/BoostForm/__testUtils__/fakeData.ts
new file mode 100644
index 0000000000..f827048bea
--- /dev/null
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/__testUtils__/fakeData.ts
@@ -0,0 +1,27 @@
+import BigNumber from 'bignumber.js';
+
+import { poolData } from '__mocks__/models/pools';
+import { weth } from '__mocks__/models/tokens';
+import type { Asset, Pool } from 'types';
+
+export const fakePool: Pool = {
+  ...poolData[0],
+  userBorrowBalanceCents: new BigNumber(1000),
+  userBorrowLimitCents: new BigNumber(100000),
+  userLiquidationThresholdCents: new BigNumber(110000),
+};
+
+export const fakeAsset = {
+  ...fakePool.assets[0],
+  liquidityCents: new BigNumber(1000000),
+  userWalletBalanceTokens: new BigNumber(10000000),
+  tokenPriceCents: new BigNumber(100),
+};
+
+export const fakeWethAsset: Asset = {
+  ...fakeAsset,
+  vToken: {
+    ...fakeAsset.vToken,
+    underlyingToken: weth,
+  },
+};
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/__snapshots__/index.spec.tsx.snap b/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/__snapshots__/index.spec.tsx.snap
new file mode 100644
index 0000000000..4604d2cbd8
--- /dev/null
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/__snapshots__/index.spec.tsx.snap
@@ -0,0 +1,77 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`BoostForm > lets user open a leveraged position using a swap 1`] = `
+[
+  {
+    "borrowedVToken": {
+      "address": "0x6d6F697e34145Bb95c54E77482d97cc261Dc237E",
+      "decimals": 8,
+      "symbol": "vXVS",
+      "underlyingToken": {
+        "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+        "decimals": 18,
+        "iconSrc": "fake-xvs-asset",
+        "symbol": "XVS",
+      },
+    },
+    "suppliedVToken": {
+      "address": "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+      "decimals": 8,
+      "symbol": "vUSDC",
+      "underlyingToken": {
+        "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+        "decimals": 6,
+        "iconSrc": "fake-usdc-asset",
+        "symbol": "USDC",
+      },
+    },
+    "swapQuote": {
+      "callData": "0x",
+      "direction": "exact-in",
+      "expectedToTokenAmountReceivedMantissa": 100000000n,
+      "fromToken": {
+        "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+        "decimals": 18,
+        "iconSrc": "fake-xvs-asset",
+        "symbol": "XVS",
+      },
+      "fromTokenAmountSoldMantissa": 1000000000000000000n,
+      "minimumToTokenAmountReceivedMantissa": 100000000n,
+      "priceImpactPercentage": 0.1,
+      "toToken": {
+        "address": "0x16227D60f7a0e586C66B005219dfc887D13C9531",
+        "decimals": 6,
+        "iconSrc": "fake-usdc-asset",
+        "symbol": "USDC",
+      },
+    },
+  },
+]
+`;
+
+exports[`BoostForm > lets user open a leveraged position using the same supplied and borrowed market 1`] = `
+[
+  {
+    "amountMantissa": 1000000000000000000n,
+    "vToken": {
+      "address": "0x6d6F697e34145Bb95c54E77482d97cc261Dc237E",
+      "decimals": 8,
+      "symbol": "vXVS",
+      "underlyingToken": {
+        "address": "0xB9e0E753630434d7863528cc73CB7AC638a7c8ff",
+        "decimals": 18,
+        "iconSrc": "fake-xvs-asset",
+        "symbol": "XVS",
+      },
+    },
+  },
+]
+`;
+
+exports[`BoostForm > renders correct available amount when asset borrow cap is the limiting factor 1`] = `"Available990 XVS"`;
+
+exports[`BoostForm > renders correct available amount when asset liquidity is the limiting factor 1`] = `"Available1 XVS"`;
+
+exports[`BoostForm > renders correct available amount when user borrow limit is the limiting factor 1`] = `"Available10 XVS"`;
+
+exports[`BoostForm > renders correct available amount when user health factor is the limiting factor 1`] = `"Available0.05 XVS"`;
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/index.spec.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/index.spec.tsx
new file mode 100644
index 0000000000..7f83334e68
--- /dev/null
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/__tests__/index.spec.tsx
@@ -0,0 +1,561 @@
+import { fireEvent, waitFor } from '@testing-library/react';
+import { chains } from '@venusprotocol/chains';
+import BigNumber from 'bignumber.js';
+import type { Mock } from 'vitest';
+
+import fakeAccountAddress from '__mocks__/models/address';
+import {
+  type GetExactInSwapQuoteInput,
+  useGetSwapQuote,
+  useOpenLeveragedPosition,
+} from 'clients/api';
+import { selectToken } from 'components/SelectTokenTextField/__testUtils__/testUtils';
+import {
+  HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
+  HEALTH_FACTOR_MODERATE_THRESHOLD,
+} from 'constants/healthFactor';
+import { MAXIMUM_PRICE_IMPACT_THRESHOLD_PERCENTAGE } from 'constants/swap';
+import { useSimulateBalanceMutations } from 'hooks/useSimulateBalanceMutations';
+import { VError } from 'libs/errors';
+import { en } from 'libs/translations';
+import { renderComponent } from 'testUtils/render';
+import { type Asset, ChainId, type Pool } from 'types';
+import { convertTokensToMantissa } from 'utilities';
+import BoostForm from '..';
+import { checkSubmitButtonIsDisabled } from '../../__testUtils__/checkFns';
+import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
+import TEST_IDS from '../testIds';
+
+const testCases = [
+  [
+    'user borrow limit',
+    {
+      asset: fakeAsset,
+      pool: fakePool,
+    },
+  ],
+  [
+    'asset borrow cap',
+    {
+      asset: {
+        ...fakeAsset,
+        borrowCapTokens: new BigNumber(1000),
+        borrowBalanceTokens: new BigNumber(10),
+        cashTokens: new BigNumber(500000),
+      },
+      pool: {
+        ...fakePool,
+        userBorrowLimitCents: new BigNumber(1000000000),
+        userBorrowBalanceCents: new BigNumber(99),
+      },
+    },
+  ],
+
+  [
+    'user health factor',
+    {
+      asset: fakeAsset,
+      pool: {
+        ...fakePool,
+        userLiquidationThresholdCents: new BigNumber(105),
+        userBorrowLimitCents: new BigNumber(100),
+        userBorrowBalanceCents: new BigNumber(99),
+      },
+    },
+  ],
+  [
+    'asset liquidity',
+    {
+      asset: {
+        ...fakeAsset,
+        cashTokens: new BigNumber(1),
+      },
+      pool: fakePool,
+    },
+  ],
+] as const;
+
+const mockOpenLeveragedPosition = vi.fn();
+
+vi.mock('hooks/useSimulateBalanceMutations', () => ({
+  useSimulateBalanceMutations: vi.fn(() => ({
+    isLoading: false,
+    data: {
+      pool: fakePool,
+    },
+  })),
+}));
+
+describe('BoostForm', () => {
+  beforeEach(() => {
+    (useOpenLeveragedPosition as Mock).mockImplementation(() => ({
+      mutateAsync: mockOpenLeveragedPosition,
+    }));
+
+    (useGetSwapQuote as Mock).mockImplementation((input: GetExactInSwapQuoteInput) => ({
+      isLoading: false,
+      data: {
+        swapQuote: {
+          fromToken: input.fromToken,
+          toToken: input.toToken,
+          direction: 'exact-in',
+          priceImpactPercentage: 0.1,
+          fromTokenAmountSoldMantissa: BigInt(
+            convertTokensToMantissa({
+              value: input.fromTokenAmountTokens,
+              token: input.fromToken,
+            }).toFixed(),
+          ),
+          expectedToTokenAmountReceivedMantissa: 100000000n,
+          minimumToTokenAmountReceivedMantissa: 100000000n,
+          callData: '0x',
+        },
+      },
+    }));
+  });
+
+  it('prompts user to connect their wallet if they are not connected', async () => {
+    const { getByText, getByTestId } = renderComponent(
+      <BoostForm pool={fakePool} asset={fakeAsset} />,
+    );
+
+    // Check "Connect wallet" button is displayed
+    expect(getByText(en.connectWallet.connectButton)).toBeInTheDocument();
+
+    // Check input is disabled
+    expect(getByTestId(TEST_IDS.tokenTextField).closest('input')).toBeDisabled();
+  });
+
+  it.each(testCases)(
+    'renders correct available amount when %s is the limiting factor',
+    async (_, { asset, pool }) => {
+      const { getByTestId } = renderComponent(<BoostForm asset={asset} pool={pool} />, {
+        accountAddress: fakeAccountAddress,
+      });
+
+      expect(getByTestId(TEST_IDS.availableAmount).textContent).toMatchSnapshot();
+    },
+  );
+
+  it('disables form and displays a warning notice if the borrow cap of this market has been reached', async () => {
+    const customFakeAsset = {
+      ...fakeAsset,
+      borrowCapTokens: new BigNumber(100),
+      borrowBalanceTokens: new BigNumber(100),
+    };
+
+    const { getByText, getByTestId } = renderComponent(
+      <BoostForm asset={customFakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(
+        getByText(en.operationForm.error.borrowCapReached.replace('{{assetBorrowCap}}', '100 XVS')),
+      ).toBeInTheDocument(),
+    );
+
+    // Check input is disabled
+    expect(getByTestId(TEST_IDS.tokenTextField).closest('input')).toBeDisabled();
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables form and displays a warning notice if user has not supplied and collateralized any tokens yet', async () => {
+    const customFakePool: Pool = {
+      ...fakePool,
+      userBorrowLimitCents: new BigNumber(0),
+      userBorrowBalanceCents: new BigNumber(0),
+      assets: fakePool.assets.map(asset => ({
+        ...asset,
+        isCollateralOfUser: false,
+      })),
+    };
+
+    const { getByText } = renderComponent(<BoostForm asset={fakeAsset} pool={customFakePool} />, {
+      accountAddress: fakeAccountAddress,
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(
+        getByText(
+          en.operationForm.error.noCollateral.replace(
+            '{{tokenSymbol}}',
+            fakeAsset.vToken.underlyingToken.symbol,
+          ),
+        ),
+      ).toBeInTheDocument(),
+    );
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button and displays a warning notice if borrow amount entered is higher than asset liquidity', async () => {
+    const customFakeAsset: Asset = {
+      ...fakeAsset,
+      liquidityCents: new BigNumber(200),
+    };
+
+    const { getByText, getByTestId } = renderComponent(
+      <BoostForm asset={customFakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    const incorrectValueTokens = new BigNumber(customFakeAsset.liquidityCents)
+      .dividedBy(customFakeAsset.tokenPriceCents)
+      // Add one token more than the available liquidity
+      .plus(1)
+      .dp(customFakeAsset.vToken.underlyingToken.decimals, BigNumber.ROUND_DOWN)
+      .toFixed();
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, {
+      target: { value: incorrectValueTokens },
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(getByText(en.operationForm.error.higherThanAvailableLiquidity)).toBeInTheDocument(),
+    );
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button and displays a warning notice if borrow amount entered is higher than asset borrow cap', async () => {
+    const customFakeAsset: Asset = {
+      ...fakeAsset,
+      borrowCapTokens: new BigNumber(100),
+      borrowBalanceTokens: new BigNumber(10),
+    };
+
+    const { getByText, getByTestId } = renderComponent(
+      <BoostForm asset={customFakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    const incorrectValueTokens = new BigNumber(customFakeAsset.borrowCapTokens!)
+      .minus(customFakeAsset.borrowBalanceTokens)
+      // Add one token too much
+      .plus(1)
+      .toFixed();
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, {
+      target: { value: incorrectValueTokens },
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(
+        getByText(
+          en.operationForm.error.higherThanBorrowCap
+            .replace('{{userMaxBorrowAmount}}', '90 XVS')
+            .replace('{{assetBorrowCap}}', '100 XVS')
+            .replace('{{assetBorrowBalance}}', '10 XVS'),
+        ),
+      ).toBeInTheDocument(),
+    );
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button if position would make user borrow balance go higher than their borrow limit', async () => {
+    const { getByTestId, getByText } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    const incorrectValueTokens = fakePool
+      .userBorrowLimitCents!.minus(fakePool.userBorrowBalanceCents!)
+      .dividedBy(fakeAsset.tokenPriceCents)
+      // Convert cents to tokens
+      // Add one token more than the maximum
+      .plus(1)
+      .dp(fakeAsset.vToken.underlyingToken.decimals, BigNumber.ROUND_DOWN)
+      .toFixed();
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, {
+      target: { value: incorrectValueTokens },
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(getByText(en.operationForm.error.higherThanAvailableAmount)).toBeInTheDocument(),
+    );
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button if position would liquidate user', async () => {
+    (useSimulateBalanceMutations as Mock).mockImplementation(() => ({
+      isLoading: false,
+      data: {
+        pool: {
+          ...fakePool,
+          userHealthFactor: HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
+        },
+      },
+    }));
+
+    const { getByTestId, getByText } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, {
+      target: { value: 1 },
+    });
+
+    // Check warning is displayed
+    await waitFor(() => expect(getByText(en.operationForm.error.tooRisky)).toBeInTheDocument());
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button if price impact is too high', async () => {
+    (useGetSwapQuote as Mock).mockImplementation((input: GetExactInSwapQuoteInput) => ({
+      isLoading: false,
+      data: {
+        swapQuote: {
+          fromToken: input.fromToken,
+          toToken: input.toToken,
+          direction: 'exact-in',
+          priceImpactPercentage: MAXIMUM_PRICE_IMPACT_THRESHOLD_PERCENTAGE,
+          fromTokenAmountSoldMantissa: BigInt(
+            convertTokensToMantissa({
+              value: input.fromTokenAmountTokens,
+              token: input.fromToken,
+            }).toFixed(),
+          ),
+          expectedToTokenAmountReceivedMantissa: 100000000n,
+          minimumToTokenAmountReceivedMantissa: 100000000n,
+          callData: '0x',
+        },
+      },
+    }));
+
+    const { getByTestId, getByText } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, {
+      target: { value: 1 },
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(getByText(en.operationForm.error.priceImpactTooHigh)).toBeInTheDocument(),
+    );
+
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button if amount to supply to open position is higher than asset supply cap', async () => {
+    const customFakeAsset: Asset = {
+      ...fakeAsset,
+      supplyCapTokens: new BigNumber(1000),
+      supplyBalanceTokens: new BigNumber(999),
+    };
+
+    const { getByTestId } = renderComponent(<BoostForm asset={customFakeAsset} pool={fakePool} />, {
+      accountAddress: fakeAccountAddress,
+    });
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(
+      () => getByTestId(TEST_IDS.tokenTextField) as HTMLInputElement,
+    );
+    fireEvent.change(tokenTextInput, {
+      target: { value: 100 },
+    });
+
+    await waitFor(() => expect(tokenTextInput.value).toEqual('100'));
+
+    // Check submit button is disabled
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('disables submit button if no swap was found', async () => {
+    (useGetSwapQuote as Mock).mockImplementation(() => ({
+      isLoading: false,
+      data: undefined,
+      error: new VError({ type: 'swapQuote', code: 'noSwapQuoteFound' }),
+    }));
+
+    const { getByTestId, getByText } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(
+      () => getByTestId(TEST_IDS.tokenTextField) as HTMLInputElement,
+    );
+    fireEvent.change(tokenTextInput, {
+      target: { value: 1 },
+    });
+
+    // Check warning is displayed
+    await waitFor(() =>
+      expect(getByText(en.operationForm.error.noSwapQuoteFound)).toBeInTheDocument(),
+    );
+
+    // Check submit button is disabled
+    await checkSubmitButtonIsDisabled();
+  });
+
+  it('prompts user to switch chain if they are connected to the wrong one', async () => {
+    const { getByText, getByTestId } = renderComponent(
+      <BoostForm pool={fakePool} asset={fakeAsset} />,
+      {
+        accountAddress: fakeAccountAddress,
+        accountChainId: ChainId.ARBITRUM_ONE,
+        chainId: ChainId.BSC_TESTNET,
+      },
+    );
+
+    const correctAmountTokens = 1;
+
+    const tokenTextInput = await waitFor(() => getByTestId(TEST_IDS.tokenTextField));
+    fireEvent.change(tokenTextInput, { target: { value: correctAmountTokens } });
+
+    // Check "Switch chain" button is displayed
+    await waitFor(() =>
+      expect(
+        getByText(
+          en.switchChain.switchButton.replace('{{chainName}}', chains[ChainId.BSC_TESTNET].name),
+        ),
+      ).toBeInTheDocument(),
+    );
+  });
+
+  it('prompts user to acknowledge risk if position would lower health factor to risky threshold', async () => {
+    (useSimulateBalanceMutations as Mock).mockImplementation(() => ({
+      isLoading: false,
+      data: {
+        pool: {
+          ...fakePool,
+          userHealthFactor: HEALTH_FACTOR_MODERATE_THRESHOLD - 0.01,
+        },
+      },
+    }));
+
+    const { getByText, getByTestId, getByRole } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(
+      () => getByTestId(TEST_IDS.tokenTextField) as HTMLInputElement,
+    );
+    fireEvent.change(tokenTextInput, {
+      target: { value: 10 },
+    });
+
+    await waitFor(() => expect(tokenTextInput.value).toEqual('10'));
+
+    // Check warning is displayed
+    expect(getByText(en.operationForm.riskyOperation.warning));
+
+    // Check submit button is disabled
+    const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
+    await waitFor(() =>
+      expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.boost),
+    );
+    expect(submitButton).toBeDisabled();
+
+    // Toggle acknowledgement
+    const toggle = getByRole('checkbox');
+    fireEvent.click(toggle);
+
+    await waitFor(() => expect(document.querySelector('button[type="submit"]')).toBeEnabled());
+  });
+
+  it('lets user open a leveraged position using a swap', async () => {
+    const { getByTestId, getByText } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(
+      () => getByTestId(TEST_IDS.tokenTextField) as HTMLInputElement,
+    );
+    fireEvent.change(tokenTextInput, {
+      target: { value: 1 },
+    });
+
+    // Click on submit button
+    await waitFor(() => getByText(en.operationForm.submitButtonLabel.boost));
+    fireEvent.click(getByText(en.operationForm.submitButtonLabel.boost));
+
+    await waitFor(() => expect(mockOpenLeveragedPosition).toHaveBeenCalledTimes(1));
+    expect(mockOpenLeveragedPosition.mock.calls[0]).toMatchSnapshot();
+  });
+
+  it('lets user open a leveraged position using the same supplied and borrowed market', async () => {
+    (useGetSwapQuote as Mock).mockImplementation(() => ({
+      isLoading: false,
+      data: undefined,
+    }));
+
+    const { getByTestId, getByText, container } = renderComponent(
+      <BoostForm asset={fakeAsset} pool={fakePool} />,
+      {
+        accountAddress: fakeAccountAddress,
+      },
+    );
+
+    // Select same supply market as borrow market
+    selectToken({
+      container,
+      selectTokenTextFieldTestId: TEST_IDS.selectTokenField,
+      token: fakeAsset.vToken.underlyingToken,
+    });
+
+    // Enter amount in input
+    const tokenTextInput = await waitFor(
+      () => getByTestId(TEST_IDS.tokenTextField) as HTMLInputElement,
+    );
+    fireEvent.change(tokenTextInput, {
+      target: { value: 1 },
+    });
+
+    // Click on submit button
+    await waitFor(() => getByText(en.operationForm.submitButtonLabel.boost));
+    fireEvent.click(getByText(en.operationForm.submitButtonLabel.boost));
+
+    await waitFor(() => expect(mockOpenLeveragedPosition).toHaveBeenCalledTimes(1));
+    expect(mockOpenLeveragedPosition.mock.calls[0]).toMatchSnapshot();
+  });
+});
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/index.tsx
index 3fa89d4445..fa663e993c 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/index.tsx
@@ -2,6 +2,7 @@ import { cn } from '@venusprotocol/ui';
 import BigNumber from 'bignumber.js';
 import { useEffect, useMemo, useState } from 'react';
 
+import { useGetSwapQuote, useOpenLeveragedPosition } from 'clients/api';
 import {
   Delimiter,
   Icon,
@@ -11,15 +12,19 @@ import {
   TokenListWrapper,
   TokenTextField,
 } from 'components';
+import { NULL_ADDRESS } from 'constants/address';
 import { HEALTH_FACTOR_MODERATE_THRESHOLD } from 'constants/healthFactor';
 import { ConnectWallet } from 'containers/ConnectWallet';
 import { SwapDetails } from 'containers/SwapDetails';
 import useDebounceValue from 'hooks/useDebounceValue';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import { useGetUserSlippageTolerance } from 'hooks/useGetUserSlippageTolerance';
 import { useSimulateBalanceMutations } from 'hooks/useSimulateBalanceMutations';
 import { useAnalytics } from 'libs/analytics';
+import { VError } from 'libs/errors';
 import { useTranslation } from 'libs/translations';
 import { useAccountAddress } from 'libs/wallet';
-import type { Asset, BalanceMutation, Pool, Swap, Token } from 'types';
+import type { Asset, BalanceMutation, Pool, Token } from 'types';
 import {
   areTokensEqual,
   compareNumbers,
@@ -32,43 +37,65 @@ import { OperationDetails } from '../OperationDetails';
 import { calculateAmountDollars } from '../calculateAmountDollars';
 import { RiskSlider } from './RiskSlider';
 import { SelectTokenField } from './SelectTokenField';
-import SubmitSection from './SubmitSection';
+import { SubmitSection } from './SubmitSection';
 import { calculateUserMaxBorrowTokens } from './calculateUserMaxBorrowTokens';
 import TEST_IDS from './testIds';
 import useForm, { type FormValues, type UseFormInput } from './useForm';
 
-// TODO: add tests
-
 export interface BoostFormProps {
   asset: Asset;
   pool: Pool;
-  onSubmitSuccess?: () => void;
 }
 
-const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSubmitSuccess }) => {
+const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool }) => {
   const { accountAddress } = useAccountAddress();
 
-  const initialFormValues: FormValues = useMemo(() => {
-    let initialSuppliedAsset = borrowedAsset;
+  const { address: leverageManagerContractAddress } = useGetContractAddress({
+    name: 'LeverageManager',
+  });
 
-    // Find asset with the highest collateral factor and initialize form with it
-    let highestCollateralFactor = 0;
+  const userBorrowingPowerCents = useMemo(
+    () => pool.userBorrowLimitCents?.minus(pool.userBorrowBalanceCents || 0),
+    [pool],
+  );
 
-    pool.assets.forEach(a => {
-      if (a.userCollateralFactor > highestCollateralFactor) {
-        highestCollateralFactor = a.userCollateralFactor;
-        initialSuppliedAsset = a;
-      }
-    });
+  const tokenBalances = useMemo(
+    () =>
+      userBorrowingPowerCents
+        ? [...pool.assets]
+            // Sort by collateral factor
+            .sort((a, b) => compareNumbers(a.userCollateralFactor, b.userCollateralFactor, 'desc'))
+            .reduce<OptionalTokenBalance[]>((acc, asset) => {
+              if (
+                asset.userCollateralFactor === 0 ||
+                // Skip vBNB
+                asset.vToken.symbol === 'vBNB' ||
+                // Skip tokens that have reached their supply cap
+                asset.supplyBalanceTokens.isGreaterThanOrEqualTo(asset.supplyCapTokens)
+              ) {
+                return acc;
+              }
+
+              const tokenBalance: OptionalTokenBalance = {
+                token: asset.vToken.underlyingToken,
+              };
+
+              return [...acc, tokenBalance];
+            }, [])
+        : [],
+    [pool.assets, userBorrowingPowerCents],
+  );
 
+  const initialFormValues: FormValues = useMemo(() => {
     const values: FormValues = {
       amountTokens: '',
-      suppliedToken: initialSuppliedAsset.vToken.underlyingToken,
+      suppliedToken:
+        tokenBalances.length > 0 ? tokenBalances[0].token : borrowedAsset.vToken.underlyingToken,
       acknowledgeRisk: false,
     };
 
     return values;
-  }, [borrowedAsset, pool.assets]);
+  }, [tokenBalances, borrowedAsset]);
 
   const [isTokenListShown, setIsTokenListShown] = useState(false);
   const [formValues, setFormValues] = useState<FormValues>(initialFormValues);
@@ -77,6 +104,10 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
     pool.assets.find(a => areTokensEqual(a.vToken.underlyingToken, formValues.suppliedToken)) ||
     borrowedAsset;
 
+  // If a user is using the same market to borrow and supply, then we don't use the swap (the
+  // borrowed tokens are directly resupplied to the same market
+  const isUsingSwap = !areTokensEqual(borrowedAsset.vToken, suppliedAsset.vToken);
+
   // Reset form when user disconnects their wallet
   useEffect(() => {
     if (!accountAddress) {
@@ -84,19 +115,43 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
     }
   }, [accountAddress, initialFormValues]);
 
-  const isSubmitting = false; // TODO: wire up
+  const { mutateAsync: openLeveragedPosition, isPending: isOpenLeveragedPositionLoading } =
+    useOpenLeveragedPosition();
+
+  const isSubmitting = isOpenLeveragedPositionLoading;
 
   const onSubmit: UseFormInput['onSubmit'] = async () => {
-    // TODO: wire up
+    if (!isUsingSwap) {
+      const amountMantissa = BigInt(
+        convertTokensToMantissa({
+          value: new BigNumber(formValues.amountTokens),
+          token: formValues.suppliedToken,
+        }).toFixed(),
+      );
+
+      return openLeveragedPosition({
+        vToken: borrowedAsset.vToken,
+        amountMantissa,
+      });
+    }
+
+    if (swapQuote?.direction !== 'exact-in') {
+      throw new VError({
+        type: 'unexpected',
+        code: 'somethingWentWrong',
+      });
+    }
+
+    return openLeveragedPosition({
+      swapQuote,
+      borrowedVToken: borrowedAsset.vToken,
+      suppliedVToken: suppliedAsset.vToken,
+    });
   };
 
   const { t } = useTranslation();
   const { captureAnalyticEvent } = useAnalytics();
 
-  const userBorrowingPowerCents = pool.userBorrowLimitCents?.minus(
-    pool.userBorrowBalanceCents || 0,
-  );
-
   // Calculate maximum amount of tokens user can borrow
   let limitTokens = new BigNumber(0);
 
@@ -111,70 +166,59 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
   const _debouncedInputAmountTokens = useDebounceValue(formValues.amountTokens);
   const debouncedInputAmountTokens = new BigNumber(_debouncedInputAmountTokens || 0);
 
-  // TODO: fetch
-  const swap: Swap | undefined = debouncedInputAmountTokens.isGreaterThan(0)
-    ? {
-        fromToken: borrowedAsset.vToken.underlyingToken,
-        toToken: suppliedAsset.vToken.underlyingToken,
-        exchangeRate: new BigNumber(1),
-        priceImpactPercentage: 0.08,
-        routePath: [],
-        fromTokenAmountSoldMantissa: convertTokensToMantissa({
-          value: debouncedInputAmountTokens,
-          token: borrowedAsset.vToken.underlyingToken,
-        }),
-        expectedToTokenAmountReceivedMantissa: convertTokensToMantissa({
-          value: new BigNumber(1000),
-          token: suppliedAsset.vToken.underlyingToken,
-        }),
-        minimumToTokenAmountReceivedMantissa: convertTokensToMantissa({
-          value: new BigNumber(900),
-          token: suppliedAsset.vToken.underlyingToken,
-        }),
-        direction: 'exactAmountIn',
-      }
-    : undefined;
+  const { userSlippageTolerancePercentage } = useGetUserSlippageTolerance();
+
+  const {
+    data: getSwapQuoteData,
+    error: getSwapQuoteError,
+    isLoading: isGetSwapQuoteLoading,
+  } = useGetSwapQuote(
+    {
+      fromToken: borrowedAsset.vToken.underlyingToken,
+      fromTokenAmountTokens: debouncedInputAmountTokens,
+      toToken: formValues.suppliedToken,
+      direction: 'exact-in',
+      recipientAddress: leverageManagerContractAddress || NULL_ADDRESS,
+      slippagePercentage: userSlippageTolerancePercentage,
+    },
+    {
+      enabled:
+        isUsingSwap &&
+        !!leverageManagerContractAddress &&
+        debouncedInputAmountTokens.isGreaterThan(0),
+    },
+  );
+  const swapQuote = getSwapQuoteData?.swapQuote;
+
+  let expectedSuppliedAmountTokens = undefined;
+
+  if (isUsingSwap && swapQuote?.direction === 'exact-in') {
+    expectedSuppliedAmountTokens = convertMantissaToTokens({
+      value: swapQuote.expectedToTokenAmountReceivedMantissa,
+      token: suppliedAsset.vToken.underlyingToken,
+    });
+  } else if (!isUsingSwap) {
+    expectedSuppliedAmountTokens = debouncedInputAmountTokens;
+  }
 
   const readableLimit = formatTokensToReadableValue({
     value: limitTokens,
     token: borrowedAsset.vToken.underlyingToken,
   });
 
-  const tokenBalances = userBorrowingPowerCents
-    ? [...pool.assets]
-        // Sort by collateral factor
-        .sort((a, b) => compareNumbers(a.userCollateralFactor, b.userCollateralFactor, 'desc'))
-        .reduce<OptionalTokenBalance[]>((acc, asset) => {
-          // Skip tokens that can't be collaterals
-          if (asset.userCollateralFactor === 0 || asset.vToken.symbol === 'vBNB') {
-            return acc;
-          }
-
-          const tokenBalance: OptionalTokenBalance = {
-            token: asset.vToken.underlyingToken,
-          };
-
-          return [...acc, tokenBalance];
-        }, [])
-    : [];
-
   const balanceMutations: BalanceMutation[] = [
     {
       type: 'asset',
       vTokenAddress: suppliedAsset.vToken.address,
       action: 'supply',
-      amountTokens: swap?.minimumToTokenAmountReceivedMantissa
-        ? convertMantissaToTokens({
-            value: swap.minimumToTokenAmountReceivedMantissa,
-            token: suppliedAsset.vToken.underlyingToken,
-          })
-        : new BigNumber(0),
+      amountTokens: expectedSuppliedAmountTokens || new BigNumber(0),
+      enableAsCollateralOfUser: true,
     },
     {
       type: 'asset',
       vTokenAddress: borrowedAsset.vToken.address,
       action: 'borrow',
-      amountTokens: debouncedInputAmountTokens,
+      amountTokens: !isUsingSwap || swapQuote ? debouncedInputAmountTokens : new BigNumber(0),
     },
   ];
 
@@ -189,11 +233,13 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
     simulatedPool?.userHealthFactor < HEALTH_FACTOR_MODERATE_THRESHOLD;
 
   const { handleSubmit, isFormValid, formError } = useForm({
-    asset: borrowedAsset,
+    borrowedAsset,
     pool,
     simulatedPool,
     limitTokens,
-    onSubmitSuccess,
+    swapQuote,
+    getSwapQuoteError: getSwapQuoteError || undefined,
+    expectedSuppliedAmountTokens,
     onSubmit,
     formValues,
     setFormValues,
@@ -301,9 +347,11 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
             onTokenClick={handleSuppliedTokenChange}
             onClose={() => setIsTokenListShown(false)}
             isListShown={isTokenListShown}
+            data-testid={TEST_IDS.selectTokenField}
           >
             <div className="flex gap-x-1">
               <TokenTextField
+                data-testid={TEST_IDS.tokenTextField}
                 className="flex-1"
                 label={t('operationForm.borrow')}
                 name="amountTokens"
@@ -317,13 +365,15 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
                   !isSubmitting &&
                   Number(formValues.amountTokens) > 0 &&
                   !!formError &&
-                  formError.code !== 'REQUIRES_RISK_ACKNOWLEDGEMENT'
+                  formError.code !== 'REQUIRES_RISK_ACKNOWLEDGEMENT' &&
+                  formError.code !== 'MISSING_DATA'
                 }
               />
 
               <Icon name="arrowRightFull" className="mt-10 size-6" />
 
               <SelectTokenField
+                data-testid={TEST_IDS.selectTokenField}
                 className="flex-1"
                 label={t('operationForm.supply')}
                 token={suppliedAsset.vToken.underlyingToken}
@@ -368,8 +418,6 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
 
           <Delimiter />
 
-          {/* TODO: add step to allow Comptroller contract as delegate */}
-
           <OperationDetails
             action="borrow"
             pool={pool}
@@ -387,15 +435,16 @@ const BoostForm: React.FC<BoostFormProps> = ({ asset: borrowedAsset, pool, onSub
 
         <div className="space-y-3">
           <SubmitSection
-            isFormSubmitting={isSubmitting}
+            isLoading={isSubmitting || isGetSwapQuoteLoading}
             isFormValid={isFormValid}
             formErrorCode={formError?.code}
+            poolComptrollerContractAddress={pool.comptrollerAddress}
           />
 
           <SwapDetails
             fromToken={borrowedAsset.vToken.underlyingToken}
             toToken={suppliedAsset.vToken.underlyingToken}
-            priceImpactPercentage={swap?.priceImpactPercentage}
+            priceImpactPercentage={swapQuote?.priceImpactPercentage}
           />
         </div>
       </ConnectWallet>
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/testIds.ts b/apps/evm/src/pages/Market/OperationForm/BoostForm/testIds.ts
index 881c9c8832..5ba4f8c703 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/testIds.ts
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/testIds.ts
@@ -1,5 +1,6 @@
 const TEST_IDS = {
-  selectTokenTextField: 'select-token-text-field',
+  tokenTextField: 'token-text-field',
+  selectTokenField: 'select-token-field',
   availableAmount: 'available-amount',
 };
 
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/index.tsx
index 65fdbb858c..05f9920d77 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/index.tsx
@@ -1,5 +1,5 @@
-import { handleError } from 'libs/errors';
-import type { Asset, Pool, Token } from 'types';
+import { type VError, handleError } from 'libs/errors';
+import type { Asset, Pool, SwapQuote } from 'types';
 
 import type BigNumber from 'bignumber.js';
 import type { FormError } from '../../types';
@@ -9,14 +9,16 @@ import useFormValidation from './useFormValidation';
 export * from './types';
 
 export interface UseFormInput {
-  asset: Asset;
+  borrowedAsset: Asset;
   pool: Pool;
   limitTokens: BigNumber;
-  onSubmit: (input: { fromToken: Token; fromTokenAmountTokens: string }) => Promise<unknown>;
+  onSubmit: () => Promise<unknown>;
   formValues: FormValues;
-  setFormValues: (setter: (currentFormValues: FormValues) => FormValues | FormValues) => void;
+  setFormValues: (setter: (currentFormValues: FormValues) => FormValues) => void;
   initialFormValues: FormValues;
-  onSubmitSuccess?: () => void;
+  swapQuote?: SwapQuote;
+  getSwapQuoteError?: VError<'swapQuote' | 'interaction'>;
+  expectedSuppliedAmountTokens?: BigNumber;
   simulatedPool?: Pool;
 }
 
@@ -27,21 +29,27 @@ interface UseFormOutput {
 }
 
 const useForm = ({
-  asset,
+  borrowedAsset,
   pool,
   simulatedPool,
   limitTokens,
-  onSubmitSuccess,
   formValues,
   setFormValues,
   initialFormValues,
+  expectedSuppliedAmountTokens,
+  swapQuote,
+  getSwapQuoteError,
+  onSubmit,
 }: UseFormInput): UseFormOutput => {
   const { isFormValid, formError } = useFormValidation({
-    asset,
+    asset: borrowedAsset,
     pool,
     limitTokens,
     simulatedPool,
     formValues,
+    swapQuote,
+    expectedSuppliedAmountTokens,
+    getSwapQuoteError,
   });
 
   const handleSubmit = async (e?: React.SyntheticEvent) => {
@@ -52,12 +60,13 @@ const useForm = ({
     }
 
     try {
-      // TODO: submit form
+      await onSubmit();
 
-      // Reset form and close modal on success only
-      setFormValues(() => initialFormValues);
-
-      onSubmitSuccess?.();
+      // Reset form
+      setFormValues(currentFormValues => ({
+        ...initialFormValues,
+        suppliedToken: currentFormValues.suppliedToken,
+      }));
     } catch (error) {
       handleError({ error });
     }
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/types.ts b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/types.ts
index bfed1566eb..9ac5a0f02d 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/types.ts
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/types.ts
@@ -11,7 +11,11 @@ export type FormErrorCode =
   | 'NO_COLLATERALS'
   | 'BORROW_CAP_ALREADY_REACHED'
   | 'HIGHER_THAN_BORROW_CAP'
+  | 'HIGHER_THAN_SUPPLY_CAP'
   | 'HIGHER_THAN_LIQUIDITY'
   | 'HIGHER_THAN_AVAILABLE_AMOUNT'
   | 'TOO_RISKY'
-  | 'REQUIRES_RISK_ACKNOWLEDGEMENT';
+  | 'REQUIRES_RISK_ACKNOWLEDGEMENT'
+  | 'NO_SWAP_QUOTE_FOUND'
+  | 'MISSING_DATA'
+  | 'SWAP_PRICE_IMPACT_TOO_HIGH';
diff --git a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/useFormValidation.ts b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/useFormValidation.ts
index 0acc072637..333bf238bc 100644
--- a/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/useFormValidation.ts
+++ b/apps/evm/src/pages/Market/OperationForm/BoostForm/useForm/useFormValidation.ts
@@ -1,13 +1,14 @@
 import BigNumber from 'bignumber.js';
 import { useMemo } from 'react';
 
-import type { Asset, Pool } from 'types';
-
 import {
   HEALTH_FACTOR_LIQUIDATION_THRESHOLD,
   HEALTH_FACTOR_MODERATE_THRESHOLD,
 } from 'constants/healthFactor';
+import { MAXIMUM_PRICE_IMPACT_THRESHOLD_PERCENTAGE } from 'constants/swap';
+import type { VError } from 'libs/errors';
 import { useTranslation } from 'libs/translations';
+import type { Asset, Pool, SwapQuote } from 'types';
 import { formatTokensToReadableValue } from 'utilities';
 import type { FormError } from '../../types';
 import type { FormErrorCode, FormValues } from './types';
@@ -17,6 +18,9 @@ interface UseFormValidationInput {
   pool: Pool;
   formValues: FormValues;
   limitTokens: BigNumber;
+  swapQuote?: SwapQuote;
+  getSwapQuoteError?: VError<'swapQuote' | 'interaction'>;
+  expectedSuppliedAmountTokens?: BigNumber;
   simulatedPool?: Pool;
 }
 
@@ -31,6 +35,9 @@ const useFormValidation = ({
   limitTokens,
   simulatedPool,
   formValues,
+  swapQuote,
+  getSwapQuoteError,
+  expectedSuppliedAmountTokens,
 }: UseFormValidationInput): UseFormValidationOutput => {
   const { t } = useTranslation();
 
@@ -59,6 +66,13 @@ const useFormValidation = ({
       };
     }
 
+    if (getSwapQuoteError?.code === 'noSwapQuoteFound') {
+      return {
+        code: 'NO_SWAP_QUOTE_FOUND',
+        message: t('operationForm.error.noSwapQuoteFound'),
+      };
+    }
+
     const borrowedTokenAmountTokens = formValues.amountTokens
       ? new BigNumber(formValues.amountTokens)
       : undefined;
@@ -70,7 +84,6 @@ const useFormValidation = ({
     }
 
     if (
-      asset.borrowCapTokens &&
       asset.borrowBalanceTokens.plus(borrowedTokenAmountTokens).isGreaterThan(asset.borrowCapTokens)
     ) {
       return {
@@ -95,6 +108,34 @@ const useFormValidation = ({
       };
     }
 
+    if (
+      expectedSuppliedAmountTokens &&
+      asset.supplyBalanceTokens
+        .plus(expectedSuppliedAmountTokens)
+        .isGreaterThan(asset.supplyCapTokens)
+    ) {
+      return {
+        code: 'HIGHER_THAN_SUPPLY_CAP',
+        message: t('operationForm.error.higherThanSupplyCap', {
+          userMaxSupplyAmount: formatTokensToReadableValue({
+            value: asset.supplyCapTokens.minus(asset.supplyBalanceTokens),
+            token: asset.vToken.underlyingToken,
+            maxDecimalPlaces: asset.vToken.underlyingToken.decimals,
+          }),
+          assetSupplyCap: formatTokensToReadableValue({
+            value: asset.supplyCapTokens,
+            token: asset.vToken.underlyingToken,
+            maxDecimalPlaces: asset.vToken.underlyingToken.decimals,
+          }),
+          assetSupplyBalance: formatTokensToReadableValue({
+            value: asset.supplyBalanceTokens,
+            token: asset.vToken.underlyingToken,
+            maxDecimalPlaces: asset.vToken.underlyingToken.decimals,
+          }),
+        }),
+      };
+    }
+
     const assetLiquidityTokens = new BigNumber(asset.liquidityCents).dividedBy(
       asset.tokenPriceCents,
     );
@@ -124,6 +165,16 @@ const useFormValidation = ({
       };
     }
 
+    if (
+      swapQuote &&
+      swapQuote?.priceImpactPercentage >= MAXIMUM_PRICE_IMPACT_THRESHOLD_PERCENTAGE
+    ) {
+      return {
+        code: 'SWAP_PRICE_IMPACT_TOO_HIGH',
+        message: t('operationForm.error.priceImpactTooHigh'),
+      };
+    }
+
     if (
       simulatedPool?.userHealthFactor !== undefined &&
       simulatedPool.userHealthFactor < HEALTH_FACTOR_MODERATE_THRESHOLD &&
@@ -133,13 +184,22 @@ const useFormValidation = ({
         code: 'REQUIRES_RISK_ACKNOWLEDGEMENT',
       };
     }
+
+    if (!simulatedPool || !expectedSuppliedAmountTokens) {
+      return {
+        code: 'MISSING_DATA',
+      };
+    }
   }, [
     asset,
     pool,
     limitTokens,
     simulatedPool,
     formValues.amountTokens,
+    expectedSuppliedAmountTokens,
+    getSwapQuoteError,
     formValues.acknowledgeRisk,
+    swapQuote,
     t,
   ]);
 
diff --git a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__testUtils__/fakeData.ts b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__testUtils__/fakeData.ts
index b4d3d7bf61..f827048bea 100644
--- a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__testUtils__/fakeData.ts
+++ b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__testUtils__/fakeData.ts
@@ -2,7 +2,6 @@ import BigNumber from 'bignumber.js';
 
 import { poolData } from '__mocks__/models/pools';
 import { weth } from '__mocks__/models/tokens';
-
 import type { Asset, Pool } from 'types';
 
 export const fakePool: Pool = {
diff --git a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/index.spec.tsx b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/index.spec.tsx
index 146a36c43e..f004ab4900 100644
--- a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/index.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/index.spec.tsx
@@ -13,17 +13,10 @@ import { chains } from '@venusprotocol/chains';
 import { useBorrow } from 'clients/api';
 import { HEALTH_FACTOR_MODERATE_THRESHOLD } from 'constants/healthFactor';
 import BorrowForm from '..';
+import { checkSubmitButtonIsDisabled } from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
 import TEST_IDS from '../testIds';
 
-const checkSubmitButtonIsDisabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
-  );
-  expect(submitButton).toBeDisabled();
-};
-
 const testCases = [
   [
     'user borrow limit',
diff --git a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/indexWrapUnwrapNative.spec.tsx b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/indexWrapUnwrapNative.spec.tsx
index 72fe06e45e..871b41cb3f 100644
--- a/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/indexWrapUnwrapNative.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BorrowForm/__tests__/indexWrapUnwrapNative.spec.tsx
@@ -10,7 +10,8 @@ import { ChainId } from 'types';
 import { useBorrow } from 'clients/api';
 import { en } from 'libs/translations';
 import Borrow from '..';
-import { fakeAsset, fakePool, fakeWethAsset } from '../__testUtils__/fakeData';
+import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
+import { fakeWethAsset } from '../__testUtils__/fakeData';
 import TEST_IDS from '../testIds';
 
 describe('BorrowForm - Feature flag enabled: wrapUnwrapNativeToken', () => {
diff --git a/apps/evm/src/pages/Market/OperationForm/BorrowForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/BorrowForm/index.tsx
index ca4d0b5bc0..dd275850a8 100644
--- a/apps/evm/src/pages/Market/OperationForm/BorrowForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BorrowForm/index.tsx
@@ -430,7 +430,7 @@ const BorrowForm: React.FC<BorrowFormProps> = ({ asset, pool, onSubmitSuccess })
   const {
     isDelegateApproved,
     isDelegateApprovedLoading,
-    isDelegateStatusLoading,
+    isUpdateDelegateStatusLoading,
     updatePoolDelegateStatus,
   } = useDelegateApproval({
     delegateeAddress: nativeTokenGatewayContractAddress || NULL_ADDRESS,
@@ -469,7 +469,7 @@ const BorrowForm: React.FC<BorrowFormProps> = ({ asset, pool, onSubmitSuccess })
       isSubmitting={isSubmitting}
       isDelegateApproved={isDelegateApproved}
       isDelegateApprovedLoading={isDelegateApprovedLoading}
-      isApproveDelegateLoading={isDelegateStatusLoading}
+      isApproveDelegateLoading={isUpdateDelegateStatusLoading}
       approveDelegateAction={() => updatePoolDelegateStatus({ approvedStatus: true })}
       isWrapUnwrapNativeTokenEnabled={isWrapUnwrapNativeTokenEnabled}
       isEModeFeatureEnabled={isEModeFeatureEnabled}
diff --git a/apps/evm/src/pages/Market/OperationForm/BorrowForm/useForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/BorrowForm/useForm/index.tsx
index bbbb5f559c..c400db1d15 100644
--- a/apps/evm/src/pages/Market/OperationForm/BorrowForm/useForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/BorrowForm/useForm/index.tsx
@@ -17,7 +17,7 @@ export interface UseFormInput {
   moderateRiskMaxTokens: BigNumber;
   onSubmit: (input: { fromToken: Token; fromTokenAmountTokens: string }) => Promise<unknown>;
   formValues: FormValues;
-  setFormValues: (setter: (currentFormValues: FormValues) => FormValues | FormValues) => void;
+  setFormValues: (setter: (currentFormValues: FormValues) => FormValues) => void;
   onSubmitSuccess?: () => void;
 }
 
diff --git a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/index.spec.tsx b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/index.spec.tsx
index 051b4ffa02..d95b63df4f 100644
--- a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/index.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/index.spec.tsx
@@ -16,27 +16,15 @@ import { en } from 'libs/translations';
 import { chains } from '@venusprotocol/chains';
 import { ChainId } from 'types';
 import Repay, { PRESET_PERCENTAGES } from '..';
+import {
+  checkSubmitButtonIsDisabled,
+  checkSubmitButtonIsEnabled,
+} from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
 import TEST_IDS from '../testIds';
 
 vi.mock('hooks/useTokenApproval');
 
-const checkSubmitButtonIsDisabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
-  );
-  expect(submitButton).toBeDisabled();
-};
-
-const checkSubmitButtonIsEnabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.repay),
-  );
-  expect(submitButton).toBeEnabled();
-};
-
 const mockRepay = vi.fn();
 
 describe('RepayForm', () => {
@@ -274,7 +262,9 @@ describe('RepayForm', () => {
     );
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to wallet balance when clicking on MAX button if user borrow balance is higher than wallet balance', async () => {
@@ -305,7 +295,9 @@ describe('RepayForm', () => {
     await waitFor(() => expect(tokenTextInput.value).toBe(expectedInputValue));
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to wallet balance when clicking on MAX button if user borrow balance is higher than wallet spending limit', async () => {
@@ -346,7 +338,9 @@ describe('RepayForm', () => {
     await waitFor(() => expect(tokenTextInput.value).toBe(expectedInputValue));
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to correct value when clicking on preset percentage buttons', async () => {
@@ -388,7 +382,9 @@ describe('RepayForm', () => {
       await waitFor(() => expect(tokenTextInput.value).toBe(expectedInputValue));
 
       // Check submit button is enabled
-      await checkSubmitButtonIsEnabled();
+      await checkSubmitButtonIsEnabled({
+        textContent: en.operationForm.submitButtonLabel.repay,
+      });
     }
   });
 
diff --git a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexIntegratedSwap.spec.tsx b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexIntegratedSwap.spec.tsx
index d7096367fa..a50fcca657 100644
--- a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexIntegratedSwap.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexIntegratedSwap.spec.tsx
@@ -24,6 +24,10 @@ import type { Asset, Swap, TokenBalance } from 'types';
 import Repay, { PRESET_PERCENTAGES } from '..';
 import SWAP_DETAILS_TEST_IDS from '../../OperationDetails/testIds';
 import SWAP_SUMMARY_TEST_IDS from '../../SwapSummary/testIds';
+import {
+  checkSubmitButtonIsDisabled,
+  checkSubmitButtonIsEnabled,
+} from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
 import REPAY_FORM_TEST_IDS from '../testIds';
 
@@ -72,22 +76,6 @@ const fakeFullRepaymentSwap: Swap = {
 
 const mockSwapTokensAndRepay = vi.fn();
 
-const checkSubmitButtonIsDisabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
-  );
-  expect(submitButton).toBeDisabled();
-};
-
-const checkSubmitButtonIsEnabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.repay),
-  );
-  expect(submitButton).toBeEnabled();
-};
-
 describe('RepayForm - Feature flag enabled: integratedSwap', () => {
   beforeEach(() => {
     (useSwapTokensAndRepay as Mock).mockReturnValue({ mutateAsync: mockSwapTokensAndRepay });
@@ -380,7 +368,9 @@ describe('RepayForm - Feature flag enabled: integratedSwap', () => {
     await waitFor(() => getByText(en.operationForm.repay.swappingWithHighPriceImpactWarning));
 
     // Check submit button label is correct
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('disables submit button when price impact has reached the maximum tolerated', async () => {
@@ -538,7 +528,9 @@ describe('RepayForm - Feature flag enabled: integratedSwap', () => {
     await waitFor(() => expect(selectTokenTextField.value).toBe(FAKE_BUSD_BALANCE_TOKENS));
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to correct value when clicking on preset percentage buttons', async () => {
diff --git a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexWrapUnwrapNative.spec.tsx b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexWrapUnwrapNative.spec.tsx
index 126a1a5d94..2e44723c8f 100644
--- a/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexWrapUnwrapNative.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/RepayForm/__tests__/indexWrapUnwrapNative.spec.tsx
@@ -17,6 +17,7 @@ import { type Asset, ChainId } from 'types';
 
 import useGetSwapInfo from 'hooks/useGetSwapInfo';
 import Repay from '..';
+import { checkSubmitButtonIsEnabled } from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool, fakeWethAsset } from '../__testUtils__/fakeData';
 import TEST_IDS from '../testIds';
 
@@ -24,14 +25,6 @@ vi.mock('hooks/useGetSwapInfo');
 
 const fakeBalanceMantissa = new BigNumber('10000000000000000000');
 
-const checkSubmitButtonIsEnabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.repay),
-  );
-  expect(submitButton).toBeEnabled();
-};
-
 const mockRepay = vi.fn();
 
 describe('RepayForm - Feature flag enabled: wrapUnwrapNativeToken', () => {
@@ -171,7 +164,9 @@ describe('RepayForm - Feature flag enabled: wrapUnwrapNativeToken', () => {
       expect(getByText(en.operationForm.repay.fullRepaymentWarning)).toBeTruthy(),
     );
 
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to wallet balance when clicking on MAX button if user borrow balance is higher than wallet balance', async () => {
@@ -232,7 +227,9 @@ describe('RepayForm - Feature flag enabled: wrapUnwrapNativeToken', () => {
       expect(selectTokenTextField.value).toBe(fakeUserWethWalletBalance.toFixed()),
     );
 
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('updates input value to wallet balance when clicking on MAX button if user borrow balance is higher than wallet spending limit', async () => {
@@ -287,7 +284,9 @@ describe('RepayForm - Feature flag enabled: wrapUnwrapNativeToken', () => {
       expect(selectTokenTextField.value).toBe(fakeWalletSpendingLimitTokens.toFixed()),
     );
 
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.repay,
+    });
   });
 
   it('lets user wrap and repay, then calls onClose callback on success', async () => {
diff --git a/apps/evm/src/pages/Market/OperationForm/RepayForm/useForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/RepayForm/useForm/index.tsx
index d8ca35d67f..72e44ba007 100644
--- a/apps/evm/src/pages/Market/OperationForm/RepayForm/useForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/RepayForm/useForm/index.tsx
@@ -27,7 +27,7 @@ export interface UseFormInput {
     fixedRepayPercentage?: number;
   }) => Promise<unknown>;
   formValues: FormValues;
-  setFormValues: (setter: (currentFormValues: FormValues) => FormValues | FormValues) => void;
+  setFormValues: (setter: (currentFormValues: FormValues) => FormValues) => void;
   onSubmitSuccess?: () => void;
   fromTokenUserBorrowBalanceTokens?: BigNumber;
   fromTokenUserWalletBalanceTokens?: BigNumber;
diff --git a/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/index.spec.tsx b/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/index.spec.tsx
index fe19abd11e..6fd21c0a85 100644
--- a/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/index.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/index.spec.tsx
@@ -19,28 +19,16 @@ import MAX_UINT256 from 'constants/maxUint256';
 import { useSimulateBalanceMutations } from 'hooks/useSimulateBalanceMutations';
 import { areTokensEqual } from 'utilities';
 import SupplyForm from '..';
+import {
+  checkSubmitButtonIsDisabled,
+  checkSubmitButtonIsEnabled,
+} from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
 import TEST_IDS from '../testIds';
 
 vi.mock('hooks/useCollateral');
 vi.mock('hooks/useTokenApproval');
 
-const checkSubmitButtonIsDisabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
-  );
-  expect(submitButton).toBeDisabled();
-};
-
-const checkSubmitButtonIsEnabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.supply),
-  );
-  expect(submitButton).toBeEnabled();
-};
-
 const mockSupply = vi.fn();
 
 describe('SupplyForm', () => {
@@ -373,7 +361,9 @@ describe('SupplyForm', () => {
     );
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.supply,
+    });
   });
 
   it('updates input value to maximum suppliable amount when clicking on max button if supply cap does not permit supplying the entire wallet balance', async () => {
@@ -406,7 +396,9 @@ describe('SupplyForm', () => {
     );
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.supply,
+    });
   });
 
   it('lets user supply BNB then calls onClose callback on success', async () => {
diff --git a/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/indexIntegratedSwap.spec.tsx b/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/indexIntegratedSwap.spec.tsx
index 2a65e6fa2d..73cee187bc 100644
--- a/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/indexIntegratedSwap.spec.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/SupplyForm/__tests__/indexIntegratedSwap.spec.tsx
@@ -26,6 +26,10 @@ import { areTokensEqual } from 'utilities';
 import Supply from '..';
 import OPERATION_DETAILS_TEST_IDS from '../../OperationDetails/testIds';
 import SWAP_SUMMARY_TEST_IDS from '../../SwapSummary/testIds';
+import {
+  checkSubmitButtonIsDisabled,
+  checkSubmitButtonIsEnabled,
+} from '../../__testUtils__/checkFns';
 import { fakeAsset, fakePool } from '../__testUtils__/fakeData';
 import SUPPLY_FORM_TEST_IDS from '../testIds';
 
@@ -59,22 +63,6 @@ vi.mock('hooks/useGetSwapTokenUserBalances');
 vi.mock('hooks/useGetSwapInfo');
 vi.mock('hooks/useGetSwapRouterContractAddress');
 
-const checkSubmitButtonIsDisabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
-  );
-  expect(submitButton).toBeDisabled();
-};
-
-const checkSubmitButtonIsEnabled = async () => {
-  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
-  await waitFor(() =>
-    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.supply),
-  );
-  expect(submitButton).toBeEnabled();
-};
-
 describe('SupplyForm - Feature flag enabled: integratedSwap', () => {
   beforeEach(() => {
     (useIsFeatureEnabled as Mock).mockImplementation(
@@ -430,7 +418,9 @@ describe('SupplyForm - Feature flag enabled: integratedSwap', () => {
     await waitFor(() => expect(selectTokenTextField.value).toBe(FAKE_BUSD_BALANCE_TOKENS));
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.supply,
+    });
   });
 
   it('displays warning notice and set correct submit button label if the swap has a high price impact', async () => {
@@ -472,7 +462,9 @@ describe('SupplyForm - Feature flag enabled: integratedSwap', () => {
     await waitFor(() => getByText(en.operationForm.warning.swappingWithHighPriceImpactWarning));
 
     // Check submit button is enabled
-    await checkSubmitButtonIsEnabled();
+    await checkSubmitButtonIsEnabled({
+      textContent: en.operationForm.submitButtonLabel.supply,
+    });
   });
 
   it('disables submit button when price impact has reached the maximum tolerated', async () => {
diff --git a/apps/evm/src/pages/Market/OperationForm/SupplyForm/useForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/SupplyForm/useForm/index.tsx
index f86bcc932a..2d2596c5c0 100644
--- a/apps/evm/src/pages/Market/OperationForm/SupplyForm/useForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/SupplyForm/useForm/index.tsx
@@ -20,7 +20,7 @@ export interface UseFormInput {
     swap?: Swap;
   }) => Promise<unknown>;
   formValues: FormValues;
-  setFormValues: (setter: (currentFormValues: FormValues) => FormValues | FormValues) => void;
+  setFormValues: (setter: (currentFormValues: FormValues) => FormValues) => void;
   isUsingSwap: boolean;
   onSubmitSuccess?: () => void;
   isFromTokenApproved?: boolean;
diff --git a/apps/evm/src/pages/Market/OperationForm/WithdrawForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/WithdrawForm/index.tsx
index 5b7cbd6f87..5627d48d44 100644
--- a/apps/evm/src/pages/Market/OperationForm/WithdrawForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/WithdrawForm/index.tsx
@@ -448,7 +448,7 @@ const WithdrawForm: React.FC<WithdrawFormProps> = ({ asset, pool, onSubmitSucces
   const {
     isDelegateApproved,
     isDelegateApprovedLoading,
-    isDelegateStatusLoading,
+    isUpdateDelegateStatusLoading,
     updatePoolDelegateStatus,
   } = useDelegateApproval({
     delegateeAddress: nativeTokenGatewayContractAddress || NULL_ADDRESS,
@@ -496,7 +496,7 @@ const WithdrawForm: React.FC<WithdrawFormProps> = ({ asset, pool, onSubmitSucces
       isSubmitting={isWithdrawLoading}
       isDelegateApproved={isDelegateApproved}
       isDelegateApprovedLoading={isDelegateApprovedLoading}
-      isApproveDelegateLoading={isDelegateStatusLoading}
+      isApproveDelegateLoading={isUpdateDelegateStatusLoading}
       approveDelegateAction={() => updatePoolDelegateStatus({ approvedStatus: true })}
     />
   );
diff --git a/apps/evm/src/pages/Market/OperationForm/WithdrawForm/useForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/WithdrawForm/useForm/index.tsx
index e0f5e3eba7..139889bb00 100644
--- a/apps/evm/src/pages/Market/OperationForm/WithdrawForm/useForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/WithdrawForm/useForm/index.tsx
@@ -17,7 +17,7 @@ export interface UseFormInput {
   moderateRiskMaxTokens: BigNumber;
   onSubmit: (input: { fromToken: Token; fromTokenAmountTokens: string }) => Promise<unknown>;
   formValues: FormValues;
-  setFormValues: (setter: (currentFormValues: FormValues) => FormValues | FormValues) => void;
+  setFormValues: (setter: (currentFormValues: FormValues) => FormValues) => void;
   userBorrowLimitCents?: number;
   onSubmitSuccess?: () => void;
 }
diff --git a/apps/evm/src/pages/Market/OperationForm/__testUtils__/checkFns.ts b/apps/evm/src/pages/Market/OperationForm/__testUtils__/checkFns.ts
new file mode 100644
index 0000000000..45b4e2bef5
--- /dev/null
+++ b/apps/evm/src/pages/Market/OperationForm/__testUtils__/checkFns.ts
@@ -0,0 +1,16 @@
+import { waitFor } from '@testing-library/dom';
+import { en } from 'libs/translations';
+
+export const checkSubmitButtonIsDisabled = async () => {
+  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
+  await waitFor(() =>
+    expect(submitButton).toHaveTextContent(en.operationForm.submitButtonLabel.enterValidAmount),
+  );
+  expect(submitButton).toBeDisabled();
+};
+
+export const checkSubmitButtonIsEnabled = async ({ textContent }: { textContent: string }) => {
+  const submitButton = document.querySelector('button[type="submit"]') as HTMLButtonElement;
+  await waitFor(() => expect(submitButton).toHaveTextContent(textContent));
+  expect(submitButton).toBeEnabled();
+};
diff --git a/apps/evm/src/pages/Market/OperationForm/index.tsx b/apps/evm/src/pages/Market/OperationForm/index.tsx
index e18f4e02e6..b82ba7b0da 100644
--- a/apps/evm/src/pages/Market/OperationForm/index.tsx
+++ b/apps/evm/src/pages/Market/OperationForm/index.tsx
@@ -107,9 +107,7 @@ export const OperationForm: React.FC<OperationFormProps> = ({
           poolComptrollerAddress={poolComptrollerAddress}
           action="boost"
         >
-          {({ asset, pool }) => (
-            <BoostForm asset={asset} pool={pool} onSubmitSuccess={onSubmitSuccess} />
-          )}
+          {({ asset, pool }) => <BoostForm asset={asset} pool={pool} />}
         </AssetAccessor>
       ),
     });
diff --git a/apps/evm/src/setupTests.tsx b/apps/evm/src/setupTests.tsx
index 83857fae93..3890b16eee 100644
--- a/apps/evm/src/setupTests.tsx
+++ b/apps/evm/src/setupTests.tsx
@@ -111,6 +111,9 @@ vi.mock('@uiw/react-markdown-preview', () => ({
 // Mock chart library
 vi.mock('recharts');
 
+// Mock @radix-ui/react-slider library
+vi.mock('@radix-ui/react-slider');
+
 initializeLibraries();
 
 global.fetch = vi.fn();
diff --git a/apps/evm/src/store/index.ts b/apps/evm/src/store/index.ts
index 2a9133a2e5..7ce69c5706 100644
--- a/apps/evm/src/store/index.ts
+++ b/apps/evm/src/store/index.ts
@@ -11,7 +11,7 @@ export interface UserChainSettings {
   showUserAssetsOnly: boolean;
   showUserEModeAssetsOnly: boolean;
   doNotShowImportPositionsModal: boolean;
-  slippageTolerancePercentage?: string;
+  slippageTolerancePercentage: string;
 }
 
 type UserSettings = Partial<Record<ChainId, Partial<UserChainSettings>>>;
diff --git a/apps/evm/src/types/index.ts b/apps/evm/src/types/index.ts
index b1b74d8fca..a5023c9ba9 100644
--- a/apps/evm/src/types/index.ts
+++ b/apps/evm/src/types/index.ts
@@ -163,6 +163,7 @@ export interface AssetBalanceMutation {
   vTokenAddress: Address;
   amountTokens: BigNumber;
   action: 'borrow' | 'repay' | 'withdraw' | 'supply';
+  enableAsCollateralOfUser?: boolean;
 }
 
 export interface VaiBalanceMutation {
@@ -553,6 +554,39 @@ export type SwapError =
 
 export type PSTokenCombination = [PSToken, PSToken];
 
+export type SwapQuoteDirection = 'exact-in' | 'exact-out' | 'approximate-out';
+
+interface SwapQuoteBase {
+  fromToken: Token;
+  toToken: Token;
+  direction: SwapQuoteDirection;
+  priceImpactPercentage: number;
+  callData: Hex;
+}
+
+export interface ExactInSwapQuote extends SwapQuoteBase {
+  fromTokenAmountSoldMantissa: bigint;
+  expectedToTokenAmountReceivedMantissa: bigint;
+  minimumToTokenAmountReceivedMantissa: bigint;
+  direction: 'exact-in';
+}
+
+export interface ExactOutSwapQuote extends SwapQuoteBase {
+  toTokenAmountReceivedMantissa: bigint;
+  expectedFromTokenAmountSoldMantissa: bigint;
+  maximumFromTokenAmountSoldMantissa: bigint;
+  direction: 'exact-out';
+}
+
+export interface ApproximateOutSwapQuote extends SwapQuoteBase {
+  fromTokenAmountSoldMantissa: bigint;
+  expectedToTokenAmountReceivedMantissa: bigint;
+  minimumToTokenAmountReceivedMantissa: bigint;
+  direction: 'approximate-out';
+}
+
+export type SwapQuote = ExactInSwapQuote | ExactOutSwapQuote | ApproximateOutSwapQuote;
+
 export type ImportableProtocol = 'aave';
 
 interface ImportableSupplyPositionBase {