@raac/rpc 2.0.0-beta.12 → 2.0.0-beta.13

package/dist/pools/stabilityPool/getAdminState.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const getWithdrawTimelockConfig_1 = require("./getWithdrawTimelockConfig");
+/**
+ * Owner, pause state, managers, linked contracts, liquidation split and withdraw timelock.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @throws When the configured address has no contract, which the generic decode error would hide.
+ */
+async function getAdminState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+    if ((await provider.getCode(address)) === "0x")
+        throw new Error(`There is no contract at the configured stability pool address ${address}.`);
+    const sp = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("stabilitypool"), provider);
+    const [owner, paused, managers, rwaVault, liquidationStrategyProxy, liquidationSwap, feeCollector, split, timelock] = await Promise.all([
+        sp.owner(),
+        sp.paused(),
+        sp.getManagerList(),
+        sp.rwaVault(),
+        sp.liquidationStrategyProxy(),
+        sp.liquidationSwap(),
+        sp.feeCollector(),
+        sp.liquidationSplit(),
+        (0, getWithdrawTimelockConfig_1.getWithdrawTimelockConfig)(chainId, provider),
+    ]);
+    return {
+        owner,
+        paused,
+        managers: [...managers].map((m) => ethers_1.ethers.getAddress(m)),
+        rwaVault,
+        liquidationStrategyProxy,
+        liquidationSwap,
+        feeCollector,
+        split: { mintBps: split[0], burnBps: split[1], swapBps: split[2], liquidityBps: split[3] },
+        withdrawTimelockDuration: timelock.duration,
+        withdrawTimelockDelay: timelock.delay,
+    };
+}
+exports.default = getAdminState;

package/dist/pools/stabilityPool/liquidation.js

@@ -0,0 +1,297 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minSharesOut = exports.sameSplit = exports.splitTotal = exports.SPLIT_KEYS = void 0;
+exports.readLiquidationContext = readLiquidationContext;
+exports.readLiquidationTarget = readLiquidationTarget;
+exports.quoteLiquidation = quoteLiquidation;
+exports.suggestSplit = suggestSplit;
+exports.simulateWithSplit = simulateWithSplit;
+/**
+ * Liquidation simulation for StabilityPool.liquidateBorrower, mirroring LiquidationStrategyProxy:
+ *   1. the seized collateral is deposited into the RWAVault for vault-token shares, unless it already is the vault token;
+ *   2. the stability pool's whole vault-token balance (the proxy runs under delegatecall) is split by BPS into
+ *      mint (treasury fee), burn, swap and liquidity (fee collector);
+ *   3. only the swap slice becomes crvUSD, through LiquidationSwap and its Curve pool;
+ *   3b. LiquidationSwap reverts when slippage protection is on and get_dy falls below pricePerShare / oracle price
+ *       less its tolerance, which is the case when Curve trades below the vault's value;
+ *   4. the crvUSD must cover the position's debt; any shortfall is withdrawn from the LendingPool with the pool's
+ *      rTokens, so stability pool depositors pay it, and the call reverts (InsufficientBalance) if they hold too few.
+ */
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const getAdapters_1 = __importDefault(require("../rwaVault/getAdapters"));
+const getParameters_1 = __importDefault(require("../lendingPool/getParameters"));
+const BPS = BigInt(10_000);
+const WAD = BigInt(10) ** BigInt(18);
+const ZERO = BigInt(0);
+const SWAP_ABI = [
+    "function liquidityPool() view returns (address)",
+    "function swapToken() view returns (address)",
+    "function iIn() view returns (uint256)",
+    "function iOut() view returns (uint256)",
+    "function enableSlippageProtection() view returns (bool)",
+    "function slippageProtectionBps() view returns (uint256)",
+    "function crvusdToUSDOracle() view returns (address)",
+];
+const CURVE_ABI = ["function get_dy(uint256 i, uint256 j, uint256 dx) view returns (uint256)", "function balances(uint256 i) view returns (uint256)"];
+const VAULT_ABI = ["function underlyingVaultToken() view returns (address)", "function previewDeposit(uint256 assetAmount) view returns (uint256)", "function pricePerShare() view returns (uint256)"];
+const VAULT_ADAPTER_ABI = ["function getAssetToken() view returns (address)", "function getAssetValue(bytes data) view returns (uint256)"];
+const ADAPTER_ABI = [
+    "function getAssetToken() view returns (address)",
+    "function getAssetType() view returns (string)",
+    "function getAssetValue(address user, bytes data) view returns (uint256)",
+    "function balanceOf(address user) view returns (uint256)",
+    "function getDepositedTokens(address user) view returns (uint256[])",
+];
+const ERC20_ABI = ["function balanceOf(address) view returns (uint256)"];
+exports.SPLIT_KEYS = ["mintBps", "burnBps", "swapBps", "liquidityBps"];
+const splitTotal = (s) => s.mintBps + s.burnBps + s.swapBps + s.liquidityBps;
+exports.splitTotal = splitTotal;
+const sameSplit = (a, b) => exports.SPLIT_KEYS.every((k) => a[k] === b[k]);
+exports.sameSplit = sameSplit;
+const contract = (address, abi, provider) => new ethers_1.ethers.Contract(address, abi, provider);
+const decodeAmount = (data) => ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["uint256"], data)[0];
+/** Reads the stability pool's liquidation route, split, balances and the LendingPool grace period. */
+async function readLiquidationContext(chainId, provider) {
+    const stabilityPool = (0, contracts_1.getContractAddress)(chainId, "stabilitypool");
+    const sp = contract(stabilityPool, (0, artifacts_1.getABI)("stabilitypool"), provider);
+    const [liquidationSwap, rwaVault, split, rToken, params] = await Promise.all([
+        sp.liquidationSwap(),
+        sp.rwaVault(),
+        sp.liquidationSplit(),
+        sp.rToken(),
+        (0, getParameters_1.default)(chainId, provider),
+    ]);
+    if (liquidationSwap === ethers_1.ethers.ZeroAddress)
+        throw new Error("The stability pool has no LiquidationSwap set, so the swap leg reverts.");
+    const swap = contract(liquidationSwap, SWAP_ABI, provider);
+    const vault = contract(rwaVault, VAULT_ABI, provider);
+    const [liquidityPool, iIn, iOut, vaultToken, protect] = await Promise.all([
+        swap.liquidityPool(),
+        swap.iIn(),
+        swap.iOut(),
+        vault.underlyingVaultToken(),
+        swap.enableSlippageProtection(),
+    ]);
+    const slippage = protect
+        ? await Promise.all([
+            swap.slippageProtectionBps(),
+            vault.pricePerShare(),
+            swap.crvusdToUSDOracle().then((o) => contract(o, ["function getPrice() view returns (uint256)"], provider).getPrice()),
+        ]).then(([bps, pricePerShare, oraclePrice]) => ({ bps, pricePerShare, oraclePrice }))
+        : null;
+    if (liquidityPool === ethers_1.ethers.ZeroAddress)
+        throw new Error("LiquidationSwap has no Curve pool set, so the swap leg reverts.");
+    const [vaultSymbol, poolVaultTokens, rTokens] = await Promise.all([
+        contract(vaultToken, ["function symbol() view returns (string)"], provider).symbol().catch(() => "vault token"),
+        contract(vaultToken, ERC20_ABI, provider).balanceOf(stabilityPool),
+        contract(rToken, ERC20_ABI, provider).balanceOf(stabilityPool),
+    ]);
+    return {
+        stabilityPool,
+        liquidationSwap,
+        liquidityPool,
+        rwaVault,
+        vaultToken,
+        vaultSymbol,
+        iIn,
+        iOut,
+        split: { mintBps: split[0], burnBps: split[1], swapBps: split[2], liquidityBps: split[3] },
+        poolVaultTokens,
+        rTokens,
+        gracePeriod: Number(params.liquidationGracePeriod),
+        slippage,
+    };
+}
+/**
+ * Rebuilds the `data` the pool adapter expects. Position ids are "user:adapter:key" with `key` a hash, so the
+ * adapter's deposits are enumerated and matched against it (ERC721AssetAdapter keys are
+ * keccak256(abi.encodePacked(token, tokenId))). ERC20 adapters only accept the full deposited balance.
+ */
+async function readLiquidationData(provider, poolAdapter, user, positionKey) {
+    const adapter = contract(poolAdapter, ADAPTER_ABI, provider);
+    const [assetType, assetToken] = await Promise.all([adapter.getAssetType(), adapter.getAssetToken()]);
+    const coder = ethers_1.ethers.AbiCoder.defaultAbiCoder();
+    if (assetType === "ERC721") {
+        const ids = [...(await adapter.getDepositedTokens(user))];
+        if (!ids.length)
+            throw new Error("The adapter holds no NFT collateral for this borrower anymore.");
+        const tokenId = positionKey ? ids.find((id) => ethers_1.ethers.solidityPackedKeccak256(["address", "uint256"], [assetToken, id]) === positionKey.toLowerCase()) : ids[0];
+        if (tokenId === undefined)
+            throw new Error("None of the borrower's deposited NFTs matches this position.");
+        return { data: coder.encode(["uint256"], [tokenId]), assetType, assetToken };
+    }
+    const balance = await adapter.balanceOf(user);
+    if (balance === ZERO)
+        throw new Error("The adapter holds no collateral for this borrower anymore.");
+    return { data: coder.encode(["uint256"], [balance]), assetType, assetToken };
+}
+/** The RWAVault adapter for the collateral's token; LiquidationStrategyProxy reverts (AdaptersAssetMismatch) otherwise. */
+async function findVaultAdapter(chainId, provider, assetToken, vaultToken) {
+    const { adapters } = await (0, getAdapters_1.default)(chainId, provider);
+    for (const candidate of adapters) {
+        const token = await contract(candidate, VAULT_ADAPTER_ABI, provider).getAssetToken().catch(() => null);
+        if (token?.toLowerCase() === assetToken.toLowerCase())
+            return ethers_1.ethers.getAddress(candidate);
+    }
+    // Vault-token collateral skips the deposit, so any adapter passes the proxy's check.
+    if (assetToken.toLowerCase() === vaultToken.toLowerCase() && adapters.length)
+        return ethers_1.ethers.getAddress(adapters[0]);
+    throw new Error("No RWAVault adapter accepts this collateral's token, so the deposit would revert.");
+}
+/** Assembles liquidateBorrower's arguments and the position's state for one position id ("user:adapter:key"). */
+async function readLiquidationTarget(chainId, provider, ctx, positionId) {
+    const [user, poolAdapter, positionKey] = positionId.split(":");
+    const { data, assetType, assetToken } = await readLiquidationData(provider, poolAdapter, user, positionKey);
+    const pool = contract((0, contracts_1.getContractAddress)(chainId, "lendingpool"), (0, artifacts_1.getABI)("lendingpool"), provider);
+    const [vaultAdapter, collateralValue, debt, position] = await Promise.all([
+        findVaultAdapter(chainId, provider, assetToken, ctx.vaultToken),
+        contract(poolAdapter, ADAPTER_ABI, provider).getAssetValue(user, data),
+        pool.getPositionScaledDebt(poolAdapter, user, data),
+        pool.getPosition(poolAdapter, user, data),
+    ]);
+    return {
+        poolAdapter: ethers_1.ethers.getAddress(poolAdapter),
+        vaultAdapter,
+        user: ethers_1.ethers.getAddress(user),
+        data,
+        assetType,
+        assetToken,
+        isVaultToken: assetToken.toLowerCase() === ctx.vaultToken.toLowerCase(),
+        collateralValue,
+        debt,
+        isUnderLiquidation: position.isUnderLiquidation,
+        isInsured: position.isInsured,
+        liquidationStartTime: Number(position.liquidationStartTime),
+    };
+}
+async function quoteDy(provider, ctx, amount) {
+    if (amount <= ZERO)
+        return ZERO;
+    return contract(ctx.liquidityPool, CURVE_ABI, provider).get_dy(ctx.iIn, ctx.iOut, amount).catch(() => null);
+}
+/** Prices the liquidation with `split`, using the deployed Curve pool's get_dy rather than the vault's oracle price. */
+async function quoteLiquidation(provider, ctx, target, split) {
+    // poolDepositAsset mints from the vault adapter's own valuation, which may use a different oracle than the pool's.
+    const sharesFromCollateral = target.isVaultToken
+        ? decodeAmount(target.data)
+        : await contract(ctx.rwaVault, VAULT_ABI, provider).previewDeposit(await contract(target.vaultAdapter, VAULT_ADAPTER_ABI, provider).getAssetValue(target.data));
+    const totalVaultTokens = sharesFromCollateral + ctx.poolVaultTokens;
+    const swapAmount = (totalVaultTokens * split.swapBps) / BPS;
+    const [swapOut, maxSwapOut, spotOut, poolReserveOut] = await Promise.all([
+        quoteDy(provider, ctx, swapAmount),
+        quoteDy(provider, ctx, totalVaultTokens),
+        quoteDy(provider, ctx, WAD),
+        contract(ctx.liquidityPool, CURVE_ABI, provider).balances(ctx.iOut).catch(() => null),
+    ]);
+    let priceImpactBps = null;
+    if (swapOut !== null && spotOut && swapAmount > ZERO) {
+        const realised = (swapOut * WAD) / swapAmount;
+        priceImpactBps = realised >= spotOut ? ZERO : ((spotOut - realised) * BPS) / spotOut;
+    }
+    return {
+        split,
+        sharesFromCollateral,
+        totalVaultTokens,
+        swapAmount,
+        swapOut,
+        minSwapOut: ctx.slippage && swapAmount > ZERO ? ((ctx.slippage.pricePerShare * swapAmount) / ctx.slippage.oraclePrice) * (BPS - ctx.slippage.bps) / BPS : null,
+        shortfall: swapOut === null ? target.debt : swapOut >= target.debt ? ZERO : target.debt - swapOut,
+        coversDebt: swapOut !== null && swapOut >= target.debt,
+        badDebt: target.collateralValue < target.debt ? target.debt - target.collateralValue : ZERO,
+        maxSwapOut,
+        priceImpactBps,
+        poolReserveOut,
+    };
+}
+/**
+ * The smallest swap share whose get_dy still covers the debt plus `bufferBps`, with the rest given back to mint,
+ * burn and liquidity in their current proportion. get_dy grows with dx, so a binary search over BPS is sound.
+ */
+async function suggestSplit(provider, ctx, target, quote, bufferBps = BigInt(100)) {
+    if (quote.totalVaultTokens <= ZERO)
+        return null;
+    const required = (target.debt * (BPS + bufferBps)) / BPS;
+    const spread = (swapBps, projectedOut, bestEffort) => {
+        const rest = BPS - swapBps;
+        const others = ctx.split.mintBps + ctx.split.burnBps + ctx.split.liquidityBps;
+        const mintBps = others === ZERO ? ZERO : (rest * ctx.split.mintBps) / others;
+        const burnBps = others === ZERO ? ZERO : (rest * ctx.split.burnBps) / others;
+        return { mintBps, burnBps, swapBps, liquidityBps: rest - mintBps - burnBps, projectedOut, bestEffort };
+    };
+    const full = quote.maxSwapOut ?? (await quoteDy(provider, ctx, quote.totalVaultTokens));
+    if (full === null)
+        return null;
+    if (full < required)
+        return spread(BPS, full, true);
+    let low = ZERO;
+    let high = BPS;
+    let best = full;
+    while (low < high) {
+        const mid = (low + high) / BigInt(2);
+        const out = await quoteDy(provider, ctx, (quote.totalVaultTokens * mid) / BPS);
+        if (out !== null && out >= required) {
+            high = mid;
+            best = out;
+        }
+        else {
+            low = mid + BigInt(1);
+        }
+    }
+    return spread(low, best, false);
+}
+/** minSharesOut for the RWAVault deposit: previewDeposit less `slippageBps`. Zero when nothing is deposited. */
+const minSharesOut = (target, quote, slippageBps) => (target.isVaultToken ? ZERO : (quote.sharesFromCollateral * (BPS - slippageBps)) / BPS);
+exports.minSharesOut = minSharesOut;
+// StabilityPoolStorage is inherited first and the OpenZeppelin parents use namespaced storage, so liquidationSplit
+// takes slots 10 to 13. Checked against the live split before it is relied on.
+const SPLIT_SLOT = 10;
+/**
+ * Simulates liquidateBorrower from `sender` with the split overridden in storage (an eth_call state override), so a
+ * split change in the same batch is simulated rather than only checked. Returns null when the RPC or the storage
+ * layout cannot be used; otherwise the revert reason, or "" when it succeeds.
+ */
+async function simulateWithSplit(provider, ctx, sender, data, split) {
+    const send = provider.send?.bind(provider);
+    if (!send)
+        return null;
+    const slot = (i) => ethers_1.ethers.toBeHex(SPLIT_SLOT + i, 32);
+    try {
+        const live = await Promise.all(exports.SPLIT_KEYS.map((_, i) => provider.getStorage(ctx.stabilityPool, SPLIT_SLOT + i)));
+        if (exports.SPLIT_KEYS.some((k, i) => BigInt(live[i]) !== ctx.split[k]))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const stateDiff = Object.fromEntries(exports.SPLIT_KEYS.map((k, i) => [slot(i), ethers_1.ethers.toBeHex(split[k], 32)]));
+    try {
+        await send("eth_call", [{ from: sender, to: ctx.stabilityPool, data }, "latest", { [ctx.stabilityPool]: { stateDiff } }]);
+        return "";
+    }
+    catch (error) {
+        if (!ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+            return null;
+        return (error.data && attemptParse(error.data)) || error.reason || error.shortMessage;
+    }
+}
+function attemptParse(data) {
+    for (const key of ["stabilitypool", "lendingpool"]) {
+        try {
+            const e = new ethers_1.ethers.Interface((0, artifacts_1.getABI)(key)).parseError(data);
+            if (e)
+                return e.name === "Error" ? String(e.args[0]) : e.name;
+        }
+        catch { }
+    }
+    try {
+        return ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["string"], ethers_1.ethers.dataSlice(data, 4))[0];
+    }
+    catch {
+        return null;
+    }
+}

package/dist/prices/tokenPricesUSD.js

@@ -11,8 +11,6 @@ exports.TOKEN_PRICES_USD = {
     pmusd: 1,
     crvusd: 1, // same token the chain config's asset registry displays as pmUSD
     ireet: 1, // RWA index token (NAV ~ 0.995, rounded to 1 for display)
-    usdc: 1,
-    leraac: 5,
 };
 /** Static USD price for a token symbol (0 if unknown). */
 function getTokenPriceUSD(symbol) {

package/dist/types/RPCLibrary.d.ts

@@ -88,12 +88,7 @@ import { quoteBuy } from "./contracts/zeno/quoteBuy";
 import { ChainId } from "./configs/chains";
 import getBaseUri from "./nfts/getBaseUri";
 import claimRewardFromPool from "./contracts/feeCollector/claimRewardFromPool";
-import { getState as getStateRentStreamer } from "./contracts/rentStreamer/getState";
-import { previewRelease as previewReleaseRentStreamer } from "./contracts/rentStreamer/previewRelease";
-import { getScheduled as getScheduledRentStreamer } from "./contracts/rentStreamer/getScheduled";
-import { getEpochProjection as getEpochProjectionRentStreamer } from "./contracts/rentStreamer/getEpochProjection";
-import { sync as syncRentStreamer } from "./contracts/rentStreamer/sync";
-import { release as releaseRentStreamer } from "./contracts/rentStreamer/release";
+import getFeeCollectorState from "./contracts/feeCollector/getState";
 import getRawUserDepositsInLendingPool from "./pools/lendingPool/getRawUserDepositsInLendingPool";
 import getRawUserDepositInStabilityPool from "./pools/stabilityPool/getRawUserDepositsInStabilityPool";
 import getEligibleUserDeposits from "./pools/lendingPool/getEligibleUserDeposits";
@@ -130,6 +125,18 @@ import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from ".
 import { getWithdrawTimelockConfig as getStabilityPoolWithdrawTimelockConfig } from "./pools/stabilityPool/getWithdrawTimelockConfig";
 import { requestWithdraw as requestStabilityPoolWithdraw } from "./pools/stabilityPool/requestWithdraw";
 import { getVaultInfo as getPsmVaultInfo } from "./contracts/psm/getVaultInfo";
+import { getVaultSettings as getPsmVaultSettings } from "./contracts/psm/getVaultSettings";
+import getHousePricesState from "./contracts/housePrices/getState";
+import getCrvUSDToUSDOracleState from "./contracts/crvUSDToUSDOracle/getState";
+import getRoles from "./contracts/getRoles";
+import getTreasuryState from "./contracts/treasury/getState";
+import getComplianceStatuses from "./contracts/complianceRegistry/getStatuses";
+import getStabilityPoolAdminState from "./pools/stabilityPool/getAdminState";
+import { readLiquidationContext, readLiquidationTarget, quoteLiquidation, suggestSplit, simulateWithSplit, minSharesOut } from "./pools/stabilityPool/liquidation";
+import { getEmissionSchedule, getSchedulePosition, getEmissionPerSecondForWeek, getMintingWeekForTimestamp } from "./minter/emissionSchedule";
+import getRWAVaultRegisteredAdapters from "./pools/rwaVault/getRegisteredAdapters";
+import getRWAVaultSeedStatus from "./pools/rwaVault/getSeedStatus";
+import getLendingPoolAdminState from "./pools/lendingPool/getAdminState";
 import { previewDeposit as previewDepositPsm } from "./contracts/psm/previewDeposit";
 import { previewRedeem as previewRedeemPsm } from "./contracts/psm/previewRedeem";
 import { previewSwap as previewSwapPsm } from "./contracts/psm/previewSwap";
@@ -146,6 +153,7 @@ import * as gaugeMethods from "./contracts/governance/gauge";
 import * as controllerMethods from "./contracts/governance/gaugeController";
 import * as gaugeSystemMethods from "./contracts/governance/gaugeSystems";
 import * as curveCommonMethods from "./contracts/curve/common";
+import * as faucetMethods from "./contracts/faucet";
 import * as userMethods from "./user";
 import { cancel as cancelProposals } from "./contracts/governance/proposals/cancel";
 import { getQuorumNumerator as getQuorumNumeratorProposals } from "./contracts/governance/proposals/getQuorumNumerator";
@@ -327,6 +335,7 @@ declare class RPCLibrary {
     curve: {
         common: typeof curveCommonMethods;
     };
+    faucet: typeof faucetMethods;
     user: typeof userMethods;
     prices: {
         getPrices: typeof getPrices;
@@ -377,8 +386,19 @@ declare class RPCLibrary {
     contracts: {
         housePrices: {
             getLatestPrice: typeof getLatestPrice;
+            getState: typeof getHousePricesState;
             setOracle: typeof setOracle;
         };
+        crvUSDToUSDOracle: {
+            getState: typeof getCrvUSDToUSDOracleState;
+        };
+        treasury: {
+            getState: typeof getTreasuryState;
+        };
+        complianceRegistry: {
+            getStatuses: typeof getComplianceStatuses;
+        };
+        getRoles: typeof getRoles;
         minter: {
             tick: typeof tick;
             get: typeof get;
@@ -394,6 +414,10 @@ declare class RPCLibrary {
             calculateScheduledMintableAmount: typeof calculateScheduledMintableAmountMinter;
             getEmissionPerSecond: typeof getEmissionPerSecondMinter;
             isPaused: typeof isPausedMinter;
+            getEmissionSchedule: typeof getEmissionSchedule;
+            getSchedulePosition: typeof getSchedulePosition;
+            getEmissionPerSecondForWeek: typeof getEmissionPerSecondForWeek;
+            getMintingWeekForTimestamp: typeof getMintingWeekForTimestamp;
         };
         getContractAddress: typeof getContractAddress;
         getContract: typeof getContract;
@@ -404,14 +428,7 @@ declare class RPCLibrary {
         getTokenMetadata: typeof getTokenMetadata;
         feeCollector: {
             claimRewardFromPool: typeof claimRewardFromPool;
-        };
-        rentStreamer: {
-            getState: typeof getStateRentStreamer;
-            previewRelease: typeof previewReleaseRentStreamer;
-            getScheduled: typeof getScheduledRentStreamer;
-            getEpochProjection: typeof getEpochProjectionRentStreamer;
-            sync: typeof syncRentStreamer;
-            release: typeof releaseRentStreamer;
+            getState: typeof getFeeCollectorState;
         };
         getABI: typeof getABI;
         pmTreasury: {
@@ -639,6 +656,7 @@ declare class RPCLibrary {
     };
     psm: {
         getVaultInfo: typeof getPsmVaultInfo;
+        getVaultSettings: typeof getPsmVaultSettings;
         previewDeposit: typeof previewDepositPsm;
         previewRedeem: typeof previewRedeemPsm;
         previewSwap: typeof previewSwapPsm;
@@ -658,6 +676,15 @@ declare class RPCLibrary {
             getWithdrawRequestInfo: typeof getStabilityPoolWithdrawRequestInfo;
             getWithdrawTimelockConfig: typeof getStabilityPoolWithdrawTimelockConfig;
             requestWithdraw: typeof requestStabilityPoolWithdraw;
+            getAdminState: typeof getStabilityPoolAdminState;
+            liquidation: {
+                getContext: typeof readLiquidationContext;
+                getTarget: typeof readLiquidationTarget;
+                quote: typeof quoteLiquidation;
+                suggestSplit: typeof suggestSplit;
+                simulateWithSplit: typeof simulateWithSplit;
+                minSharesOut: typeof minSharesOut;
+            };
         };
         lendingPool: {
             getAdapters: typeof getAdapters;
@@ -668,6 +695,7 @@ declare class RPCLibrary {
             depositAssetToLendingPool: typeof depositAssetToLendingPool;
             withdrawAssetFromLendingPool: typeof withdrawAssetFromLendingPool;
             getLendingPoolInfo: typeof getLendingPoolInfo;
+            getAdminState: typeof getLendingPoolAdminState;
             getRawUserDepositsInLendingPool: typeof getRawUserDepositsInLendingPool;
             getEligibleUserDeposits: typeof getEligibleUserDeposits;
             getHealthFactor: typeof getHealthFactor;
@@ -695,6 +723,8 @@ declare class RPCLibrary {
             depositToRWAVault: typeof depositToRWAVault;
             redeemNFTFromRWAVault: typeof redeemNFTFromRWAVault;
             getRWAVaultInfo: typeof getRWAVaultInfo;
+            getRegisteredAdapters: typeof getRWAVaultRegisteredAdapters;
+            getSeedStatus: typeof getRWAVaultSeedStatus;
             getNextRandomNFT: typeof getNextRandomNFT;
             checkRedeemEligibility: typeof checkRWAVaultRedeemEligibility;
             requestRandomSeed: typeof requestRandomSeed;

package/dist/types/contracts/complianceRegistry/getStatuses.d.ts

@@ -0,0 +1,25 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** Whether an address is blocked by the ComplianceRegistry, and why. */
+export interface ComplianceStatus {
+    address: string;
+    /** `isBlacklisted`: on the registry's own list, or sanctioned. */
+    blocked: boolean;
+    /** On the registry's own list; null when its storage layout could not be confirmed. */
+    listed: boolean | null;
+    /** On the external sanctions list; unblacklisting does not clear this. */
+    sanctioned: boolean;
+}
+/**
+ * Reads the sanctions list and each address's compliance status. `_blacklisted` is private, so the own-list flag is
+ * read from storage, trusted only when slot 2 matches `sanctionsList()`; otherwise `listed` is null where it cannot
+ * be told apart from a sanction.
+ * @param chainId The chain id.
+ * @param addresses The addresses to check.
+ * @param provider The provider to read with.
+ */
+declare function getStatuses(chainId: ChainId, addresses: readonly string[], provider: Provider): Promise<{
+    sanctionsList: string;
+    statuses: ComplianceStatus[];
+}>;
+export default getStatuses;

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

@@ -0,0 +1,36 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+/** Which route the crvUSD/USD price came from, as `getLatestPrice`'s third value reports it. */
+export declare const CRVUSD_PRICE_SOURCES: readonly ["chainlink", "curve", "fallback"];
+export type CrvUSDPriceSource = (typeof CRVUSD_PRICE_SOURCES)[number];
+/** CrvUSDToUSDOracle state. Prices are 18-decimal USD; times are seconds. */
+export interface CrvUSDToUSDOracleState {
+    owner: string;
+    /** Null when every route reverts. */
+    price: bigint | null;
+    priceTimestamp: number | null;
+    source: CrvUSDPriceSource | null;
+    circuitBreakerEnabled: boolean;
+    minPriceThreshold: bigint;
+    maxPriceThreshold: bigint;
+    fallbackPriceInUSD: bigint;
+    lastFallbackUpdateTimestamp: number;
+    /** How stale the Chainlink crvUSD/USD feed may be before the Curve route is tried. */
+    maxStableStaleTime: bigint;
+    /** How stale the ETH/USD feed may be before the fallback price is used. */
+    maxUnstableStaleTime: bigint;
+    crvUSDDataFeed: string;
+    ethDataFeed: string;
+    curveOracle: string;
+    /** Coin index the Curve oracle prices ETH in. */
+    K: bigint;
+}
+/**
+ * Reads the crvUSD/USD oracle's current price and route and every setting behind them. A reverting price read gives
+ * `price: null` instead of failing, since that is exactly when the settings matter.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ * @param oracleAddress Optional address, e.g. from `housePrices.getState`; defaults to the registry's `crvusdtousdoracle`.
+ */
+declare function getState(chainId: ChainId, provider: Provider, oracleAddress?: string): Promise<CrvUSDToUSDOracleState>;
+export default getState;

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

@@ -1,4 +1,4 @@
-import { ethers, Provider } from "ethers";
+import { ethers, Provider, Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 import { CurvePoolEntry, CurvePools } from "../../../configs/chains/chain";
 /**
@@ -14,3 +14,12 @@ export declare function getCurvePoolContract(chainId: ChainId, poolAddressOrId:
     contract: ethers.Contract;
     provider: ethers.Provider;
 };
+/** The pool contract with its flavour's swap and liquidity ABI, bound to a signer or provider. */
+export declare function getCurvePoolFlavourContract(chainId: ChainId, poolAddressOrId: string, runner?: Signer | Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+};
+/** Checks an amounts array matches the pool's coin count before it reaches the encoder. */
+export declare function assertCoinCount(entry: CurvePoolEntry, amounts: readonly bigint[], what: string): void;
+/** Checks a coin index is inside the pool. */
+export declare function assertCoinIndex(entry: CurvePoolEntry, index: number): void;

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

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposits coins into a Curve pool for LP tokens. The caller approves each non-zero coin to the pool first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param amounts - One amount per coin, in pool order and each coin's base units; 0 for a coin not deposited.
+ * @param minMintAmount - The least LP to accept (18 decimals); the deposit reverts below it. See `calcTokenAmount`.
+ * @param receiver - Who receives the LP tokens.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const addLiquidity: (chainId: ChainId, poolAddressOrId: string, amounts: bigint[], minMintAmount: bigint, receiver: string, signer: Signer) => Promise<any>;

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

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * LP tokens a deposit (or, with `isDeposit` false, a proportional withdrawal) of `amounts` mints or burns at the
+ * pool's current state. Fees are not included, so apply a slippage margin before using it as a minimum.
+ *
+ * @param amounts - One amount per coin, in pool order and each coin's base units.
+ * @returns LP tokens (18 decimals).
+ */
+export declare const calcTokenAmount: (chainId: ChainId, poolAddressOrId: string, amounts: bigint[], isDeposit: boolean, provider?: Provider) => Promise<bigint>;

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

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * How much of coin `i` burning `lpAmount` LP tokens returns at the pool's current state.
+ *
+ * @returns The output amount in coin `i`'s base units.
+ */
+export declare const calcWithdrawOneCoin: (chainId: ChainId, poolAddressOrId: string, lpAmount: bigint, i: number, provider?: Provider) => Promise<bigint>;

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

@@ -0,0 +1,16 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Swaps `amountIn` of coin `i` for coin `j` in a Curve pool. The caller approves coin `i` to the pool first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param i - Index of the coin sold, in pool order.
+ * @param j - Index of the coin bought, in pool order.
+ * @param amountIn - Amount of coin `i`, in its base units.
+ * @param minAmountOut - The least of coin `j` to accept, in its base units; the swap reverts below it.
+ * @param receiver - Who receives coin `j`.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const exchange: (chainId: ChainId, poolAddressOrId: string, i: number, j: number, amountIn: bigint, minAmountOut: bigint, receiver: string, signer: Signer) => Promise<any>;

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

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * How much of coin `j` a swap of `amountIn` of coin `i` returns at the pool's current state, before slippage.
+ *
+ * @returns The output amount in coin `j`'s base units.
+ */
+export declare const getDy: (chainId: ChainId, poolAddressOrId: string, i: number, j: number, amountIn: bigint, provider?: Provider) => Promise<bigint>;

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

@@ -1,2 +1,9 @@
+export * from "./addLiquidity";
+export * from "./calcTokenAmount";
+export * from "./calcWithdrawOneCoin";
+export * from "./exchange";
+export * from "./getDy";
 export * from "./getPools";
 export * from "./getVirtualPrice";
+export * from "./removeLiquidity";
+export * from "./removeLiquidityOneCoin";

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

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Burns LP tokens for every coin of a Curve pool in proportion to its balances.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param lpAmount - LP tokens to burn (18 decimals).
+ * @param minAmounts - The least of each coin to accept, in pool order and each coin's base units.
+ * @param receiver - Who receives the coins.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+export declare const removeLiquidity: (chainId: ChainId, poolAddressOrId: string, lpAmount: bigint, minAmounts: bigint[], receiver: string, signer: Signer) => Promise<any>;