Chat Agent

z.object({
  userAddress: z.string().describe("The user's wallet address")
})

export const get_user_vault_balance = createTool({
  name: "get_my_balance",
  description: "Gets the current user's vault share balance and withdrawable LINK amount. Only returns data for the requesting user.",
  fn: async ({ userAddress }) => {
    const [balance, assets] = await Promise.all([
      chain_read(env.VAULT_ADDRESS, VaultABI.abi, "balanceOf", [userAddress]),
      chain_read(env.VAULT_ADDRESS, VaultABI.abi, "convertToAssets", [
        await chain_read(env.VAULT_ADDRESS, VaultABI.abi, "balanceOf", [userAddress])
      ])
    ]);
    
    return {
      raw: { shares: balance.toString(), withdrawable: assets.toString() },
      human: { shares: format18(balance), withdrawable: format18(assets) }
    };
  }
});

z.object({
  wallet: z.string().describe("The user's wallet address")
})

export const get_wallet_link_balance = createTool({
  name: "get_link_balance",
  description: "Returns the user's LINK balance in their wallet.",
  fn: async ({ wallet }) => {
    const rawBalance = await chain_read(
      env.LINK_ADDRESS,
      MockERC20ABI.abi,
      "balanceOf",
      [wallet]
    );
    
    return {
      wallet,
      rawBalance: rawBalance.toString(),
      balance: format18(rawBalance),
      symbol: "LINK",
      message: `The wallet ${wallet} has ${format18(rawBalance)} LINK.`
    };
  }
});

z.object({
  amount: z.string().describe("Amount of LINK to deposit")
})

export const user_deposit = createTool({
  name: "user_deposit",
  description: "Prepares an unsigned LINK deposit transaction for the user to sign in their wallet.",
  fn: async ({ amount }) => {
    const parsedAmount = parseUnits(amount);
    const iface = new ethers.Interface(VaultABI.abi);
    const data = iface.encodeFunctionData("deposit", [parsedAmount]);
    
    return {
      success: true,
      unsignedTx: {
        to: env.VAULT_ADDRESS,
        data,
        value: "0"
      },
      message: `Please sign this deposit transaction for ${amount} LINK.`
    };
  }
});

z.object({
  shares: z.string().describe("Number of shares to withdraw (in human-readable format)")
})

export const user_withdraw = createTool({
  name: "user_withdraw",
  description: "Withdraws shares from the vault for the user. Returns transaction hash.",
  fn: async ({ shares }) => {
    const parsedAmount = parseUnits(shares);
    const iface = new ethers.Interface(VaultABI.abi);
    const data = iface.encodeFunctionData("withdraw", [parsedAmount]);
    
    return {
      success: true,
      unsignedTx: {
        to: env.VAULT_ADDRESS,
        data,
        value: "0"
      },
      message: `Please sign this withdraw transaction for ${shares} LINK.`
    };
  }
});

z.object({
  amount: z.string().describe("The amount of LINK (in Human Readable Format)")
})

export const convert_to_shares = createTool({
  name: "convert_to_shares",
  description: "To convert LINK amount to Vault Share Tokens(VST).",
  fn: async ({ amount }) => {
    const shares = await chain_read(
      env.VAULT_ADDRESS,
      VaultABI.abi,
      "convertToShares",
      [parseUnits(amount)]
    );
    return format18(shares);
  }
});

z.object({
  shares: z.string().describe("The amount of shares or VST (in Human Readable Format)")
})

export const convert_to_assets = createTool({
  name: "convert_to_assets",
  description: "To convert Vault Share Tokens(VST) to LINK.",
  fn: async ({ shares }) => {
    const linkAmount = await chain_read(
      env.VAULT_ADDRESS,
      VaultABI.abi,
      "convertToAssets",
      [parseUnits(shares)]
    );
    return format18(linkAmount);
  }
});

export const get_public_vault_info = createTool({
  name: "get_public_vault_info",
  description: "Gets public vault information including total managed assets and total supply. This is public information available to all users.",
  fn: async () => {
    const [totalManaged, totalSupply] = await Promise.all([
      chain_read(env.VAULT_ADDRESS, VaultABI.abi, "totalManagedAssets", []),
      chain_read(env.VAULT_ADDRESS, VaultABI.abi, "totalSupply", []),
    ]);
    
    return {
      raw: { totalManaged: totalManaged.toString(), totalSupply: totalSupply.toString() },
      human: { totalManaged: format18(totalManaged), totalSupply: format18(totalSupply) }
    };
  }
});

export const get_token_prices = createTool({
  name: "get_token_prices",
  description: "Fetches real-time LINK price from CoinGecko API. Returns public market prices.",
  fn: async () => {
    const response = await fetch(
      "https://api.coingecko.com/api/v3/simple/price?ids=chainlink,weth&vs_currencies=usd&include_24hr_change=true"
    );
    const data = await response.json();
    
    const linkPriceUSD = data.chainlink?.usd;
    const link24hChange = data.chainlink?.usd_24h_change;
    
    return {
      raw: { linkPriceUSD: BigInt(Math.floor(linkPriceUSD * 1e18)).toString() },
      human: { 
        linkPriceUSD: linkPriceUSD.toFixed(2),
        link24hChange: link24hChange.toFixed(2) + "%" 
      },
      source: "CoinGecko API"
    };
  }
});

import { calculateVaultAPY } from "../strategy-sentinel-agent/tools";

export const get_vault_apy = createTool({
  name: "get_vault_apy",
  description: "Gets the current vault APY based on TVL growth. This is public information.",
  fn: async (_params: {}, toolContext: ToolContext) => {
    return calculateVaultAPY(toolContext);
  }
});

z.object({
  wallet: z.string(),
  amount: z.string()
})

export const check_allowance = createTool({
  name: "check_allowance",
  description: "Checks if user's LINK token allowance is enough for a deposit.",
  fn: async ({ wallet, amount }) => {
    const needed = parseUnits(amount);
    const allowance = await chain_read(
      env.LINK_ADDRESS,
      MockERC20ABI.abi,
      "allowance",
      [wallet, env.VAULT_ADDRESS]
    );
    
    return {
      allowance: allowance.toString(),
      enough: allowance >= needed,
      needed: needed.toString(),
      wallet
    };
  }
});

z.object({
  amount: z.string()
})

export const approve_link = createTool({
  name: "approve_link",
  description: "Prepares an unsigned approval transaction so the vault can spend LINK.",
  fn: async ({ amount }) => {
    const iface = new ethers.Interface(MockERC20ABI.abi);
    const data = iface.encodeFunctionData("approve", [
      env.VAULT_ADDRESS,
      parseUnits(amount)
    ]);
    
    return {
      unsignedTx: {
        to: env.LINK_ADDRESS,
        data,
        value: "0"
      },
      message: `Please sign this transaction to approve ${amount} LINK for spending.`
    };
  }
});