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

package/dist/types/contracts/lockers/botLocker/getRoles.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerRoles {
+    /** Grants and revokes roles, and calls `rescueTokens`. */
+    defaultAdminRole: string;
+    /** Calls `pause` and `unpause`. */
+    pauserRole: string;
+    /** Calls `addRewardTokens`. */
+    managerRole: string;
+    /** Calls `distributeRewardToken`; held by RAACLiquidLocker. */
+    distributorRole: string;
+}
+/**
+ * Gets the access-control role identifiers used by the bot locker.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The bytes32 role identifiers.
+ */
+export declare const getRoles: (chainId: ChainId, provider?: Provider) => Promise<BotLockerRoles>;

package/dist/types/contracts/lockers/botLocker/getUnlockWindow.d.ts

@@ -0,0 +1,24 @@
+/** EPOCH_DURATION on RAACBotLocker, seconds. */
+export declare const BOT_LOCKER_EPOCH_DURATION: number;
+/** LOCK_DURATION_IN_EPOCH on RAACBotLocker. */
+export declare const BOT_LOCKER_LOCK_DURATION_EPOCHS = 4;
+export interface BotLockerUnlockWindow {
+    /** True when `now` is inside an unlock window. */
+    unlockable: boolean;
+    /** Start of the current window when unlockable, otherwise of the next one, unix seconds. */
+    opensAt: number;
+    /** End (exclusive) of that window, unix seconds. */
+    closesAt: number;
+}
+/**
+ * Unlock window of a locked NFT, computed locally without an RPC call.
+ *
+ * The contract allows `unlockAndClaim` when `floor((now - lockedAt) / epochDuration)` is a non-zero multiple of `lockDurationEpochs`, so windows are `[lockedAt + k * cycle, lockedAt + k * cycle + epochDuration)` for `k >= 1`, where `cycle = lockDurationEpochs * epochDuration`. They are relative to each NFT's own `lockedAt`, not to a global epoch, and a missed window reopens one cycle later.
+ *
+ * @param lockedAt - Lock timestamp of the NFT, unix seconds (`locks(tokenId).lockedAt`, or `lockedAt` from the subgraph).
+ * @param now - Current time, unix seconds. Use the latest block timestamp to match the contract exactly.
+ * @param epochDuration - Epoch length, seconds. Defaults to the contract constant.
+ * @param lockDurationEpochs - Epochs per lock cycle. Defaults to the contract constant.
+ * @returns Whether the NFT can unlock now and the bounds of the current or next window.
+ */
+export declare const getUnlockWindow: (lockedAt: number, now: number, epochDuration?: number, lockDurationEpochs?: number) => BotLockerUnlockWindow;

package/dist/types/contracts/lockers/botLocker/grantRole.d.ts

@@ -0,0 +1,20 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Grant a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to grant the role to.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const grantRole: (chainId: ChainId, role: string, account: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+/**
+ * Revoke a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to revoke the role from.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const revokeRole: (chainId: ChainId, role: string, account: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/hasRole.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Checks whether an account holds a bot locker role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to check.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns True if the account holds the role.
+ */
+export declare const hasRole: (chainId: ChainId, role: string, account: string, provider?: Provider) => Promise<boolean>;

package/dist/types/contracts/lockers/botLocker/pause.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/** Pause lock, unlockAndClaim and claim. PAUSER_ROLE only. */
+export declare const pause: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+/** PAUSER_ROLE only. */
+export declare const unpause: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/rescueTokens.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Send the locker's entire balance of `token` to `recipient`. DEFAULT_ADMIN_ROLE only.
+ * This includes rewards lockers have not claimed yet, so later claims of that token revert until it is refilled.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - ERC20 address to rescue.
+ * @param recipient - Address receiving the balance.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const rescueTokens: (chainId: ChainId, token: string, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/liquidLocker/getUnlockSchedule.d.ts

@@ -0,0 +1,23 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+export interface LockerUnlockEpoch {
+    /** UNIX seconds the epoch ends and its RAAC moves from locked to withdrawable. */
+    epochEnd: number;
+    /** `epochEnd / 7 days`, the epoch number the locker and veRAAC use. */
+    epoch: number;
+    /** RAAC that unlock requests scheduled for this epoch end. */
+    amount: TokenAmount;
+    /** The end has passed but the locker has not processed it yet; the next deposit, unlock or harvest does. */
+    due: boolean;
+}
+/**
+ * The RAAC scheduled to unlock from the liquid locker, by epoch: every entry of `epochEnds` from `processedEpochIndexes`
+ * on, with its `epochEndToLockAmount`. Processed epochs are left out (their RAAC is already withdrawable); an entry
+ * whose end has passed but is not processed yet is marked `due`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Pending epochs in the order the locker schedules them, soonest first.
+ */
+export declare const getUnlockSchedule: (chainId: ChainId, provider?: Provider) => Promise<LockerUnlockEpoch[]>;

package/dist/types/contracts/lockers/liquidLocker/hasHarvestRole.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Checks whether `account` holds `HARVEST_ROLE` on the liquid locker - distinct
+ * from `isKeeper`, since `harvest()` is gated by `onlyRole(HARVEST_ROLE)`, not
+ * `onlyKeeper`.
+ */
+export declare const hasHarvestRole: (chainId: ChainId, account: string, provider?: Provider) => Promise<boolean>;

package/dist/types/contracts/psm/_helpers.d.ts

@@ -0,0 +1,18 @@
+import { ethers, Provider, Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { PsmVaultEntry } from "../../configs/chains/chain";
+import { PSMVault } from "../../typechain-types/psm/PSMVault";
+import { RateProvider } from "../../typechain-types/psm/RateProvider";
+/**
+ * Resolves a PSM vault entry by its config key (any casing) or its deployed
+ * address, since callers may have either on hand.
+ */
+export declare function resolvePsmVault(chainId: ChainId, vaultKeyOrAddress: string): {
+    key: string;
+    entry: PsmVaultEntry;
+};
+export declare function getPsmVaultContract(chainId: ChainId, vaultKeyOrAddress: string, providerOrSigner?: Provider | Signer): PSMVault;
+export declare function getPsmRateProviderContract(chainId: ChainId, vaultKeyOrAddress: string, providerOrSigner?: Provider | Signer): RateProvider;
+export declare function getDefaultProvider(chainId: ChainId): Provider;
+export declare function getTokenReaderContract(address: string, providerOrSigner?: Provider | Signer): ethers.Contract;
+export declare function getModuleContract(address: string, providerOrSigner?: Provider | Signer): ethers.Contract;

package/dist/types/contracts/psm/cancelExit.d.ts

@@ -0,0 +1,4 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** Cancels a pending exit request from a PSM vault. */
+export declare function cancelExit(chainId: ChainId, vaultKeyOrAddress: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/deposit.d.ts

@@ -0,0 +1,9 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Deposits savings token into a PSM vault for shares.
+ * @param savingsAmount The amount to deposit, in savings token base units.
+ * @param minSharesOut The minimum shares to accept, in share base units.
+ * @param receiver The address to receive the shares.
+ */
+export declare function deposit(chainId: ChainId, vaultKeyOrAddress: string, savingsAmount: bigint, minSharesOut: bigint, receiver: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/getVaultInfo.d.ts

@@ -0,0 +1,77 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount, ScaledValue } from "../../utils/amount";
+export interface PsmVaultUserInfo {
+    shareBalance: TokenAmount;
+    savingsTokenBalance: TokenAmount;
+    baseAssetBalance: TokenAmount;
+    redeemRequest: {
+        shares: TokenAmount;
+        exitTime: number;
+    };
+    savingsTokenAllowance: TokenAmount;
+    baseAssetAllowance: TokenAmount;
+}
+export interface PsmVaultInfo {
+    totalAssets: TokenAmount;
+    totalSupply: TokenAmount;
+    depositCap: TokenAmount;
+    /** Basis points (of 10_000). */
+    swapFee: bigint;
+    /** Basis points (of 10_000), the fee that currently applies given the vault's reserve ratio. */
+    computeWithdrawFee: bigint;
+    /** Seconds a redeem request must wait before it's claimable. */
+    withdrawTime: number;
+    /** Seconds after `withdrawTime` a ready request stays claimable before it expires. */
+    withdrawTimeLimit: number;
+    /** pmUSD released per second while a donation streams in. */
+    dripRate: TokenAmount;
+    /** Unix timestamp the current reward stream finishes. */
+    dripEnd: number;
+    /** Reward pmUSD not yet streamed into `totalAssets`. */
+    pendingRewards: TokenAmount;
+    vaultComposition: {
+        baseAssetValue: TokenAmount;
+        savingsTokenValue: TokenAmount;
+        total: TokenAmount;
+    };
+    /** Basis points (of 10_000). */
+    minWithdrawFee: bigint;
+    /** Basis points (of 10_000). */
+    maxWithdrawFee: bigint;
+    rebalancer: string;
+    /** Null when the vault has no base asset module configured. */
+    baseAssetModule: string | null;
+    /** Minimum pmUSD balance (excl. pendingRewards) to trigger a rebalance. */
+    rebalanceThreshold: TokenAmount;
+    /** 18-decimal ratio, e.g. 0.20e18 = 20%. */
+    reserveRatioFloor: ScaledValue;
+    /** Seconds a donation's rewards stream in over. */
+    dripDuration: number;
+    paused: boolean;
+    circuitBreakerEnabled: boolean;
+    /** 18-decimal NAV floor from the base asset's NAV oracle. */
+    navFloor: ScaledValue;
+    /** Address of the vault's savings token. */
+    savingsToken: string;
+    /** Address of the vault's base asset (pmUSD). */
+    baseAsset: string;
+    /** 18-decimal savings token rate from the rate provider. */
+    savingsTokenRate: ScaledValue;
+    /** The vault's own savings token holdings. */
+    vaultSavingsTokenBalance: TokenAmount;
+    /** Raw module-token base units; null when the vault has no base asset module configured. */
+    moduleVaultBalance: bigint | null;
+    /** 18-decimal rate, pmUSD value of one module share; null when the vault has no base asset module configured. */
+    moduleConvertToAssets: ScaledValue | null;
+    /** Null when no `userAddress` was given. */
+    user: PsmVaultUserInfo | null;
+}
+/**
+ * Gets aggregate and (optionally) user-specific info for a PSM vault.
+ * @param chainId - The chain/network to use.
+ * @param vaultKeyOrAddress - The vault's config key (e.g. "rpsm-sUSDS") or its deployed address.
+ * @param userAddress - When given, also returns the user's balances, allowances and redeem request.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare function getVaultInfo(chainId: ChainId, vaultKeyOrAddress: string, userAddress?: string, provider?: Provider): Promise<PsmVaultInfo>;

package/dist/types/contracts/psm/getVaultSettings.d.ts

@@ -0,0 +1,38 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** The governance-controlled settings of a PSM vault, as stored. */
+export interface PsmVaultSettings {
+    paused: boolean;
+    /** Basis points (of 10_000). */
+    swapFee: bigint;
+    minWithdrawFee: bigint;
+    maxWithdrawFee: bigint;
+    /** Seconds a redeem request waits before it can be claimed. */
+    withdrawTime: bigint;
+    /** Seconds a ready request stays claimable. */
+    withdrawTimeLimit: bigint;
+    circuitBreakerEnabled: boolean;
+    /** 18-decimal NAV floor (1e18 = a NAV of 1.00). */
+    navFloor: bigint;
+    /** 18-decimal ratio (1e18 = 100%). */
+    reserveRatioFloor: bigint;
+    /** Base asset (pmUSD) base units. */
+    rebalanceThreshold: bigint;
+    /** Savings token base units; `MaxUint256` means no cap. */
+    depositCap: bigint;
+    savingsTokenDecimals: number;
+    baseAsset: string;
+    savingsToken: string;
+    rateProvider: string;
+    rebalancer: string;
+    baseAssetModule: string;
+}
+/**
+ * Reads a PSM vault's settings from its storage getters only. Unlike `getVaultInfo`, nothing here touches the rate
+ * provider, so it still answers when the savings token price is stale (`StalePrice`), which is when an operator
+ * needs to see and change these settings.
+ * @param chainId - The chain/network to use.
+ * @param vaultKeyOrAddress - The vault's config key (e.g. "rpsm-susds") or its deployed address.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare function getVaultSettings(chainId: ChainId, vaultKeyOrAddress: string, provider?: Provider): Promise<PsmVaultSettings>;

package/dist/types/contracts/psm/previewDeposit.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews depositing `savingsAmount` (savings token base units) into a PSM vault.
+ * @returns The shares out, in share base units.
+ */
+export declare function previewDeposit(chainId: ChainId, vaultKeyOrAddress: string, savingsAmount: bigint, provider?: Provider): Promise<bigint>;

package/dist/types/contracts/psm/previewProportionalSplit.d.ts

@@ -0,0 +1,9 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+export interface ProportionalSplit {
+    moduleTokenOut: bigint;
+    baseAssetOut: bigint;
+    savingsTokenOut: bigint;
+}
+/** @returns The 3-way split of `entitlement` across the module token, base asset, and savings token. */
+export declare function previewProportionalSplit(chainId: ChainId, vaultKeyOrAddress: string, entitlement: bigint, provider?: Provider): Promise<ProportionalSplit>;

package/dist/types/contracts/psm/previewRedeem.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews redeeming `shares` (share base units) from a PSM vault.
+ * @returns The assets out after fee, in base asset base units.
+ */
+export declare function previewRedeem(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, provider?: Provider): Promise<bigint>;

package/dist/types/contracts/psm/previewSwap.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews swapping `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @returns The amount out, in tokenOut base units.
+ */
+export declare function previewSwap(chainId: ChainId, vaultKeyOrAddress: string, tokenIn: string, tokenOut: string, amountIn: bigint, provider?: Provider): Promise<bigint>;

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

@@ -0,0 +1,9 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Redeems `shares` (share base units) from a PSM vault, after a ready exit request.
+ * Use `previewProportionalSplit` beforehand to preview the 3-way split.
+ * @param minAssetsOut The minimum total assets to accept, in base asset base units.
+ * @param receiver The address to receive the assets.
+ */
+export declare function redeem(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, receiver: string, minAssetsOut: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/requestExit.d.ts

@@ -0,0 +1,4 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** Requests an exit from a PSM vault for `shares` (share base units), starting the withdraw timelock. */
+export declare function requestExit(chainId: ChainId, vaultKeyOrAddress: string, shares: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/swap.d.ts

@@ -0,0 +1,8 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Swaps `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @param minAmountOut The minimum output to accept, in tokenOut base units.
+ * @param receiver The address to receive the output.
+ */
+export declare function swap(chainId: ChainId, vaultKeyOrAddress: string, tokenIn: string, tokenOut: string, amountIn: bigint, minAmountOut: bigint, receiver: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/rentStreamer/_helpers.d.ts

@@ -0,0 +1,4 @@
+import { Provider, Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { RentStreamer } from "../../typechain-types";
+export declare function getRentStreamerContract(chainId: ChainId, runner?: Provider | Signer): Promise<RentStreamer>;

package/dist/types/contracts/rentStreamer/getEpochProjection.d.ts

@@ -0,0 +1,40 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+export interface RentStreamerEpochAmount {
+    /** Epoch start timestamp. */
+    epoch: number;
+    /** Already deposited into the RWA GaugeRewardsDistributor for this epoch, by any depositor. Always zero for the next epoch. */
+    deposited: TokenAmount;
+    /** What the streamer will release into this epoch from what it holds now, before the keeper bounty. */
+    pending: TokenAmount;
+    /** Keeper bounty on `pending` at the maximum fee. */
+    maxBounty: TokenAmount;
+    /** `deposited + pending - maxBounty`: the least this epoch receives from what is deposited or held now. */
+    projected: TokenAmount;
+}
+export interface RentStreamerEpochProjection {
+    /** Streamed token (USDC). */
+    token: string;
+    numEpochs: number;
+    killed: boolean;
+    /** Whether the current epoch's release already happened. */
+    currentReleased: boolean;
+    /** Token sent to the streamer and not yet split into buckets: balance - processed. */
+    unsynced: TokenAmount;
+    current: RentStreamerEpochAmount;
+    next: RentStreamerEpochAmount;
+}
+/**
+ * Projects what the RWA gauge system receives from the RentStreamer in the current and the next epoch, counting
+ * token sent to the streamer but not yet synced as it will be split: from the current epoch when the current epoch
+ * is not released yet, otherwise from the next one. Reads every value at one block.
+ *
+ * Assumes the current epoch is released before it ends; an unreleased bucket rolls into the next release. Rent sent
+ * after this read adds to later buckets, so the next epoch's figure can still grow.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Both epochs' deposited, pending and projected amounts in the streamed token's base units.
+ */
+export declare const getEpochProjection: (chainId: ChainId, provider?: Provider) => Promise<RentStreamerEpochProjection>;

package/dist/types/contracts/rentStreamer/getScheduled.d.ts

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads the amount bucketed for one epoch. Released epochs read zero.
+ *
+ * @param chainId - The chain/network to use.
+ * @param epoch - Epoch start timestamp, a multiple of one week.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The scheduled amount in the streamed token's base units.
+ */
+export declare const getScheduled: (chainId: ChainId, epoch: bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/rentStreamer/getState.d.ts

@@ -0,0 +1,33 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { ScaledValue, TokenAmount } from "../../utils/amount";
+export interface RentStreamerState {
+    /** Streamed token (USDC). */
+    token: string;
+    /** GaugeRewardsDistributor every release deposits into. */
+    distributor: string;
+    /** Number of weekly buckets each synced amount is split over. */
+    numEpochs: number;
+    /** Keeper bounty at the start of an epoch, 18-decimal fraction of the released amount (1.0 = 100%). */
+    minBountyFee: ScaledValue;
+    /** Keeper bounty once `bountyDuration` has passed, 18-decimal fraction of the released amount (1.0 = 100%). */
+    maxBountyFee: ScaledValue;
+    /** Seconds over which the bounty ramps from min to max after an epoch starts. */
+    bountyDuration: number;
+    /** Whether the streamer was permanently shut down. */
+    killed: boolean;
+    /** Token synced into buckets and not yet released. */
+    processed: TokenAmount;
+    /** Token released so far, bounties included. */
+    released: TokenAmount;
+    /** Start timestamp of the last released epoch. */
+    lastEpochProcessed: number;
+}
+/**
+ * Reads the RentStreamer's configuration and running totals.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The streamer state; see `RentStreamerState` for the unit of each field.
+ */
+export declare const getState: (chainId: ChainId, provider?: Provider) => Promise<RentStreamerState>;

package/dist/types/contracts/rentStreamer/previewRelease.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+export interface RentStreamerReleasePreview {
+    /** Total the next release takes out of the buckets, bounty included. */
+    amountToRelease: TokenAmount;
+    /** Part deposited into the RWA GaugeRewardsDistributor. */
+    amountToDistribute: TokenAmount;
+    /** Part paid to the keeper that calls `release`. */
+    bountyFee: TokenAmount;
+}
+/**
+ * Previews what a `release` would move right now. All zero when the current epoch was already released or the
+ * streamer is killed. The bounty grows with time since the epoch start, so the real release can differ.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The release preview, in the streamed token's base units.
+ */
+export declare const previewRelease: (chainId: ChainId, provider?: Provider) => Promise<RentStreamerReleasePreview>;

package/dist/types/contracts/rentStreamer/release.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Releases the current epoch's buckets: pays the keeper bounty and deposits the rest into the RWA
+ * GaugeRewardsDistributor. Permissionless, once per epoch; reverts while the RWA gauge system has no active gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param receiver - Address paid the bounty; the signer when omitted.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction.
+ */
+export declare const release: (chainId: ChainId, receiver: string | undefined, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/rentStreamer/sync.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Splits token sent to the streamer since the last sync over the next `numEpochs` weekly buckets. Permissionless;
+ * `release` also syncs first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction.
+ */
+export declare const sync: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/veRAAC/getRewardTokens.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the reward token addresses configured on the veRAAC contract.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The reward token addresses.
+ */
+export declare const getRewardTokens: (chainId: ChainId, provider?: Provider) => Promise<string[]>;

package/dist/types/contracts/treasury/getState.d.ts

@@ -0,0 +1,24 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+import { TokenAmount } from "../../utils/amount";
+/** One token the Treasury supports. */
+export interface TreasuryToken {
+    address: string;
+    symbol: string;
+    /** Null when the token's decimals could not be read; amounts then cannot be entered safely. */
+    decimals: number | null;
+    /** What the Treasury's own accounting holds (`getBalance`); `withdraw` is limited to this. */
+    tracked: TokenAmount;
+    /** The token's actual `balanceOf(treasury)`; null when unreadable. Differs from `tracked` for tokens sent directly or rebasing. */
+    held: TokenAmount | null;
+}
+/**
+ * Reads every token the Treasury supports, with its tracked and actual balances. Walks `supportedTokens(i)` until the
+ * index reverts; any other error is thrown so a flaky node never returns a shortened list.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+declare function getState(chainId: ChainId, provider: Provider): Promise<{
+    tokens: TreasuryToken[];
+}>;
+export default getState;

package/dist/types/contracts/yearn/vault/_helpers.d.ts

@@ -0,0 +1,24 @@
+import { ethers, Provider, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { YearnVaultEntry, YearnVaults } from "../../../configs/chains/chain";
+/**
+ * The Yearn V3 vault surface (VaultV3.vy, API 3.0.x) these methods use. ERC4626 calls use the standard
+ * signatures: Yearn's `withdraw` defaults to a 0 max loss and `redeem` to 100%, which only matter for a vault
+ * with strategies.
+ */
+export declare const YEARN_VAULT_ABI: string[];
+/** `profitUnlockingRate` is shares per second scaled by this (VaultV3.vy `MAX_BPS_EXTENDED`). */
+export declare const PROFIT_UNLOCKING_RATE_SCALE: bigint;
+/**
+ * The APR the vault pays right now: the assets its locked profit releases per second, annualised, over total
+ * assets, as a WAD. Zero once the last reported profit has fully unlocked. It reflects the current stream only.
+ */
+export declare function aprFromUnlockingRate(contract: ethers.Contract, profitUnlockingRate: bigint, fullProfitUnlockDate: bigint, totalAssets: bigint, now: bigint): Promise<bigint>;
+export declare const getYearnVaults: (chainId: ChainId) => YearnVaults;
+/** Resolves a Yearn vault by its config key (any casing) or its address. */
+export declare function resolveYearnVault(chainId: ChainId, vaultAddressOrId: string): YearnVaultEntry;
+/** The vault contract bound to `runner`, or to the chain's default RPC when none is given. */
+export declare function getYearnVaultContract(chainId: ChainId, vaultAddressOrId: string, runner?: Provider | Signer): {
+    entry: YearnVaultEntry;
+    contract: ethers.Contract;
+};

package/dist/types/contracts/yearn/vault/deposit.d.ts

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposits `assets` of the vault asset for shares. The signer approves the vault for the asset first
+ * (`wallet.assets.approveAsset(chainId, vault.asset, vault.contract, amount, signer)`).
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param receiver - Who receives the shares.
+ * @param signer - The signer sending the transaction and paying the assets.
+ * @returns The mined transaction receipt.
+ */
+export declare const deposit: (chainId: ChainId, vaultAddressOrId: string, assets: bigint, receiver: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/yearn/vault/getApr.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { ScaledValue } from "../../../utils/amount";
+/**
+ * The APR a Yearn V3 vault pays right now, from the profit still unlocking: assets released per second,
+ * annualised, over total assets. It is 0 once the last report has fully unlocked, so it reflects the current
+ * reward stream, not a historical average.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The APR as a WAD (0.05e18 = 5%).
+ */
+export declare const getApr: (chainId: ChainId, vaultAddressOrId: string, provider?: Provider) => Promise<ScaledValue>;

package/dist/types/contracts/yearn/vault/getUserInfo.d.ts

@@ -0,0 +1,29 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+export interface YearnVaultUserInfo {
+    /** Vault shares held. */
+    shares: TokenAmount;
+    /** What `shares` redeem for now, in the vault asset. */
+    assets: TokenAmount;
+    /** Wallet balance of the vault asset. */
+    assetBalance: TokenAmount;
+    /** Vault asset allowance to the vault, which `deposit` and `mint` pull from. */
+    assetAllowance: TokenAmount;
+    /** Most the user can deposit now, in the vault asset. */
+    maxDeposit: TokenAmount;
+    /** Most the user can withdraw now, in the vault asset. */
+    maxWithdraw: TokenAmount;
+    /** Most shares the user can redeem now; redeem `shares` instead for a full exit, as this can round 1 wei short. */
+    maxRedeem: TokenAmount;
+}
+/**
+ * Gets a user's position in a Yearn V3 vault, plus their vault asset balance and allowance.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section (e.g. "spmusd"), or its address.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The user's shares, their asset value, balances, allowance and limits, in base units.
+ */
+export declare function getUserInfo(chainId: ChainId, vaultAddressOrId: string, account: string, provider?: Provider): Promise<YearnVaultUserInfo>;