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

# prepareApproveWithdrawOrderTxData

> Prepare an approval transaction for account share withdrawals

Prepare transaction data to approve account shares for withdrawal via the WithdrawQueue contract.

<Info>
  Before withdrawing, you must approve the WithdrawQueue contract to spend your
  account shares. Consider using
  [prepareWithdrawalAuthorization](/v0.5.2/intro/products/earn/developers/api/prepareWithdrawalAuthorization)
  for a higher-level API that handles approval checking automatically.
</Info>

## Import

```typescript theme={null}
import { prepareApproveWithdrawOrderTxData } from '@paxoslabs/amplify-sdk'
```

## Usage

```typescript theme={null}
// First discover the vault
const [vault] = await getVaultsByConfig({
  yieldType: 'CORE',
  chainId: 1,
})

const txData = await prepareApproveWithdrawOrderTxData({
  vaultName: vault.name,
  wantAssetAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  withdrawAmount: '100.0',
  chainId: 1,
})

// Execute approval
const hash = await walletClient.writeContract(txData)
```

***

## Parameters

| Parameter          | Type      | Required | Description                                                             |
| ------------------ | --------- | -------- | ----------------------------------------------------------------------- |
| `vaultName`        | `string`  | Yes      | Account name from `AmplifyVault.name` (e.g. from `getVaultsByConfig()`) |
| `wantAssetAddress` | `Address` | Yes      | Token address you want to receive                                       |
| `withdrawAmount`   | `string`  | No       | Amount to approve (defaults to max uint256)                             |
| `chainId`          | `number`  | Yes      | Chain ID                                                                |
| `shareDecimals`    | `number`  | No       | Pre-fetched account share decimals (avoids redundant RPC call)          |

***

## Return Type

<Tabs>
  <Tab title="Type Definition">
    ```typescript theme={null}
    interface ApproveWithdrawOrderTxData {
      abi: typeof BoringVaultAbi;
      address: `0x${string}`;         // Vault shares (BoringVault) address
      functionName: "approve";
      args: [spender: `0x${string}`, amount: bigint];
    }
    ```
  </Tab>

  <Tab title="Example Response">
    ```typescript theme={null}
    {
      abi: [/* BoringVault ABI */],
      address: "0x1234567890abcdef...", // Vault shares address
      functionName: "approve",
      args: [
        "0xfedcba0987654321...", // WithdrawQueue address (spender)
        115792089237316195423570985008687907853269984665640564039457584007913129639935n, // Max approval
      ],
    }
    ```
  </Tab>
</Tabs>

***

## Examples

<Tabs>
  <Tab title="Viem">
    ```typescript theme={null}
    import {
      getVaultsByConfig,
      prepareApproveWithdrawOrderTxData,
      YieldType,
    } from "@paxoslabs/amplify-sdk";
    import { createWalletClient, createPublicClient, http } from "viem";
    import { mainnet } from "viem/chains";

    async function approveWithdraw(userAddress: `0x${string}`) {
      const walletClient = createWalletClient({
        account: userAddress,
        chain: mainnet,
        transport: http(),
      });
      const publicClient = createPublicClient({
        chain: mainnet,
        transport: http(),
      });

      const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

      const [vault] = await getVaultsByConfig({
        yieldType: YieldType.CORE,
        chainId: 1,
      });

      // Approve specific amount
      const txData = await prepareApproveWithdrawOrderTxData({
        vaultName: vault.name,
        wantAssetAddress: USDC,
        withdrawAmount: "100.0",
        chainId: 1,
      });

      const hash = await walletClient.writeContract(txData);
      const receipt = await publicClient.waitForTransactionReceipt({ hash });

      console.log("Approval confirmed:", receipt.transactionHash);
      return hash;
    }
    ```
  </Tab>

  <Tab title="Wagmi">
    ```tsx theme={null}
    import {
      getVaultsByConfig,
      prepareApproveWithdrawOrderTxData,
      YieldType,
    } from "@paxoslabs/amplify-sdk";
    import { useAccount, useWriteContract, useWaitForTransactionReceipt } from "wagmi";
    import { useState } from "react";

    function ApproveWithdrawButton() {
      const { address } = useAccount();
      const { writeContractAsync, data: hash } = useWriteContract();
      const { isLoading: isConfirming } = useWaitForTransactionReceipt({ hash });
      const [status, setStatus] = useState("idle");

      async function handleApprove() {
        if (!address) return;

        const USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

        try {
          const [vault] = await getVaultsByConfig({
            yieldType: YieldType.CORE,
            chainId: 1,
          });

          setStatus("Preparing approval...");
          const txData = await prepareApproveWithdrawOrderTxData({
            vaultName: vault.name,
            wantAssetAddress: USDC,
            chainId: 1, // Max approval (no withdrawAmount)
          });

          setStatus("Confirm in wallet...");
          await writeContractAsync(txData);
          setStatus("Waiting for confirmation...");
        } catch (error) {
          setStatus(`Error: ${(error as Error).message}`);
        }
      }

      return (
        <div>
          <button onClick={handleApprove} disabled={isConfirming}>
            {isConfirming ? "Confirming..." : "Approve Withdrawal"}
          </button>
          <p>{status}</p>
        </div>
      );
    }
    ```
  </Tab>
</Tabs>

***

## Max vs Specific Approval

### Max Approval (Default)

When `withdrawAmount` is not provided, the SDK approves the maximum amount. This is a one-time approval that covers all future withdrawals:

```typescript theme={null}
const [vault] = await getVaultsByConfig({ yieldType: 'CORE', chainId: 1 })

// Max approval - no amount specified
const txData = await prepareApproveWithdrawOrderTxData({
  vaultName: vault.name,
  wantAssetAddress: USDC_ADDRESS,
  chainId: 1,
})
```

### Specific Amount Approval

For tighter security, approve only the amount you intend to withdraw:

```typescript theme={null}
// Approve exactly 100 shares
const txData = await prepareApproveWithdrawOrderTxData({
  vaultName: vault.name,
  wantAssetAddress: USDC_ADDRESS,
  withdrawAmount: '100.0',
  chainId: 1,
})
```

***

## Checking Existing Approval

Before approving, check if approval is already granted:

```typescript theme={null}
import {
  getVaultsByConfig,
  isWithdrawalSpendApproved,
  prepareApproveWithdrawOrderTxData,
} from '@paxoslabs/amplify-sdk'

async function ensureApproval(userAddress: `0x${string}`) {
  const USDC = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'

  const [vault] = await getVaultsByConfig({ yieldType: 'CORE', chainId: 1 })

  const approvalInfo = await isWithdrawalSpendApproved({
    vaultName: vault.name,
    wantAssetAddress: USDC,
    recipientAddress: userAddress,
    chainId: 1,
  })

  if (approvalInfo.isApproved) {
    console.log(`Already approved. Allowance: ${approvalInfo.allowance}`)
    return null
  }

  // Need to approve first
  return prepareApproveWithdrawOrderTxData({
    vaultName: vault.name,
    wantAssetAddress: USDC,
    chainId: 1,
  })
}
```

<Info>
  Consider using
  [prepareWithdrawalAuthorization](/v0.5.2/intro/products/earn/developers/api/prepareWithdrawalAuthorization)
  instead, which combines the approval check and approval preparation into a
  single call.
</Info>

***

## Error Handling

| Error                                           | Description                    | Resolution                                    |
| ----------------------------------------------- | ------------------------------ | --------------------------------------------- |
| `Vault not found`                               | No account matches `vaultName` | Verify account name via `getVaultsByConfig()` |
| `Vault chain mismatch`                          | Account not on requested chain | Verify chainId matches account deployment     |
| `BoringVault contract address not configured`   | Missing account config         | Check account configuration                   |
| `WithdrawQueue contract address not configured` | Missing queue config           | Check account configuration                   |

***

## Related

* [getVaultsByConfig](/v0.5.2/intro/products/earn/developers/api/getVaultsByConfig) - Discover account names
* [prepareWithdrawalAuthorization](/v0.5.2/intro/products/earn/developers/api/prepareWithdrawalAuthorization) - Unified authorization (recommended)
* [prepareWithdrawOrderTxData](/v0.5.2/intro/products/earn/developers/api/prepareWithdrawOrderTxData) - Submit the withdrawal order
* [Withdrawals Guide](/v0.5.2/intro/products/earn/developers/guides/withdrawals) - Complete withdrawal flow