@raac/rpc 1.2.0-beta.9 → 2.0.0-beta.1

package/dist/types/contracts/housePrices/getLatestPrice.d.ts

@@ -1,10 +1,20 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getLatestPrice(chainId: ChainId, tokenId: string, provider: Provider): Promise<{
-    price: bigint;
+import { TokenAmount } from "../../utils/amount";
+/** Latest house price of a RAAC NFT. */
+export interface LatestHousePrice {
+    /** The house price denominated in the NFT payment token from the chain config (`nfts.raacnft.asset`). */
+    price: TokenAmount;
+    /** UNIX timestamp (seconds) of the last price update. */
     timestamp: bigint;
-} | {
-    price: bigint;
-    timestamp: number;
-}>;
+}
+/**
+ * Reads the latest house price of a RAAC NFT from RAACHousePrices. The contract stores the USD price with 18
+ * decimals and converts it to crvUSD through the crvUSD/USD oracle, returning 18 decimals.
+ * @param chainId The chain id.
+ * @param tokenId The RAAC NFT token id.
+ * @param provider The provider to read with.
+ * @returns The crvUSD price and the timestamp of its last update.
+ */
+declare function getLatestPrice(chainId: ChainId, tokenId: string, provider: Provider): Promise<LatestHousePrice>;
 export default getLatestPrice;

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

@@ -1,6 +1,13 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Claimable amount of a single reward token for `account`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param token - Address of the reward token.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The claimable amount in `token` base units, with its registry decimals and symbol.
  */
-export declare const getClaimable: (chainId: ChainId, account: string, token: string, provider?: Provider) => Promise<bigint>;
+export declare const getClaimable: (chainId: ChainId, account: string, token: string, provider?: Provider) => Promise<TokenAmount>;

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

@@ -1,10 +1,17 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface BotLockerClaimable {
     token: string;
-    amount: bigint;
+    /** Claimable amount in this token's base units, with its registry decimals and symbol. */
+    amount: TokenAmount;
 }
 /**
  * Claimable amounts across all registered reward tokens for `account`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns One entry per reward token, each amount in that token's base units.
  */
 export declare const getClaimables: (chainId: ChainId, account: string, provider?: Provider) => Promise<BotLockerClaimable[]>;

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

@@ -1,7 +1,17 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface BotLockerClaimedReward {
     token: string;
-    amount: bigint;
+    /** Amount already claimed, in this token's base units, with its registry decimals and symbol. */
+    amount: TokenAmount;
 }
+/**
+ * Rewards `account` has already claimed, per reward token.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns One entry per reward token, each amount in that token's base units.
+ */
 export declare const getClaimedRewards: (chainId: ChainId, account: string, provider?: Provider) => Promise<BotLockerClaimedReward[]>;

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

@@ -3,5 +3,10 @@ import { ChainId } from "../../../configs/chains";
 /**
  * Borrow leRAAC against the caller's locked RAAC collateral.
  * If `depositToMaturityVault` is true, borrowed leRAAC is forwarded to the maturity vault for the caller.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - leRAAC to borrow, base units.
+ * @param depositToMaturityVault - True to forward the borrowed leRAAC to the maturity vault.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const borrow: (chainId: ChainId, amount: string | number | bigint, depositToMaturityVault: boolean, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const borrow: (chainId: ChainId, amount: bigint, depositToMaturityVault: boolean, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,9 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Whether a user's position is currently overcollateralised.
+ *
+ * Reserved collateral is scheduled to leave and so is netted out before the check, which is
+ * why a position can go unhealthy on requestUnlock alone, without any new borrowing.
+ */
+export declare const checkAccountHealth: (chainId: ChainId, account: string, provider?: Provider) => Promise<boolean>;

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

@@ -3,5 +3,9 @@ import { ChainId } from "../../../configs/chains";
 /**
  * Deposit RAAC into the liquid locker; locks underlying RAAC into veRAAC for the locker.
  * Caller must have approved the locker to spend RAAC beforehand.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - RAAC to deposit, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const deposit: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const deposit: (chainId: ChainId, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -2,5 +2,9 @@ import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Donate RAAC to be distributed pro-rata to all lockers.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - RAAC to donate, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const donate: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const donate: (chainId: ChainId, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -1,5 +1,6 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { ScaledValue } from "../../../utils/amount";
 export interface LiquidLockerConfig {
     raac: string;
     leRAAC: string;
@@ -11,17 +12,28 @@ export interface LiquidLockerConfig {
     cleverFeeRecipient: string;
     raacBotLocker: string;
     lockDurationEpochs: number;
-    reserveRate: bigint;
-    repayFeePercentage: bigint;
-    harvestBountyPercentage: bigint;
-    treasuryFeePercentage: bigint;
-    feeSharesBots: bigint;
-    feeSharesClever: bigint;
-    feeSharesTreasury: bigint;
+    /** Collateral ratio backing the debt, 9-decimal fixed point (the locker's FEE_PRECISION; 0.5 = 50%). */
+    reserveRate: ScaledValue;
+    /** Fee taken on repay, 9-decimal fixed point (1.0 = 100%). */
+    repayFeePercentage: ScaledValue;
+    /** Share of a harvest paid to the caller, 9-decimal fixed point (1.0 = 100%). */
+    harvestBountyPercentage: ScaledValue;
+    /** Total platform fee on distributed rewards, 9-decimal fixed point (1.0 = 100%). */
+    treasuryFeePercentage: ScaledValue;
+    /** Part of `treasuryFeePercentage` routed to the bot locker, 9-decimal fixed point. */
+    feeSharesBots: ScaledValue;
+    /** Part of `treasuryFeePercentage` routed to the clever fee recipient, 9-decimal fixed point. */
+    feeSharesClever: ScaledValue;
+    /** Part of `treasuryFeePercentage` routed to the treasury, 9-decimal fixed point. */
+    feeSharesTreasury: ScaledValue;
     paused: boolean;
 }
 /**
  * Read the locker's configuration parameters in a single call batch.
  * Frontend setup screens / dashboards should call this to render fee % and linked addresses.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The linked addresses and the fee and ratio parameters as 9-decimal fixed-point values.
  */
 export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<LiquidLockerConfig>;

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

@@ -1,24 +1,27 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { ScaledValue, TokenAmount } from "../../../utils/amount";
 export interface LiquidLockerGlobalInfo {
-    totalLockedGlobal: string;
-    totalUnlockedGlobal: string;
-    totalDebtGlobal: string;
-    pendingCumulatedAmount: string;
-    accRewardPerShare: string;
-    totalRaacInPool: string;
-    poolLockedUnderlying: string;
-    raw: {
-        totalLockedGlobal: bigint;
-        totalUnlockedGlobal: bigint;
-        totalDebtGlobal: bigint;
-        pendingCumulatedAmount: bigint;
-        accRewardPerShare: bigint;
-        totalRaacInPool: bigint;
-        poolLockedUnderlying: bigint;
-    };
+    /** RAAC locked by every user, base units. */
+    totalLockedGlobal: TokenAmount;
+    /** RAAC matured and withdrawable, base units. */
+    totalUnlockedGlobal: TokenAmount;
+    /** leRAAC debt outstanding across every user, base units. */
+    totalDebtGlobal: TokenAmount;
+    /** RAAC waiting to be folded into `accRewardPerShare`, base units. */
+    pendingCumulatedAmount: TokenAmount;
+    /** Accumulated RAAC reward per locked RAAC, 18-decimal fixed point (the locker's PRECISION). */
+    accRewardPerShare: ScaledValue;
+    /** RAAC held by the locker across veRAAC and its own balance, base units. */
+    totalRaacInPool: TokenAmount;
+    /** RAAC locked in veRAAC by the locker, base units. */
+    poolLockedUnderlying: TokenAmount;
 }
 /**
  * One-shot snapshot of locker global accounting.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The global totals; see `LiquidLockerGlobalInfo` for the unit of each field.
  */
 export declare const getGlobalInfo: (chainId: ChainId, provider?: Provider) => Promise<LiquidLockerGlobalInfo>;

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

@@ -1,21 +1,24 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface LiquidLockerUserInfo {
-    totalDeposited: string;
-    totalPendingUnlocked: string;
-    totalUnlocked: string;
-    totalBorrowed: string;
-    totalReward: string;
-    raw: {
-        totalDeposited: bigint;
-        totalPendingUnlocked: bigint;
-        totalUnlocked: bigint;
-        totalBorrowed: bigint;
-        totalReward: bigint;
-    };
+    /** RAAC the user has locked, base units. */
+    totalDeposited: TokenAmount;
+    /** RAAC scheduled to unlock but not yet matured, base units. */
+    totalPendingUnlocked: TokenAmount;
+    /** RAAC matured and withdrawable, base units. */
+    totalUnlocked: TokenAmount;
+    /** leRAAC debt outstanding, base units. */
+    totalBorrowed: TokenAmount;
+    /** RAAC rewards accrued to the user, base units. */
+    totalReward: TokenAmount;
 }
 /**
- * Get a user's locker totals. Mirrors RAACLiquidLocker.getUserInfo with both
- * formatted (ether) and raw values returned for convenience.
+ * Get a user's locker totals. Mirrors RAACLiquidLocker.getUserInfo.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The user's totals; see `LiquidLockerUserInfo` for the unit of each field.
  */
 export declare const getUserInfo: (chainId: ChainId, account: string, provider?: Provider) => Promise<LiquidLockerUserInfo>;

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

@@ -1,17 +1,30 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface PendingUnlockInfo {
-    pendingUnlock: string;
+    /** Total RAAC held in this bucket, base units, maturing at the start of `unlockEpoch`. */
+    pendingUnlock: TokenAmount;
+    /** The portion of `pendingUnlock` already scheduled to unlock, RAAC base units. */
+    reservedAmount: TokenAmount;
+    /** The portion still open, which auto-relocks at maturity unless reserved first, RAAC base units. */
+    openAmount: TokenAmount;
     unlockEpoch: number;
     unlockTimestamp: number;
+    /** Any part of this bucket is scheduled to unlock. */
     reserved: boolean;
-    raw: {
-        pendingUnlock: bigint;
-        unlockEpoch: bigint;
-        reserved: boolean;
-    };
+    /** The whole bucket is scheduled to unlock; nothing here will relock. */
+    fullyReserved: boolean;
 }
 /**
- * Returns the user's pending (future) unlock entries.
+ * Returns the user's pending (future) unlock buckets.
+ *
+ * Reservations are partial: a bucket can be wholly open, wholly reserved, or split between
+ * the two, so `reserved` alone does not say how much of it is leaving. Use `openAmount` for
+ * what is still reservable via requestUnlock and `reservedAmount` for what is already scheduled.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The buckets, with every amount in RAAC base units.
  */
 export declare const getUserLocks: (chainId: ChainId, account: string, provider?: Provider) => Promise<PendingUnlockInfo[]>;

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

@@ -3,5 +3,10 @@ import { ChainId } from "../../../configs/chains";
 /**
  * Harvest veRAAC rewards, swap to RAAC via the configured Zap, and distribute.
  * Caller must hold HARVEST_ROLE; receives the harvest bounty at `recipient`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param recipient - Address that receives the harvest bounty.
+ * @param minimumOut - Minimum RAAC the swap must return, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const harvest: (chainId: ChainId, recipient: string, minimumOut: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const harvest: (chainId: ChainId, recipient: string, minimumOut: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,22 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+export interface LiquidLockerWithdrawPreview {
+    /** RAAC that would be paid out to the user, base units. */
+    payout: TokenAmount;
+    /** RAAC that would be relocked instead, to keep the outstanding debt backed, base units. */
+    relock: TokenAmount;
+}
+/**
+ * Projects how the caller's matured reservations would split on withdrawUnlocked.
+ *
+ * A withdrawal never leaves the debt undercollateralised: whatever the position is short of
+ * the collateral the debt requires is relocked rather than paid out. Mirrors the same split
+ * withdrawUnlocked applies, so the preview cannot drift from the transaction.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The payout and relock split, in RAAC base units.
+ */
+export declare const previewWithdraw: (chainId: ChainId, account: string, provider?: Provider) => Promise<LiquidLockerWithdrawPreview>;

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

@@ -2,6 +2,10 @@ import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Repay outstanding leRAAC debt. The fee portion is transferred to the treasury,
- * the net portion is burned via leRAAC.burnFrom — caller must approve the locker on the leRAAC token first.
+ * the net portion is burned via leRAAC.burnFrom - caller must approve the locker on the leRAAC token first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param leRAACAmount - leRAAC to repay, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const repay: (chainId: ChainId, leRAACAmount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const repay: (chainId: ChainId, leRAACAmount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -1,7 +1,19 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
- * Reserve `numLocks` of the caller's pending future-locks for unlock at their existing maturity epoch(s).
- * Health is checked against (totalLocked - newUnlock) and current debt.
+ * Schedule `amount` of the caller's locked RAAC, in base units, for unlock.
+ *
+ * The locker reserves against the caller's future unlock buckets soonest-maturing first,
+ * partial-reserving the boundary bucket. When the remainder left in that bucket would fall
+ * below veRAAC's minimum lock, the whole bucket is taken instead — so the amount actually
+ * scheduled can exceed `amount` by up to that minimum. Scheduling less than `amount`
+ * (open capacity is short) reverts with InsufficientToUnlock.
+ *
+ * Health is checked against (totalLocked - alreadyReserved - amount) and current debt,
+ * reverting with InsufficientCollateral when the remaining collateral would not back the debt.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - RAAC to schedule for unlock, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const requestUnlock: (chainId: ChainId, numLocks: number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const requestUnlock: (chainId: ChainId, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -2,6 +2,12 @@ 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).
+ * `weight` is in basis points (0 to 10000, where 10000 is 100% of the locker's voting power).
+ *
+ * @param chainId - The chain/network to use.
+ * @param controller - Address of the GaugeController.
+ * @param gauge - Address of the gauge.
+ * @param weight - Vote weight in basis points.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const voteGauge: (chainId: ChainId, controller: string, gauge: string, weight: number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const voteGauge: (chainId: ChainId, controller: string, gauge: string, weight: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -3,5 +3,9 @@ import { ChainId } from "../../../configs/chains";
 /**
  * Deposit leRAAC into the maturity vault for the caller.
  * Caller must have approved leRAAC to the vault first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - leRAAC to deposit, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const deposit: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const deposit: (chainId: ChainId, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -2,5 +2,10 @@ import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Deposit leRAAC into the maturity vault crediting `account`. Caller pays.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address credited with the deposit.
+ * @param amount - leRAAC to deposit, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const depositFor: (chainId: ChainId, account: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const depositFor: (chainId: ChainId, account: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -3,5 +3,10 @@ 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.
+ *
+ * @param chainId - The chain/network to use.
+ * @param origin - Address whose RAAC is pulled.
+ * @param amount - RAAC to distribute, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const distribute: (chainId: ChainId, origin: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const distribute: (chainId: ChainId, origin: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -1,12 +1,22 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { ScaledValue } from "../../../utils/amount";
 export interface MaturityVaultConfig {
     raac: string;
     leRAAC: string;
     platform: string;
     governor: string;
     owner: string;
-    platformFeePercentage: bigint;
-    harvestBountyPercentage: bigint;
+    /** Platform fee on distributed rewards, 9-decimal fixed point (1.0 = 100%). */
+    platformFeePercentage: ScaledValue;
+    /** Share of a harvest paid to the caller, 9-decimal fixed point (1.0 = 100%). */
+    harvestBountyPercentage: ScaledValue;
 }
+/**
+ * Reads the vault's linked addresses and fee parameters.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The addresses and the fees as 9-decimal fixed-point values.
+ */
 export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<MaturityVaultConfig>;

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

@@ -1,32 +1,32 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface MaturityVaultRewardInfo {
-    ratePerSecond: string;
+    /** RAAC distributed per second by the active linear schedule, base units. */
+    ratePerSecond: TokenAmount;
+    /** Schedule length, seconds. */
     periodLength: number;
     lastUpdate: number;
     finishAt: number;
-    raw: {
-        ratePerSecond: bigint;
-        periodLength: bigint;
-        lastUpdate: bigint;
-        finishAt: bigint;
-    };
 }
 export interface MaturityVaultGlobalInfo {
-    totalRAACInPool: string;
-    totalUnrealised: string;
-    totalRealised: string;
+    /** RAAC held by the vault, base units. */
+    totalRAACInPool: TokenAmount;
+    /** leRAAC still waiting to be paid off, base units. */
+    totalUnrealised: TokenAmount;
+    /** RAAC realised and claimable by depositors, base units. */
+    totalRealised: TokenAmount;
+    /** Product of the per-distribution unrealised fractions, an unsigned 128.128 binary fixed-point value (2^128 = 1). */
     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.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault totals and reward schedule; see `MaturityVaultGlobalInfo` for the unit of each field.
  */
 export declare const getGlobalInfo: (chainId: ChainId, provider?: Provider) => Promise<MaturityVaultGlobalInfo>;

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

@@ -1,14 +1,18 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface MaturityVaultUserInfo {
-    unrealised: string;
-    realised: string;
-    raw: {
-        unrealised: bigint;
-        realised: bigint;
-    };
+    /** leRAAC still earning, not yet paid off, base units. */
+    unrealised: TokenAmount;
+    /** RAAC realised and claimable, base units. */
+    realised: TokenAmount;
 }
 /**
  * Returns the user's unrealised (still-earning leRAAC) and realised (claimable RAAC) totals.
+ *
+ * @param chainId - The chain/network to use.
+ * @param account - Address of the user.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The user's unrealised leRAAC and realised RAAC, in base units.
  */
 export declare const getUserInfo: (chainId: ChainId, account: string, provider?: Provider) => Promise<MaturityVaultUserInfo>;

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

@@ -2,5 +2,10 @@ import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Withdraw `amount` of unrealised leRAAC to `recipient`.
+ *
+ * @param chainId - The chain/network to use.
+ * @param recipient - Address that receives the leRAAC.
+ * @param amount - leRAAC to withdraw, base units.
+ * @param signer - An ethers.js Signer instance (required).
  */
-export declare const withdraw: (chainId: ChainId, recipient: string, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const withdraw: (chainId: ChainId, recipient: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/**
+ * Builds the pmBlender (TokenBlender) contract for reads.
+ * @param chainId The chain id.
+ * @param provider Optional provider; defaults to the chain's first configured RPC.
+ * @returns The contract and its address.
+ */
+export declare function getPmBlenderContract(chainId: ChainId, provider?: Provider): {
+    contract: any;
+    address: string;
+};

package/dist/types/contracts/pmBlender/getReserveBalance.d.ts

@@ -1,3 +1,11 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getReserveBalance(chainId: ChainId): Promise<string | -1>;
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads the pmBlender reserve: the sum of every supported token balance converted at its ratio.
+ * @param chainId The chain id.
+ * @param provider Optional provider; defaults to the chain's first configured RPC.
+ * @returns The reserve, denominated in the pmBlender token (registry decimals and symbol, else 18 decimals: TokenBlender is an 18-decimal ERC20).
+ */
+declare function getReserveBalance(chainId: ChainId, provider?: Provider): Promise<TokenAmount>;
 export default getReserveBalance;

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

@@ -1,3 +1,13 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function previewDeposit(chainId: ChainId, token: string, amount: string): Promise<bigint | -1>;
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Previews how many pmBlender tokens a deposit mints.
+ * @param chainId The chain id.
+ * @param token The supported token to deposit.
+ * @param amount The deposit in `token` base units (TokenBlender only supports 18-decimal tokens).
+ * @param provider Optional provider; defaults to the chain's first configured RPC.
+ * @returns The pmBlender tokens minted, in the pmBlender token (registry decimals and symbol, else 18 decimals: TokenBlender is an 18-decimal ERC20).
+ */
+declare function previewDeposit(chainId: ChainId, token: string, amount: bigint, provider?: Provider): Promise<TokenAmount>;
 export default previewDeposit;

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

@@ -1,3 +1,14 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function previewSwap(chainId: ChainId, tokenIn: string, tokenOut: string, amountIn: string): Promise<string | -1>;
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Previews a swap between two supported tokens.
+ * @param chainId The chain id.
+ * @param tokenIn The supported token sent.
+ * @param tokenOut The supported token received.
+ * @param amountIn The amount sent in `tokenIn` base units (TokenBlender only supports 18-decimal tokens).
+ * @param provider Optional provider; defaults to the chain's first configured RPC.
+ * @returns The amount of `tokenOut` received, with its registry decimals and symbol (18 decimals if not in the registry, which TokenBlender enforces for supported tokens).
+ */
+declare function previewSwap(chainId: ChainId, tokenIn: string, tokenOut: string, amountIn: bigint, provider?: Provider): Promise<TokenAmount>;
 export default previewSwap;

package/dist/types/contracts/pmBlender/previewWithdraw.d.ts

@@ -1,3 +1,13 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function previewWithdraw(chainId: ChainId, token: string, amountOut: string): Promise<string | -1>;
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Previews how many pmBlender tokens are burned to withdraw an exact amount of a supported token.
+ * @param chainId The chain id.
+ * @param token The supported token to withdraw.
+ * @param amountOut The amount to receive in `token` base units (TokenBlender only supports 18-decimal tokens).
+ * @param provider Optional provider; defaults to the chain's first configured RPC.
+ * @returns The pmBlender tokens burned, in the pmBlender token (registry decimals and symbol, else 18 decimals: TokenBlender is an 18-decimal ERC20).
+ */
+declare function previewWithdraw(chainId: ChainId, token: string, amountOut: bigint, provider?: Provider): Promise<TokenAmount>;
 export default previewWithdraw;