고정이율 볼트 연동하기

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');          // 기초 자산 100개 입금 후 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; block.timestamp > deadline이면 만료
    uint88 atomicPrice;  // 1e18 shares당 ASSET 최소 단위
    uint96 offerAmount;  // 18-decimal share 수량
    bool inSolve;       // 사용자 입력은 false; 체결 중 Queue가 관리
}

const cancellationReceipt = await api.cancelWithdraw();
// 여기서 요청 취소는 확정되었습니다. 다음 서명을 거절해도 취소가 되돌려지지 않습니다.
await api.revokeQueueAllowance();
const status = await api.getStatus(); // request.offerAmount === 0n, allowance === 0n 확인

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

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

const api = await connectFixedRate(provider, kairosDeployment);
await api.mintMockUSDT('1000');     // 누구나 본인 지갑에 1,000 mUSDT 발행 가능
await api.deposit('100');
const requestReceipt = await api.requestWithdraw('10');
// requestReceipt.transactionHash를 팀에 전달하여 체결 일정을 조율하세요.