Non-Custodial DeFi via vaults.fyi

// All markets across every supported network
async function fetchAllMarkets() {
  const res = await fetch(`/api/vaultsfyi/beta/borrow/markets/?perPage=50`);
  if (!res.ok) throw new Error("Failed to fetch markets");
  return res.json();
}

// Markets on a specific network (network is a path param, not a query param)
async function fetchMarketsByNetwork(network: string) {
  const res = await fetch(`/api/vaultsfyi/beta/borrow/markets/${network}`);
  if (!res.ok) throw new Error("Failed to fetch markets");
  return res.json();
}

async function fetchBorrowContext(
  userAddress: string,
  network: string,
  marketId: string,
  assetAddress: string,
) {
  const res = await fetch(
    `/api/vaultsfyi/beta/borrow/markets/transactions/context/${userAddress}/${network}/${marketId}/${assetAddress}`,
  );
  return res.json();
}

import { useExecuteEvm } from "@/hooks/useExecuteEvm";

function BorrowControls(props: { userAddress: string; network: string; marketId: string; assetAddress: string }) {
  const { execute } = useExecuteEvm();

  async function borrowAction(
    action: "supply" | "withdraw" | "borrow" | "repay",
    amount: string, // wei string
    opts?: { all?: boolean }, // `all: true` repays/withdraws the full position
  ) {
    const params = new URLSearchParams({ amount });
    if (opts?.all) params.set("all", "true");

    const res = await fetch(
      `/api/vaultsfyi/beta/borrow/markets/transactions/${action}/${props.userAddress}/${props.network}/${props.marketId}/${props.assetAddress}?${params}`,
    );
    const { currentActionIndex, actions } = await res.json();
    await execute(currentActionIndex, actions);
  }

  // ... wire to buttons
}

async function fetchBorrowPositions(userAddress: string) {
  const res = await fetch(`/api/vaultsfyi/beta/borrow/portfolio/positions/${userAddress}`);
  return res.json();
}

async function fetchFixedTermDetails(network: string, vaultId: string) {
  const res = await fetch(`/api/vaultsfyi/beta/fixed-term/detailed/${network}/${vaultId}`);
  return res.json(); // returns { name, apy, asset, expiry, lpToken, protocol, tvl }
}

async function fetchFixedTermContext(
  userAddress: string,
  network: string,
  vaultId: string,
) {
  const res = await fetch(
    `/api/vaultsfyi/beta/fixed-term/context/${userAddress}/${network}/${vaultId}`,
  );
  return res.json();
}

import { useExecuteEvm } from "@/hooks/useExecuteEvm";

function FixedTermControls(props: { userAddress: string; network: string; vaultId: string; assetAddress: string }) {
  const { execute } = useExecuteEvm();

  async function fixedTermAction(
    action: "swap-in" | "swap-out",
    amount: string, // wei string
  ) {
    const params = new URLSearchParams({ assetAddress: props.assetAddress, amount });
    const res = await fetch(
      `/api/vaultsfyi/beta/fixed-term/transactions/${action}/${props.userAddress}/${props.network}/${props.vaultId}?${params}`,
    );
    const { currentActionIndex, actions } = await res.json();
    await execute(currentActionIndex, actions);
  }

  // ... wire to buttons
}

async function fetchSolanaVaults() {
  const params = new URLSearchParams({
    allowedAssets: "USDC",
    sortBy: "apy7day",
    sortOrder: "desc",
    perPage: "20",
  });
  const res = await fetch(`/api/vaultsfyi/beta/svm/detailed-vaults?${params}`);
  return res.json();
}

async function fetchSvmContext(userAddress: string, vaultAddress: string) {
  const res = await fetch(
    `/api/vaultsfyi/beta/svm/transactions/context/${userAddress}/${vaultAddress}`,
  );
  return res.json();
}

// src/hooks/useExecuteSolana.ts
"use client";

import { useCallback, useState } from "react";
import { Buffer } from "buffer";
import { VersionedTransaction } from "@solana/web3.js";
import { useSigners } from "./useSigners";

type SolanaActionStep = {
  name: string;
  tx: { type: "solana"; transaction: string }; // base64
};

export function useExecuteSolana() {
  const [state, setState] = useState({
    running: false,
    signatures: [] as { signature: string; name: string }[],
    error: null as string | null,
  });
  const { solana } = useSigners();

  const execute = useCallback(
    async (currentActionIndex: number, actions: SolanaActionStep[]) => {
      if (!solana.isInitialized || !solana.signer || !solana.connection) return;

      const remaining = actions.slice(currentActionIndex);
      setState({ running: true, signatures: [], error: null });
      const signatures: { signature: string; name: string }[] = [];

      try {
        for (const step of remaining) {
          const txBuffer = Buffer.from(step.tx.transaction, "base64");
          const tx = VersionedTransaction.deserialize(txBuffer);
          const signed = await solana.signer.signVersionedTransaction(tx);

          const signature = await solana.connection.sendRawTransaction(
            signed.serialize(),
            { skipPreflight: false, maxRetries: 3 },
          );

          // Poll the submitted signature. Do not fetch a new blockhash here:
          // it would be unrelated to the blockhash in the signed transaction.
          const confirmationDeadline = Date.now() + 90_000;
          let confirmed = false;
          while (Date.now() < confirmationDeadline) {
            const { value: status } =
              await solana.connection.getSignatureStatus(signature, {
                searchTransactionHistory: true,
              });

            if (status?.err) {
              throw new Error(
                `Transaction failed: ${JSON.stringify(status.err)}`,
              );
            }
            if (
              status?.confirmationStatus === "confirmed" ||
              status?.confirmationStatus === "finalized"
            ) {
              confirmed = true;
              break;
            }
            await new Promise((resolve) => setTimeout(resolve, 500));
          }

          if (!confirmed) {
            throw new Error(
              `Confirmation timed out for ${signature}. Check its status before retrying.`,
            );
          }
          signatures.push({ signature, name: step.name });
        }
        setState({ running: false, signatures, error: null });
      } catch (error) {
        const message = error instanceof Error ? error.message : "Unknown error";
        setState((s) => ({ ...s, running: false, error: message }));
      }
    },
    [solana],
  );

  return { ...state, execute };
}

import { useExecuteSolana } from "@/hooks/useExecuteSolana";
import { useSigners } from "@/hooks/useSigners";

function SolanaDepositForm({ vaultAddress, assetAddress }: { vaultAddress: string; assetAddress: string }) {
  const { execute, running } = useExecuteSolana();
  const { solana } = useSigners();

  async function handleSolanaDeposit(amount: string /* base units; USDC has 6 decimals */) {
    if (!solana.address) return;
    const params = new URLSearchParams({ assetAddress, amount });
    const res = await fetch(
      `/api/vaultsfyi/beta/svm/transactions/deposit/${solana.address}/${vaultAddress}?${params}`,
    );
    const { currentActionIndex, actions } = await res.json();
    await execute(currentActionIndex, actions);
  }

  return <button onClick={() => handleSolanaDeposit("1000000")} disabled={!solana.address || running}>
    Deposit 1 USDC
  </button>;
}

async function fetchSolanaPositions(userAddress: string) {
  const res = await fetch(`/api/vaultsfyi/beta/svm/portfolio/positions/${userAddress}`);
  return res.json();
}

const params = new URLSearchParams({ assetAddress, amount: sharesToRedeem });
const res = await fetch(
  `/api/vaultsfyi/beta/svm/transactions/redeem/${userAddress}/${vaultAddress}?${params}`,
);
const { currentActionIndex, actions } = await res.json();
await execute(currentActionIndex, actions);