@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/types/contracts/zeno/quoteBuy.d.ts

@@ -0,0 +1,34 @@
+export interface BuyQuoteInput {
+    /** Price in payment token base units per whole ZENO, from `priceAt` or `getPrice`. */
+    price: bigint;
+    /** Payment token to spend, in base units. */
+    paymentAmount: bigint;
+    /** ZENO decimals, equal to the underlying's. */
+    zenoDecimals: number;
+    /** ZENO left to sell, in base units (`totalRemaining`). */
+    totalRemaining: bigint;
+    /** Tolerance below `zenoOut` for `minZenoOut`, in basis points (10000 = 100%). Defaults to 0. */
+    slippageBps?: bigint;
+}
+export interface BuyQuote {
+    /** ZENO minted for `paymentAmount` at `price`, in base units. */
+    zenoOut: bigint;
+    /** `zenoOut` less the slippage tolerance; pass it to `buy` as `minZenoOut`. */
+    minZenoOut: bigint;
+    /** The largest payment `buy` accepts at `price`; anything above mints more than `totalRemaining` and reverts. */
+    maxPayment: bigint;
+    /** True when `paymentAmount` is above `maxPayment`. */
+    exceedsRemaining: boolean;
+}
+/**
+ * What a buy mints, computed locally without an RPC call with `Auction.buy`'s integer maths:
+ * `zenoOut = paymentAmount * 10^zenoDecimals / price`, truncated.
+ *
+ * A Dutch price only falls, so a buy mined after the quote mints at least `zenoOut`; `minZenoOut` guards against a
+ * fixed price or a stale quote. The same fall means a payment at exactly `maxPayment` can revert a block later, so
+ * leave headroom when buying out the remainder.
+ *
+ * @param input The price, payment, ZENO decimals, remaining supply and slippage tolerance.
+ * @returns The ZENO out, the `minZenoOut` to send, and the payment ceiling.
+ */
+export declare const quoteBuy: (input: BuyQuoteInput) => BuyQuote;

package/dist/types/contracts/zeno/redeem.d.ts

@@ -0,0 +1,20 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Redeems ZENO 1:1 for the underlying. Reverts before maturity, and while the bond's collateral is short of its
+ * outstanding supply (`getBondState(...).isFunded`).
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param amount ZENO to redeem, in base units.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+export declare function redeem(chainId: ChainId, zeno: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Redeems the signer's whole ZENO balance for the underlying. Same conditions as `redeem`.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+export declare function redeemAll(chainId: ChainId, zeno: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/zeno/setAuction.d.ts

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Binds a ZENO to the auction that sells it. One-shot, ZENO owner only; reverts unless the auction's `zeno()` points
+ * back at this ZENO. Until it is set, the auction's buys revert.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param auction The auction created for it.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+declare function setAuction(chainId: ChainId, zeno: string, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default setAuction;

package/dist/types/contracts/zeno/sweepSurplus.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Sweeps underlying held above the ZENO's outstanding supply: unsold prefill, overpayments and post-maturity residue.
+ * ZENO owner only, and only once the bound auction has ended. `getBondState(...).sweepableSurplus` is the most it takes.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param to The recipient of the underlying.
+ * @param amount Underlying to sweep, in base units.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+declare function sweepSurplus(chainId: ChainId, zeno: string, to: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default sweepSurplus;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 import RPCLibrary from "./RPCLibrary";
 export * from "./utils/amount";
+export * from "./utils/rpcError";
 export default RPCLibrary;

package/dist/types/minter/emissionSchedule.d.ts

@@ -0,0 +1,53 @@
+/**
+ * TypeScript port of contracts/libraries/minters/EmissionSchedule.sol. The schedule is pure (no storage), so the
+ * whole curve can be drawn without one RPC call per week; the only on-chain input is the activation timestamp
+ * (`mintingStartAtTimestamp`). All amounts are RAAC base units (18 decimals).
+ */
+/** RAAC emitted in each of the first 104 weeks. Divisible by 604800, so the per-second rate is exact. */
+export declare const BASE_WEEKLY_EMISSION: bigint;
+export declare const BASE_PER_SECOND: bigint;
+/** First week of the reduction phase. */
+export declare const WEEK_REDUCTION_START = 105;
+/** The rate drops by 5% every this many weeks. */
+export declare const WEEKS_PER_PERIOD = 13;
+/** Weeks 781 and later emit nothing. */
+export declare const LAST_EMISSION_WEEK = 780;
+/**
+ * RAAC emitted per second during a 1-based schedule week.
+ * @param week The schedule week; 0 and weeks after 780 emit nothing.
+ */
+export declare function getEmissionPerSecondForWeek(week: number): bigint;
+/**
+ * The 1-based schedule week a timestamp falls in, 0 before activation.
+ * @param activationTimestamp `mintingStartAtTimestamp`, in UNIX seconds.
+ * @param timestamp The moment to place, in UNIX seconds.
+ */
+export declare function getMintingWeekForTimestamp(activationTimestamp: number, timestamp: number): number;
+/** One week of the schedule. */
+export interface EmissionWeek {
+    week: number;
+    /** RAAC base units per second. */
+    perSecond: bigint;
+    /** RAAC base units emitted over the whole week. */
+    weekly: bigint;
+    /** RAAC base units emitted from week 1 through the end of this week. */
+    cumulative: bigint;
+}
+/** Every week of the schedule, 1 through 780, with running totals. The last `cumulative` is the lifetime emission. */
+export declare function getEmissionSchedule(): EmissionWeek[];
+/** Where a moment sits on the schedule. */
+export interface SchedulePosition {
+    /** 0 before activation, above 780 once emissions have ended. */
+    week: number;
+    /** Seconds elapsed in the current week. */
+    secondsIntoWeek: number;
+    perSecond: bigint;
+    /** RAAC base units the schedule allows from activation to `timestamp`, before any MAX_SUPPLY cap. */
+    scheduledToDate: bigint;
+}
+/**
+ * Places a moment on the schedule, e.g. to compare what has been minted with what the schedule allowed.
+ * @param activationTimestamp `mintingStartAtTimestamp`, in UNIX seconds.
+ * @param timestamp The moment to place, in UNIX seconds.
+ */
+export declare function getSchedulePosition(activationTimestamp: number, timestamp: number): SchedulePosition;

package/dist/types/nfts/getNFTBalance.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Get how many tokens of an NFT contract an address holds
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param owner - The address to check
+ * @param provider - The provider to use for the contract call
+ * @returns The number of tokens held
+ */
+declare function getNFTBalance(chainId: ChainId, nftContractName: NftContractNames, owner: string, provider: Provider): Promise<bigint>;
+export default getNFTBalance;

package/dist/types/nfts/getPriceStaleness.d.ts

@@ -0,0 +1,22 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+/**
+ * Reads RAACNFT's `PRICE_STALENESS_THRESHOLD`, the maximum age of a house price that `mint` accepts. The variable has
+ * no getter, so it is read from storage slot 18, trusted only when the neighbouring slots match `token()`,
+ * `TRADE_FEE_PERCENTAGE()` and `feeCollector()` (the layout is as expected).
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @returns The threshold in seconds (0 turns the check off), or null when the storage layout could not be confirmed.
+ */
+declare function getPriceStalenessThreshold(chainId: ChainId, provider: Provider): Promise<number | null>;
+/**
+ * Whether RAACNFT's `mint` would reject a house price as stale (`StalePriceData`), as `_validatePriceFreshness` decides:
+ * a price never set, or older than the threshold when the threshold is not 0. Only minting checks this; the lending
+ * pool's NFT adapter values collateral at the price whatever its age.
+ * @param priceTimestamp Unix seconds of the house price update; 0 when never priced.
+ * @param threshold `getPriceStalenessThreshold` in seconds.
+ * @param now Unix seconds to judge at, normally the latest block's timestamp.
+ * @returns True when a mint of this token would revert with `StalePriceData`.
+ */
+export declare function isHousePriceStale(priceTimestamp: number, threshold: number, now: number): boolean;
+export default getPriceStalenessThreshold;

package/dist/types/nfts/transferNFT.d.ts

@@ -0,0 +1,15 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Transfer an NFT from the signer to another address with safeTransferFrom
+ * Do not use it to put a Bot NFT into the bot locker: the locker only records NFTs deposited through `lockers.botLocker.lock`.
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param to - The recipient address
+ * @param tokenId - The token ID to transfer
+ * @param signer - The signer that owns the token
+ * @returns Transaction receipt
+ */
+declare function transferNFT(chainId: ChainId, nftContractName: NftContractNames, to: string, tokenId: string | number | bigint, signer: Signer): Promise<ethers.ContractTransactionReceipt>;
+export default transferNFT;

package/dist/types/pools/lendingPool/adapters/erc20/getERC20AdapterBalance.d.ts

@@ -1,4 +1,4 @@
-import { Signer } from "ethers";
+import { Provider, Signer } from "ethers";
 import { ChainId } from "../../../../configs/chains";
 import { TokenAmount } from "../../../../utils/amount";
 /**
@@ -6,8 +6,8 @@ import { TokenAmount } from "../../../../utils/amount";
  * @param chainId The chain id, used to look up the adapter token's decimals in the token registry.
  * @param adapterAddress The ERC20 asset adapter address.
  * @param userAddress The user.
- * @param signer The signer to read with.
+ * @param runner The signer or provider to read with. A read-only provider is enough.
  * @returns The deposited balance in base units of the adapter's token, with its registry decimals and symbol (18 decimals if the token is not in the registry).
  */
-declare function getERC20AdapterBalance(chainId: ChainId, adapterAddress: string, userAddress: string, signer: Signer): Promise<TokenAmount>;
+declare function getERC20AdapterBalance(chainId: ChainId, adapterAddress: string, userAddress: string, runner: Signer | Provider): Promise<TokenAmount>;
 export default getERC20AdapterBalance;

package/dist/types/pools/lendingPool/getAdminState.d.ts

@@ -0,0 +1,26 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** The lending pool's pause state, linked contracts, collateral adapters and reserve tokens. */
+export interface LendingPoolAdminState {
+    paused: boolean;
+    primeRateOracle: string;
+    stabilityPool: string;
+    liquidationProxy: string;
+    /** The yield vault; the zero address when none is set. */
+    vault: string;
+    feeCollector: string;
+    /** Collateral adapters registered on the pool (`getAdapters()`). */
+    adapters: string[];
+    /** The asset depositors supply. */
+    reserveAsset: string;
+    rToken: string;
+    debtToken: string;
+}
+/**
+ * Reads what an operator administers on the lending pool, next to `getParameters` (risk and fee values) and
+ * `getLendingPoolInfo` (liquidity and rates).
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getAdminState(chainId: ChainId, provider: Provider): Promise<LendingPoolAdminState>;
+export default getAdminState;

package/dist/types/pools/rwaVault/adapters/erc721/getERC721VaultAdapterAssetValue.d.ts

@@ -5,7 +5,7 @@ import { TokenAmount } from "../../../../utils/amount";
  * @param adapterAddress The ERC721 vault adapter address.
  * @param tokenId The NFT token id.
  * @param signer The signer to read with.
- * @returns The oracle value in crvUSD base units, 18 decimals.
+ * @returns The oracle value in USD, 18 decimals.
  */
 declare function getERC721VaultAdapterAssetValue(adapterAddress: string, tokenId: bigint, signer: Signer): Promise<TokenAmount>;
 export default getERC721VaultAdapterAssetValue;

package/dist/types/pools/rwaVault/adapters/erc721/getERC721VaultAdapterTotalValue.d.ts

@@ -4,7 +4,7 @@ import { TokenAmount } from "../../../../utils/amount";
  * Reads the value of all NFTs held by an ERC721 vault adapter.
  * @param adapterAddress The ERC721 vault adapter address.
  * @param signer The signer to read with.
- * @returns The summed oracle value in crvUSD base units, 18 decimals.
+ * @returns The summed oracle value in USD, 18 decimals.
  */
 declare function getERC721VaultAdapterTotalValue(adapterAddress: string, signer: Signer): Promise<TokenAmount>;
 export default getERC721VaultAdapterTotalValue;

package/dist/types/pools/rwaVault/checkRedeemEligibility.d.ts

@@ -0,0 +1,15 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+export type RedeemEligibilityReason = "no-draw" | "kyc" | "not-redeemable" | "insufficient-shares" | "other";
+export interface RedeemEligibility {
+    eligible: boolean;
+    reason?: RedeemEligibilityReason;
+    adapter?: string;
+    tokenId?: string;
+}
+/**
+ * Simulates a redeem (via `staticCall`, no transaction sent) to determine
+ * whether `account` can currently redeem an NFT from the RWA vault, reading
+ * the revert name from each simulated call to classify why not, when not.
+ */
+export declare function checkRedeemEligibility(chainId: ChainId, account: string, maxSharesBurn: bigint, provider?: Provider): Promise<RedeemEligibility>;

package/dist/types/pools/rwaVault/getRWAVaultInfo.d.ts

@@ -1,7 +1,7 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
 import { TokenAmount } from "../../utils/amount";
-/** RWA vault state. Values are in crvUSD base units with 18 decimals, as priced by the vault adapters. */
+/** RWA vault state. Values are the sum of the adapters' values, 18 decimals: USD for the house NFT adapter (crvUSD for any ERC20 adapter). */
 export interface RWAVaultInfo {
     /** Total value of all assets held by the vault. */
     totalAssets: TokenAmount;

package/dist/types/pools/rwaVault/getRegisteredAdapters.d.ts

@@ -0,0 +1,33 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/** One adapter registered on the RWA vault, as the vault itself reports it. */
+export interface RegisteredVaultAdapter {
+    address: string;
+    /** `getAssetType()`: "ERC721" or "ERC20"; "unknown" when the adapter could not be read. */
+    type: string;
+    /** The asset the adapter holds: the NFT collection or the ERC20 token. */
+    token: string;
+    tokenSymbol: string;
+    /** 0 for NFTs. */
+    tokenDecimals: number;
+    /** Listed in `depositableAdapters`. */
+    depositable: boolean;
+    /** Listed in `redeemableERC721Adapters`. */
+    redeemable: boolean;
+    /** Oracle value of everything held, 18 decimals: USD for NFT adapters (RAACNFTVaultAdapterOracle), crvUSD for ERC20 adapters (their price oracle); null when the adapter could not price it. */
+    value: TokenAmount | null;
+    /** Token ids held, for ERC721 adapters. */
+    tokenIds: bigint[];
+    /** Set when the adapter itself could not be read; the other asset fields are then placeholders. */
+    error?: string;
+}
+/**
+ * Every adapter registered on the RWA vault, read from the vault's own arrays rather than the chain config (which
+ * `getAdapters` returns), with deposit and redemption flags and what each adapter holds. One adapter failing to read
+ * gives a row with `error` instead of failing the whole list.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getRegisteredAdapters(chainId: ChainId, provider: Provider): Promise<RegisteredVaultAdapter[]>;
+export default getRegisteredAdapters;

package/dist/types/pools/rwaVault/getSeedStatus.d.ts

@@ -0,0 +1,27 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** Where the RWA vault's randomness request stands. */
+export interface SeedStatus {
+    /** The VRF consumer the vault uses; the zero address when none is set (requests then revert). */
+    consumer: string;
+    /** UNIX seconds of the last request, 0 if never. */
+    lastRequest: number;
+    /** UNIX seconds of the last fulfilment, 0 if never. */
+    lastFulfil: number;
+    /** A request exists and has not been fulfilled yet. */
+    pending: boolean;
+    /** Seconds after which a pending request may be replaced (`MAX_STALL`). */
+    maxStall: number;
+    /** Seconds required between the last fulfilment and a new public request (`vrfRequestDelay`). */
+    delay: number;
+    /** Whether anyone may call `requestRandomSeed` (`allowVRFRequest`). */
+    allowed: boolean;
+}
+/**
+ * Reads the RWA vault's VRF consumer: the last request and fulfilment and the stall window, plus the vault's own
+ * request rules. With no consumer set, the time fields are 0.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getSeedStatus(chainId: ChainId, provider: Provider): Promise<SeedStatus>;
+export default getSeedStatus;

package/dist/types/pools/rwaVault/previewDeposit.d.ts

@@ -4,7 +4,7 @@ import { TokenAmount } from "../../utils/amount";
 /**
  * Previews how many vault shares are minted for depositing `assetValue`.
  * @param chainId The chain id.
- * @param assetValue The asset value in vault value base units (crvUSD, 18 decimals, as returned by the vault adapters).
+ * @param assetValue The asset value in vault value base units (USD for house NFTs, 18 decimals, as returned by the vault adapters).
  * @param provider The provider to read with.
  * @returns The shares (rounded down), in share token (RWA index token) base units.
  */

package/dist/types/pools/rwaVault/previewWithdraw.d.ts

@@ -4,7 +4,7 @@ import { TokenAmount } from "../../utils/amount";
 /**
  * Previews how many vault shares are burned to withdraw `assetValue`.
  * @param chainId The chain id.
- * @param assetValue The asset value in vault value base units (crvUSD, 18 decimals, as returned by the vault adapters).
+ * @param assetValue The asset value in vault value base units (USD for house NFTs, 18 decimals, as returned by the vault adapters).
  * @param provider The provider to read with.
  * @returns The shares (rounded up), in share token (RWA index token) base units.
  */

package/dist/types/pools/stabilityPool/getAdminState.d.ts

@@ -0,0 +1,25 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+import type { LiquidationSplit } from "./liquidation";
+export interface StabilityPoolState {
+    owner: string;
+    paused: boolean;
+    managers: string[];
+    rwaVault: string;
+    liquidationStrategyProxy: string;
+    liquidationSwap: string;
+    feeCollector: string;
+    split: LiquidationSplit;
+    /** Seconds a withdrawal request waits before it can be withdrawn. */
+    withdrawTimelockDuration: number;
+    /** Seconds a ready request stays valid. */
+    withdrawTimelockDelay: number;
+}
+/**
+ * Owner, pause state, managers, linked contracts, liquidation split and withdraw timelock.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @throws When the configured address has no contract, which the generic decode error would hide.
+ */
+declare function getAdminState(chainId: ChainId, provider: Provider): Promise<StabilityPoolState>;
+export default getAdminState;

package/dist/types/pools/stabilityPool/getWithdrawTimelockConfig.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+export interface WithdrawTimelockConfig {
+    /** Seconds after a withdraw request before it's ready. */
+    duration: number;
+    /** Seconds a ready request stays valid before it expires. */
+    delay: number;
+}
+/**
+ * Reads the stability pool's withdraw timelock configuration. The pool's
+ * actual enforced window for a given request is `readyAt + delay` (see
+ * `getWithdrawRequestInfo`'s `readyAt`), not `withdrawTimelock(user).expireAt`.
+ */
+export declare function getWithdrawTimelockConfig(chainId: ChainId, provider?: Provider): Promise<WithdrawTimelockConfig>;

package/dist/types/pools/stabilityPool/liquidation.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Liquidation simulation for StabilityPool.liquidateBorrower, mirroring LiquidationStrategyProxy:
+ *   1. the seized collateral is deposited into the RWAVault for vault-token shares, unless it already is the vault token;
+ *   2. the stability pool's whole vault-token balance (the proxy runs under delegatecall) is split by BPS into
+ *      mint (treasury fee), burn, swap and liquidity (fee collector);
+ *   3. only the swap slice becomes crvUSD, through LiquidationSwap and its Curve pool;
+ *   3b. LiquidationSwap reverts when slippage protection is on and get_dy falls below pricePerShare / oracle price
+ *       less its tolerance, which is the case when Curve trades below the vault's value;
+ *   4. the crvUSD must cover the position's debt; any shortfall is withdrawn from the LendingPool with the pool's
+ *      rTokens, so stability pool depositors pay it, and the call reverts (InsufficientBalance) if they hold too few.
+ */
+import { type Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** The four shares of the vault-token balance, in basis points; they must add up to 10_000. */
+export interface LiquidationSplit {
+    mintBps: bigint;
+    burnBps: bigint;
+    swapBps: bigint;
+    liquidityBps: bigint;
+}
+export declare const SPLIT_KEYS: readonly ["mintBps", "burnBps", "swapBps", "liquidityBps"];
+export declare const splitTotal: (s: LiquidationSplit) => bigint;
+export declare const sameSplit: (a: LiquidationSplit, b: LiquidationSplit) => boolean;
+/** The stability pool's liquidation route, read once per review. */
+export interface LiquidationContext {
+    stabilityPool: string;
+    liquidationSwap: string;
+    liquidityPool: string;
+    rwaVault: string;
+    vaultToken: string;
+    vaultSymbol: string;
+    iIn: bigint;
+    iOut: bigint;
+    split: LiquidationSplit;
+    /** Vault tokens already in the stability pool; the split divides these too. */
+    poolVaultTokens: bigint;
+    /** rTokens the stability pool holds, which is the most a swap shortfall can draw from the LendingPool. */
+    rTokens: bigint;
+    /** LendingPool grace period, in seconds, before an insured position can be finalized. */
+    gracePeriod: number;
+    /** LiquidationSwap's own floor: null when protection is off, else pricePerShare / oracle price less its tolerance. */
+    slippage: {
+        bps: bigint;
+        pricePerShare: bigint;
+        oraclePrice: bigint;
+    } | null;
+}
+/** Everything liquidateBorrower needs for one position, plus its state on chain. */
+export interface LiquidationTarget {
+    poolAdapter: string;
+    vaultAdapter: string;
+    user: string;
+    /** abi.encode(uint256): the tokenId for ERC721 collateral, the full deposited amount for ERC20. */
+    data: string;
+    assetType: string;
+    assetToken: string;
+    /** The collateral already is the vault token, so no RWAVault deposit happens. */
+    isVaultToken: boolean;
+    collateralValue: bigint;
+    /** getPositionScaledDebt: the debt with accrued interest, which is what the liquidation repays. */
+    debt: bigint;
+    isUnderLiquidation: boolean;
+    isInsured: boolean;
+    liquidationStartTime: number;
+}
+export interface LiquidationQuote {
+    split: LiquidationSplit;
+    /** Vault tokens this liquidation adds: shares minted for the collateral, or the collateral itself. */
+    sharesFromCollateral: bigint;
+    /** sharesFromCollateral plus the pool's existing balance: what the split divides. */
+    totalVaultTokens: bigint;
+    swapAmount: bigint;
+    /** get_dy from the deployed Curve pool; null when the quote reverted. */
+    swapOut: bigint | null;
+    /** LiquidationSwap's minimum output for swapAmount; null when its slippage protection is off. */
+    minSwapOut: bigint | null;
+    /** Debt the swap does not cover, drawn from depositors' rTokens; the whole debt when the quote reverted. */
+    shortfall: bigint;
+    coversDebt: boolean;
+    /** The collateral is worth less than the debt, so depositors lose whatever the split. */
+    badDebt: bigint;
+    /** get_dy for the whole balance: the most any split can recover. */
+    maxSwapOut: bigint | null;
+    /** How far the realised swap rate falls below the spot rate, in basis points. */
+    priceImpactBps: bigint | null;
+    /** The crvUSD side of the Curve pool; the swap can never return more. */
+    poolReserveOut: bigint | null;
+}
+export interface SuggestedSplit extends LiquidationSplit {
+    projectedOut: bigint;
+    /** No split covers the debt; this is the best effort (100% swap). */
+    bestEffort: boolean;
+}
+/** Reads the stability pool's liquidation route, split, balances and the LendingPool grace period. */
+export declare function readLiquidationContext(chainId: ChainId, provider: Provider): Promise<LiquidationContext>;
+/** Assembles liquidateBorrower's arguments and the position's state for one position id ("user:adapter:key"). */
+export declare function readLiquidationTarget(chainId: ChainId, provider: Provider, ctx: LiquidationContext, positionId: string): Promise<LiquidationTarget>;
+/** Prices the liquidation with `split`, using the deployed Curve pool's get_dy rather than the vault's oracle price. */
+export declare function quoteLiquidation(provider: Provider, ctx: LiquidationContext, target: LiquidationTarget, split: LiquidationSplit): Promise<LiquidationQuote>;
+/**
+ * The smallest swap share whose get_dy still covers the debt plus `bufferBps`, with the rest given back to mint,
+ * burn and liquidity in their current proportion. get_dy grows with dx, so a binary search over BPS is sound.
+ */
+export declare function suggestSplit(provider: Provider, ctx: LiquidationContext, target: LiquidationTarget, quote: LiquidationQuote, bufferBps?: bigint): Promise<SuggestedSplit | null>;
+/** minSharesOut for the RWAVault deposit: previewDeposit less `slippageBps`. Zero when nothing is deposited. */
+export declare const minSharesOut: (target: LiquidationTarget, quote: LiquidationQuote, slippageBps: bigint) => bigint;
+/**
+ * Simulates liquidateBorrower from `sender` with the split overridden in storage (an eth_call state override), so a
+ * split change in the same batch is simulated rather than only checked. Returns null when the RPC or the storage
+ * layout cannot be used; otherwise the revert reason, or "" when it succeeds.
+ */
+export declare function simulateWithSplit(provider: Provider, ctx: LiquidationContext, sender: string, data: string, split: LiquidationSplit): Promise<string | null>;

package/dist/types/prices/computeStakingAPY.d.ts

@@ -0,0 +1,2 @@
+/** Simple staking APY = annualized emission value (RAAC x $) over staked value. */
+export declare function computeStakingAPY(weeklyEmissionRAAC: number, stakedAmount: number, stakingTokenPriceUSD: number): number;

package/dist/types/prices/getCurveLPPriceUSD.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export declare function getCurveLPPriceUSD(chainId: ChainId, token: string, provider?: Provider): Promise<number | null>;

package/dist/types/prices/getPrices.d.ts

@@ -1,12 +1,8 @@
 import { ScaledValue } from "../utils/amount";
-/** Placeholder USD prices per whole token, each scaled by 1e18. */
-export interface Prices {
-    pmUSD: ScaledValue;
-    crvUSD: ScaledValue;
-    raac: ScaledValue;
-}
+/** USD price per whole token, each scaled by 1e18, keyed by lowercase symbol. */
+export type Prices = Record<string, ScaledValue>;
 /**
- * Returns the USD price of each token.
- * @returns The prices, each a USD price per whole token scaled by 1e18.
+ * Returns the static USD price of each known token.
+ * @returns The prices, each a USD price per whole token scaled by 1e18, keyed by lowercase symbol.
  */
 export declare const getPrices: () => Promise<Prices>;

package/dist/types/prices/getStakingTokenPriceUSD.d.ts

@@ -0,0 +1,16 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface StakingTokenLike {
+    stakingToken?: string;
+    stakingTokenSymbol?: string;
+    wrapped?: boolean;
+    wrapper?: string;
+    underlyingSymbol?: string;
+}
+/**
+ * USD value of one unit of a gauge's staking token:
+ *  - wrapped gauges -> ERC4626 wrapper share price (underlying reserve token value),
+ *  - Curve-LP staking tokens -> LP price from pool reserves,
+ *  - otherwise -> static price by symbol.
+ */
+export declare function getStakingTokenPriceUSD(chainId: ChainId, gauge: StakingTokenLike, provider?: Provider): Promise<number>;

package/dist/types/prices/getWrapperPriceUSD.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+/**
+ * USD value of one ERC4626 wrapper share = assets-per-share x underlying price
+ * (e.g. a wrapped RToken share -> its reserve token per share x that token's price).
+ */
+export declare function getWrapperPriceUSD(chainId: ChainId, wrapper: string, underlyingSymbol?: string, provider?: Provider): Promise<number>;

package/dist/types/prices/tokenPricesUSD.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical static USD price per whole token, by lowercase symbol. Testnet
+ * placeholder values - swap for a real oracle/feed in production.
+ */
+export declare const TOKEN_PRICES_USD: Record<string, number>;
+/** Static USD price for a token symbol (0 if unknown). */
+export declare function getTokenPriceUSD(symbol?: string): number;

package/dist/types/scripts/generateErrorCatalogue.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Generates generated/errors.json: one entry per (contract, error) pair, with
+ * an AI-drafted title/message, meant for human review in the PR that
+ * regenerates it. See rpc#16.
+ *
+ * Keeps one entry per contract, keyed `${ContractType}:${selector}` - the
+ * same ContractType key findContract/RpcError already use - rather than
+ * collapsing same-named errors from different contracts into one entry,
+ * which was the root cause of rpc#16's "contract" field problem.
+ *
+ * Needs a checkout of the sibling `contracts` repo (../contracts relative to
+ * this repo) for Solidity source/NatSpec, and ANTHROPIC_API_KEY in .env. Not
+ * part of `npm run build` - run by hand, output committed and reviewed like
+ * any other code.
+ *
+ * Run:
+ *   npm run generate:catalogue
+ */
+import { ContractType } from "../utils/artifacts";
+interface ErrorEntry {
+    contractType: ContractType;
+    contractName: string;
+    sourceName: string;
+    name: string;
+    signature: string;
+    selector: string;
+    inputs: {
+        name: string;
+        type: string;
+    }[];
+}
+interface ErrorContext {
+    natspec: string | null;
+    usageSnippets: string[];
+}
+export declare function collectErrors(): ErrorEntry[];
+/**
+ * NatSpec immediately above the `error` declaration, if any, plus every
+ * `revert ErrorName(` usage found anywhere in the file. Errors are not always
+ * declared near their revert sites (RWAVault.sol declares 5 at the end of the
+ * file while they're thrown 300+ lines earlier), so usage is gathered
+ * file-wide, independent of where the declaration sits.
+ */
+export declare function extractContext(sourceName: string, errorName: string): ErrorContext;
+export {};