@raac/rpc 2.0.0-beta.1 → 2.0.0-beta.10

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

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Buys ZENO: spends exactly `paymentAmount` of the payment token, sent to the issuer, at the price of the block it is
+ * mined in. Needs a payment token allowance for the auction (`wallet.assets.approveAsset`). Reverts while paused,
+ * outside the auction window, when the ZENO out would exceed what is left, or when it is below `minZenoOut`.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param paymentAmount Payment token to spend, in base units.
+ * @param minZenoOut The least ZENO to accept, in ZENO base units; `quoteBuy` sizes it.
+ * @param signer The buyer, who receives the ZENO.
+ * @returns The transaction receipt; its `ZENOPurchased` log carries the ZENO minted and the price paid.
+ */
+declare function buy(chainId: ChainId, auction: string, paymentAmount: bigint, minZenoOut: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default buy;

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

@@ -1,17 +1,27 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
+/** How an auction's ZENO is backed by the underlying asset. Mirrors `IAuction.FundingMode`. */
+export declare enum FundingMode {
+    /** The ZENO must already hold underlying for the full allocation. */
+    Prefilled = 0,
+    /** The issuer tops up the underlying before maturity. */
+    Float = 1
+}
 /**
- * Creates a ZENO auction through the AuctionFactory.
+ * Creates a ZENO auction through the AuctionFactory. Only the factory owner can call this.
  * @param chainId The chain id.
  * @param zenoAddress The ZENO bond token sold.
- * @param usdcAddress The payment token bidders pay with.
- * @param businessAddress The issuer receiving the proceeds.
+ * @param tokenAddress The payment token bidders pay with.
+ * @param issuer The issuer receiving the proceeds.
  * @param auctionStartTime UNIX timestamp (seconds) the auction starts.
  * @param auctionEndTime UNIX timestamp (seconds) the auction ends.
  * @param startingPrice The Dutch auction starting price, in payment token base units per whole ZENO.
  * @param reservePrice The Dutch auction reserve price, in payment token base units per whole ZENO.
  * @param totalZenoAllocated The ZENO offered, in ZENO base units.
- * @param signer The signer sending the transaction.
+ * @param fundingMode How the ZENO is backed; `Prefilled` requires the ZENO to hold underlying for the full allocation.
+ * @param initialOwner The owner of the new auction.
+ * @param signer The factory owner.
+ * @returns The address of the new auction.
  */
-declare function createAuction(chainId: ChainId, zenoAddress: string, usdcAddress: string, businessAddress: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, signer: Signer): Promise<void>;
+declare function createAuction(chainId: ChainId, zenoAddress: string, tokenAddress: string, issuer: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, fundingMode: FundingMode, initialOwner: string, signer: Signer): Promise<string>;
 export default createAuction;

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

@@ -1,4 +1,13 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function createZeno(chainId: ChainId, usdcAddress: string, maturityDate: string, signer: Signer): Promise<string>;
+/**
+ * Creates a ZENO bond through the ZENOFactory. Only the factory owner can call this.
+ * @param chainId The chain id.
+ * @param tokenAddress The underlying asset the bond redeems for.
+ * @param maturityDate UNIX timestamp (seconds) the bond matures. Must be in the future.
+ * @param initialOwner The owner of the new bond, typically the auction or a multisig.
+ * @param signer The factory owner.
+ * @returns The address of the new ZENO bond.
+ */
+declare function createZeno(chainId: ChainId, tokenAddress: string, maturityDate: bigint, initialOwner: string, signer: Signer): Promise<string>;
 export default createZeno;

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

@@ -0,0 +1,45 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
+/** A ZENO auction's terms and live state. Prices take the payment token's decimals, ZENO amounts the underlying's. */
+export interface AuctionState {
+    /** The auction contract. */
+    auction: string;
+    /** The ZENO bond it sells. */
+    zeno: string;
+    /** What buyers pay with. */
+    paymentToken: string;
+    /** Receives every payment. */
+    issuer: string;
+    fundingMode: FundingMode;
+    /** UNIX timestamp (seconds) buying opens. */
+    startTime: bigint;
+    /** UNIX timestamp (seconds) buying closes, unless it sells out first. */
+    endTime: bigint;
+    /** Price at `startTime`, in payment token base units per whole ZENO. */
+    startingPrice: TokenAmount;
+    /** Price at and after `endTime`; equal to `startingPrice` for a fixed-price bond. */
+    reservePrice: TokenAmount;
+    /** True when the price does not decay. */
+    isFixedPrice: boolean;
+    /** `getPrice()` as of the block read. A Dutch price keeps falling every block, also while paused. */
+    price: TokenAmount;
+    /** ZENO on offer. */
+    totalAllocated: TokenAmount;
+    /** ZENO not yet sold; `buy` reverts when it would mint more. */
+    totalRemaining: TokenAmount;
+    /** True while `buy` is halted by the pauser. */
+    paused: boolean;
+    /** True once past `endTime` or sold out, as `checkAuctionEnded()` says. */
+    ended: boolean;
+}
+/**
+ * Reads one auction's terms and live state.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The auction's state.
+ */
+declare function getAuctionState(chainId: ChainId, auction: string, provider?: Provider): Promise<AuctionState>;
+export default getAuctionState;

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

@@ -1,14 +1,17 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
 import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
 /** A ZENO auction, with its amounts in base units. */
 export interface AuctionDetails {
     /** The auction contract address. */
     auctionAddress: string;
     /** The ZENO bond token sold. */
     zenoAddress: string;
+    /** The payment token bidders pay with. */
+    tokenAddress: string;
     /** The issuer receiving the proceeds. */
-    businessAddress: string;
+    issuer: string;
     /** UNIX timestamp (seconds) the auction starts. */
     auctionStartTime: bigint;
     /** UNIX timestamp (seconds) the auction ends. */
@@ -23,19 +26,16 @@ export interface AuctionDetails {
     totalZENOAllocated: TokenAmount;
     /** ZENO still unsold, in ZENO base units. */
     totalZENORemaining: TokenAmount;
-    /** UNIX timestamp (seconds) of the last bid. */
-    lastBidTime: bigint;
-    /** The address of the last bidder. */
-    lastBidder: string;
-    /** The last bid, in payment token base units. */
-    lastBidAmount: TokenAmount;
+    /** How the auction's ZENO is backed by the underlying asset. */
+    fundingMode: FundingMode;
 }
 /**
  * Lists every auction created by the AuctionFactory.
  * @param chainId The chain id.
- * @param signer The signer to read with.
- * @returns One record per auction. Price and bid amounts use the auction's payment token, ZENO amounts the ZENO
- * token; decimals and symbols come from the chain config registry and fall back to 18 when the token is not listed.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO's underlying,
+ * whose decimals ZENO shares; decimals and symbols come from the chain config registry and fall back to 18 when the
+ * token is not listed.
  */
-declare function getAuctions(chainId: ChainId, signer: Signer): Promise<AuctionDetails[]>;
+declare function getAuctions(chainId: ChainId, provider?: Provider): Promise<AuctionDetails[]>;
 export default getAuctions;

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

@@ -0,0 +1,42 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond's live state. ZENO amounts take the underlying's decimals. */
+export interface BondState {
+    /** The ZENO bond contract. */
+    zeno: string;
+    /** ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** What 1 ZENO redeems for at maturity. */
+    underlying: string;
+    /** The auction bound by `setAuction`, the only one that can mint; null until it is set. */
+    auction: string | null;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** True once maturity has passed. Redemption also needs `isFunded`. */
+    isRedeemable: boolean;
+    /** ZENO minted over the bond's lifetime; never falls. */
+    totalMinted: TokenAmount;
+    /** ZENO outstanding, still to be redeemed. */
+    totalSupply: TokenAmount;
+    /** ZENO redeemed for the underlying. */
+    totalRedeemed: TokenAmount;
+    /** Underlying held by the ZENO, in the underlying's base units. */
+    collateral: TokenAmount;
+    /** Underlying above outstanding supply, which the owner may sweep once the auction has ended. */
+    sweepableSurplus: TokenAmount;
+    /** True when collateral covers outstanding supply. `redeem` reverts with `InsufficientCollateral` while it is false, which only a Float bond the issuer has not topped up can reach. */
+    isFunded: boolean;
+}
+/**
+ * Reads a ZENO bond's live state: supply, collateral and whether it can be redeemed. Collateral is read here rather
+ * than indexed, because top-ups are plain transfers on the underlying that no ZENO event records.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The bond's state.
+ */
+declare function getBondState(chainId: ChainId, zeno: string, provider?: Provider): Promise<BondState>;
+export default getBondState;

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

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads an auction's current price. Read it right before `buy` to size `minZenoOut`: a Dutch price falls every block.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The price in payment token base units per whole ZENO.
+ */
+declare function getPrice(chainId: ChainId, auction: string, provider?: Provider): Promise<TokenAmount>;
+export default getPrice;

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

@@ -1,4 +1,27 @@
-import { Signer } from "ethers";
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getZenos(chainId: ChainId, signer: Signer): Promise<any[]>;
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond, with its amounts in base units. */
+export interface ZenoDetails {
+    /** The ZENO bond contract address. */
+    zenoAddress: string;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** The bond's ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** The bond's ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** ZENO minted over the bond's lifetime, in ZENO base units. */
+    totalMinted: TokenAmount;
+    /** ZENO redeemed for the underlying, in ZENO base units. */
+    totalRedeemed: TokenAmount;
+}
+/**
+ * Lists every ZENO bond created by the ZENOFactory.
+ * @param chainId The chain id.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per bond. ZENO shares its underlying's decimals, so amounts take the underlying's from the chain
+ * config registry and fall back to 18 when it is not listed.
+ */
+declare function getZenos(chainId: ChainId, provider?: Provider): Promise<ZenoDetails[]>;
 export default getZenos;

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

@@ -0,0 +1,22 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Grants an auction role, e.g. PAUSER_ROLE to a guardian bot. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to grant it to.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function grantRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Revokes an auction role. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to revoke it from.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function revokeRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

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

@@ -0,0 +1,18 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Halts `buy` on an auction. PAUSER_ROLE only. A Dutch price keeps falling while paused.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A PAUSER_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function pause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Resumes `buy` on an auction. DEFAULT_ADMIN_ROLE only, so a compromised pauser cannot reopen buying.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function unpause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

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

@@ -0,0 +1,20 @@
+/** The auction terms that set its price. All values as the contract stores them. */
+export interface AuctionPriceTerms {
+    /** UNIX timestamp (seconds). */
+    startTime: bigint;
+    /** UNIX timestamp (seconds). */
+    endTime: bigint;
+    /** Payment token base units per whole ZENO. */
+    startingPrice: bigint;
+    /** Payment token base units per whole ZENO. */
+    reservePrice: bigint;
+}
+/**
+ * An auction's price at `now`, computed locally without an RPC call. Mirrors `Auction.getPrice()` exactly, truncating
+ * division included: the starting price before the window, the reserve from `endTime` on, a linear fall between.
+ *
+ * @param terms The auction's price terms, e.g. from `getAuctionState` or the subgraph's `BondAuction`.
+ * @param now UNIX timestamp (seconds). Use the latest block timestamp to match the contract exactly.
+ * @returns The price in payment token base units per whole ZENO.
+ */
+export declare const priceAt: (terms: AuctionPriceTerms, now: bigint) => bigint;

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/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/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/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/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/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 {};

package/dist/types/typechain-types/@openzeppelin/contracts/index.d.ts

@@ -2,6 +2,8 @@ import type * as access from "./access";
 export type { access };
 import type * as interfaces from "./interfaces";
 export type { interfaces };
+import type * as proxy from "./proxy";
+export type { proxy };
 import type * as token from "./token";
 export type { token };
 import type * as utils from "./utils";