Withdrawals

// src/hooks/useWithdraw.ts
import { useCallback, useEffect, useState } from "react";
import { useWaitForTransactionReceipt, useWriteContract } from "wagmi";
import {
  prepareApproveWithdrawTxData,
  prepareWithdrawTxData,
  type YieldType,
} from "@paxoslabs/amplify-sdk";
import type { Address } from "viem";

interface WithdrawParams {
  yieldType: YieldType;
  offerAmount: string;
  wantAssetAddress: Address;
  chainId: number;
  userAddress: Address;
  slippage?: number;
}

export function useWithdraw() {
  const [error, setError] = useState<Error | null>(null);
  const [status, setStatus] = useState<
    "idle" | "approving" | "submitting" | "confirming" | "success"
  >("idle");

  // Wagmi hooks for writing contracts
  const {
    writeContractAsync,
    data: hash,
    isPending: isSubmitting,
  } = useWriteContract();

  // Wait for transaction confirmation
  const { isLoading: isConfirming } = useWaitForTransactionReceipt({
    hash,
    confirmations: 1,
    query: { enabled: Boolean(hash) },
  });

  const withdraw = useCallback(
    async ({
      yieldType,
      offerAmount,
      wantAssetAddress,
      chainId,
      userAddress,
      slippage = 75,
    }: WithdrawParams) => {
      setError(null);

      try {
        // Step 1: Approve withdrawal
        setStatus("approving");
        const approval = await prepareApproveWithdrawTxData({
          chainId,
          wantAssetAddress,
          yieldType,
        });

        await writeContractAsync({
          ...approval,
          account: userAddress,
        });

        // Step 2: Execute withdrawal
        setStatus("submitting");
        const tx = await prepareWithdrawTxData({
          yieldType,
          offerAmount,
          wantAssetAddress,
          chainId,
          slippage,
        });

        const transactionHash = await writeContractAsync({
          ...tx,
          account: userAddress,
        });

        setStatus("confirming");
        return transactionHash;
      } catch (err) {
        const error = err instanceof Error ? err : new Error(String(err));
        setError(error);
        setStatus("idle");
        throw error;
      }
    },
    [writeContractAsync]
  );

  useEffect(() => {
    if (hash && !isSubmitting && !isConfirming) {
      setStatus("success");
    }
  }, [hash, isSubmitting, isConfirming]);

  return {
    withdraw,
    status,
    hash,
    error,
    isIdle: status === "idle",
    isSubmitting,
    isConfirming,
    isSuccess: status === "success",
  };
}

// withdraw.ts
import {
  initAmplifySDK,
  fetchSupportedAssets,
  prepareApproveWithdrawTxData,
  prepareWithdrawTxData,
  YieldType,
} from "@paxoslabs/amplify-sdk";
import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";

declare const process: { env: Record<string, string>, exit: (code: number) => never };

const CONFIG = {
  apiKey: process.env.AMPLIFY_API_KEY!,
  chainId: 1,
  yieldType: YieldType.CORE,
  offerAmount: "5.0", // decimal string of the earn token to exchange
  slippage: 75, // 0.75% slippage tolerance in basis points
  rpcUrl: process.env.RPC_URL ?? "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
  privateKey: process.env.PRIVATE_KEY!,
};

async function main() {
  // Step 1: Initialize SDK
  console.log("Initializing SDK...");
  await initAmplifySDK(CONFIG.apiKey);

  // Step 2: Setup wallet client
  const account = privateKeyToAccount(CONFIG.privateKey as `0x${string}`);

  const publicClient = createPublicClient({
    chain: mainnet,
    transport: http(CONFIG.rpcUrl),
  });

  const walletClient = createWalletClient({
    account,
    chain: mainnet,
    transport: http(CONFIG.rpcUrl),
  });

  // Step 3: Fetch supported assets to get the want asset address
  console.log("Fetching supported assets...");
  const supportedAssets = await fetchSupportedAssets({
    yieldType: CONFIG.yieldType,
  });

  const asset = supportedAssets[0];
  if (!asset) {
    throw new Error("No supported assets found for the selected yield type.");
  }

  const wantAssetAddress = asset.address as `0x${string}`;
  console.log(`Using asset: ${asset.symbol} (${wantAssetAddress})`);

  try {
    // Step 4: Approve withdrawal
    console.log("\nStep 1: Preparing approval transaction...");
    const approvalTx = await prepareApproveWithdrawTxData({
      chainId: CONFIG.chainId,
      wantAssetAddress,
      yieldType: CONFIG.yieldType,
    });

    console.log(`Approval target: ${approvalTx.address}`);
    console.log("Executing approval transaction...");
    const approvalHash = await walletClient.writeContract(approvalTx);
    console.log(`Approval tx hash: ${approvalHash}`);

    console.log("Waiting for approval confirmation...");
    const approvalReceipt = await publicClient.waitForTransactionReceipt({
      hash: approvalHash,
    });

    if (approvalReceipt.status === "success") {
      console.log(`Approval confirmed in block ${approvalReceipt.blockNumber}`);
    } else {
      throw new Error("Approval transaction failed");
    }

    // Step 5: Execute withdrawal
    console.log("\nStep 2: Preparing withdrawal transaction...");
    const tx = await prepareWithdrawTxData({
      yieldType: CONFIG.yieldType,
      wantAssetAddress,
      offerAmount: CONFIG.offerAmount,
      chainId: CONFIG.chainId,
      slippage: CONFIG.slippage,
    });

    console.log("Submitting withdrawal...");
    const withdrawalHash = await walletClient.writeContract({ ...tx, account });
    console.log(`Withdrawal sent: ${withdrawalHash}`);

    console.log("Waiting for confirmation...");
    const withdrawalReceipt = await publicClient.waitForTransactionReceipt({
      hash: withdrawalHash,
    });

    if (withdrawalReceipt.status !== "success") {
      throw new Error(`Withdrawal reverted in tx ${withdrawalHash}`);
    }

    console.log(`Withdrawal confirmed in block ${withdrawalReceipt.blockNumber}`);
    return withdrawalReceipt;
  } catch (error) {
    console.error("\nWithdrawal failed");
    if (error instanceof Error) {
      console.error(`Error: ${error.message}`);
    }
    throw error;
  }
}

main()
  .then(() => process.exit(0))
  .catch(() => process.exit(1));