atfi 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1369 @@
+// src/ATFiSDK.ts
+import {
+  decodeEventLog
+} from "viem";
+
+// src/abis/FactoryATFi.ts
+var FactoryATFiABI = [{ "inputs": [{ "internalType": "address", "name": "_treasury", "type": "address" }, { "internalType": "address", "name": "_morphoVault", "type": "address" }, { "internalType": "address", "name": "_usdcToken", "type": "address" }], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "EnforcedPause", "type": "error" }, { "inputs": [], "name": "ExceedsMaxParticipants", "type": "error" }, { "inputs": [], "name": "ExpectedPause", "type": "error" }, { "inputs": [], "name": "InvalidStakeAmount", "type": "error" }, { "inputs": [], "name": "InvalidTokenAddress", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }], "name": "OwnableInvalidOwner", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }], "name": "OwnableUnauthorizedAccount", "type": "error" }, { "inputs": [], "name": "ReentrancyGuardReentrantCall", "type": "error" }, { "inputs": [], "name": "TokenNotSupported", "type": "error" }, { "inputs": [], "name": "YieldOnlySupportsUSDC", "type": "error" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "token", "type": "address" }, { "indexed": false, "internalType": "bool", "name": "status", "type": "bool" }], "name": "AssetTokenRegistered", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" }], "name": "OwnershipTransferred", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "address", "name": "account", "type": "address" }], "name": "Paused", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "address", "name": "account", "type": "address" }], "name": "Unpaused", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "uint256", "name": "vaultId", "type": "uint256" }, { "indexed": true, "internalType": "address", "name": "vault", "type": "address" }, { "indexed": true, "internalType": "address", "name": "owner", "type": "address" }, { "indexed": false, "internalType": "address", "name": "assetToken", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "stakeAmount", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "maxParticipants", "type": "uint256" }, { "indexed": false, "internalType": "address", "name": "yieldVault", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "timestamp", "type": "uint256" }], "name": "VaultCreated", "type": "event" }, { "inputs": [{ "internalType": "address", "name": "assetToken", "type": "address" }, { "internalType": "uint256", "name": "stakeAmount", "type": "uint256" }, { "internalType": "uint256", "name": "maxParticipants", "type": "uint256" }], "name": "createVault", "outputs": [{ "internalType": "uint256", "name": "vaultId", "type": "uint256" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "assetToken", "type": "address" }, { "internalType": "uint256", "name": "stakeAmount", "type": "uint256" }, { "internalType": "uint256", "name": "maxParticipants", "type": "uint256" }], "name": "createVaultNoYield", "outputs": [{ "internalType": "uint256", "name": "vaultId", "type": "uint256" }], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "vaultId", "type": "uint256" }], "name": "getVault", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getVaultCount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "isTokenSupported", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "vault", "type": "address" }], "name": "isValidVault", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "", "type": "address" }], "name": "isVault", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "morphoVault", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "pause", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "paused", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }, { "internalType": "bool", "name": "supported", "type": "bool" }], "name": "registerAssetToken", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "_morphoVault", "type": "address" }], "name": "setMorphoVault", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "", "type": "address" }], "name": "supportedAssetTokens", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "newOwner", "type": "address" }], "name": "transferOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "treasury", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "unpause", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "usdcToken", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "vaultIdCounter", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "name": "vaults", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }];
+
+// src/abis/VaultATFi.ts
+var VaultATFiABI = [{ "inputs": [{ "internalType": "uint256", "name": "_vaultId", "type": "uint256" }, { "internalType": "address", "name": "_owner", "type": "address" }, { "internalType": "address", "name": "_factory", "type": "address" }, { "internalType": "address", "name": "_assetToken", "type": "address" }, { "internalType": "uint256", "name": "_stakeAmount", "type": "uint256" }, { "internalType": "uint256", "name": "_maxParticipants", "type": "uint256" }, { "internalType": "address", "name": "_treasury", "type": "address" }, { "internalType": "address", "name": "_yieldVault", "type": "address" }], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [], "name": "AlreadyClaimed", "type": "error" }, { "inputs": [], "name": "AlreadyStaked", "type": "error" }, { "inputs": [], "name": "AlreadyVerified", "type": "error" }, { "inputs": [], "name": "EventAlreadyStarted", "type": "error" }, { "inputs": [], "name": "InvalidAddress", "type": "error" }, { "inputs": [], "name": "InvalidMaxParticipants", "type": "error" }, { "inputs": [], "name": "InvalidStakeAmount", "type": "error" }, { "inputs": [], "name": "InvalidYieldVault", "type": "error" }, { "inputs": [], "name": "MaxParticipantsReached", "type": "error" }, { "inputs": [], "name": "NoAssetsToDeposit", "type": "error" }, { "inputs": [], "name": "NoParticipants", "type": "error" }, { "inputs": [], "name": "NotStaked", "type": "error" }, { "inputs": [], "name": "NotVerified", "type": "error" }, { "inputs": [], "name": "NothingToClaim", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "owner", "type": "address" }], "name": "OwnableInvalidOwner", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "account", "type": "address" }], "name": "OwnableUnauthorizedAccount", "type": "error" }, { "inputs": [], "name": "ReentrancyGuardReentrantCall", "type": "error" }, { "inputs": [{ "internalType": "address", "name": "token", "type": "address" }], "name": "SafeERC20FailedOperation", "type": "error" }, { "inputs": [], "name": "StakingClosedError", "type": "error" }, { "inputs": [], "name": "VaultAlreadySettled", "type": "error" }, { "inputs": [], "name": "VaultNotSettled", "type": "error" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "participant", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }], "name": "Claimed", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "shares", "type": "uint256" }], "name": "DepositedToYield", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "uint256", "name": "totalStaked", "type": "uint256" }], "name": "EventStarted", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" }], "name": "OwnershipTransferred", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": false, "internalType": "uint256", "name": "totalYield", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "protocolFee", "type": "uint256" }, { "indexed": false, "internalType": "uint256", "name": "noShowFee", "type": "uint256" }], "name": "Settled", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "participant", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "amount", "type": "uint256" }], "name": "Staked", "type": "event" }, { "anonymous": false, "inputs": [], "name": "StakingClosed", "type": "event" }, { "anonymous": false, "inputs": [], "name": "StakingOpened", "type": "event" }, { "anonymous": false, "inputs": [{ "indexed": true, "internalType": "address", "name": "participant", "type": "address" }], "name": "Verified", "type": "event" }, { "inputs": [], "name": "assetToken", "outputs": [{ "internalType": "contract IERC20", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "claim", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "closeStaking", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "depositToYield", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "depositedAmount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "eventStarted", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "factory", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "participant", "type": "address" }], "name": "getClaimable", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getCurrentBalance", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getParticipantCount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getProtocolFees", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }, { "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "participant", "type": "address" }], "name": "getStatus", "outputs": [{ "internalType": "enum ICommitmentVault.Status", "name": "", "type": "uint8" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getVaultInfo", "outputs": [{ "internalType": "address", "name": "_assetToken", "type": "address" }, { "internalType": "uint256", "name": "_stakeAmount", "type": "uint256" }, { "internalType": "uint256", "name": "_maxParticipants", "type": "uint256" }, { "internalType": "uint256", "name": "_currentParticipants", "type": "uint256" }, { "internalType": "bool", "name": "_stakingOpen", "type": "bool" }, { "internalType": "bool", "name": "_eventStarted", "type": "bool" }, { "internalType": "bool", "name": "_settled", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getVerifiedCount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "getYieldInfo", "outputs": [{ "internalType": "bool", "name": "_hasYield", "type": "bool" }, { "internalType": "uint256", "name": "currentBalance", "type": "uint256" }, { "internalType": "uint256", "name": "deposited", "type": "uint256" }, { "internalType": "uint256", "name": "estimatedYield", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "hasYield", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "isEventStarted", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "isSettled", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "isStakingClosed", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "maxParticipants", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "openStaking", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "name": "participantList", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "", "type": "address" }], "name": "participants", "outputs": [{ "internalType": "bool", "name": "hasStaked", "type": "bool" }, { "internalType": "bool", "name": "isVerified", "type": "bool" }, { "internalType": "bool", "name": "hasClaimed", "type": "bool" }, { "internalType": "uint256", "name": "claimableAmount", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "settle", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "settled", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "sharesHeld", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "stake", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "stakeAmount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "stakingOpen", "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalProtocolFees", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalStaked", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "totalYieldEarned", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "newOwner", "type": "address" }], "name": "transferOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "treasury", "outputs": [{ "internalType": "address", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "vaultId", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "verifiedCount", "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], "stateMutability": "view", "type": "function" }, { "inputs": [{ "internalType": "address", "name": "participant", "type": "address" }], "name": "verify", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [{ "internalType": "address[]", "name": "_participants", "type": "address[]" }], "name": "verifyBatch", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "yieldVault", "outputs": [{ "internalType": "contract IERC4626", "name": "", "type": "address" }], "stateMutability": "view", "type": "function" }];
+
+// src/abis/index.ts
+var ERC20ABI = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ type: "string" }],
+    stateMutability: "view"
+  }
+];
+
+// src/constants/addresses.ts
+var CHAIN_ID = 8453;
+var CONTRACTS = {
+  FACTORY: "0x0be05a5fa7116c1b33f2b0036eb0d9690db9075f",
+  MORPHO_VAULT: "0x050cE30b927Da55177A4914EC73480238BAD56f0"
+};
+var TOKENS = {
+  USDC: {
+    address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    decimals: 6,
+    symbol: "USDC",
+    supportsYield: true
+  },
+  IDRX: {
+    address: "0x18Bc5bcC660cf2B9cE3cd51a404aFe1a0cBD3C22",
+    decimals: 2,
+    symbol: "IDRX",
+    supportsYield: false
+  }
+};
+var getTokenByAddress = (address) => {
+  const normalizedAddress = address.toLowerCase();
+  for (const [sym, token] of Object.entries(TOKENS)) {
+    if (token.address.toLowerCase() === normalizedAddress) {
+      return { ...token, symbol: sym };
+    }
+  }
+  return null;
+};
+var getTokenBySymbol = (symbol) => {
+  return TOKENS[symbol];
+};
+
+// src/utils/decimals.ts
+import { parseUnits, formatUnits } from "viem";
+function toTokenUnits(amount, decimals) {
+  return parseUnits(amount, decimals);
+}
+function fromTokenUnits(amount, decimals) {
+  return formatUnits(amount, decimals);
+}
+function formatAmount(amount, decimals = 2) {
+  const num = parseFloat(amount);
+  if (isNaN(num)) return "0";
+  return num.toFixed(decimals);
+}
+
+// src/utils/errors.ts
+var ATFiErrorCode = /* @__PURE__ */ ((ATFiErrorCode2) => {
+  ATFiErrorCode2["INVALID_AMOUNT"] = "INVALID_AMOUNT";
+  ATFiErrorCode2["INVALID_ADDRESS"] = "INVALID_ADDRESS";
+  ATFiErrorCode2["TOKEN_NOT_SUPPORTED"] = "TOKEN_NOT_SUPPORTED";
+  ATFiErrorCode2["YIELD_ONLY_USDC"] = "YIELD_ONLY_USDC";
+  ATFiErrorCode2["STAKING_CLOSED"] = "STAKING_CLOSED";
+  ATFiErrorCode2["EVENT_ALREADY_STARTED"] = "EVENT_ALREADY_STARTED";
+  ATFiErrorCode2["EVENT_NOT_STARTED"] = "EVENT_NOT_STARTED";
+  ATFiErrorCode2["ALREADY_STAKED"] = "ALREADY_STAKED";
+  ATFiErrorCode2["NOT_STAKED"] = "NOT_STAKED";
+  ATFiErrorCode2["ALREADY_VERIFIED"] = "ALREADY_VERIFIED";
+  ATFiErrorCode2["NOT_VERIFIED"] = "NOT_VERIFIED";
+  ATFiErrorCode2["VAULT_NOT_SETTLED"] = "VAULT_NOT_SETTLED";
+  ATFiErrorCode2["VAULT_ALREADY_SETTLED"] = "VAULT_ALREADY_SETTLED";
+  ATFiErrorCode2["ALREADY_CLAIMED"] = "ALREADY_CLAIMED";
+  ATFiErrorCode2["NOTHING_TO_CLAIM"] = "NOTHING_TO_CLAIM";
+  ATFiErrorCode2["MAX_PARTICIPANTS_REACHED"] = "MAX_PARTICIPANTS_REACHED";
+  ATFiErrorCode2["NOT_OWNER"] = "NOT_OWNER";
+  ATFiErrorCode2["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+  ATFiErrorCode2["INSUFFICIENT_ALLOWANCE"] = "INSUFFICIENT_ALLOWANCE";
+  ATFiErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  ATFiErrorCode2["CONTRACT_ERROR"] = "CONTRACT_ERROR";
+  ATFiErrorCode2["VAULT_NOT_FOUND"] = "VAULT_NOT_FOUND";
+  return ATFiErrorCode2;
+})(ATFiErrorCode || {});
+var ATFiError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ATFiError";
+  }
+};
+var CONTRACT_ERROR_MAP = {
+  AlreadyClaimed: "ALREADY_CLAIMED" /* ALREADY_CLAIMED */,
+  AlreadyStaked: "ALREADY_STAKED" /* ALREADY_STAKED */,
+  AlreadyVerified: "ALREADY_VERIFIED" /* ALREADY_VERIFIED */,
+  EventAlreadyStarted: "EVENT_ALREADY_STARTED" /* EVENT_ALREADY_STARTED */,
+  InvalidAddress: "INVALID_ADDRESS" /* INVALID_ADDRESS */,
+  InvalidStakeAmount: "INVALID_AMOUNT" /* INVALID_AMOUNT */,
+  InvalidMaxParticipants: "INVALID_AMOUNT" /* INVALID_AMOUNT */,
+  MaxParticipantsReached: "MAX_PARTICIPANTS_REACHED" /* MAX_PARTICIPANTS_REACHED */,
+  NoAssetsToDeposit: "INVALID_AMOUNT" /* INVALID_AMOUNT */,
+  NoParticipants: "INVALID_AMOUNT" /* INVALID_AMOUNT */,
+  NotStaked: "NOT_STAKED" /* NOT_STAKED */,
+  NotVerified: "NOT_VERIFIED" /* NOT_VERIFIED */,
+  NothingToClaim: "NOTHING_TO_CLAIM" /* NOTHING_TO_CLAIM */,
+  StakingClosedError: "STAKING_CLOSED" /* STAKING_CLOSED */,
+  TokenNotSupported: "TOKEN_NOT_SUPPORTED" /* TOKEN_NOT_SUPPORTED */,
+  VaultAlreadySettled: "VAULT_ALREADY_SETTLED" /* VAULT_ALREADY_SETTLED */,
+  VaultNotSettled: "VAULT_NOT_SETTLED" /* VAULT_NOT_SETTLED */,
+  YieldOnlySupportsUSDC: "YIELD_ONLY_USDC" /* YIELD_ONLY_USDC */,
+  OwnableUnauthorizedAccount: "NOT_OWNER" /* NOT_OWNER */
+};
+function parseContractError(error) {
+  if (error instanceof ATFiError) {
+    return error;
+  }
+  const errorString = String(error);
+  for (const [errorName, code] of Object.entries(CONTRACT_ERROR_MAP)) {
+    if (errorString.includes(errorName)) {
+      return new ATFiError(
+        `Contract error: ${errorName}`,
+        code,
+        error
+      );
+    }
+  }
+  if (errorString.includes("insufficient funds") || errorString.includes("exceeds balance")) {
+    return new ATFiError(
+      "Insufficient balance",
+      "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+      error
+    );
+  }
+  return new ATFiError(
+    "Transaction failed",
+    "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    error
+  );
+}
+
+// src/types/index.ts
+var ParticipantStatus = /* @__PURE__ */ ((ParticipantStatus3) => {
+  ParticipantStatus3[ParticipantStatus3["NOT_STAKED"] = 0] = "NOT_STAKED";
+  ParticipantStatus3[ParticipantStatus3["STAKED"] = 1] = "STAKED";
+  ParticipantStatus3[ParticipantStatus3["VERIFIED"] = 2] = "VERIFIED";
+  ParticipantStatus3[ParticipantStatus3["CLAIMED"] = 3] = "CLAIMED";
+  return ParticipantStatus3;
+})(ParticipantStatus || {});
+var EventStatus = /* @__PURE__ */ ((EventStatus2) => {
+  EventStatus2["OPEN"] = "OPEN";
+  EventStatus2["STARTED"] = "STARTED";
+  EventStatus2["SETTLED"] = "SETTLED";
+  return EventStatus2;
+})(EventStatus || {});
+
+// src/ATFiSDK.ts
+var ATFiSDK = class _ATFiSDK {
+  constructor(publicClient, walletClient, config) {
+    this.publicClient = publicClient;
+    this.walletClient = walletClient ? walletClient : null;
+    this.factoryAddress = config?.factoryAddress ?? CONTRACTS.FACTORY;
+    this._isReadOnly = !walletClient;
+  }
+  /**
+   * Create a read-only SDK instance (no wallet required)
+   * Use this to show event data before user connects wallet
+   *
+   * @example
+   * ```ts
+   * const sdk = ATFiSDK.readOnly(publicClient);
+   * const events = await sdk.getAllEvents();
+   * const info = await sdk.getEventInfo(vaultAddress);
+   * ```
+   */
+  static readOnly(publicClient, config) {
+    return new _ATFiSDK(publicClient, null, config);
+  }
+  /** Check if SDK is in read-only mode */
+  get isReadOnly() {
+    return this._isReadOnly;
+  }
+  /** Get connected wallet address (null if read-only) */
+  get address() {
+    return this.walletClient?.account?.address ?? null;
+  }
+  // ============ Token Helpers ============
+  /**
+   * Get token balance for connected wallet or any address
+   *
+   * @example
+   * ```ts
+   * const myBalance = await sdk.getTokenBalance('USDC');
+   * const otherBalance = await sdk.getTokenBalance('USDC', '0xOther...');
+   * ```
+   */
+  async getTokenBalance(token, address) {
+    const tokenInfo = getTokenBySymbol(token);
+    if (!tokenInfo) throw new ATFiError(`Token ${token} not supported`, "TOKEN_NOT_SUPPORTED" /* TOKEN_NOT_SUPPORTED */);
+    const targetAddress = address ?? this.walletClient?.account?.address;
+    if (!targetAddress) throw new ATFiError("No address provided and no wallet connected", "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+    const balance = await this.publicClient.readContract({
+      address: tokenInfo.address,
+      abi: ERC20ABI,
+      functionName: "balanceOf",
+      args: [targetAddress]
+    });
+    return fromTokenUnits(balance, tokenInfo.decimals);
+  }
+  /**
+   * Get all supported token balances for an address
+   */
+  async getAllTokenBalances(address) {
+    const targetAddress = address ?? this.walletClient?.account?.address;
+    if (!targetAddress) throw new ATFiError("No address provided", "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+    const [usdcBalance, idrxBalance] = await Promise.all([
+      this.publicClient.readContract({
+        address: TOKENS.USDC.address,
+        abi: ERC20ABI,
+        functionName: "balanceOf",
+        args: [targetAddress]
+      }),
+      this.publicClient.readContract({
+        address: TOKENS.IDRX.address,
+        abi: ERC20ABI,
+        functionName: "balanceOf",
+        args: [targetAddress]
+      })
+    ]);
+    return {
+      USDC: fromTokenUnits(usdcBalance, TOKENS.USDC.decimals),
+      IDRX: fromTokenUnits(idrxBalance, TOKENS.IDRX.decimals)
+    };
+  }
+  // ============ User-Centric Queries ============
+  /**
+   * Get all events created by an address
+   *
+   * @example
+   * ```ts
+   * const myEvents = await sdk.getEventsByOwner(myAddress);
+   * ```
+   */
+  async getEventsByOwner(ownerAddress) {
+    const allEvents = await this.getAllEvents();
+    const ownerEvents = [];
+    for (const event of allEvents) {
+      if (event.owner.toLowerCase() === ownerAddress.toLowerCase()) {
+        const info = await this.getEventInfo(event.vaultAddress);
+        ownerEvents.push(info);
+      }
+    }
+    return ownerEvents;
+  }
+  /**
+   * Get all events where user has registered (staked)
+   *
+   * @example
+   * ```ts
+   * const myRegistrations = await sdk.getRegisteredEvents(myAddress);
+   * ```
+   */
+  async getRegisteredEvents(participantAddress) {
+    const allEvents = await this.getAllEvents();
+    const registeredEvents = [];
+    for (const event of allEvents) {
+      const status = await this.getParticipantStatus(event.vaultAddress, participantAddress);
+      if (status.hasStaked) {
+        const info = await this.getEventInfo(event.vaultAddress);
+        registeredEvents.push({
+          ...info,
+          userStatus: {
+            isOwner: info.owner.toLowerCase() === participantAddress.toLowerCase(),
+            hasStaked: status.hasStaked,
+            isVerified: status.isVerified,
+            hasClaimed: status.hasClaimed,
+            claimableAmount: status.claimableAmount
+          }
+        });
+      }
+    }
+    return registeredEvents;
+  }
+  /**
+   * Get all events where user can claim rewards
+   *
+   * @example
+   * ```ts
+   * const claimable = await sdk.getClaimableEvents(myAddress);
+   * for (const event of claimable) {
+   *   console.log(`Can claim ${event.userStatus.claimableAmount} from ${event.vaultAddress}`);
+   * }
+   * ```
+   */
+  async getClaimableEvents(participantAddress) {
+    const registered = await this.getRegisteredEvents(participantAddress);
+    return registered.filter(
+      (e) => e.settled && e.userStatus.isVerified && !e.userStatus.hasClaimed && parseFloat(e.userStatus.claimableAmount) > 0
+    );
+  }
+  /**
+   * Get user's complete dashboard data in one call
+   *
+   * @example
+   * ```ts
+   * const dashboard = await sdk.getUserDashboard(myAddress);
+   * console.log('Created:', dashboard.createdEvents.length);
+   * console.log('Registered:', dashboard.registeredEvents.length);
+   * console.log('Claimable:', dashboard.claimableEvents.length);
+   * ```
+   */
+  async getUserDashboard(userAddress) {
+    const [createdEvents, registeredEvents, tokenBalances] = await Promise.all([
+      this.getEventsByOwner(userAddress),
+      this.getRegisteredEvents(userAddress),
+      this.getAllTokenBalances(userAddress)
+    ]);
+    const claimableEvents = registeredEvents.filter(
+      (e) => e.settled && e.userStatus.isVerified && !e.userStatus.hasClaimed && parseFloat(e.userStatus.claimableAmount) > 0
+    );
+    const totalClaimable = claimableEvents.reduce((sum, e) => sum + parseFloat(e.userStatus.claimableAmount), 0).toFixed(6);
+    return {
+      createdEvents,
+      registeredEvents,
+      claimableEvents,
+      totalClaimable,
+      tokenBalances
+    };
+  }
+  // ============ Event Watching (Real-time) ============
+  /**
+   * Watch a vault for real-time updates
+   *
+   * @example
+   * ```ts
+   * const unwatch = sdk.watchVault(vaultAddress, {
+   *   onParticipantJoined: (addr, total) => {
+   *     console.log(`${addr} joined! Total: ${total}`);
+   *     refetchParticipants();
+   *   },
+   *   onSettled: (yield, fee) => {
+   *     showClaimButton();
+   *   },
+   * });
+   *
+   * // Later: stop watching
+   * unwatch();
+   * ```
+   */
+  watchVault(vaultAddress, callbacks) {
+    const unwatchers = [];
+    if (callbacks.onParticipantJoined) {
+      const unwatch = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "Staked",
+        onLogs: async (logs) => {
+          for (const log of logs) {
+            try {
+              const participant = log.args?.participant;
+              const count = await this.publicClient.readContract({
+                address: vaultAddress,
+                abi: VaultATFiABI,
+                functionName: "getParticipantCount"
+              });
+              callbacks.onParticipantJoined(participant, Number(count));
+            } catch (e) {
+              callbacks.onError?.(e);
+            }
+          }
+        }
+      });
+      unwatchers.push(unwatch);
+    }
+    if (callbacks.onParticipantVerified) {
+      const unwatch = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "Verified",
+        onLogs: async (logs) => {
+          for (const log of logs) {
+            try {
+              const participant = log.args?.participant;
+              const count = await this.publicClient.readContract({
+                address: vaultAddress,
+                abi: VaultATFiABI,
+                functionName: "verifiedCount"
+              });
+              callbacks.onParticipantVerified(participant, Number(count));
+            } catch (e) {
+              callbacks.onError?.(e);
+            }
+          }
+        }
+      });
+      unwatchers.push(unwatch);
+    }
+    if (callbacks.onSettled) {
+      const unwatch = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "Settled",
+        onLogs: async (logs) => {
+          for (const log of logs) {
+            try {
+              const args = log.args;
+              const assetToken = await this.publicClient.readContract({
+                address: vaultAddress,
+                abi: VaultATFiABI,
+                functionName: "assetToken"
+              });
+              const tokenInfo = getTokenByAddress(assetToken);
+              const decimals = tokenInfo?.decimals ?? 6;
+              callbacks.onSettled(
+                fromTokenUnits(args.totalYield, decimals),
+                fromTokenUnits(args.protocolFee, decimals)
+              );
+            } catch (e) {
+              callbacks.onError?.(e);
+            }
+          }
+        }
+      });
+      unwatchers.push(unwatch);
+    }
+    if (callbacks.onClaimed) {
+      const unwatch = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "Claimed",
+        onLogs: async (logs) => {
+          for (const log of logs) {
+            try {
+              const args = log.args;
+              const assetToken = await this.publicClient.readContract({
+                address: vaultAddress,
+                abi: VaultATFiABI,
+                functionName: "assetToken"
+              });
+              const tokenInfo = getTokenByAddress(assetToken);
+              const decimals = tokenInfo?.decimals ?? 6;
+              callbacks.onClaimed(
+                args.participant,
+                fromTokenUnits(args.amount, decimals)
+              );
+            } catch (e) {
+              callbacks.onError?.(e);
+            }
+          }
+        }
+      });
+      unwatchers.push(unwatch);
+    }
+    if (callbacks.onStakingStatusChanged) {
+      const unwatchOpen = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "StakingOpened",
+        onLogs: () => callbacks.onStakingStatusChanged(true)
+      });
+      const unwatchClose = this.publicClient.watchContractEvent({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        eventName: "StakingClosed",
+        onLogs: () => callbacks.onStakingStatusChanged(false)
+      });
+      unwatchers.push(unwatchOpen, unwatchClose);
+    }
+    return () => {
+      unwatchers.forEach((unwatch) => unwatch());
+    };
+  }
+  // ============ Write Functions (with built-in simulation) ============
+  ensureWallet() {
+    if (!this.walletClient) {
+      throw new ATFiError("Wallet not connected. Use ATFiSDK.readOnly() for read operations only.", "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+    }
+    return this.walletClient;
+  }
+  /**
+   * Create a new event (commitment vault)
+   */
+  async createEvent(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateCreateEvent(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeCreateEvent(params, callbacks);
+      }
+    };
+  }
+  /**
+   * Register for an event (stake tokens)
+   */
+  async register(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateRegister(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeRegister(params, callbacks);
+      }
+    };
+  }
+  /**
+   * Start an event (deposit to yield if enabled)
+   */
+  async startEvent(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateStartEvent(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeStartEvent(params, callbacks);
+      }
+    };
+  }
+  /**
+   * Verify participants (mark attendance)
+   */
+  async verifyParticipant(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateVerifyParticipant(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeVerifyParticipant(params, callbacks);
+      }
+    };
+  }
+  /**
+   * Settle an event (distribute rewards)
+   */
+  async settleEvent(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateSettleEvent(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeSettleEvent(params, callbacks);
+      }
+    };
+  }
+  /**
+   * Claim rewards after event settlement
+   */
+  async claim(params) {
+    this.ensureWallet();
+    const simulation = await this._simulateClaim(params);
+    return {
+      simulation,
+      execute: async (callbacks) => {
+        if (!simulation.success) {
+          throw new ATFiError(simulation.error?.message || "Simulation failed", simulation.error?.code || "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+        }
+        return this._executeClaim(params, callbacks);
+      }
+    };
+  }
+  // ============ Read Functions ============
+  /**
+   * Get detailed event information
+   */
+  async getEventInfo(vaultAddress) {
+    const [
+      vaultInfo,
+      vaultId,
+      owner,
+      hasYield,
+      totalStaked,
+      verifiedCount,
+      yieldInfo
+    ] = await Promise.all([
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "getVaultInfo"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "vaultId"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "owner"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "hasYield"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "totalStaked"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "verifiedCount"
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "getYieldInfo"
+      })
+    ]);
+    const info = vaultInfo;
+    const yield_ = yieldInfo;
+    const tokenInfo = getTokenByAddress(info[0]);
+    const decimals = tokenInfo?.decimals ?? 6;
+    const symbol = tokenInfo?.symbol ?? "UNKNOWN";
+    return {
+      vaultId,
+      vaultAddress,
+      owner,
+      assetToken: info[0],
+      tokenSymbol: symbol,
+      tokenDecimals: decimals,
+      stakeAmount: fromTokenUnits(info[1], decimals),
+      maxParticipants: Number(info[2]),
+      currentParticipants: Number(info[3]),
+      verifiedCount: Number(verifiedCount),
+      stakingOpen: info[4],
+      eventStarted: info[5],
+      settled: info[6],
+      hasYield,
+      totalStaked: fromTokenUnits(totalStaked, decimals),
+      yieldInfo: hasYield ? {
+        currentBalance: fromTokenUnits(yield_[1], decimals),
+        deposited: fromTokenUnits(yield_[2], decimals),
+        estimatedYield: fromTokenUnits(yield_[3], decimals)
+      } : void 0
+    };
+  }
+  /**
+   * Get participant status
+   */
+  async getParticipantStatus(vaultAddress, participantAddress) {
+    const [participant, status, claimable, assetToken] = await Promise.all([
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "participants",
+        args: [participantAddress]
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "getStatus",
+        args: [participantAddress]
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "getClaimable",
+        args: [participantAddress]
+      }),
+      this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "assetToken"
+      })
+    ]);
+    const p = participant;
+    const tokenInfo = getTokenByAddress(assetToken);
+    const decimals = tokenInfo?.decimals ?? 6;
+    return {
+      address: participantAddress,
+      hasStaked: p[0],
+      isVerified: p[1],
+      hasClaimed: p[2],
+      claimableAmount: fromTokenUnits(claimable, decimals),
+      status
+    };
+  }
+  /**
+   * Get all events (vaults) created - uses batched calls for efficiency
+   */
+  async getAllEvents() {
+    const vaultCount = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: FactoryATFiABI,
+      functionName: "getVaultCount"
+    });
+    const count = Number(vaultCount);
+    if (count === 0) return [];
+    const vaultAddressPromises = [];
+    for (let i = 1; i <= count; i++) {
+      vaultAddressPromises.push(
+        this.publicClient.readContract({
+          address: this.factoryAddress,
+          abi: FactoryATFiABI,
+          functionName: "getVault",
+          args: [BigInt(i)]
+        })
+      );
+    }
+    const vaultAddresses = await Promise.all(vaultAddressPromises);
+    const validAddresses = vaultAddresses.filter(
+      (addr) => addr !== "0x0000000000000000000000000000000000000000"
+    );
+    const eventInfoPromises = validAddresses.map((addr) => this.getEventInfo(addr));
+    const eventInfos = await Promise.all(eventInfoPromises);
+    return eventInfos.map((info) => {
+      let status;
+      if (info.settled) {
+        status = "SETTLED" /* SETTLED */;
+      } else if (info.eventStarted) {
+        status = "STARTED" /* STARTED */;
+      } else {
+        status = "OPEN" /* OPEN */;
+      }
+      return {
+        vaultId: info.vaultId,
+        vaultAddress: info.vaultAddress,
+        owner: info.owner,
+        assetToken: info.assetToken,
+        stakeAmount: info.stakeAmount,
+        maxParticipants: info.maxParticipants,
+        currentParticipants: info.currentParticipants,
+        status
+      };
+    });
+  }
+  /**
+   * Get vault address by ID
+   */
+  async getVaultAddress(vaultId) {
+    const address = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: FactoryATFiABI,
+      functionName: "getVault",
+      args: [BigInt(vaultId)]
+    });
+    if (address === "0x0000000000000000000000000000000000000000") {
+      return null;
+    }
+    return address;
+  }
+  /**
+   * Get total vault count
+   */
+  async getVaultCount() {
+    const count = await this.publicClient.readContract({
+      address: this.factoryAddress,
+      abi: FactoryATFiABI,
+      functionName: "getVaultCount"
+    });
+    return Number(count);
+  }
+  // ============ Private: Simulation Methods ============
+  async _simulateCreateEvent(params) {
+    const { stakeAmount, maxParticipants, useYield = false, token = "USDC" } = params;
+    if (useYield && token !== "USDC") {
+      return {
+        success: false,
+        error: { code: "YIELD_ONLY_USDC" /* YIELD_ONLY_USDC */, message: "Yield mode only supports USDC" }
+      };
+    }
+    const tokenInfo = getTokenBySymbol(token);
+    if (!tokenInfo) {
+      return {
+        success: false,
+        error: { code: "TOKEN_NOT_SUPPORTED" /* TOKEN_NOT_SUPPORTED */, message: `Token ${token} not supported` }
+      };
+    }
+    if (maxParticipants <= 0 || maxParticipants > 1e4) {
+      return {
+        success: false,
+        error: { code: "INVALID_AMOUNT" /* INVALID_AMOUNT */, message: "Max participants must be between 1 and 10000" }
+      };
+    }
+    const stakeAmountBigInt = toTokenUnits(stakeAmount, tokenInfo.decimals);
+    if (stakeAmountBigInt <= 0n) {
+      return {
+        success: false,
+        error: { code: "INVALID_AMOUNT" /* INVALID_AMOUNT */, message: "Stake amount must be greater than 0" }
+      };
+    }
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const functionName = useYield ? "createVault" : "createVaultNoYield";
+      await this.publicClient.simulateContract({
+        address: this.factoryAddress,
+        abi: FactoryATFiABI,
+        functionName,
+        args: [tokenInfo.address, stakeAmountBigInt, BigInt(maxParticipants)],
+        account
+      });
+      const vaultCount = await this.publicClient.readContract({
+        address: this.factoryAddress,
+        abi: FactoryATFiABI,
+        functionName: "getVaultCount"
+      });
+      const gasEstimate = await this.publicClient.estimateContractGas({
+        address: this.factoryAddress,
+        abi: FactoryATFiABI,
+        functionName,
+        args: [tokenInfo.address, stakeAmountBigInt, BigInt(maxParticipants)],
+        account
+      });
+      return {
+        success: true,
+        expectedVaultId: vaultCount + 1n,
+        token: { address: tokenInfo.address, symbol: tokenInfo.symbol, decimals: tokenInfo.decimals },
+        stakeAmount,
+        maxParticipants,
+        useYield,
+        gasEstimate
+      };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  async _simulateRegister(params) {
+    const { vaultAddress } = params;
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const [stakeAmount, assetToken, stakingOpen, eventStarted, currentParticipants, maxParticipants] = await Promise.all([
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stakeAmount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stakingOpen" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "eventStarted" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getParticipantCount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "maxParticipants" })
+      ]);
+      const tokenInfo = getTokenByAddress(assetToken);
+      const decimals = tokenInfo?.decimals ?? 6;
+      const symbol = tokenInfo?.symbol ?? "UNKNOWN";
+      const baseResult = {
+        stakeAmount: fromTokenUnits(stakeAmount, decimals),
+        tokenSymbol: symbol,
+        currentParticipants: Number(currentParticipants),
+        maxParticipants: Number(maxParticipants)
+      };
+      if (!stakingOpen) {
+        return { success: false, error: { code: "STAKING_CLOSED" /* STAKING_CLOSED */, message: "Staking is closed" }, ...baseResult };
+      }
+      if (eventStarted) {
+        return { success: false, error: { code: "EVENT_ALREADY_STARTED" /* EVENT_ALREADY_STARTED */, message: "Event already started" }, ...baseResult };
+      }
+      if (currentParticipants >= maxParticipants) {
+        return { success: false, error: { code: "MAX_PARTICIPANTS_REACHED" /* MAX_PARTICIPANTS_REACHED */, message: "Event is full" }, ...baseResult };
+      }
+      const participant = await this.publicClient.readContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "participants",
+        args: [account.address]
+      });
+      if (participant[0]) {
+        return { success: false, error: { code: "ALREADY_STAKED" /* ALREADY_STAKED */, message: "Already registered" }, ...baseResult };
+      }
+      const [balance, allowance] = await Promise.all([
+        this.publicClient.readContract({ address: assetToken, abi: ERC20ABI, functionName: "balanceOf", args: [account.address] }),
+        this.publicClient.readContract({ address: assetToken, abi: ERC20ABI, functionName: "allowance", args: [account.address, vaultAddress] })
+      ]);
+      const needsApproval = allowance < stakeAmount;
+      if (balance < stakeAmount) {
+        return {
+          success: false,
+          error: { code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */, message: `Insufficient ${symbol} balance` },
+          ...baseResult,
+          userBalance: fromTokenUnits(balance, decimals),
+          currentAllowance: fromTokenUnits(allowance, decimals),
+          needsApproval
+        };
+      }
+      await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stake", account });
+      const gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "stake", account });
+      return {
+        success: true,
+        ...baseResult,
+        userBalance: fromTokenUnits(balance, decimals),
+        currentAllowance: fromTokenUnits(allowance, decimals),
+        needsApproval,
+        gasEstimate
+      };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  async _simulateStartEvent(params) {
+    const { vaultAddress } = params;
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const [owner, totalStaked, hasYield, eventStarted, participantCount, assetToken] = await Promise.all([
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "owner" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "totalStaked" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "hasYield" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "eventStarted" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getParticipantCount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" })
+      ]);
+      const tokenInfo = getTokenByAddress(assetToken);
+      const decimals = tokenInfo?.decimals ?? 6;
+      const baseResult = {
+        totalStaked: fromTokenUnits(totalStaked, decimals),
+        hasYield,
+        participantCount: Number(participantCount)
+      };
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        return { success: false, error: { code: "NOT_OWNER" /* NOT_OWNER */, message: "Only owner can start" }, ...baseResult };
+      }
+      if (eventStarted) {
+        return { success: false, error: { code: "EVENT_ALREADY_STARTED" /* EVENT_ALREADY_STARTED */, message: "Already started" }, ...baseResult };
+      }
+      if (participantCount === 0n) {
+        return { success: false, error: { code: "INVALID_AMOUNT" /* INVALID_AMOUNT */, message: "No participants" }, ...baseResult };
+      }
+      await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "depositToYield", account });
+      const gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "depositToYield", account });
+      return { success: true, ...baseResult, gasEstimate };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  async _simulateVerifyParticipant(params) {
+    const { vaultAddress, participants } = params;
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const owner = await this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "owner" });
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        return { success: false, error: { code: "NOT_OWNER" /* NOT_OWNER */, message: "Only owner can verify" } };
+      }
+      const toVerify = [];
+      const alreadyVerified = [];
+      const notStaked = [];
+      const participantChecks = await Promise.all(
+        participants.map(
+          (addr) => this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "participants", args: [addr] })
+        )
+      );
+      for (let i = 0; i < participants.length; i++) {
+        const [hasStaked, isVerified] = participantChecks[i];
+        if (!hasStaked) notStaked.push(participants[i]);
+        else if (isVerified) alreadyVerified.push(participants[i]);
+        else toVerify.push(participants[i]);
+      }
+      if (notStaked.length > 0) {
+        return { success: false, error: { code: "NOT_STAKED" /* NOT_STAKED */, message: `${notStaked.length} not staked` }, toVerify, alreadyVerified, notStaked };
+      }
+      if (toVerify.length === 0) {
+        return { success: false, error: { code: "ALREADY_VERIFIED" /* ALREADY_VERIFIED */, message: "All already verified" }, toVerify, alreadyVerified, notStaked };
+      }
+      const currentVerified = await this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "verifiedCount" });
+      let gasEstimate;
+      if (participants.length === 1) {
+        await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "verify", args: [participants[0]], account });
+        gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "verify", args: [participants[0]], account });
+      } else {
+        await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "verifyBatch", args: [participants], account });
+        gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "verifyBatch", args: [participants], account });
+      }
+      return {
+        success: true,
+        toVerify,
+        alreadyVerified,
+        notStaked,
+        currentVerified: Number(currentVerified),
+        newVerifiedCount: Number(currentVerified) + toVerify.length,
+        gasEstimate
+      };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  async _simulateSettleEvent(params) {
+    const { vaultAddress } = params;
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const [owner, totalStaked, verifiedCount, participantCount, settled, hasYield, assetToken, stakeAmount, yieldInfo] = await Promise.all([
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "owner" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "totalStaked" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "verifiedCount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getParticipantCount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "settled" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "hasYield" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stakeAmount" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getYieldInfo" })
+      ]);
+      const tokenInfo = getTokenByAddress(assetToken);
+      const decimals = tokenInfo?.decimals ?? 6;
+      const noShowCount = Number(participantCount) - Number(verifiedCount);
+      const baseResult = {
+        totalStaked: fromTokenUnits(totalStaked, decimals),
+        verifiedCount: Number(verifiedCount),
+        noShowCount
+      };
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        return { success: false, error: { code: "NOT_OWNER" /* NOT_OWNER */, message: "Only owner can settle" }, ...baseResult };
+      }
+      if (settled) {
+        return { success: false, error: { code: "VAULT_ALREADY_SETTLED" /* VAULT_ALREADY_SETTLED */, message: "Already settled" }, ...baseResult };
+      }
+      const yield_ = yieldInfo;
+      const estimatedYield = hasYield ? yield_[3] : 0n;
+      const noShowStakes = BigInt(noShowCount) * stakeAmount;
+      const protocolFeeOnYield = estimatedYield / 10n;
+      const protocolFeeOnNoShow = noShowStakes / 10n;
+      const totalProtocolFees = protocolFeeOnYield + protocolFeeOnNoShow;
+      const netBonus = noShowStakes - protocolFeeOnNoShow + (estimatedYield - protocolFeeOnYield);
+      const rewardPerParticipant = Number(verifiedCount) > 0 ? stakeAmount + netBonus / BigInt(Number(verifiedCount)) : 0n;
+      await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "settle", account });
+      const gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "settle", account });
+      return {
+        success: true,
+        ...baseResult,
+        estimatedYield: fromTokenUnits(estimatedYield, decimals),
+        estimatedProtocolFees: fromTokenUnits(totalProtocolFees, decimals),
+        estimatedNoShowFees: fromTokenUnits(protocolFeeOnNoShow, decimals),
+        estimatedRewardPerParticipant: fromTokenUnits(rewardPerParticipant, decimals),
+        gasEstimate
+      };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  async _simulateClaim(params) {
+    const { vaultAddress } = params;
+    try {
+      const wallet = this.ensureWallet();
+      const account = wallet.account;
+      if (!account) {
+        return { success: false, error: { code: "CONTRACT_ERROR" /* CONTRACT_ERROR */, message: "No account connected" } };
+      }
+      const [claimable, participant, settled, assetToken, stakeAmount] = await Promise.all([
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getClaimable", args: [account.address] }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "participants", args: [account.address] }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "settled" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" }),
+        this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stakeAmount" })
+      ]);
+      const tokenInfo = getTokenByAddress(assetToken);
+      const decimals = tokenInfo?.decimals ?? 6;
+      const symbol = tokenInfo?.symbol ?? "UNKNOWN";
+      const p = participant;
+      if (!settled) return { success: false, error: { code: "VAULT_NOT_SETTLED" /* VAULT_NOT_SETTLED */, message: "Not settled yet" }, tokenSymbol: symbol };
+      if (!p[0]) return { success: false, error: { code: "NOT_STAKED" /* NOT_STAKED */, message: "Not registered" }, tokenSymbol: symbol };
+      if (!p[1]) return { success: false, error: { code: "NOT_VERIFIED" /* NOT_VERIFIED */, message: "Not verified" }, tokenSymbol: symbol, stakeAmount: fromTokenUnits(stakeAmount, decimals) };
+      if (p[2]) return { success: false, error: { code: "ALREADY_CLAIMED" /* ALREADY_CLAIMED */, message: "Already claimed" }, tokenSymbol: symbol };
+      if (claimable === 0n) return { success: false, error: { code: "NOTHING_TO_CLAIM" /* NOTHING_TO_CLAIM */, message: "Nothing to claim" }, tokenSymbol: symbol };
+      const claimableAmount = claimable;
+      const stakeAmountBigInt = stakeAmount;
+      const bonusShare = claimableAmount > stakeAmountBigInt ? claimableAmount - stakeAmountBigInt : 0n;
+      await this.publicClient.simulateContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "claim", account });
+      const gasEstimate = await this.publicClient.estimateContractGas({ address: vaultAddress, abi: VaultATFiABI, functionName: "claim", account });
+      return {
+        success: true,
+        claimableAmount: fromTokenUnits(claimableAmount, decimals),
+        tokenSymbol: symbol,
+        stakeAmount: fromTokenUnits(stakeAmountBigInt, decimals),
+        bonusShare: fromTokenUnits(bonusShare, decimals),
+        gasEstimate
+      };
+    } catch (error) {
+      const parsed = parseContractError(error);
+      return { success: false, error: { code: parsed.code, message: parsed.message } };
+    }
+  }
+  // ============ Private: Execution Methods ============
+  async _executeCreateEvent(params, callbacks) {
+    const { stakeAmount, maxParticipants, useYield = false, token = "USDC" } = params;
+    const tokenInfo = getTokenBySymbol(token);
+    const stakeAmountBigInt = toTokenUnits(stakeAmount, tokenInfo.decimals);
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    const functionName = useYield ? "createVault" : "createVaultNoYield";
+    callbacks?.onSubmitting?.();
+    const hash = await wallet.writeContract({
+      address: this.factoryAddress,
+      abi: FactoryATFiABI,
+      functionName,
+      args: [tokenInfo.address, stakeAmountBigInt, BigInt(maxParticipants)],
+      account,
+      chain: null
+    });
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const vaultCreatedLog = receipt.logs.find((log) => {
+      try {
+        return decodeEventLog({ abi: FactoryATFiABI, data: log.data, topics: log.topics }).eventName === "VaultCreated";
+      } catch {
+        return false;
+      }
+    });
+    if (!vaultCreatedLog) throw new ATFiError("VaultCreated event not found", "CONTRACT_ERROR" /* CONTRACT_ERROR */);
+    const decoded = decodeEventLog({ abi: FactoryATFiABI, data: vaultCreatedLog.data, topics: vaultCreatedLog.topics });
+    const args = decoded.args;
+    return { vaultId: args.vaultId, vaultAddress: args.vault, txHash: hash };
+  }
+  async _executeRegister(params, callbacks) {
+    const { vaultAddress } = params;
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    const [stakeAmount, assetToken] = await Promise.all([
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "stakeAmount" }),
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" })
+    ]);
+    const tokenInfo = getTokenByAddress(assetToken);
+    const decimals = tokenInfo?.decimals ?? 6;
+    const allowance = await this.publicClient.readContract({
+      address: assetToken,
+      abi: ERC20ABI,
+      functionName: "allowance",
+      args: [account.address, vaultAddress]
+    });
+    if (allowance < stakeAmount) {
+      callbacks?.onApproving?.();
+      const approveHash = await wallet.writeContract({
+        address: assetToken,
+        abi: ERC20ABI,
+        functionName: "approve",
+        args: [vaultAddress, stakeAmount],
+        account,
+        chain: null
+      });
+      callbacks?.onApproved?.(approveHash);
+      await this.publicClient.waitForTransactionReceipt({ hash: approveHash });
+    }
+    callbacks?.onSubmitting?.();
+    const hash = await wallet.writeContract({
+      address: vaultAddress,
+      abi: VaultATFiABI,
+      functionName: "stake",
+      account,
+      chain: null
+    });
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    await this.publicClient.waitForTransactionReceipt({ hash });
+    return { txHash: hash, stakeAmount: fromTokenUnits(stakeAmount, decimals) };
+  }
+  async _executeStartEvent(params, callbacks) {
+    const { vaultAddress } = params;
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    callbacks?.onSubmitting?.();
+    const hash = await wallet.writeContract({
+      address: vaultAddress,
+      abi: VaultATFiABI,
+      functionName: "depositToYield",
+      account,
+      chain: null
+    });
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const [totalStaked, hasYield, assetToken] = await Promise.all([
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "totalStaked" }),
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "hasYield" }),
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" })
+    ]);
+    const tokenInfo = getTokenByAddress(assetToken);
+    const decimals = tokenInfo?.decimals ?? 6;
+    let sharesReceived;
+    const depositLog = receipt.logs.find((log) => {
+      try {
+        return decodeEventLog({ abi: VaultATFiABI, data: log.data, topics: log.topics }).eventName === "DepositedToYield";
+      } catch {
+        return false;
+      }
+    });
+    if (depositLog && hasYield) {
+      const decoded = decodeEventLog({ abi: VaultATFiABI, data: depositLog.data, topics: depositLog.topics });
+      sharesReceived = decoded.args.shares.toString();
+    }
+    return { txHash: hash, totalStaked: fromTokenUnits(totalStaked, decimals), hasYield, sharesReceived };
+  }
+  async _executeVerifyParticipant(params, callbacks) {
+    const { vaultAddress, participants } = params;
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    callbacks?.onSubmitting?.();
+    let hash;
+    if (participants.length === 1) {
+      hash = await wallet.writeContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "verify",
+        args: [participants[0]],
+        account,
+        chain: null
+      });
+    } else {
+      hash = await wallet.writeContract({
+        address: vaultAddress,
+        abi: VaultATFiABI,
+        functionName: "verifyBatch",
+        args: [participants],
+        account,
+        chain: null
+      });
+    }
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    await this.publicClient.waitForTransactionReceipt({ hash });
+    const totalVerified = await this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "verifiedCount" });
+    return { txHash: hash, verifiedCount: participants.length, totalVerified: Number(totalVerified) };
+  }
+  async _executeSettleEvent(params, callbacks) {
+    const { vaultAddress } = params;
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    const assetToken = await this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" });
+    const tokenInfo = getTokenByAddress(assetToken);
+    const decimals = tokenInfo?.decimals ?? 6;
+    callbacks?.onSubmitting?.();
+    const hash = await wallet.writeContract({
+      address: vaultAddress,
+      abi: VaultATFiABI,
+      functionName: "settle",
+      account,
+      chain: null
+    });
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const settledLog = receipt.logs.find((log) => {
+      try {
+        return decodeEventLog({ abi: VaultATFiABI, data: log.data, topics: log.topics }).eventName === "Settled";
+      } catch {
+        return false;
+      }
+    });
+    let totalYieldEarned = "0", protocolFees = "0", noShowFees = "0";
+    if (settledLog) {
+      const decoded = decodeEventLog({ abi: VaultATFiABI, data: settledLog.data, topics: settledLog.topics });
+      const args = decoded.args;
+      totalYieldEarned = fromTokenUnits(args.totalYield, decimals);
+      protocolFees = fromTokenUnits(args.protocolFee, decimals);
+      noShowFees = fromTokenUnits(args.noShowFee, decimals);
+    }
+    return { txHash: hash, totalYieldEarned, protocolFees, noShowFees };
+  }
+  async _executeClaim(params, callbacks) {
+    const { vaultAddress } = params;
+    const wallet = this.ensureWallet();
+    const account = wallet.account;
+    const [claimable, assetToken] = await Promise.all([
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "getClaimable", args: [account.address] }),
+      this.publicClient.readContract({ address: vaultAddress, abi: VaultATFiABI, functionName: "assetToken" })
+    ]);
+    const tokenInfo = getTokenByAddress(assetToken);
+    const decimals = tokenInfo?.decimals ?? 6;
+    callbacks?.onSubmitting?.();
+    const hash = await wallet.writeContract({
+      address: vaultAddress,
+      abi: VaultATFiABI,
+      functionName: "claim",
+      account,
+      chain: null
+    });
+    callbacks?.onSubmitted?.(hash);
+    callbacks?.onConfirming?.();
+    await this.publicClient.waitForTransactionReceipt({ hash });
+    return { txHash: hash, amountClaimed: fromTokenUnits(claimable, decimals) };
+  }
+};
+export {
+  ATFiError,
+  ATFiErrorCode,
+  ATFiSDK,
+  CHAIN_ID,
+  CONTRACTS,
+  ERC20ABI,
+  EventStatus,
+  FactoryATFiABI,
+  ParticipantStatus,
+  TOKENS,
+  VaultATFiABI,
+  formatAmount,
+  fromTokenUnits,
+  getTokenByAddress,
+  getTokenBySymbol,
+  parseContractError,
+  toTokenUnits
+};