Execute

import { account, createUnlinkClient, evm } from "@unlink-xyz/sdk/browser";
import { encodeFunctionData } from "viem";

const client = createUnlinkClient({
  environment: "base-sepolia",
  account: account.fromMnemonic({ mnemonic }),
  evm: evm.fromEip1193({ provider: window.ethereum }),
});

const token = "0xTokenAddress";
const vault = "0xVaultAddress";
const amount = 1_000_000_000_000_000_000n;

const approveCall = {
  target: token,
  value: "0",
  data: encodeFunctionData({
    abi: erc20Abi,
    functionName: "approve",
    args: [vault, amount],
  }),
  label: "approve",
};

const supplyCall = {
  target: vault,
  value: "0",
  data: encodeFunctionData({
    abi: vaultAbi,
    functionName: "supply",
    args: [token, amount],
  }),
  label: "supply",
};

const result = await client.execute({
  withdrawFromPool: [{ token, amount: amount.toString() }],
  calls: [approveCall, supplyCall],
});

console.log(result.status, result.executionId);

const returnAmount = 900_000_000_000_000_000n;

const result = await client.execute({
  withdrawFromPool: [{ token, amount: amount.toString() }],
  calls: [approveCall, supplyCall],
  returnToPool: [{ token, amount: returnAmount.toString() }],
});

console.log(result.status, result.executionId);

const first = await client.execute({
  withdrawFromPool: [{ token, amount: amount.toString() }],
  calls: [approveCall, supplyCall],
  // Default waits resolve on confirmed evidence, often before the terminal
  // status — wait for "processed" when you gate on `completed`.
  waitUntil: "processed",
});

if (first.status !== "completed") {
  throw new Error(`execute ended with status ${first.status}`);
}

const followUp = await client.executeAccountCall({
  accountIndex: first.execution.account_index,
  calls: [
    {
      target: vault,
      value: "0",
      data: encodeFunctionData({
        abi: vaultAbi,
        functionName: "claimRewards",
        args: [],
      }),
    },
  ],
});

console.log(followUp.status, followUp.executionId);

const result = await client.execute({
  withdrawFromPool: [{ token, amount: amount.toString() }],
  calls: [approveCall, swapCall],
  returnToPool: [
    {
      token: outputToken,
      sweep: true,
      // Cap: deposit up to this much, keep any surplus liquid in the account.
      max_total: maxOut.toString(),
      // Optional floor: revert the whole execution if less than this is returned.
      min_total: minOut.toString(),
    },
  ],
});

// Paginated list of the caller's accounts (stable keyset cursor).
const page = await client.executionAccounts.list({
  environment, // optional filter
  limit, // 1–100, default 50
  cursor, // page.next_cursor from a previous call
});

// One account by id.
const byId = await client.executionAccounts.get(accountId);

// One account by its on-chain address (or null), scoped to the caller.
const byAddress = await client.executionAccounts.getByAddress({
  environment,
  address,
});

// Reserve (or reuse) backend-authoritative account indices.
const reserved = await client.executionAccounts.reserve({
  policy: "fresh", // "fresh" | "reuseLatest" | { slotIndex }
});