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

package/dist/types/contracts/curve/common/_helpers.d.ts

@@ -0,0 +1,16 @@
+import { ethers, Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry, CurvePools } from "../../../configs/chains/chain";
+/**
+ * Reads every Curve pool flavour shares. Coin indexes differ (uint256 vs int128) only in swap and liquidity
+ * methods, which are not here.
+ */
+export declare const CURVE_POOL_READ_ABI: string[];
+export declare const getCurvePools: (chainId: ChainId) => CurvePools;
+/** Resolves a Curve pool by its config key (any casing) or its address. */
+export declare function resolveCurvePool(chainId: ChainId, poolAddressOrId: string): CurvePoolEntry;
+export declare function getCurvePoolContract(chainId: ChainId, poolAddressOrId: string, provider?: Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+    provider: ethers.Provider;
+};

package/dist/types/contracts/curve/common/getPools.d.ts

@@ -0,0 +1,30 @@
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry } from "../../../configs/chains/chain";
+export interface CurvePoolCoin {
+    /** Asset key in the chain config, e.g. "pmusd". */
+    asset: string;
+    address: string;
+    /** From the token registry; the asset key when the registry has no symbol. */
+    symbol: string;
+    decimals: number;
+}
+export interface CurvePool extends Omit<CurvePoolEntry, "coins"> {
+    /** In pool index order: coins[i] is coin i on chain. */
+    coins: CurvePoolCoin[];
+}
+/**
+ * Lists the Curve pools in the chain config.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured pool with its flavour and coins in pool index order; empty when the chain has none.
+ */
+export declare const getPools: (chainId: ChainId) => CurvePool[];
+/**
+ * Looks up one Curve pool in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's config key or its address.
+ * @returns The pool with its flavour and coins in pool index order.
+ * @throws If the pool is not configured on the chain.
+ */
+export declare const getPool: (chainId: ChainId, poolAddressOrId: string) => CurvePool;

package/dist/types/contracts/curve/common/getVirtualPrice.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Reads a Curve pool's virtual price: the value of one whole LP token in units of the pool's underlying coins,
+ * which only grows with fees. For a stableswap pool of $1 coins it is the LP token's USD price.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns `get_virtual_price()` as an 18-decimal amount, e.g. 1.0021 underlying per LP token.
+ */
+export declare const getVirtualPrice: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/curve/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./getPools";
+export * from "./getVirtualPrice";

package/dist/types/contracts/findContract.d.ts

@@ -5,8 +5,10 @@ export interface ContractInfo {
     address: string;
     /** The entry's id in the chain config, e.g. "treasury" or "RAAC_pmUSD". */
     id: string;
-    /** The entry's display name, e.g. "Treasury". */
+    /** The entry's internal name, e.g. "Treasury". */
     name: string;
+    /** The user-facing name, e.g. "Treasury". Same as `name` except for adapters, which report their pool or vault ("RWA Vault"). */
+    label: string;
     /** Top-level config section the entry came from, e.g. "contracts", "gauges", "proposals". */
     section: string;
     /** Key into `ABIS`, or null when this library ships no ABI for the contract. */

package/dist/types/contracts/getTokenMetadata.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface TokenMetadata {
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Reads `symbol()`/`decimals()` directly from an arbitrary ERC20 token address -
+ * for tokens not in the chain config's asset registry (e.g. a veRAAC reward
+ * token or a gauge's reward token), where there's no registry entry to look
+ * up instead.
+ */
+export declare const getTokenMetadata: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenMetadata>;

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

@@ -6,23 +6,3 @@
  * @returns The checksummed address.
  */
 export declare const requireAddress: (address: string, name: string) => string;
-/** The fields a caller needs to explain a failed transaction, lifted from an ethers error. */
-export interface GovernanceTxError extends Error {
-    /** ethers error code, e.g. "ACTION_REJECTED", "CALL_EXCEPTION", "INSUFFICIENT_FUNDS". */
-    code?: string;
-    /** Revert data, when the node returned it. */
-    data?: string;
-    /** Decoded custom error name, e.g. "AlreadyVoted". */
-    errorName?: string;
-    cause: unknown;
-}
-/**
- * Wraps a failed write so the message says what failed while the original
- * error stays reachable: its code (a wallet rejection is ACTION_REJECTED), its
- * revert data and the decoded custom error name.
- *
- * @param prefix - What was being attempted, e.g. "Failed to cast vote".
- * @param error - The error ethers threw.
- * @returns An Error carrying `code`, `data`, `errorName` and `cause`.
- */
-export declare const toGovernanceTxError: (prefix: string, error: any) => GovernanceTxError;

package/dist/types/contracts/governance/proposals/castVote.d.ts

@@ -1,6 +1,5 @@
 import { ethers, Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
-import { TokenAmount } from "../../../utils/amount";
 /**
  * Casts a vote on a governance proposal.
  * Allows veToken holders to vote on active proposals.
@@ -17,5 +16,5 @@ import { TokenAmount } from "../../../utils/amount";
  */
 export declare const castVote: (chainId: ChainId, governance: string, proposalId: number | bigint, support: boolean, signer: Signer) => Promise<{
     tx: ethers.ContractTransactionResponse;
-    weight: TokenAmount;
+    weight: import("../../../utils/amount").TokenAmount;
 }>;

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

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Register reward tokens that can be distributed to lockers. MANAGER_ROLE only.
+ * Reverts if any token is the zero address or already registered.
+ *
+ * @param chainId - The chain/network to use.
+ * @param tokens - ERC20 addresses to register.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const addRewardTokens: (chainId: ChainId, tokens: string[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Distribute `amount` of a registered reward token across all currently locked NFTs. DISTRIBUTOR_ROLE only.
+ * The signer's tokens are pulled via transferFrom, so approve the locker for `amount` first.
+ * Reverts when nothing is locked.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - Address of a registered reward token.
+ * @param amount - Amount to distribute, in `token` base units.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const distributeRewardToken: (chainId: ChainId, token: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerConfig {
+    /** Address of the RAAC Bot NFT collection the locker accepts. */
+    nft: string;
+    /** Length of one epoch, seconds (EPOCH_DURATION). */
+    epochDuration: number;
+    /** Epochs per lock cycle; an NFT can unlock when its locked epochs are a non-zero multiple of this (LOCK_DURATION_IN_EPOCH). */
+    lockDurationEpochs: number;
+    rewardTokens: string[];
+    paused: boolean;
+}
+/**
+ * Read the locker's configuration in a single call batch.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The NFT collection, lock timing constants, reward tokens and pause state.
+ */
+export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<BotLockerConfig>;

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

@@ -9,6 +9,10 @@ export interface BotLockerNFTLock {
  * Returns every active NFT lock across all owners.
  */
 export declare const getLocks: (chainId: ChainId, provider?: Provider) => Promise<BotLockerNFTLock[]>;
+/**
+ * Returns the lock of a single NFT, or null when it is not locked.
+ */
+export declare const getLock: (chainId: ChainId, tokenId: string | number | bigint, provider?: Provider) => Promise<BotLockerNFTLock | null>;
 /**
  * Returns every active NFT lock owned by `owner`.
  */

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