> ## Documentation Index
> Fetch the complete documentation index at: https://docs.arc.io/llms.txt
> Use this file to discover all available pages before exploring further.

# How-to: Remove funds trustlessly

> Initiate and complete a trustless withdrawal from a Unified Balance

The App Kit SDK supports trustless withdrawals from a Unified Balance, keeping
your funds under your control. Withdrawals require two steps: initiate the
removal, then complete it. On EVM networks, a 7-day waiting period applies
between steps. On Solana, you can complete the removal immediately after
initiation.

<Note>
  `removeFund` is designed as a trustless escape hatch for fallback or recovery
  scenarios only. In normal situations,
  [use `spend`](/app-kit/quickstarts/unified-balance-deposit-and-spend).
</Note>

## Prerequisites

Before you begin, ensure that you've:

* [Installed the App Kit SDK](/app-kit/tutorials/installation)
* [Configured an adapter](/app-kit/tutorials/adapter-setups)

These are required so any example below runs with a valid `kit` and `adapter`.

## Initiate and complete a removal

<Tabs>
  <Tab title="EVM">
    <Steps>
      <Step title="Initiate the removal">
        Call `initiateRemoveFund` to record the request to remove funds and start the
        7-day waiting period.

        This example initiates a removal of 1 USDC on Base Sepolia:

        ```typescript TypeScript theme={null}
        const initiateResult = await kit.unifiedBalance.initiateRemoveFund({
          from: {
            adapter,
            chain: "Base_Sepolia",
          },
          amount: "1.00",
        });

        console.log("Remove fund initiated:", initiateResult);
        ```

        `initiateRemoveFund` returns a result object that includes the transaction
        details for the pending removal. In step 2, pass the same `adapter` and `chain`
        values to `removeFund` to complete it (you can reuse the same variables as in
        this example).
      </Step>

      <Step title="Complete the removal">
        After the waiting period, call `removeFund` to return funds to the wallet for
        that adapter on that blockchain:

        ```typescript TypeScript theme={null}
        const removeResult = await kit.unifiedBalance.removeFund({
          from: {
            adapter,
            chain: "Base_Sepolia",
          },
        });

        console.log("Remove fund complete:", removeResult);
        ```
      </Step>
    </Steps>

    What to know about removals on EVM:

    * Calling `removeFund` before the waiting period has elapsed will fail.
    * Funds go to the wallet associated with the adapter on the specified
      blockchain.
    * Only one pending `removeFund` request is allowed per blockchain and address.
  </Tab>

  <Tab title="Solana">
    Call `initiateRemoveFund`, then `removeFund` with the same `from` context. No
    waiting period is required on Solana, so you can call both in sequence.

    This example initiates and completes a removal of 1 USDC on Solana Devnet:

    ```typescript TypeScript theme={null}
    const from = { adapter, chain: "Solana_Devnet" as const };

    const initiateResult = await kit.unifiedBalance.initiateRemoveFund({
      from,
      amount: "1.00",
    });

    console.log("Initiate result:", initiateResult);

    const removeResult = await kit.unifiedBalance.removeFund({ from });

    console.log("Remove result:", removeResult);
    ```

    What to know about removals on Solana:

    * No waiting period is required between `initiateRemoveFund` and `removeFund`.
    * Funds return to the wallet for the Solana adapter you use in `from`.
    * The sample uses `"Solana_Devnet" as const` so TypeScript narrows the chain
      type for `from`.
  </Tab>
</Tabs>