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

package/dist/contracts/curve/common/removeLiquidityOneCoin.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLiquidityOneCoin = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Burns LP tokens for a single coin of a Curve pool.
+ *
+ * @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 i - Index of the coin to receive, in pool order.
+ * @param minAmount - The least of coin `i` to accept, in its base units. See `calcWithdrawOneCoin`.
+ * @param receiver - Who receives the coin.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const removeLiquidityOneCoin = async (chainId, poolAddressOrId, lpAmount, i, minAmount, receiver, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getCurvePoolFlavourContract)(chainId, poolAddressOrId, signer);
+    (0, _helpers_1.assertCoinIndex)(entry, i);
+    try {
+        const tx = await contract.remove_liquidity_one_coin(lpAmount, i, minAmount, receiver);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("curve.removeLiquidityOneCoin", error, { chainId, address: entry.contract });
+    }
+};
+exports.removeLiquidityOneCoin = removeLiquidityOneCoin;

package/dist/contracts/faucet/claim.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claim = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
+const FAUCET_CLAIM_ABI = [
+    "function claim(address token, uint256 amount)",
+    "function claimMultiple(address[] tokens, uint256[] amounts)",
+];
+/**
+ * Claims testnet tokens from the faucet: one `claim` for a single token, one `claimMultiple` for several.
+ *
+ * @param chainId - The chain/network to use; only chains with a `faucet` contract in their config.
+ * @param claims - The tokens and amounts to claim.
+ * @param signer - The signer sending the transaction; the tokens go to its address.
+ * @returns The mined transaction receipt.
+ * @throws If the chain has no faucet, `claims` is empty, or the transaction fails.
+ */
+const claim = async (chainId, claims, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    if (claims.length === 0)
+        throw new Error("Nothing to claim");
+    const address = (0, contracts_1.getContractAddress)(chainId, "faucet");
+    try {
+        const faucet = new ethers_1.ethers.Contract(address, FAUCET_CLAIM_ABI, signer);
+        const tx = claims.length === 1
+            ? await faucet.claim(claims[0].token, claims[0].amount)
+            : await faucet.claimMultiple(claims.map(({ token }) => token), claims.map(({ amount }) => amount));
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("faucet.claim", error, { chainId, address });
+    }
+};
+exports.claim = claim;

package/dist/contracts/faucet/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./claim"), exports);

package/dist/contracts/feeCollector/getState.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_FEE_TYPES = exports.FEE_TARGETS = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+/** The six places a fee type splits into, as FeeCollector names them. */
+exports.FEE_TARGETS = ["TREASURY", "REPAIR_FUND", "BURN", "VERAAC", "RAAC_CORP", "OTHER"];
+/** Fee type names used across the protocol; others show as their raw bytes32. */
+exports.KNOWN_FEE_TYPES = [
+    "LENDING_POOL_YIELD",
+    "RAAC_NFT_SALE",
+    "ROYALTY_FEE",
+    "SWAP_FEE",
+    "INSURANCE_FEE",
+    "PROTOCOL_FEE",
+    "LENDING_FEE",
+    "MINT_FEE",
+    "RWA_INDEX_TOKEN_SWAP_FEE",
+    "RWA_INDEX_TOKEN_LIQUIDITY_REWARDS",
+];
+const TARGET_GETTERS = {
+    TREASURY: "treasuryAddress",
+    REPAIR_FUND: "repairFundAddress",
+    BURN: "burnAddress",
+    VERAAC: "veRAACAddress",
+    RAAC_CORP: "raacCorpAddress",
+    OTHER: "otherAddress",
+};
+const AMOUNT_FIELDS = {
+    TREASURY: "treasuryAmount",
+    REPAIR_FUND: "repairFundAmount",
+    BURN: "burnAmount",
+    VERAAC: "veRAACTokenAmount",
+    RAAC_CORP: "raacCorpAmount",
+    OTHER: "otherAmount",
+};
+const SHARE_FIELDS = {
+    TREASURY: "treasuryShare",
+    REPAIR_FUND: "repairFundShare",
+    BURN: "burnShare",
+    VERAAC: "veRAACTokenShare",
+    RAAC_CORP: "raacCorpShare",
+    OTHER: "otherShare",
+};
+/**
+ * Reads the FeeCollector: pause state, targets, fee types and their splits, supported tokens, and what is still owed
+ * per token, fee type and target. Walks `supportedTokens(i)` until the index reverts.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "feecollector");
+    try {
+        const fc = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("feecollector"), provider);
+        const [paused, targetList, rawTypes] = await Promise.all([
+            fc.paused(),
+            Promise.all(exports.FEE_TARGETS.map((t) => fc[TARGET_GETTERS[t]]())),
+            fc.getFeeTypes(),
+        ]);
+        const names = new Map(exports.KNOWN_FEE_TYPES.map((n) => [ethers_1.ethers.id(n), n]));
+        const feeTypes = rawTypes.map((t) => ({
+            id: t.feeType,
+            name: names.get(t.feeType) ?? null,
+            shares: Object.fromEntries(exports.FEE_TARGETS.map((target) => [target, BigInt(t[SHARE_FIELDS[target]])])),
+        }));
+        const list = [];
+        for (let i = 0; i < 200; i++) {
+            try {
+                list.push(ethers_1.ethers.getAddress(await fc.supportedTokens(i)));
+            }
+            catch (error) {
+                if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                    break;
+                throw error;
+            }
+        }
+        const tokens = await Promise.all(list.map(async (token) => {
+            const erc20 = new ethers_1.ethers.Contract(token, ["function symbol() view returns (string)", "function decimals() view returns (uint8)"], provider);
+            const [symbol, decimals] = await Promise.all([erc20.symbol().catch(() => "?"), erc20.decimals().then(Number).catch(() => 18)]);
+            return { address: token, symbol, decimals };
+        }));
+        const pairs = tokens.flatMap((token) => feeTypes.map((feeType) => ({ token, feeType })));
+        const collected = (await Promise.all(pairs.map(async ({ token, feeType }) => {
+            const c = await fc.getCollectedFees(token.address, feeType.id);
+            return {
+                token: token.address,
+                feeType: feeType.id,
+                amounts: Object.fromEntries(exports.FEE_TARGETS.map((t) => [t, (0, amount_1.toAmount)(c[AMOUNT_FIELDS[t]], token.decimals, token.symbol)])),
+            };
+        }))).filter((c) => exports.FEE_TARGETS.some((t) => c.amounts[t].value > BigInt(0)));
+        return { paused, targets: Object.fromEntries(exports.FEE_TARGETS.map((t, i) => [t, targetList[i]])), feeTypes, tokens, collected };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("feeCollector.getState", error, { chainId, address });
+    }
+}
+exports.default = getState;

package/dist/contracts/getRoles.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roleId = roleId;
+const ethers_1 = require("ethers");
+const rpcError_1 = require("../utils/rpcError");
+const ACCESS_ABI = ["function hasRole(bytes32 role, address account) view returns (bool)"];
+/** OpenZeppelin role ids: DEFAULT_ADMIN_ROLE is zero, every other role is the keccak of its name. */
+function roleId(role) {
+    if (/^0x[0-9a-fA-F]{64}$/.test(role))
+        return role;
+    return role === "DEFAULT_ADMIN_ROLE" ? ethers_1.ethers.ZeroHash : ethers_1.ethers.id(role);
+}
+/**
+ * Which of an AccessControl contract's roles each account holds, e.g. to show what a Safe and a wallet may do.
+ * @param chainId The chain id, for error context.
+ * @param contractAddress The AccessControl contract.
+ * @param roles Role names ("GUARDIAN_ROLE", "DEFAULT_ADMIN_ROLE") or raw 32-byte ids.
+ * @param accounts The accounts to check.
+ * @param provider The provider to read with.
+ * @returns Keyed by lowercased account address, then by role as passed in.
+ */
+async function getRoles(chainId, contractAddress, roles, accounts, provider) {
+    try {
+        const contract = new ethers_1.ethers.Contract(contractAddress, ACCESS_ABI, provider);
+        const entries = await Promise.all(accounts.map(async (account) => {
+            const held = await Promise.all(roles.map((role) => contract.hasRole(roleId(role), account)));
+            return [account.toLowerCase(), Object.fromEntries(roles.map((role, i) => [role, held[i]]))];
+        }));
+        return Object.fromEntries(entries);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("contracts.getRoles", error, { chainId, address: contractAddress });
+    }
+}
+exports.default = getRoles;

package/dist/contracts/housePrices/getState.js

@@ -0,0 +1,41 @@
+"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 rpcError_1 = require("../../utils/rpcError");
+/**
+ * Reads who administers RAACHousePrices, who may set prices, and its syncers.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "raachouseprices");
+    try {
+        const hp = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("raachouseprices"), provider);
+        const [owner, oracle, crvUSDToUSDOracle, count, lastUpdateTimestamp, maxSyncers] = await Promise.all([
+            hp.owner(),
+            hp.oracle(),
+            hp.crvUSDToUSDOracle(),
+            hp.count(),
+            hp.lastUpdateTimestamp(),
+            hp.MAX_SYNCERS(),
+        ]);
+        const syncers = [];
+        for (let i = 0; i < Number(maxSyncers); i++) {
+            try {
+                syncers.push(ethers_1.ethers.getAddress(await hp.syncers(i)));
+            }
+            catch (error) {
+                if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                    break;
+                throw error;
+            }
+        }
+        return { owner, oracle, crvUSDToUSDOracle, count: Number(count), lastUpdateTimestamp: Number(lastUpdateTimestamp), syncers, maxSyncers: Number(maxSyncers) };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("housePrices.getState", error, { chainId, address });
+    }
+}
+exports.default = getState;

package/dist/contracts/psm/getVaultSettings.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaultSettings = getVaultSettings;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Reads a PSM vault's settings from its storage getters only. Unlike `getVaultInfo`, nothing here touches the rate
+ * provider, so it still answers when the savings token price is stale (`StalePrice`), which is when an operator
+ * needs to see and change these settings.
+ * @param chainId - The chain/network to use.
+ * @param vaultKeyOrAddress - The vault's config key (e.g. "rpsm-susds") or its deployed address.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+async function getVaultSettings(chainId, vaultKeyOrAddress, provider) {
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider ?? (0, _helpers_1.getDefaultProvider)(chainId));
+        const [paused, swapFee, minWithdrawFee, maxWithdrawFee, withdrawTime, withdrawTimeLimit, circuitBreakerEnabled, navFloor, reserveRatioFloor, rebalanceThreshold, depositCap, savingsTokenDecimals, baseAsset, savingsToken, rateProvider, rebalancer, baseAssetModule,] = await Promise.all([
+            vault.paused(),
+            vault.swapFee(),
+            vault.minWithdrawFee(),
+            vault.maxWithdrawFee(),
+            vault.withdrawTime(),
+            vault.withdrawTimeLimit(),
+            vault.circuitBreakerEnabled(),
+            vault.navFloor(),
+            vault.reserveRatioFloor(),
+            vault.rebalanceThreshold(),
+            vault.depositCap(),
+            vault.savingsTokenDecimals(),
+            vault.baseAsset(),
+            vault.savingsToken(),
+            vault.rateProvider(),
+            vault.rebalancer(),
+            vault.baseAssetModule(),
+        ]);
+        return {
+            paused,
+            swapFee,
+            minWithdrawFee,
+            maxWithdrawFee,
+            withdrawTime,
+            withdrawTimeLimit,
+            circuitBreakerEnabled,
+            navFloor,
+            reserveRatioFloor,
+            rebalanceThreshold,
+            depositCap,
+            savingsTokenDecimals: Number(savingsTokenDecimals),
+            baseAsset,
+            savingsToken,
+            rateProvider,
+            rebalancer,
+            baseAssetModule,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.getVaultSettings", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/treasury/getState.js

@@ -0,0 +1,46 @@
+"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 amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const ERC20 = ["function symbol() view returns (string)", "function decimals() view returns (uint8)", "function balanceOf(address) view returns (uint256)"];
+/**
+ * Reads every token the Treasury supports, with its tracked and actual balances. Walks `supportedTokens(i)` until the
+ * index reverts; any other error is thrown so a flaky node never returns a shortened list.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getState(chainId, provider) {
+    const address = (0, contracts_1.getContractAddress)(chainId, "treasury");
+    try {
+        const treasury = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("treasury"), provider);
+        const list = [];
+        for (let i = 0; i < 200; i++) {
+            try {
+                list.push(ethers_1.ethers.getAddress(await treasury.supportedTokens(i)));
+            }
+            catch (error) {
+                if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                    break;
+                throw error;
+            }
+        }
+        const tokens = await Promise.all(list.map(async (token) => {
+            const erc20 = new ethers_1.ethers.Contract(token, ERC20, provider);
+            const [symbol, decimals, tracked, held] = await Promise.all([
+                erc20.symbol().catch(() => "?"),
+                erc20.decimals().then(Number).catch(() => null),
+                treasury.getBalance(token),
+                erc20.balanceOf(address).catch(() => null),
+            ]);
+            return { address: token, symbol, decimals, tracked: (0, amount_1.toAmount)(tracked, decimals ?? 18, symbol), held: held === null ? null : (0, amount_1.toAmount)(held, decimals ?? 18, symbol) };
+        }));
+        return { tokens };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("treasury.getState", error, { chainId, address });
+    }
+}
+exports.default = getState;

package/dist/minter/emissionSchedule.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * TypeScript port of contracts/libraries/minters/EmissionSchedule.sol. The schedule is pure (no storage), so the
+ * whole curve can be drawn without one RPC call per week; the only on-chain input is the activation timestamp
+ * (`mintingStartAtTimestamp`). All amounts are RAAC base units (18 decimals).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAST_EMISSION_WEEK = exports.WEEKS_PER_PERIOD = exports.WEEK_REDUCTION_START = exports.BASE_PER_SECOND = exports.BASE_WEEKLY_EMISSION = void 0;
+exports.getEmissionPerSecondForWeek = getEmissionPerSecondForWeek;
+exports.getMintingWeekForTimestamp = getMintingWeekForTimestamp;
+exports.getEmissionSchedule = getEmissionSchedule;
+exports.getSchedulePosition = getSchedulePosition;
+const E18 = BigInt("1000000000000000000");
+const WEEK = BigInt(7 * 24 * 3600);
+/** RAAC emitted in each of the first 104 weeks. Divisible by 604800, so the per-second rate is exact. */
+exports.BASE_WEEKLY_EMISSION = BigInt("23852798580398015692800");
+exports.BASE_PER_SECOND = exports.BASE_WEEKLY_EMISSION / WEEK;
+/** First week of the reduction phase. */
+exports.WEEK_REDUCTION_START = 105;
+/** The rate drops by 5% every this many weeks. */
+exports.WEEKS_PER_PERIOD = 13;
+/** Weeks 781 and later emit nothing. */
+exports.LAST_EMISSION_WEEK = 780;
+/** 0.95^exponent with 1e18 precision, rounding exactly as the contract's `pow95`. */
+function pow95(exponent) {
+    let base = BigInt("950000000000000000");
+    let result = E18;
+    let e = exponent;
+    while (e !== BigInt(0)) {
+        if ((e & BigInt(1)) === BigInt(1))
+            result = (result * base) / E18;
+        base = (base * base) / E18;
+        e >>= BigInt(1);
+    }
+    return result;
+}
+/**
+ * RAAC emitted per second during a 1-based schedule week.
+ * @param week The schedule week; 0 and weeks after 780 emit nothing.
+ */
+function getEmissionPerSecondForWeek(week) {
+    if (week <= 0 || week > exports.LAST_EMISSION_WEEK)
+        return BigInt(0);
+    if (week < exports.WEEK_REDUCTION_START)
+        return exports.BASE_PER_SECOND;
+    const periods = BigInt(Math.floor((week - exports.WEEK_REDUCTION_START) / exports.WEEKS_PER_PERIOD) + 1);
+    return (exports.BASE_PER_SECOND * pow95(periods)) / E18;
+}
+/**
+ * The 1-based schedule week a timestamp falls in, 0 before activation.
+ * @param activationTimestamp `mintingStartAtTimestamp`, in UNIX seconds.
+ * @param timestamp The moment to place, in UNIX seconds.
+ */
+function getMintingWeekForTimestamp(activationTimestamp, timestamp) {
+    if (!activationTimestamp || timestamp < activationTimestamp)
+        return 0;
+    return Math.floor((timestamp - activationTimestamp) / Number(WEEK)) + 1;
+}
+let schedule = null;
+/** Every week of the schedule, 1 through 780, with running totals. The last `cumulative` is the lifetime emission. */
+function getEmissionSchedule() {
+    if (schedule)
+        return schedule;
+    let cumulative = BigInt(0);
+    schedule = Array.from({ length: exports.LAST_EMISSION_WEEK }, (_, i) => {
+        const week = i + 1;
+        const perSecond = getEmissionPerSecondForWeek(week);
+        const weekly = perSecond * WEEK;
+        cumulative += weekly;
+        return { week, perSecond, weekly, cumulative };
+    });
+    return schedule;
+}
+/**
+ * Places a moment on the schedule, e.g. to compare what has been minted with what the schedule allowed.
+ * @param activationTimestamp `mintingStartAtTimestamp`, in UNIX seconds.
+ * @param timestamp The moment to place, in UNIX seconds.
+ */
+function getSchedulePosition(activationTimestamp, timestamp) {
+    const week = getMintingWeekForTimestamp(activationTimestamp, timestamp);
+    if (week === 0)
+        return { week, secondsIntoWeek: 0, perSecond: BigInt(0), scheduledToDate: BigInt(0) };
+    const weeks = getEmissionSchedule();
+    if (week > exports.LAST_EMISSION_WEEK)
+        return { week, secondsIntoWeek: 0, perSecond: BigInt(0), scheduledToDate: weeks[exports.LAST_EMISSION_WEEK - 1].cumulative };
+    const secondsIntoWeek = (timestamp - activationTimestamp) % Number(WEEK);
+    const perSecond = getEmissionPerSecondForWeek(week);
+    const before = week > 1 ? weeks[week - 2].cumulative : BigInt(0);
+    return { week, secondsIntoWeek, perSecond, scheduledToDate: before + perSecond * BigInt(secondsIntoWeek) };
+}

package/dist/pools/lendingPool/getAdminState.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const getContractAddress_1 = __importDefault(require("../../contracts/getContractAddress"));
+const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Reads what an operator administers on the lending pool, next to `getParameters` (risk and fee values) and
+ * `getLendingPoolInfo` (liquidity and rates).
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getAdminState(chainId, provider) {
+    const address = (0, getContractAddress_1.default)(chainId, "lendingpool");
+    try {
+        const pool = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("lendingpool"), provider);
+        const [paused, primeRateOracle, stabilityPool, liquidationProxy, vault, feeCollector, adapters, reserve] = await Promise.all([
+            pool.paused(),
+            pool.primeRateOracle(),
+            pool.stabilityPool(),
+            pool.liquidationProxy(),
+            pool.vault(),
+            pool.feeCollector(),
+            pool.getAdapters(),
+            pool.reserve(),
+        ]);
+        return {
+            paused,
+            primeRateOracle,
+            stabilityPool,
+            liquidationProxy,
+            vault,
+            feeCollector,
+            adapters: [...adapters].map((a) => ethers_1.ethers.getAddress(a)),
+            reserveAsset: reserve.reserveAssetAddress,
+            rToken: reserve.reserveRTokenAddress,
+            debtToken: reserve.reserveDebtTokenAddress,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("lendingPool.getAdminState", error, { chainId, address });
+    }
+}
+exports.default = getAdminState;

package/dist/pools/rwaVault/getRegisteredAdapters.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const getContractAddress_1 = __importDefault(require("../../contracts/getContractAddress"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Walks a public address array (`adapters(i)`) until the index reverts. Any other error (network, RPC) is thrown,
+ * so a flaky node never returns a shortened list as if it were complete.
+ */
+async function readList(vault, method) {
+    const out = [];
+    for (let i = 0; i < 100; i++) {
+        let item;
+        try {
+            item = await vault[method](i);
+        }
+        catch (error) {
+            if (ethers_1.ethers.isError(error, "CALL_EXCEPTION"))
+                break;
+            throw error;
+        }
+        if (item === ethers_1.ethers.ZeroAddress)
+            break;
+        out.push(ethers_1.ethers.getAddress(item));
+    }
+    return out;
+}
+async function readAdapter(address, provider) {
+    const erc20 = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("erc20vaultadapter"), provider);
+    const [type, token] = await Promise.all([erc20.getAssetType(), erc20.getAssetToken()]);
+    const erc721 = type === "ERC721";
+    const adapter = erc721 ? new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("erc721vaultadapter"), provider) : erc20;
+    const asset = new ethers_1.ethers.Contract(token, ["function symbol() view returns (string)", "function decimals() view returns (uint8)"], provider);
+    const [tokenSymbol, tokenDecimals, value, tokenIds] = await Promise.all([
+        asset.symbol().catch(() => (erc721 ? "NFTs" : "tokens")),
+        erc721 ? 0 : asset.decimals().then(Number),
+        adapter.totalValue().catch(() => null),
+        erc721 ? adapter.getDepositedTokens() : Promise.resolve([]),
+    ]);
+    return { type, token, tokenSymbol, tokenDecimals, value: value === null ? null : (0, amount_1.toAmount)(value, amount_1.WAD_DECIMALS, "crvUSD"), tokenIds: [...tokenIds] };
+}
+/**
+ * Every adapter registered on the RWA vault, read from the vault's own arrays rather than the chain config (which
+ * `getAdapters` returns), with deposit and redemption flags and what each adapter holds. One adapter failing to read
+ * gives a row with `error` instead of failing the whole list.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getRegisteredAdapters(chainId, provider) {
+    const vaultAddress = (0, getContractAddress_1.default)(chainId, "rwavault");
+    try {
+        const vault = new ethers_1.ethers.Contract(vaultAddress, (0, artifacts_1.getABI)("rwavault"), provider);
+        const [all, depositable, redeemable] = await Promise.all([
+            readList(vault, "adapters"),
+            readList(vault, "depositableAdapters"),
+            readList(vault, "redeemableERC721Adapters"),
+        ]);
+        return Promise.all(all.map(async (address) => {
+            const flags = { address, depositable: depositable.includes(address), redeemable: redeemable.includes(address) };
+            try {
+                return { ...flags, ...(await readAdapter(address, provider)) };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return { ...flags, type: "unknown", token: ethers_1.ethers.ZeroAddress, tokenSymbol: "?", tokenDecimals: 0, value: null, tokenIds: [], error: message };
+            }
+        }));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("rwaVault.getRegisteredAdapters", error, { chainId, address: vaultAddress });
+    }
+}
+exports.default = getRegisteredAdapters;

package/dist/pools/rwaVault/getSeedStatus.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const getContractAddress_1 = __importDefault(require("../../contracts/getContractAddress"));
+const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Reads the RWA vault's VRF consumer: the last request and fulfilment and the stall window, plus the vault's own
+ * request rules. With no consumer set, the time fields are 0.
+ * @param chainId The chain id.
+ * @param provider The provider to read with.
+ */
+async function getSeedStatus(chainId, provider) {
+    const vaultAddress = (0, getContractAddress_1.default)(chainId, "rwavault");
+    try {
+        const vault = new ethers_1.ethers.Contract(vaultAddress, (0, artifacts_1.getABI)("rwavault"), provider);
+        const [consumer, delay, allowed] = await Promise.all([vault.vrfConsumer(), vault.vrfRequestDelay(), vault.allowVRFRequest()]);
+        if (consumer === ethers_1.ethers.ZeroAddress) {
+            return { consumer, lastRequest: 0, lastFulfil: 0, pending: false, maxStall: 0, delay: Number(delay), allowed };
+        }
+        const vrf = new ethers_1.ethers.Contract(consumer, (0, artifacts_1.getABI)("vrfconsumer"), provider);
+        const [lastRequest, lastFulfil, status, maxStall] = await Promise.all([
+            vrf.lastRequestTimestamp(),
+            vrf.getLastFulfillTimestamp(),
+            vrf.getRequestStatus(),
+            vrf.MAX_STALL(),
+        ]);
+        return {
+            consumer,
+            lastRequest: Number(lastRequest),
+            lastFulfil: Number(lastFulfil),
+            pending: status.exists && !status.fulfilled,
+            maxStall: Number(maxStall),
+            delay: Number(delay),
+            allowed,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("rwaVault.getSeedStatus", error, { chainId, address: vaultAddress });
+    }
+}
+exports.default = getSeedStatus;