Integrate the Fixed-Rate Vault

import {
  createPublicClient, createWalletClient, custom, defineChain, http,
  erc20Abi, parseAbi, parseUnits, type EIP1193Provider, type Hash, type Address, type Chain,
} from 'viem';

export const kairosAddresses = {
  "asset": "0xFD9a576384e9872fb6f7b3ed24c9be915E809C78",
  "router": "0xCF5A814F8D5fa5E51C7D25d00Af1fa930EDc51Bf",
  "vault": "0xada4481a03c26d378554e0F24247DaFc8Afa542F",
  "accountant": "0xc9de16B4E7Ab99c5466c3bA4F958C113faF20eef",
  "queue": "0x1Cb256edad979cfc25622b35fD54d848Cdce8DD5",
  "controller": "0xA3914f4685838359b2a8403E8acea85f2cc4cB97",
  "keeper": "0xC819088522bedD6f4AC78bE42B98B384F5c5795b",
  "teller": "0xEbD6156c992000D78035663995d3e3896B29d2c3"
} as const;
export const kairos = defineChain({
  id: 1001, name: 'Kaia Kairos',
  nativeCurrency: { name: 'KAIA', symbol: 'KAIA', decimals: 18 },
  rpcUrls: { default: { http: ['https://public-en-kairos.node.kaia.io'] } },
  blockExplorers: { default: { name: 'KaiaScan', url: 'https://kairos.kaiascan.io' } },
});
export type FixedRateDeployment = {
  chain: Chain;
  addresses: Record<keyof typeof kairosAddresses, Address>;
};
export const kairosDeployment: FixedRateDeployment = {
  chain: kairos, addresses: kairosAddresses,
};
export const mockAbi = parseAbi(['function mint(address receiver, uint256 amount)']);
export const routerAbi = parseAbi([
  'function deposit(uint256 assets, uint256 minimumShares, address receiver) returns (uint256 shares)',
  'function paused() view returns (bool)',
  'function supplyCap() view returns (uint256)',
  'function whitelistEnabled() view returns (bool)',
  'event Deposited(address indexed payer, address indexed receiver, uint256 assets, uint256 shares)',
]);
export const accountantAbi = parseAbi([
  'function getRate() view returns (uint256)',
  'function getRateSafe() view returns (uint256)',
  'function accountantState() view returns (address payoutAddress, uint96 highwaterMark, uint128 feesOwedInBase, uint128 totalSharesLastUpdate, uint96 exchangeRate, uint16 allowedExchangeRateChangeUpper, uint16 allowedExchangeRateChangeLower, uint64 lastUpdateTimestamp, bool isPaused, uint24 minimumUpdateDelayInSeconds, uint16 managementFee, uint16 performanceFee)',
  'event ExchangeRateUpdated(uint96 oldRate, uint96 newRate, uint64 currentTime)',
]);
export const queueAbi = parseAbi([
  'struct AtomicRequest { uint64 deadline; uint88 atomicPrice; uint96 offerAmount; bool inSolve; }',
  'function updateAtomicRequest(address offer, address want, AtomicRequest request)',
  'function safeUpdateAtomicRequest(address offer, address want, AtomicRequest request, address accountant, uint256 discount)',
  'function getUserAtomicRequest(address user, address offer, address want) view returns (AtomicRequest)',
  'function isPaused() view returns (bool)',
  'event AtomicRequestUpdated(address indexed user, address indexed offerToken, address indexed wantToken, uint256 amount, uint256 deadline, uint256 minPrice, uint256 timestamp)',
  'event AtomicRequestFulfilled(address indexed user, address indexed offerToken, address indexed wantToken, uint256 offerAmountSpent, uint256 wantAmountReceived, uint256 timestamp)',
]);
export const controllerAbi = parseAbi([
  'function aprBps() view returns (uint256)',
  'function lastPokeAt() view returns (uint256)',
  'function minInterval() view returns (uint256)',
  'function previewNextRate() view returns (uint256 newRate, uint256 dt)',
]);
const pauseAbi = parseAbi(['function isPaused() view returns (bool)']);
const keeperAbi = parseAbi(['function paused() view returns (bool)']);

// Invoke from a wallet-connect button. Reconnect after accountsChanged/chainChanged.
export async function connectFixedRate(
  provider: EIP1193Provider,
  deployment: FixedRateDeployment,
  rpcUrl = deployment.chain.rpcUrls.default.http[0],
) {
  const { chain, addresses: a } = deployment;
  const wallet = createWalletClient({ chain, transport: custom(provider) });
  const [account] = await wallet.requestAddresses();
  if (!account) throw new Error('Connect a wallet');
  if (await wallet.getChainId() !== chain.id) throw new Error(`Switch wallet to ${chain.name} (${chain.id})`);
  const client = createPublicClient({ chain, transport: http(rpcUrl) });
  if (await client.getChainId() !== chain.id) throw new Error(`RPC must use chain ${chain.id}`);
  const assetDecimals = await client.readContract({ address: a.asset, abi: erc20Abi,
    functionName: 'decimals' });
  const wait = async (hash: Hash) => {
    const receipt = await client.waitForTransactionReceipt({ hash });
    if (receipt.status !== 'success') throw new Error(`Transaction reverted: ${hash}`);
    return receipt;
  };
  async function approveExact(token: `0x${string}`, spender: `0x${string}`, amount: bigint) {
    const allowance = await client.readContract({ address: token, abi: erc20Abi,
      functionName: 'allowance', args: [account, spender] });
    if (allowance === amount) return;
    if (allowance !== 0n) await wait(await wallet.writeContract({ account,
      address: token, abi: erc20Abi, functionName: 'approve', args: [spender, 0n] }));
    await wait(await wallet.writeContract({ account, address: token, abi: erc20Abi,
      functionName: 'approve', args: [spender, amount] }));
  }
  // Revocation calls the token directly; it also works while Queue is paused.
  async function revokeAllowance(token: Address, spender: Address) {
    const remaining = await client.readContract({ address: token, abi: erc20Abi,
      functionName: 'allowance', args: [account, spender] });
    if (remaining === 0n) return; // Already revoked.
    return wait(await wallet.writeContract({ account, address: token, abi: erc20Abi,
      functionName: 'approve', args: [spender, 0n] }));
  }
  const revokeDepositAllowance = () => revokeAllowance(a.asset, a.router);
  const revokeQueueAllowance = () => revokeAllowance(a.vault, a.queue);
  function parseAmount(value: string, decimals: number) {
    if (!/^(0|[1-9]\d*)(\.\d+)?$/.test(value)
      || (value.split('.')[1]?.length ?? 0) > decimals) {
      throw new Error('Use a positive decimal string within token precision');
    }
    return parseUnits(value, decimals);
  }
  // Test token helper: available only for the published Kairos mockUSDT.
  async function mintMockUSDT(amount = '1000') {
    if (chain.id !== kairos.id || a.asset.toLowerCase() !== kairosAddresses.asset.toLowerCase()) {
      throw new Error('mockUSDT mint is only available for the Kairos test deployment');
    }
    const units = parseAmount(amount, assetDecimals);
    if (units <= 0n) throw new Error('Amount must be positive');
    const { request } = await client.simulateContract({ account, address: a.asset,
      abi: mockAbi, functionName: 'mint', args: [account, units] });
    return wait(await wallet.writeContract(request));
  }
  async function deposit(amount: string, slippageBps = 10n) {
    const assets = parseAmount(amount, assetDecimals);
    if (assets <= 0n || slippageBps < 0n || slippageBps >= 10000n) throw new Error('Invalid amount/slippage');
    await approveExact(a.asset, a.router, assets);
    const rate = await client.readContract({ address: a.accountant, abi: accountantAbi,
      functionName: 'getRateSafe' });
    const minimumShares = (assets * 10n ** 18n / rate) * (10000n - slippageBps) / 10000n;
    if (minimumShares === 0n) throw new Error('Deposit too small');
    const { request } = await client.simulateContract({ account, address: a.router,
      abi: routerAbi, functionName: 'deposit', args: [assets, minimumShares, account] });
    return wait(await wallet.writeContract(request));
  }
  async function requestWithdraw(shareAmount: string) {
    const shares = parseAmount(shareAmount, 18);
    if (shares <= 0n || shares > (1n << 96n) - 1n) throw new Error('Invalid share amount');
    const old = await client.readContract({ address: a.queue, abi: queueAbi,
      functionName: 'getUserAtomicRequest', args: [account, a.vault, a.asset] });
    // Clear even expired stored requests before granting a new allowance.
    if (old.offerAmount > 0n) throw new Error('Cancel stored request before approving a new one, including expired requests');
    const balance = await client.readContract({ address: a.vault, abi: erc20Abi,
      functionName: 'balanceOf', args: [account] });
    if (shares > balance) throw new Error('Insufficient shares');
    await approveExact(a.vault, a.queue, shares);
    const rate = await client.readContract({ address: a.accountant, abi: accountantAbi,
      functionName: 'getRateSafe' });
    if (rate <= 0n || rate > (1n << 88n) - 1n) throw new Error('Invalid atomic price');
    if (shares * rate / 10n ** 18n === 0n) throw new Error('Withdrawal rounds to zero');
    const block = await client.getBlock();
    const atomicRequest = { deadline: block.timestamp + 7n * 86400n,
      // Ignored by safeUpdateAtomicRequest: price is read from Accountant at execution.
      atomicPrice: 0n, offerAmount: shares, inSolve: false };
    const { request } = await client.simulateContract({ account, address: a.queue,
      abi: queueAbi, functionName: 'safeUpdateAtomicRequest',
      args: [a.vault, a.asset, atomicRequest, a.accountant, 0n] });
    return wait(await wallet.writeContract(request));
  }
  async function cancelWithdraw() {
    // The safe entrypoint rejects zero amounts; use the regular entrypoint to cancel.
    const { request } = await client.simulateContract({ account, address: a.queue,
      abi: queueAbi, functionName: 'updateAtomicRequest', args: [a.vault, a.asset,
        { deadline: 0n, atomicPrice: 0n, offerAmount: 0n, inSolve: false }] });
    // Return cancellation success independently of allowance cleanup.
    return wait(await wallet.writeContract(request));
  }
  async function getStatus() {
    const block = await client.getBlock();
    const blockNumber = block.number;
    const [assets, shares, rate, request, state, aprBps, lastPokeAt, preview,
      routerPaused, tellerPaused, queuePaused, keeperPaused, allowance, depositAllowance] = await Promise.all([
      client.readContract({ address: a.asset, abi: erc20Abi, functionName: 'balanceOf', args: [account], blockNumber }),
      client.readContract({ address: a.vault, abi: erc20Abi, functionName: 'balanceOf', args: [account], blockNumber }),
      client.readContract({ address: a.accountant, abi: accountantAbi, functionName: 'getRate', blockNumber }),
      client.readContract({ address: a.queue, abi: queueAbi, functionName: 'getUserAtomicRequest', args: [account, a.vault, a.asset], blockNumber }),
      client.readContract({ address: a.accountant, abi: accountantAbi, functionName: 'accountantState', blockNumber }),
      client.readContract({ address: a.controller, abi: controllerAbi, functionName: 'aprBps', blockNumber }),
      client.readContract({ address: a.controller, abi: controllerAbi, functionName: 'lastPokeAt', blockNumber }),
      client.readContract({ address: a.controller, abi: controllerAbi, functionName: 'previewNextRate', blockNumber }),
      client.readContract({ address: a.router, abi: routerAbi, functionName: 'paused', blockNumber }),
      client.readContract({ address: a.teller, abi: pauseAbi, functionName: 'isPaused', blockNumber }),
      client.readContract({ address: a.queue, abi: queueAbi, functionName: 'isPaused', blockNumber }),
      client.readContract({ address: a.keeper, abi: keeperAbi, functionName: 'paused', blockNumber }),
      client.readContract({ address: a.vault, abi: erc20Abi, functionName: 'allowance', args: [account, a.queue], blockNumber }),
      client.readContract({ address: a.asset, abi: erc20Abi, functionName: 'allowance', args: [account, a.router], blockNumber }),
    ]);
    const requestState = request.offerAmount === 0n ? 'none'
      : request.deadline < block.timestamp ? 'expired' : 'open';
    return { account, blockNumber, assets, shares, rate, value: shares * rate / 10n ** 18n,
      aprBps, lastPokeAt, previewRate: preview[0], request, requestState,
      requestPayout: request.offerAmount * request.atomicPrice / 10n ** 18n,
      sharesLocked: requestState === 'open', allowance, depositAllowance,
      accountantPaused: state[8], routerPaused, tellerPaused, queuePaused, keeperPaused };
  }
  return { account, client, mintMockUSDT, deposit, requestWithdraw, cancelWithdraw,
    revokeDepositAllowance, revokeQueueAllowance, getStatus };
}

import { connectFixedRate, type FixedRateDeployment } from './client';

async function integrate(provider: Parameters<typeof connectFixedRate>[0], deployment: FixedRateDeployment) {
  const api = await connectFixedRate(provider, deployment);
  await api.deposit('100');          // Deposit 100 underlying tokens and receive shares
  const before = await api.getStatus();
  const requestReceipt = await api.requestWithdraw('10');
  const pending = await api.getStatus();
  return { before, pending, requestReceipt };
}

struct AtomicRequest {
    uint64 deadline;     // Unix seconds; expired when block.timestamp > deadline
    uint88 atomicPrice;  // ASSET base units per 1e18 shares
    uint96 offerAmount;  // 18-decimal share amount
    bool inSolve;       // Set false; Queue manages this during settlement
}

const cancellationReceipt = await api.cancelWithdraw();
// Cancellation is confirmed here, even if the next signature is rejected.
await api.revokeQueueAllowance();
const status = await api.getStatus(); // Check request.offerAmount === 0n and allowance === 0n

newRate = floor(anchorRate × ratePerSecond^(now - anchorTime))

import { connectFixedRate, kairosDeployment } from './client';

const api = await connectFixedRate(provider, kairosDeployment);
await api.mintMockUSDT('1000');     // Anyone can mint 1,000 mUSDT to their wallet
await api.deposit('100');
const requestReceipt = await api.requestWithdraw('10');
// Send requestReceipt.transactionHash to the team to arrange settlement.