Treasury in Aave, within limits you set, back when you need it.

# Check Aave and Chainlink against the chain, at the pinned block:
# Pool and aToken proxies, implementations and selectors, each asset
# (USDC; on Sepolia also EURS), where Aave's oracle takes its price from,
# the four feeds (EUR/USD included)
node packages/pack-aave/dist/bin.js verify --network mainnet-fork
node packages/pack-aave/dist/bin.js verify --network sepolia

# Register the Pool, the asset (EURS on Sepolia), its aToken, Aave's oracle
# and the feeds by name; --asset usdc when USDC's supply cap has room
CRYPTORAIL_API_KEY=<admin key> \
node packages/pack-aave/dist/bin.js setup --network sepolia --url <service URL>
# Run again: the same ids, nothing registered twice

import { MAINNET_FORK, aavePolicy } from '@cryptorail/pack-aave'

const policy = aavePolicy({
  version: 'treasury-2026-10',        // recorded with every decision
  network: MAINNET_FORK,
  treasury: treasuryAddress,          // the treasury's own key
  dailySupplyCap: '100000',           // USDC supplied per UTC day
  approvalThreshold: '50000',         // from here, a supply waits
  approverIds: [treasurerId],
})

// What it says, as the rules engine reads it:
// deny    the treasury's key, unless approve on USDC
//         or supply / withdraw on the Pool
// deny    approve        when spender is not the Pool
// deny    approve        when amount is above the daily cap
// deny    supply         when onBehalfOf is not the treasury
// deny    withdraw       when to is not the treasury
// limit   supply amount  100,000 USDC per day
// approve supply         from 50,000 USDC, 1 of the treasurers

import { createClient } from '@cryptorail/sdk'
import { supplyBatch } from '@cryptorail/pack-aave'

const cryptorail = createClient({ baseUrl, apiKey })
const actor = { network: MAINNET_FORK, contracts,  // ids from the setup
  identityId: treasuryId, treasury: treasuryAddress }

const { data } = await cryptorail.POST('/v1/transactions/batch', {
  params: { header: { 'idempotency-key': `supply-${reference}` } },
  body: supplyBatch(actor, 25_000_000_000n),   // 25,000 USDC
})
// One ordered batch, one identity, consecutive nonces:
// 0  approve(spender: Pool, amount: 25000000000)        on USDC
// 1  supply(asset: USDC, amount: 25000000000,
//           onBehalfOf: treasury, referralCode: 0)      on the Pool
// From 50,000 USDC, step 1 waits in PENDING_APPROVAL for a treasurer

// supply(…, onBehalfOf: someone else): refused before anything is signed
{
  "state": "REJECTED_BY_POLICY",
  "failure": {
    "stage": "policy",
    "cause": "policy.operation-denied",
    …
  }
}
// A supply past the daily cap: "cause": "policy.limit-exceeded"
// Ordered is not atomic: the exact approve before it stays mined, and
// only the treasury's own next supply can use it

import { readPosition } from '@cryptorail/pack-aave'

// balanceOf on aEthUSDC and getReserveData on the Pool, through CryptoRail:
// reads, nothing signed
const position = await readPosition(cryptorail, MAINNET_FORK, contracts, treasuryAddress)
// position.suppliedUsdc  about '25000'  what could be withdrawn now, interest included
// position.walletUsdc    '175000'
// position.rate          { aprPercent: 4.72, apyPercent: 4.83 }
//   currentLiquidityRate, a yearly rate in ray: the APR as Aave stores it,
//   and the APY compounded every second, as Aave's own interface shows it

import { readPrices } from '@cryptorail/pack-aave'

// latestRoundData and decimals on each Chainlink feed, getAssetPrice on Aave's oracle
const prices = await readPrices(cryptorail, MAINNET_FORK, contracts, nowSeconds)
// prices.feeds: [
//   { pair: 'ETH/USD',  price: '2470.57',  ageSeconds: 60n,    heartbeatSeconds: 3600,  stale: false },
//   { pair: 'BTC/USD',  price: '81628.13', ageSeconds: 2700n,  heartbeatSeconds: 3600,  stale: false },
//   { pair: 'USDC/USD', price: '0.99986',  ageSeconds: 16560n, heartbeatSeconds: 86400, stale: false },
// ]
// prices.aaveUsdc: { price: '0.99981945' }   the price Aave itself uses
// stale: older than the feed's heartbeat. Informative: no rule depends on a price

import { withdrawIntent } from '@cryptorail/pack-aave'

// Part of it
await cryptorail.POST('/v1/transactions', {
  params: { header: { 'idempotency-key': `withdraw-${reference}` } },
  body: withdrawIntent(actor, 10_000_000_000n),   // 10,000 USDC
})
// Everything, interest included: amount type(uint256).max
await cryptorail.POST('/v1/transactions', {
  params: { header: { 'idempotency-key': `withdraw-all-${reference}` } },
  body: withdrawIntent(actor, 'all'),
})
// withdraw(asset: USDC, amount, to: treasury): no approval, it only brings
// the treasury's own money back to it; any other 'to' is refused