@raac/rpc 1.1.0-beta.92 → 1.2.0-beta.10

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

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the earliest unlock time across all of a user's locks.
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - The address to query.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The minimum lock end timestamp.
+ */
+export declare const getMinLockEnd: (chainId: ChainId, address: string, provider?: Provider) => Promise<number>;

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

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the ragequit cooldown duration (in epochs) from the veRAAC contract.
+ * The actual cooldown in seconds is `ragequitEpochs * epochDuration`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Number of epochs the user must wait between ragequit initiation and finalization.
+ */
+export declare const getRagequitEpochs: (chainId: ChainId, provider?: Provider) => Promise<number>;

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

@@ -0,0 +1,18 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface RagequitRequest {
+    amount: string;
+    grossAmount: string;
+    fixedPenaltyAmount: string;
+    variablePenaltyAmount: string;
+    readyAt: number;
+}
+/**
+ * Gets a user's pending ragequit request.
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - The address to query.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The ragequit request data, or null values if none pending.
+ */
+export declare const getRagequitRequest: (chainId: ChainId, address: string, provider?: Provider) => Promise<RagequitRequest>;

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

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the raw ERC20 balance (minted veRAAC, before decay).
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - The address to query.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The raw balance formatted in ether units.
+ */
+export declare const getRawBalanceOf: (chainId: ChainId, address: string, provider?: Provider) => Promise<string>;

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

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the raw total supply (minted veRAAC, before decay).
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The raw total supply formatted in ether units.
+ */
+export declare const getRawTotalSupply: (chainId: ChainId, provider?: Provider) => Promise<string>;

package/dist/types/contracts/{rcrvUSDToken → tokens/veRAAC}/getTotalSupply.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from "ethers";
-import { ChainId } from "../../configs/chains";
+import { ChainId } from "../../../configs/chains";
 /**
  *
  * @param {string} contractAddress

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

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the total supply of veRAAC tokens at a specific block.
+ *
+ * @param chainId - The chain/network to use.
+ * @param blockNumber - The block number to check the total supply at.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The total supply at the specified block formatted in ether units.
+ */
+export declare const getTotalSupplyAt: (chainId: ChainId, blockNumber: number | bigint, provider?: Provider) => Promise<string>;

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

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the total voting power across all accounts at a specific timestamp.
+ *
+ * @param chainId - The chain/network to use.
+ * @param timestamp - The timestamp to check the total supply at (in seconds).
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The total voting power at the specified timestamp formatted in ether units.
+ */
+export declare const getTotalSupplyAtTime: (chainId: ChainId, timestamp: number | bigint, provider?: Provider) => Promise<string>;

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

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface UserPoint {
+    bias: string;
+    totalLocked: string;
+    ts: number;
+    blk: number;
+    accExpiredLocks: string;
+}
+/**
+ * Gets the user's point history from the veRAAC contract.
+ * Each point records the bias (voting power), totalLocked, timestamp, and block
+ * at the time of a lock/extend/increase/withdraw action.
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - The address to query.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Array of user point history entries.
+ */
+export declare const getUserPointHistory: (chainId: ChainId, address: string, provider?: Provider) => Promise<UserPoint[]>;

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

@@ -0,0 +1,13 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Increases the amount of tokens in an existing lock.
+ * Adds more RAAC tokens to an existing lock position without changing the unlock time.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amountToAdd - Amount of additional RAAC tokens to add to the lock.
+ * @param epochEnd - The epoch end time of the existing lock to increase.
+ * @param signer - An ethers.js Signer instance (must be connected to wallet).
+ * @returns Transaction receipt after the increase is made.
+ */
+export declare const increase: (chainId: ChainId, amountToAdd: string | number | bigint, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,13 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Increases the amount of tokens in an existing lock, auto-approving the veRAAC
+ * contract first if the current allowance is insufficient.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amountToAdd - Additional RAAC amount to add to the existing lock (decimal string).
+ * @param epochEnd - The epoch end time of the existing lock to increase.
+ * @param signer - An ethers.js Signer (must be connected to wallet).
+ * @returns Transaction receipt of the increase tx.
+ */
+export declare const increaseWithApproval: (chainId: ChainId, amountToAdd: string, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,33 @@
+export { getBalance } from "./getBalance";
+export { getTotalSupply } from "./getTotalSupply";
+export { getLockedBalance } from "./getLockedBalance";
+export { getLocks, type LockedBalance } from "./getLocks";
+export { getGlobalLockInfo, type GlobalLockInfo } from "./getGlobalLockInfo";
+export { getMaxLockEnd } from "./getMaxLockEnd";
+export { getMinLockEnd } from "./getMinLockEnd";
+export { getEffectiveLockEnd } from "./getEffectiveLockEnd";
+export { getBalanceAt } from "./getBalanceAt";
+export { getBalanceAtTime } from "./getBalanceAtTime";
+export { getTotalSupplyAt } from "./getTotalSupplyAt";
+export { getTotalSupplyAtTime } from "./getTotalSupplyAtTime";
+export { getRawBalanceOf } from "./getRawBalanceOf";
+export { getRawTotalSupply } from "./getRawTotalSupply";
+export { getClaimed } from "./getClaimed";
+export { getClaimable } from "./getClaimable";
+export { getEarned } from "./getEarned";
+export { getUserPointHistory, type UserPoint } from "./getUserPointHistory";
+export { getCheckpoint, type Checkpoint } from "./getCheckpoint";
+export { getRagequitRequest, type RagequitRequest } from "./getRagequitRequest";
+export { getRagequitEpochs } from "./getRagequitEpochs";
+export { getMaxUnclaimedDistributions } from "./getMaxUnclaimedDistributions";
+export { lock } from "./lock";
+export { lockWithApproval } from "./lockWithApproval";
+export { increase } from "./increase";
+export { increaseWithApproval } from "./increaseWithApproval";
+export { extend } from "./extend";
+export { withdraw } from "./withdraw";
+export { claimReward } from "./claimReward";
+export { ragequitAll } from "./ragequitAll";
+export { ragequitLock } from "./ragequitLock";
+export { finalizeRagequit } from "./finalizeRagequit";
+export { distributeRewards } from "./distributeRewards";

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

@@ -0,0 +1,12 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Locks RAAC tokens for a specified duration to receive veRAAC voting power.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - The amount of RAAC tokens to lock.
+ * @param epochs - Number of epochs to lock tokens for (1 epoch = 7 days).
+ * @param signer - An ethers.js Signer instance (must be connected to wallet).
+ * @returns Transaction receipt after the lock is made.
+ */
+export declare const lock: (chainId: ChainId, amount: string | number | bigint, epochs: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,14 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Locks RAAC tokens, auto-approving the veRAAC contract first if the current
+ * allowance is insufficient. Convenience wrapper so callers don't have to
+ * orchestrate the approve+lock dance themselves.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - The amount of RAAC tokens to lock (decimal string).
+ * @param epochs - Number of epochs to lock tokens for.
+ * @param signer - An ethers.js Signer (must be connected to wallet).
+ * @returns Transaction receipt of the lock tx.
+ */
+export declare const lockWithApproval: (chainId: ChainId, amount: string, epochs: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,11 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Ragequits all locks for the caller.
+ * Initiates a ragequit process with cooldown period and fees.
+ *
+ * @param chainId - The chain/network to use.
+ * @param signer - An ethers.js Signer instance (must be connected to wallet).
+ * @returns Transaction receipt after the ragequit is initiated.
+ */
+export declare const ragequitAll: (chainId: ChainId, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,12 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Ragequits a specific lock by epoch end time.
+ * Initiates a ragequit process for a single lock with cooldown period and fees.
+ *
+ * @param chainId - The chain/network to use.
+ * @param epochEnd - The epoch end time of the lock to ragequit.
+ * @param signer - An ethers.js Signer instance (must be connected to wallet).
+ * @returns Transaction receipt after the ragequit is initiated.
+ */
+export declare const ragequitLock: (chainId: ChainId, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

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

@@ -0,0 +1,11 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraws expired tokens from all eligible lock positions.
+ * Withdraws all expired tokens and transfers them to the caller, also claims rewards.
+ *
+ * @param chainId - The chain/network to use.
+ * @param signer - An ethers.js Signer instance (must be connected to wallet).
+ * @returns Transaction receipt after the withdrawal is made.
+ */
+export declare const withdraw: (chainId: ChainId, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

package/dist/types/contracts/tokens/xPM/getBalance.d.ts

@@ -0,0 +1,2 @@
+import { ChainId } from "../../../configs/chains";
+export declare const getBalance: (chainId: ChainId, address: string) => Promise<string>;

package/dist/types/contracts/tokens/xPM/getTotalSupply.d.ts

@@ -0,0 +1,7 @@
+import { ChainId } from "../../../configs/chains";
+/**
+ *
+ * @param {number} chainId
+ * @returns {Promise<string>}
+ */
+export declare const getTotalSupply: (chainId: ChainId) => Promise<string>;

package/dist/types/contracts/zap/aladdin/_helpers.d.ts

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

package/dist/types/contracts/zap/aladdin/_types.d.ts

@@ -0,0 +1,44 @@
+export declare enum AladdinPoolType {
+    UniswapV2 = 0,
+    UniswapV3 = 1,
+    BalancerV2 = 2,
+    CurveETHPool = 3,
+    CurveCryptoPool = 4,
+    CurveMetaCryptoPool = 5,
+    CurveTriCryptoPool = 6,
+    CurveBasePool = 7,
+    CurveAPool = 8,
+    CurveAPoolUnderlying = 9,
+    CurveYPool = 10,
+    CurveYPoolUnderlying = 11,
+    CurveMetaPool = 12,
+    CurveMetaPoolUnderlying = 13,
+    CurveFactoryPlainPool = 14,
+    CurveFactoryMetaPool = 15,
+    CurveFactoryUSDMetaPoolUnderlying = 16,
+    CurveFactoryBTCMetaPoolUnderlying = 17,
+    LidoStake = 18,
+    LidoWrap = 19,
+    CurveFactoryFraxBPMetaPoolUnderlying = 20,
+    AladdinCompounder = 21
+}
+export declare const ALADDIN_POOL_TYPE_MAX = AladdinPoolType.AladdinCompounder;
+export declare enum AladdinAction {
+    Swap = 0,
+    AddLiquidity = 1,
+    RemoveLiquidity = 2
+}
+export interface DecodedAladdinRoute {
+    pool: string;
+    poolType: AladdinPoolType;
+    tokens: number;
+    indexIn: number;
+    indexOut: number;
+    action: AladdinAction;
+    raw: bigint;
+}
+export interface AladdinRouteValidation {
+    valid: boolean;
+    errors: string[];
+    decoded: DecodedAladdinRoute;
+}

package/dist/types/contracts/zap/aladdin/decodeRoute.d.ts

@@ -0,0 +1,14 @@
+import { DecodedAladdinRoute } from "./_types";
+/**
+ * Decode a single Aladdin zap route uint256 into its component fields.
+ *
+ * Encoding (low → high bits):
+ *  | 160 bits     | 8 bits     | 2 bits         | 2 bits   | 2 bits    | 2 bits |
+ *  | pool address | pool type  | tokens (count-1) | index_in | index_out | action |
+ */
+export declare const decodeRoute: (route: string | bigint | number) => DecodedAladdinRoute;
+/**
+ * Human-readable description of a route (delegates to the shared `decodePoolV2` codec).
+ * Format: `${PoolType}[${pool}].${Action} tokenIn[i] tokenOut[j]`.
+ */
+export declare const describeRoute: (route: string | bigint | number) => string;

package/dist/types/contracts/zap/aladdin/encodeRoute.d.ts

@@ -0,0 +1,18 @@
+import { AladdinAction, AladdinPoolType } from "./_types";
+export interface EncodeRouteParams {
+    pool: string;
+    poolType: AladdinPoolType;
+    /** Number of tokens in the pool (must be 1–4). Encoded as `tokens - 1`. */
+    tokens: number;
+    indexIn: number;
+    indexOut: number;
+    action: AladdinAction;
+}
+/**
+ * Encode a route into the packed uint256 used by AladdinZap.updateRoute / zapWithRoutes.
+ * Delegates to the shared codec (`encodePoolHintV2`) ported from
+ * `contracts/test/utils/codec.js` so the encoding stays in lockstep with the contracts repo.
+ *
+ * Throws on out-of-range fields — pair with validateRoute before sending an admin tx.
+ */
+export declare const encodeRoute: (params: EncodeRouteParams) => bigint;

package/dist/types/contracts/zap/aladdin/getCurvePoolToken.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { AladdinPoolType } from "./_types";
+/**
+ * Read the LP token address registered for a Curve pool, falling back to the
+ * `pool2token` override if the registry doesn't know the pool.
+ */
+export declare const getCurvePoolToken: (chainId: ChainId, poolType: AladdinPoolType, pool: string, provider?: Provider) => Promise<string>;

package/dist/types/contracts/zap/aladdin/getOwner.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const getOwner: (chainId: ChainId, provider?: Provider) => Promise<string>;

package/dist/types/contracts/zap/aladdin/getPool2Token.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Read the manual pool→LP-token override map (`pool2token`).
+ */
+export declare const getPool2Token: (chainId: ChainId, pool: string, provider?: Provider) => Promise<string>;

package/dist/types/contracts/zap/aladdin/getRoutes.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { DecodedAladdinRoute } from "./_types";
+export interface GetRoutesResult {
+    raw: bigint[];
+    decoded: DecodedAladdinRoute[];
+}
+/**
+ * Fetch the full route list (zero-or-more packed uint256s) configured for swapping
+ * `fromToken` → `toToken` on AladdinZap. Returns both raw values and decoded
+ * descriptions for UI rendering.
+ */
+export declare const getRoutes: (chainId: ChainId, fromToken: string, toToken: string, provider?: Provider) => Promise<GetRoutesResult>;

package/dist/types/contracts/zap/aladdin/getVersion.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const getVersion: (chainId: ChainId, provider?: Provider) => Promise<string>;

package/dist/types/contracts/zap/aladdin/rescue.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Owner-only: drain the listed tokens' balances from the zap into `recipient`.
+ */
+export declare const rescue: (chainId: ChainId, tokens: string[], recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/updatePoolTokens.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Owner-only: register pool → LP-token overrides used by `getCurvePoolToken`.
+ */
+export declare const updatePoolTokens: (chainId: ChainId, pools: string[], tokens: string[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/updateRoute.d.ts

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Owner-only: register the route list used to swap `fromToken → toToken`.
+ *
+ * Routes are validated client-side first (action/index/poolType invariants); set
+ * `skipValidation: true` to bypass — useful when adding routes whose pool types are
+ * deliberately outside the documented set, but normally a misencoded route here will
+ * silently make the route revert at swap time, so we default to strict checking.
+ */
+export declare const updateRoute: (chainId: ChainId, fromToken: string, toToken: string, routes: (string | bigint | number)[], signer: Signer, options?: {
+    skipValidation?: boolean;
+}) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/validateRoute.d.ts

@@ -0,0 +1,26 @@
+import { AladdinRouteValidation } from "./_types";
+/**
+ * Validate a single packed-uint256 Aladdin route. Returns the decoded fields plus a list of
+ * problems. Use this before calling `updateRoute` to catch typos and impossible encodings
+ * before they get committed to a transaction.
+ *
+ * Rules enforced (matching TokenZapLogic.swap dispatch):
+ *  - poolType is within the known enum range (0..21)
+ *  - pool address is non-zero
+ *  - action ∈ {Swap, AddLiquidity, RemoveLiquidity}
+ *  - Swap requires indexIn != indexOut
+ *  - AddLiquidity / RemoveLiquidity require indexIn == indexOut
+ *  - LidoStake / LidoWrap support only `action = AddLiquidity` (1)
+ *  - UniswapV2 / UniswapV3 / BalancerV2 / AladdinCompounder only support Swap; the
+ *    `_addCurvePool` / `_removeCurvePool` paths reject these pool types at runtime.
+ *  - For non-Lido pool types, indexIn / indexOut must be < tokens
+ */
+export declare const validateRoute: (route: string | bigint | number) => AladdinRouteValidation;
+/**
+ * Validate every route in a list. Returns one validation entry per route plus an
+ * `allValid` summary so callers can short-circuit before sending a transaction.
+ */
+export declare const validateRoutes: (routes: (string | bigint | number)[]) => {
+    allValid: boolean;
+    results: AladdinRouteValidation[];
+};

package/dist/types/contracts/zap/aladdin/zap.d.ts

@@ -0,0 +1,8 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Run the configured route for `fromToken → toToken`, assuming `fromToken` is already
+ * sitting in the zap contract (or msg.value covers ETH). Use `zapFrom` if the caller
+ * is the holder of the input token instead.
+ */
+export declare const zap: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, minOut: string | number | bigint, signer: Signer, value?: string | number | bigint) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/zapFrom.d.ts

@@ -0,0 +1,8 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Pull `amountIn` of `fromToken` from the caller into the zap, then run the configured
+ * route to `toToken`. Caller must approve the zap on `fromToken` for ERC20 inputs,
+ * or pass `value` for ETH input.
+ */
+export declare const zapFrom: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, minOut: string | number | bigint, signer: Signer, value?: string | number | bigint) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/zapWithRoutes.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Run an explicit list of packed-uint256 routes from `fromToken` to `toToken`.
+ * Routes are validated client-side first; pass `skipValidation: true` only if you
+ * really know what you're doing.
+ */
+export declare const zapWithRoutes: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, routes: (string | bigint | number)[], minOut: string | number | bigint, signer: Signer, options?: {
+    value?: string | number | bigint;
+    skipValidation?: boolean;
+}) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/codec.d.ts

@@ -0,0 +1,36 @@
+type EnumLike = {
+    [key: string]: number | string;
+};
+export declare const PoolType: EnumLike;
+export declare const PoolTypeV3: EnumLike;
+export declare const Action: EnumLike;
+export type PoolHintV3Options = {
+    fee_num?: number | bigint;
+    twamm?: boolean;
+    use_eth?: boolean;
+    use_underlying?: boolean;
+    protocol?: number | bigint;
+};
+export declare function encodePoolHint(poolAddress: string, poolType: number, indexIn: number, indexOut: number): bigint;
+export declare function encodePoolHintV2(poolAddress: string, poolType: number, tokens: number, indexIn: number, indexOut: number, action: number): bigint;
+export declare function encodePoolHintV3(poolAddress: string, poolType: number, tokens: number, indexIn: number, indexOut: number, action: number, options?: PoolHintV3Options): bigint;
+export declare function decodePoolV2(encoding: bigint): string;
+export declare function decodePoolV3(encoding: bigint): string;
+export declare const SpotPricePoolType: EnumLike;
+export type SpotPriceOptions = {
+    base_index?: number | bigint;
+    quote_index?: number | bigint;
+    base_scale?: number | bigint;
+    quote_scale?: number | bigint;
+    tokens?: number;
+    has_amm_precise?: boolean;
+    scales?: (number | bigint)[];
+    use_cache?: boolean;
+    base_is_underlying?: boolean;
+    base_is_ETH?: boolean;
+};
+export declare function encodeSpotPricePool(poolAddress: string, poolType: number, options: SpotPriceOptions): bigint;
+export declare function decodeSpotPricePool(encoding: bigint): string;
+export declare function encodeSpotPriceSources(sources: bigint[][]): string;
+export declare function encodeChainlinkPriceFeed(feed: string, scale: bigint, heartbeat: number | bigint): bigint;
+export {};

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

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

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

@@ -0,0 +1,8 @@
+import { Signer } from "ethers";
+import { ChainId } from "../configs/chains";
+/**
+ * Activate the minting schedule. UPDATER_ROLE only. Reverts if already activated.
+ * After activation, `mintingStartAtTimestamp` is set to `block.timestamp` and the
+ * geometric weekly emission schedule begins counting from week 1.
+ */
+export declare const activate: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../configs/chains";
+/**
+ * Register a new distribution pool with the given weight. UPDATER_ROLE only.
+ * Reverts if the pool already exists. Calls `tick()` first to clear pending emissions.
+ */
+export declare const addDistributionPool: (chainId: ChainId, pool: string, weight: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+/**
+ * Returns the total RAAC scheduled to be mintable between two timestamps,
+ * applying the geometric weekly emission reduction (see EmissionSchedule.sol).
+ * Both `startPeriod` and `endPeriod` are absolute UNIX timestamps in seconds.
+ */
+export declare const calculateScheduledMintableAmount: (chainId: ChainId, startPeriod: number | bigint, endPeriod: number | bigint, provider?: Provider) => Promise<bigint>;

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

@@ -1,17 +1,29 @@
-import { Signer } from "ethers";
-import { ChainId } from "../configs/chains/index";
-declare function get(chainId: ChainId, signer: Signer): Promise<{
-    emissionRate: bigint;
-    benchmarkRate: bigint;
-    minEmissionRate: bigint;
-    maxEmissionRate: bigint;
-    utilizationTarget: bigint;
-    excessTokens: bigint;
-    lastUpdateBlock: bigint;
-    raacToken: string | bigint;
-    stabilityPool: string | bigint;
-    lendingPool: string | bigint;
-    owner: string | bigint;
-    BLOCKS_PER_DAY: bigint;
-}>;
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface MinterInfo {
+    raacToken: string;
+    mintingStartAtTimestamp: number;
+    lastUpdateBlockTimestamp: number;
+    excessTokens: string;
+    maxSupply: string;
+    totalWeight: bigint;
+    distributionPoolCount: number;
+    distributionPools: string[];
+    paused: boolean;
+    raw: {
+        mintingStartAtTimestamp: bigint;
+        lastUpdateBlockTimestamp: bigint;
+        excessTokens: bigint;
+        maxSupply: bigint;
+        totalWeight: bigint;
+    };
+}
+/**
+ * Read the RAAC minter's global state. Mirrors the new RAACMinter contract — the
+ * old emissionRate / benchmarkRate / BLOCKS_PER_DAY / stabilityPool / lendingPool
+ * fields no longer exist; emissions are now driven by a time-based geometric
+ * schedule (see `EmissionSchedule.sol`) and routed through weighted distribution
+ * pools (see `getDistributionPools`).
+ */
+declare function get(chainId: ChainId, provider?: Provider): Promise<MinterInfo>;
 export default get;

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

@@ -1,4 +1,21 @@
 import { Provider } from "ethers";
-import { ChainId } from "../configs/chains/index";
-declare function getApy(chainId: ChainId, provider: Provider): Promise<bigint>;
+import { ChainId } from "../configs/chains";
+export interface MinterApy {
+    emissionPerSecond: bigint;
+    yearlyEmission: bigint;
+    totalSupply: bigint;
+    apy: number;
+    apyBps: bigint;
+}
+/**
+ * Compute APY against current RAAC supply using the new time-based emission
+ * schedule. The minter no longer has a flat `emissionRate` — emissions follow a
+ * geometric schedule (see `EmissionSchedule.sol`). We derive the per-second
+ * emission from `calculateScheduledMintableAmount(now, now + 1)` and the yearly
+ * emission from `calculateScheduledMintableAmount(now, now + 1y)`, then divide
+ * by current total RAAC supply.
+ *
+ * Returns zeros if minting hasn't been activated or supply is 0.
+ */
+declare function getApy(chainId: ChainId, provider?: Provider): Promise<MinterApy>;
 export default getApy;