@raac/rpc 1.2.0-beta.4 → 1.2.0-beta.6

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

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Vote on a gauge using the locker's veRAAC voting power. Treasury-only.
+ * `weight` is in basis points (0–10000).
+ */
+export declare const voteGauge: (chainId: ChainId, controller: string, gauge: string, weight: number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Cast a governance vote with the locker's veRAAC voting power. Treasury-only.
+ */
+export declare const voteGovernance: (chainId: ChainId, governance: string, proposalId: number | bigint, support: boolean, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraw all matured (reserved & unlocked) RAAC for the caller.
+ */
+export declare const withdrawUnlocked: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/_helpers.d.ts

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

package/dist/types/contracts/lockers/maturityVault/claim.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Claim realised RAAC to `recipient` (burns the matured leRAAC).
+ */
+export declare const claim: (chainId: ChainId, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/deposit.d.ts

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposit leRAAC into the maturity vault for the caller.
+ * Caller must have approved leRAAC to the vault first.
+ */
+export declare const deposit: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/depositFor.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposit leRAAC into the maturity vault crediting `account`. Caller pays.
+ */
+export declare const depositFor: (chainId: ChainId, account: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/distribute.d.ts

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Distribute RAAC into the vault to pay down leRAAC debt. Whitelisted callers only.
+ * `origin` is the address whose RAAC balance is consumed via transferFrom.
+ */
+export declare const distribute: (chainId: ChainId, origin: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/exit.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Exit: withdraw all unrealised leRAAC AND claim all realised RAAC to `recipient`.
+ */
+export declare const exit: (chainId: ChainId, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface MaturityVaultConfig {
+    raac: string;
+    leRAAC: string;
+    platform: string;
+    governor: string;
+    owner: string;
+    platformFeePercentage: bigint;
+    harvestBountyPercentage: bigint;
+}
+export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<MaturityVaultConfig>;

package/dist/types/contracts/lockers/maturityVault/getGlobalInfo.d.ts

@@ -0,0 +1,32 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface MaturityVaultRewardInfo {
+    ratePerSecond: string;
+    periodLength: number;
+    lastUpdate: number;
+    finishAt: number;
+    raw: {
+        ratePerSecond: bigint;
+        periodLength: bigint;
+        lastUpdate: bigint;
+        finishAt: bigint;
+    };
+}
+export interface MaturityVaultGlobalInfo {
+    totalRAACInPool: string;
+    totalUnrealised: string;
+    totalRealised: string;
+    accUnrealisedFraction: bigint;
+    distributeIndex: bigint;
+    lastPaidOffDistributeIndex: bigint;
+    rewardInfo: MaturityVaultRewardInfo;
+    raw: {
+        totalRAACInPool: bigint;
+        totalUnrealised: bigint;
+        totalRealised: bigint;
+    };
+}
+/**
+ * Snapshot of the maturity vault's global accounting and active reward schedule.
+ */
+export declare const getGlobalInfo: (chainId: ChainId, provider?: Provider) => Promise<MaturityVaultGlobalInfo>;

package/dist/types/contracts/lockers/maturityVault/getUserInfo.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface MaturityVaultUserInfo {
+    unrealised: string;
+    realised: string;
+    raw: {
+        unrealised: bigint;
+        realised: bigint;
+    };
+}
+/**
+ * Returns the user's unrealised (still-earning leRAAC) and realised (claimable RAAC) totals.
+ */
+export declare const getUserInfo: (chainId: ChainId, account: string, provider?: Provider) => Promise<MaturityVaultUserInfo>;

package/dist/types/contracts/lockers/maturityVault/harvest.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Harvest free RAAC in the vault and distribute. Whitelisted callers only.
+ */
+export declare const harvest: (chainId: ChainId, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/isWhitelisted.d.ts

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

package/dist/types/contracts/lockers/maturityVault/updatePendingDistribution.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Permissionlessly accrue pending linear-distribution rewards.
+ */
+export declare const updatePendingDistribution: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/withdraw.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraw `amount` of unrealised leRAAC to `recipient`.
+ */
+export declare const withdraw: (chainId: ChainId, recipient: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/maturityVault/withdrawAll.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Withdraw all unrealised leRAAC to `recipient`.
+ */
+export declare const withdrawAll: (chainId: ChainId, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/leRAAC/_helpers.d.ts

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

package/dist/types/contracts/tokens/leRAAC/approve.d.ts

@@ -0,0 +1,3 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const approve: (chainId: ChainId, spender: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/leRAAC/burn.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Burn `amount` of the caller's leRAAC.
+ */
+export declare const burn: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/leRAAC/burnFrom.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Burn `amount` of `account`'s leRAAC. Caller must have ERC20 allowance from `account`.
+ */
+export declare const burnFrom: (chainId: ChainId, account: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/leRAAC/getAllowance.d.ts

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

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

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

package/dist/types/contracts/tokens/leRAAC/getMinterInfo.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface LeRAACMinterInfo {
+    isMinter: boolean;
+    ceiling: bigint;
+    minted: bigint;
+}
+export declare const getMinterInfo: (chainId: ChainId, minter: string, provider?: Provider) => Promise<LeRAACMinterInfo>;

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

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

package/dist/types/contracts/tokens/leRAAC/transfer.d.ts

@@ -0,0 +1,3 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const transfer: (chainId: ChainId, to: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/leRAAC/transferFrom.d.ts

@@ -0,0 +1,3 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const transferFrom: (chainId: ChainId, from: string, to: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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;

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

@@ -0,0 +1,16 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface DistributionPoolInfo {
+    pool: string;
+    weight: bigint;
+    pendingRewards: string;
+    pendingRewardsRaw: bigint;
+    exists: boolean;
+    weightShare: number;
+}
+/**
+ * Returns full distribution-pool table along with each pool's share of
+ * `totalWeight`. Iterates `distributionPools(i)` until it reverts (mirrors how
+ * the contract stores the dynamic array) and reads `poolInfo(pool)` for each.
+ */
+export declare const getDistributionPools: (chainId: ChainId, provider?: Provider) => Promise<DistributionPoolInfo[]>;