Earn error handling

import {
  isKitError,
  isInputError,
  isRetryableError,
  isResumableError,
  isFatalError,
  getErrorCode,
  getErrorMessage,
  EarnError,
} from "@circle-fin/app-kit";

import { AppKit } from "@circle-fin/app-kit";
import { createViemAdapterFromPrivateKey } from "@circle-fin/adapter-viem-v2";
import {
  isKitError,
  isInputError,
  isRetryableError,
  isFatalError,
  getErrorCode,
  getErrorMessage,
  EarnError,
} from "@circle-fin/app-kit";

const kit = new AppKit();

const adapter = createViemAdapterFromPrivateKey({
  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
});

async function depositWithRetry(
  vaultAddress: string,
  amount: string,
  maxRetries = 3,
): Promise<void> {
  let attempt = 0;

  while (attempt < maxRetries) {
    try {
      const result = await kit.earn.deposit({
        from: { adapter, chain: "Arc_Testnet" },
        vaultAddress,
        amount,
      });

      console.log("Deposit succeeded:", result.txHash);
      return;
    } catch (error) {
      if (!isKitError(error)) throw error;

      const code = getErrorCode(error);
      const message = getErrorMessage(error);

      // Specific code: tailored handling
      if (code === EarnError.VAULT_NOT_FOUND.code) {
        console.error(`Vault not found: ${vaultAddress}`);
        throw error;
      }

      if (isInputError(error)) {
        // Fix your parameters. Retrying with the same inputs won't help
        console.error(`Input error [${code}]: ${message}`);
        throw error;
      }

      if (isFatalError(error)) {
        // Cannot be recovered. Stop immediately
        console.error(`Fatal error [${code}]: ${message}`);
        throw error;
      }

      if (isRetryableError(error)) {
        attempt++;
        if (attempt >= maxRetries) {
          console.error(
            `Max retries reached. Last error [${code}]: ${message}`,
          );
          throw error;
        }
        // Exponential backoff: 1s, 2s, 4s
        const delay = Math.pow(2, attempt - 1) * 1000;
        console.warn(
          `Retryable error [${code}]: ${message}. Retrying in ${delay}ms...`,
        );
        await new Promise((resolve) => setTimeout(resolve, delay));
      }
    }
  }
}

try {
  await kit.earn.deposit({
    from: { adapter, chain: "Arc_Testnet" },
    vaultAddress,
    amount: "10.00",
  });
} catch (error) {
  if (isKitError(error) && isResumableError(error)) {
    await kit.earn.retry(error);
  } else {
    throw error;
  }
}

kit.on("earn.deposit", (payload) => {
  console.log(`Deposit ${payload.method}: ${payload.values.state}`);
});

kit.on("earn.approve", (payload) => {
  if (payload.values.state === "success") {
    console.log("Approval tx:", payload.values.txHash);
  }
});

// Match all earn events
kit.on("earn.*", (payload) => {
  /* ... */
});

const { vaults, errors } = await kit.earn.getVaults({
  vaults: [
    { chain: "Arc_Testnet", vaultAddress: "0x8eB67..." },
    { chain: "Arc_Testnet", vaultAddress: "0xBEEF..." },
  ],
});

for (const e of errors) {
  console.warn(`Vault ${e.vaultAddress} failed: [${e.code}] ${e.message}`);
}