@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/scripts/generateErrorCatalogue.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Generates generated/errors.json: one entry per (contract, error) pair, with
+ * an AI-drafted title/message, meant for human review in the PR that
+ * regenerates it. See rpc#16.
+ *
+ * Keeps one entry per contract, keyed `${ContractType}:${selector}` - the
+ * same ContractType key findContract/RpcError already use - rather than
+ * collapsing same-named errors from different contracts into one entry,
+ * which was the root cause of rpc#16's "contract" field problem.
+ *
+ * Needs a checkout of the sibling `contracts` repo (../contracts relative to
+ * this repo) for Solidity source/NatSpec, and ANTHROPIC_API_KEY in .env. Not
+ * part of `npm run build` - run by hand, output committed and reviewed like
+ * any other code.
+ *
+ * Run:
+ *   npm run generate:catalogue
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectErrors = collectErrors;
+exports.extractContext = extractContext;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const ethers_1 = require("ethers");
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const artifacts_1 = require("../utils/artifacts");
+const ARTIFACTS_DIR = path_1.default.join(process.cwd(), "artifacts");
+const CONTRACTS_REPO_ROOT = path_1.default.join(process.cwd(), "..", "contracts");
+const OUTPUT_PATH = path_1.default.join(process.cwd(), "generated", "errors.json");
+const MODEL = "claude-sonnet-5";
+// Bump whenever buildPrompt's instructions change meaningfully - otherwise a
+// wording-style fix here wouldn't invalidate already-cached entries, since the
+// hash below is keyed on the entry's own facts, not on how we asked for them.
+const PROMPT_VERSION = 2;
+function walkDir(dir) {
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory())
+            results.push(...walkDir(full));
+        else if (entry.name.endsWith(".json") && !entry.name.endsWith(".dbg.json"))
+            results.push(full);
+    }
+    return results;
+}
+/**
+ * Matches a ContractType (an ABIS key, e.g. "veraac") to its artifact file by
+ * ABI content, since ABIS only exports the already-extracted `.abi` array,
+ * not the sourceName the catalogue needs to find the .sol file.
+ */
+function findArtifactForContractType(contractType, files) {
+    const target = JSON.stringify(artifacts_1.ABIS[contractType]);
+    for (const file of files) {
+        try {
+            const json = JSON.parse(fs_1.default.readFileSync(file, "utf-8"));
+            if (Array.isArray(json.abi) && JSON.stringify(json.abi) === target)
+                return json;
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function collectErrors() {
+    const files = walkDir(ARTIFACTS_DIR);
+    const entries = [];
+    const contractTypes = Object.keys(artifacts_1.ABIS);
+    for (const contractType of contractTypes) {
+        const artifact = findArtifactForContractType(contractType, files);
+        if (!artifact) {
+            console.warn(`No artifact file found for ContractType "${contractType}" - skipping.`);
+            continue;
+        }
+        for (const item of artifact.abi) {
+            if (item.type !== "error")
+                continue;
+            const inputs = (item.inputs || []);
+            const signature = `${item.name}(${inputs.map((i) => i.type).join(",")})`;
+            const selector = (0, ethers_1.id)(signature).slice(0, 10).toLowerCase();
+            entries.push({
+                contractType,
+                contractName: artifact.contractName,
+                sourceName: artifact.sourceName,
+                name: item.name,
+                signature,
+                selector,
+                inputs: inputs.map((i) => ({ name: i.name || "", type: i.type })),
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * NatSpec immediately above the `error` declaration, if any, plus every
+ * `revert ErrorName(` usage found anywhere in the file. Errors are not always
+ * declared near their revert sites (RWAVault.sol declares 5 at the end of the
+ * file while they're thrown 300+ lines earlier), so usage is gathered
+ * file-wide, independent of where the declaration sits.
+ */
+function extractContext(sourceName, errorName) {
+    const filePath = path_1.default.join(CONTRACTS_REPO_ROOT, sourceName);
+    if (!fs_1.default.existsSync(filePath))
+        return { natspec: null, usageSnippets: [] };
+    const lines = fs_1.default.readFileSync(filePath, "utf-8").split("\n");
+    const declIndex = lines.findIndex((l) => new RegExp(`\\berror\\s+${errorName}\\s*\\(`).test(l));
+    let natspec = null;
+    if (declIndex !== -1) {
+        const collected = [];
+        let i = declIndex - 1;
+        while (i >= 0) {
+            const trimmed = lines[i].trim();
+            if (trimmed === "")
+                break;
+            if (trimmed.startsWith("///") || trimmed.startsWith("*") || trimmed.startsWith("/**")) {
+                collected.unshift(lines[i]);
+                if (trimmed.startsWith("/**"))
+                    break;
+                i--;
+                continue;
+            }
+            break;
+        }
+        if (collected.length > 0)
+            natspec = collected.join("\n").trim();
+    }
+    const usageRegex = new RegExp(`revert\\s+${errorName}\\s*\\(`);
+    const usageSnippets = [];
+    for (let li = 0; li < lines.length && usageSnippets.length < 3; li++) {
+        if (usageRegex.test(lines[li])) {
+            usageSnippets.push(lines.slice(Math.max(0, li - 2), Math.min(lines.length, li + 2)).join("\n"));
+        }
+    }
+    return { natspec, usageSnippets };
+}
+function hashInputs(entry, context) {
+    return (0, crypto_1.createHash)("sha256")
+        .update(JSON.stringify({ promptVersion: PROMPT_VERSION, signature: entry.signature, natspec: context.natspec, usage: context.usageSnippets }))
+        .digest("hex");
+}
+function buildPrompt(entry, context) {
+    const params = entry.inputs.length > 0 ? `Parameters: ${entry.inputs.map((i) => `${i.name || "(unnamed)"}: ${i.type}`).join(", ")}` : "No parameters.";
+    const natspecBlock = context.natspec ? `\nDocumentation comment on the error:\n${context.natspec}` : "\n(No documentation comment exists for this error.)";
+    const usageBlock = context.usageSnippets.length > 0 ? `\nWhere it's actually thrown in the contract:\n${context.usageSnippets.join("\n---\n")}` : "";
+    return `You are writing a short, human-readable explanation of a Solidity custom error for a DeFi app's error messages. This is shown directly to the person whose transaction just failed - write to them, not about a third party. Use "you"/"your" for the caller/account whenever the error is plausibly about them (which is true for almost every error here); only use third person if the error is clearly about someone else's address (e.g. checking another account's position).
+
+Contract: ${entry.contractName}
+Error: ${entry.signature}
+${params}
+${natspecBlock}
+${usageBlock}
+
+Reply with ONLY a JSON object, no other text, in exactly this shape:
+{"title": "short 2-5 word title", "message": "one sentence explaining what went wrong, plain language, no jargon, written to the user as \"you\"/\"your\""}`;
+}
+async function generateOne(client, entry, context) {
+    const response = await client.messages.create({
+        model: MODEL,
+        // 512 was too tight for entries with multiple/long usage snippets - the
+        // response can get cut off mid-JSON before the closing brace.
+        max_tokens: 1024,
+        messages: [{ role: "user", content: buildPrompt(entry, context) }],
+    });
+    const block = response.content.find((b) => b.type === "text");
+    const text = block && "text" in block ? block.text : "";
+    const match = text.match(/\{[\s\S]*\}/);
+    if (!match)
+        throw new Error(`Could not parse a JSON object from Claude's response for ${entry.contractName}.${entry.signature}: ${text}`);
+    const parsed = JSON.parse(match[0]);
+    return {
+        title: parsed.title ?? entry.name,
+        message: parsed.message ?? `${entry.name} error occurred`,
+    };
+}
+async function main() {
+    if (!fs_1.default.existsSync(CONTRACTS_REPO_ROOT)) {
+        console.error(`Sibling contracts repo not found at ${CONTRACTS_REPO_ROOT}. This script needs it checked out to read Solidity source/NatSpec.`);
+        process.exit(1);
+    }
+    if (!process.env.ANTHROPIC_API_KEY) {
+        console.error("ANTHROPIC_API_KEY is not set. Add it to .env (see rpc#16).");
+        process.exit(1);
+    }
+    const client = new sdk_1.default({ apiKey: process.env.ANTHROPIC_API_KEY });
+    let existing = {};
+    try {
+        existing = JSON.parse(fs_1.default.readFileSync(OUTPUT_PATH, "utf-8"));
+    }
+    catch {
+        // No catalogue yet - everything gets generated fresh.
+    }
+    console.log("Scanning ABIs for error definitions...");
+    let entries = collectErrors();
+    console.log(`Found ${entries.length} (contract, error) pairs across ${new Set(entries.map((e) => e.contractType)).size} contracts.`);
+    const limit = process.env.CATALOGUE_LIMIT ? parseInt(process.env.CATALOGUE_LIMIT, 10) : undefined;
+    if (limit) {
+        entries = entries.slice(0, limit);
+        console.log(`CATALOGUE_LIMIT set - only generating the first ${entries.length}.`);
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(OUTPUT_PATH), { recursive: true });
+    const output = { ...existing };
+    let generated = 0;
+    let reused = 0;
+    for (const entry of entries) {
+        const key = `${entry.contractType}:${entry.selector}`;
+        const context = extractContext(entry.sourceName, entry.name);
+        const hash = hashInputs(entry, context);
+        if (existing[key]?._hash === hash) {
+            reused++;
+            continue;
+        }
+        try {
+            const drafted = await generateOne(client, entry, context);
+            output[key] = { ...drafted, _hash: hash };
+            generated++;
+            console.log(`  generated ${key} (${entry.contractName}.${entry.name})`);
+            // Written after every entry, not just at the end: a 700+ entry run
+            // against a live API is exactly the kind of job that gets
+            // interrupted, and losing all progress to that would be wasteful.
+            fs_1.default.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+        }
+        catch (error) {
+            console.warn(`  failed to generate ${key} (${entry.contractName}.${entry.name}):`, error);
+        }
+    }
+    console.log(`\nWrote ${Object.keys(output).length} entries to ${OUTPUT_PATH} (${generated} generated, ${reused} reused unchanged this run).`);
+}
+if (require.main === module) {
+    main();
+}

package/dist/types/RPCLibrary.d.ts

@@ -25,6 +25,7 @@ import depositToRWAVault from "./pools/rwaVault/depositToRWAVault";
 import redeemNFTFromRWAVault from "./pools/rwaVault/redeemNFTFromRWAVault";
 import getRWAVaultInfo from "./pools/rwaVault/getRWAVaultInfo";
 import getNextRandomNFT from "./pools/rwaVault/getNextRandomNFT";
+import { checkRedeemEligibility as checkRWAVaultRedeemEligibility } from "./pools/rwaVault/checkRedeemEligibility";
 import requestRandomSeed from "./pools/rwaVault/requestRandomSeed";
 import previewDeposit from "./pools/rwaVault/previewDeposit";
 import previewWithdraw from "./pools/rwaVault/previewWithdraw";
@@ -45,6 +46,7 @@ import getContract from "./contracts/getContract";
 import { findContract } from "./contracts/findContract";
 import { decodeCall } from "./contracts/decodeCall";
 import { resolveName, resolveNames } from "./contracts/resolveName";
+import { getTokenMetadata } from "./contracts/getTokenMetadata";
 import getLatestPrice from "./contracts/housePrices/getLatestPrice";
 import setOracle from "./contracts/housePrices/setOracle";
 import tick from "./minter/tick";
@@ -106,9 +108,19 @@ import setApprovalForAll from "./nfts/setApprovalForAll";
 import approveNFT from "./nfts/approveNFT";
 import vaultOpened from "./pools/lendingPool/vaultOpened";
 import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from "./pools/stabilityPool/getWithdrawRequestInfo";
+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 { previewDeposit as previewDepositPsm } from "./contracts/psm/previewDeposit";
+import { previewRedeem as previewRedeemPsm } from "./contracts/psm/previewRedeem";
+import { previewSwap as previewSwapPsm } from "./contracts/psm/previewSwap";
+import { previewProportionalSplit as previewProportionalSplitPsm } from "./contracts/psm/previewProportionalSplit";
+import { deposit as depositPsm } from "./contracts/psm/deposit";
+import { requestExit as requestExitPsm } from "./contracts/psm/requestExit";
+import { cancelExit as cancelExitPsm } from "./contracts/psm/cancelExit";
+import { redeem as redeemPsm } from "./contracts/psm/redeem";
+import { swap as swapPsm } from "./contracts/psm/swap";
 import { getABI } from "./utils/artifacts";
-import { decodeErrorName, getErrorInfo, attachDecodedError, decodeErrorMessage, attachDecodedErrorMessage } from "./utils/errorDecoder";
 import { toAmount, toScaled, parseAmount, toDecimalString, serializeAmount, deserializeAmount, getAssetDecimals, getTokenInfo, toTokenAmount } from "./utils/amount";
 import * as distributorMethods from "./contracts/governance/distributor";
 import * as gaugeMethods from "./contracts/governance/gauge";
@@ -157,6 +169,7 @@ import { getTotalSupply as getVeRAACTotalSupply } from "./contracts/tokens/veRAA
 import { getLockedBalance as getVeRAACLockedBalance } from "./contracts/tokens/veRAAC/getLockedBalance";
 import { getLocks as getVeRAACLocks } from "./contracts/tokens/veRAAC/getLocks";
 import { getGlobalLockInfo as getVeRAACGlobalLockInfo } from "./contracts/tokens/veRAAC/getGlobalLockInfo";
+import { getRewardTokens as getRewardTokensVeRAAC } from "./contracts/tokens/veRAAC/getRewardTokens";
 import { getMaxLockEnd as getVeRAACMaxLockEnd } from "./contracts/tokens/veRAAC/getMaxLockEnd";
 import { getBalanceAt as getVeRAACBalanceAt } from "./contracts/tokens/veRAAC/getBalanceAt";
 import { getBalanceAtTime as getVeRAACBalanceAtTime } from "./contracts/tokens/veRAAC/getBalanceAtTime";
@@ -204,6 +217,7 @@ import { getUserLocks as getUserLocksLiquidLocker } from "./contracts/lockers/li
 import { getGlobalInfo as getGlobalInfoLiquidLocker } from "./contracts/lockers/liquidLocker/getGlobalInfo";
 import { getConfig as getConfigLiquidLocker } from "./contracts/lockers/liquidLocker/getConfig";
 import { isKeeper as isKeeperLiquidLocker } from "./contracts/lockers/liquidLocker/isKeeper";
+import { hasHarvestRole as hasHarvestRoleLiquidLocker } from "./contracts/lockers/liquidLocker/hasHarvestRole";
 import { previewWithdraw as previewWithdrawLiquidLocker } from "./contracts/lockers/liquidLocker/previewWithdraw";
 import { checkAccountHealth as checkAccountHealthLiquidLocker } from "./contracts/lockers/liquidLocker/checkAccountHealth";
 import { deposit as depositMaturityVault } from "./contracts/lockers/maturityVault/deposit";
@@ -269,6 +283,11 @@ import { default as previewDepositPmBlender } from "./contracts/pmBlender/previe
 import { default as previewWithdrawPmBlender } from "./contracts/pmBlender/previewWithdraw";
 import { default as previewSwapPmBlender } from "./contracts/pmBlender/previewSwap";
 import { getPrices } from "./prices/getPrices";
+import { getTokenPriceUSD } from "./prices/tokenPricesUSD";
+import { getCurveLPPriceUSD } from "./prices/getCurveLPPriceUSD";
+import { getWrapperPriceUSD } from "./prices/getWrapperPriceUSD";
+import { getStakingTokenPriceUSD } from "./prices/getStakingTokenPriceUSD";
+import { computeStakingAPY } from "./prices/computeStakingAPY";
 declare class RPCLibrary {
     signer: Signer | null;
     isConnected: boolean;
@@ -277,6 +296,11 @@ declare class RPCLibrary {
     privateKey: any;
     prices: {
         getPrices: typeof getPrices;
+        getTokenPriceUSD: typeof getTokenPriceUSD;
+        getCurveLPPriceUSD: typeof getCurveLPPriceUSD;
+        getWrapperPriceUSD: typeof getWrapperPriceUSD;
+        getStakingTokenPriceUSD: typeof getStakingTokenPriceUSD;
+        computeStakingAPY: typeof computeStakingAPY;
     };
     assets: {
         getAsset: typeof getAsset;
@@ -341,6 +365,7 @@ declare class RPCLibrary {
         decodeCall: typeof decodeCall;
         resolveName: typeof resolveName;
         resolveNames: typeof resolveNames;
+        getTokenMetadata: typeof getTokenMetadata;
         feeCollector: {
             claimRewardFromPool: typeof claimRewardFromPool;
         };
@@ -419,6 +444,7 @@ declare class RPCLibrary {
             getLockedBalance: typeof getVeRAACLockedBalance;
             getLocks: typeof getVeRAACLocks;
             getGlobalLockInfo: typeof getVeRAACGlobalLockInfo;
+            getRewardTokens: typeof getRewardTokensVeRAAC;
             getMaxLockEnd: typeof getVeRAACMaxLockEnd;
             getBalanceAt: typeof getVeRAACBalanceAt;
             getBalanceAtTime: typeof getVeRAACBalanceAtTime;
@@ -493,6 +519,7 @@ declare class RPCLibrary {
             getGlobalInfo: typeof getGlobalInfoLiquidLocker;
             getConfig: typeof getConfigLiquidLocker;
             isKeeper: typeof isKeeperLiquidLocker;
+            hasHarvestRole: typeof hasHarvestRoleLiquidLocker;
             previewWithdraw: typeof previewWithdrawLiquidLocker;
             checkAccountHealth: typeof checkAccountHealthLiquidLocker;
         };
@@ -554,6 +581,18 @@ declare class RPCLibrary {
             Action: typeof zapCodec.Action;
         };
     };
+    psm: {
+        getVaultInfo: typeof getPsmVaultInfo;
+        previewDeposit: typeof previewDepositPsm;
+        previewRedeem: typeof previewRedeemPsm;
+        previewSwap: typeof previewSwapPsm;
+        previewProportionalSplit: typeof previewProportionalSplitPsm;
+        deposit: typeof depositPsm;
+        requestExit: typeof requestExitPsm;
+        cancelExit: typeof cancelExitPsm;
+        redeem: typeof redeemPsm;
+        swap: typeof swapPsm;
+    };
     pools: {
         stabilityPool: {
             getStabilityPoolInfo: typeof getStabilityPoolInfo;
@@ -561,6 +600,7 @@ declare class RPCLibrary {
             withdrawFromStabilityPool: typeof withdrawFromStabilityPool;
             getRawUserDepositInStabilityPool: typeof getRawUserDepositInStabilityPool;
             getWithdrawRequestInfo: typeof getStabilityPoolWithdrawRequestInfo;
+            getWithdrawTimelockConfig: typeof getStabilityPoolWithdrawTimelockConfig;
             requestWithdraw: typeof requestStabilityPoolWithdraw;
         };
         lendingPool: {
@@ -600,6 +640,7 @@ declare class RPCLibrary {
             redeemNFTFromRWAVault: typeof redeemNFTFromRWAVault;
             getRWAVaultInfo: typeof getRWAVaultInfo;
             getNextRandomNFT: typeof getNextRandomNFT;
+            checkRedeemEligibility: typeof checkRWAVaultRedeemEligibility;
             requestRandomSeed: typeof requestRandomSeed;
             getERC20VaultAdapterInfo: typeof getERC20VaultAdapterInfo;
             getERC20VaultAdapterTotalValue: typeof getERC20VaultAdapterTotalValue;
@@ -636,13 +677,6 @@ declare class RPCLibrary {
     checkAllowance: typeof checkAllowance;
     getChainsConfig: typeof getChainsConfig;
     setChainsConfig: typeof setChainConfig;
-    errors: {
-        decodeErrorName: typeof decodeErrorName;
-        getErrorInfo: typeof getErrorInfo;
-        attachDecodedError: typeof attachDecodedError;
-        decodeErrorMessage: typeof decodeErrorMessage;
-        attachDecodedErrorMessage: typeof attachDecodedErrorMessage;
-    };
     amounts: {
         toAmount: typeof toAmount;
         toScaled: typeof toScaled;

package/dist/types/configs/chains/index.d.ts

@@ -128,6 +128,14 @@ declare const chains: {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -164,6 +172,13 @@ declare const chains: {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;
@@ -380,6 +395,14 @@ export declare const configs: {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -416,6 +439,13 @@ export declare const configs: {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;

package/dist/types/configs/index.d.ts

@@ -128,6 +128,14 @@ declare function getChainsConfig(): {
             };
         };
         proposals: any[];
+        psm: {
+            "rpsm-susds": {
+                id: string;
+                name: string;
+                contract: string;
+                rateProvider: string;
+            };
+        };
         pools: {
             stabilitypool: {
                 id: string;
@@ -164,6 +172,13 @@ declare function getChainsConfig(): {
                 decimals: number;
                 contract: string;
             };
+            susds: {
+                id: string;
+                name: string;
+                symbol: string;
+                decimals: number;
+                contract: string;
+            };
             xpm: {
                 id: string;
                 name: string;

package/dist/types/contracts/getTokenMetadata.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains";
+export interface TokenMetadata {
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Reads `symbol()`/`decimals()` directly from an arbitrary ERC20 token address -
+ * for tokens not in the chain config's asset registry (e.g. a veRAAC reward
+ * token or a gauge's reward token), where there's no registry entry to look
+ * up instead.
+ */
+export declare const getTokenMetadata: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenMetadata>;

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

@@ -6,23 +6,3 @@
  * @returns The checksummed address.
  */
 export declare const requireAddress: (address: string, name: string) => string;
-/** The fields a caller needs to explain a failed transaction, lifted from an ethers error. */
-export interface GovernanceTxError extends Error {
-    /** ethers error code, e.g. "ACTION_REJECTED", "CALL_EXCEPTION", "INSUFFICIENT_FUNDS". */
-    code?: string;
-    /** Revert data, when the node returned it. */
-    data?: string;
-    /** Decoded custom error name, e.g. "AlreadyVoted". */
-    errorName?: string;
-    cause: unknown;
-}
-/**
- * Wraps a failed write so the message says what failed while the original
- * error stays reachable: its code (a wallet rejection is ACTION_REJECTED), its
- * revert data and the decoded custom error name.
- *
- * @param prefix - What was being attempted, e.g. "Failed to cast vote".
- * @param error - The error ethers threw.
- * @returns An Error carrying `code`, `data`, `errorName` and `cause`.
- */
-export declare const toGovernanceTxError: (prefix: string, error: any) => GovernanceTxError;

package/dist/types/contracts/governance/proposals/castVote.d.ts

@@ -1,6 +1,5 @@
 import { ethers, Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
-import { TokenAmount } from "../../../utils/amount";
 /**
  * Casts a vote on a governance proposal.
  * Allows veToken holders to vote on active proposals.
@@ -17,5 +16,5 @@ import { TokenAmount } from "../../../utils/amount";
  */
 export declare const castVote: (chainId: ChainId, governance: string, proposalId: number | bigint, support: boolean, signer: Signer) => Promise<{
     tx: ethers.ContractTransactionResponse;
-    weight: TokenAmount;
+    weight: import("../../../utils/amount").TokenAmount;
 }>;

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

@@ -0,0 +1,8 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Checks whether `account` holds `HARVEST_ROLE` on the liquid locker - distinct
+ * from `isKeeper`, since `harvest()` is gated by `onlyRole(HARVEST_ROLE)`, not
+ * `onlyKeeper`.
+ */
+export declare const hasHarvestRole: (chainId: ChainId, account: string, provider?: Provider) => Promise<boolean>;

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

@@ -0,0 +1,18 @@
+import { ethers, Provider, Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { PsmVaultEntry } from "../../configs/chains/chain";
+import { PSMVault } from "../../typechain-types/psm/PSMVault";
+import { RateProvider } from "../../typechain-types/psm/RateProvider";
+/**
+ * Resolves a PSM vault entry by its config key (any casing) or its deployed
+ * address, since callers may have either on hand.
+ */
+export declare function resolvePsmVault(chainId: ChainId, vaultKeyOrAddress: string): {
+    key: string;
+    entry: PsmVaultEntry;
+};
+export declare function getPsmVaultContract(chainId: ChainId, vaultKeyOrAddress: string, providerOrSigner?: Provider | Signer): PSMVault;
+export declare function getPsmRateProviderContract(chainId: ChainId, vaultKeyOrAddress: string, providerOrSigner?: Provider | Signer): RateProvider;
+export declare function getDefaultProvider(chainId: ChainId): Provider;
+export declare function getTokenReaderContract(address: string, providerOrSigner?: Provider | Signer): ethers.Contract;
+export declare function getModuleContract(address: string, providerOrSigner?: Provider | Signer): ethers.Contract;

package/dist/types/contracts/psm/cancelExit.d.ts

@@ -0,0 +1,4 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/** Cancels a pending exit request from a PSM vault. */
+export declare function cancelExit(chainId: ChainId, vaultKeyOrAddress: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/deposit.d.ts

@@ -0,0 +1,9 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Deposits savings token into a PSM vault for shares.
+ * @param savingsAmount The amount to deposit, in savings token base units.
+ * @param minSharesOut The minimum shares to accept, in share base units.
+ * @param receiver The address to receive the shares.
+ */
+export declare function deposit(chainId: ChainId, vaultKeyOrAddress: string, savingsAmount: bigint, minSharesOut: bigint, receiver: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

package/dist/types/contracts/psm/getVaultInfo.d.ts

@@ -0,0 +1,77 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount, ScaledValue } from "../../utils/amount";
+export interface PsmVaultUserInfo {
+    shareBalance: TokenAmount;
+    savingsTokenBalance: TokenAmount;
+    baseAssetBalance: TokenAmount;
+    redeemRequest: {
+        shares: TokenAmount;
+        exitTime: number;
+    };
+    savingsTokenAllowance: TokenAmount;
+    baseAssetAllowance: TokenAmount;
+}
+export interface PsmVaultInfo {
+    totalAssets: TokenAmount;
+    totalSupply: TokenAmount;
+    depositCap: TokenAmount;
+    /** Basis points (of 10_000). */
+    swapFee: bigint;
+    /** Basis points (of 10_000), the fee that currently applies given the vault's reserve ratio. */
+    computeWithdrawFee: bigint;
+    /** Seconds a redeem request must wait before it's claimable. */
+    withdrawTime: number;
+    /** Seconds after `withdrawTime` a ready request stays claimable before it expires. */
+    withdrawTimeLimit: number;
+    /** pmUSD released per second while a donation streams in. */
+    dripRate: TokenAmount;
+    /** Unix timestamp the current reward stream finishes. */
+    dripEnd: number;
+    /** Reward pmUSD not yet streamed into `totalAssets`. */
+    pendingRewards: TokenAmount;
+    vaultComposition: {
+        baseAssetValue: TokenAmount;
+        savingsTokenValue: TokenAmount;
+        total: TokenAmount;
+    };
+    /** Basis points (of 10_000). */
+    minWithdrawFee: bigint;
+    /** Basis points (of 10_000). */
+    maxWithdrawFee: bigint;
+    rebalancer: string;
+    /** Null when the vault has no base asset module configured. */
+    baseAssetModule: string | null;
+    /** Minimum pmUSD balance (excl. pendingRewards) to trigger a rebalance. */
+    rebalanceThreshold: TokenAmount;
+    /** 18-decimal ratio, e.g. 0.20e18 = 20%. */
+    reserveRatioFloor: ScaledValue;
+    /** Seconds a donation's rewards stream in over. */
+    dripDuration: number;
+    paused: boolean;
+    circuitBreakerEnabled: boolean;
+    /** 18-decimal NAV floor from the base asset's NAV oracle. */
+    navFloor: ScaledValue;
+    /** Address of the vault's savings token. */
+    savingsToken: string;
+    /** Address of the vault's base asset (pmUSD). */
+    baseAsset: string;
+    /** 18-decimal savings token rate from the rate provider. */
+    savingsTokenRate: ScaledValue;
+    /** The vault's own savings token holdings. */
+    vaultSavingsTokenBalance: TokenAmount;
+    /** Raw module-token base units; null when the vault has no base asset module configured. */
+    moduleVaultBalance: bigint | null;
+    /** 18-decimal rate, pmUSD value of one module share; null when the vault has no base asset module configured. */
+    moduleConvertToAssets: ScaledValue | null;
+    /** Null when no `userAddress` was given. */
+    user: PsmVaultUserInfo | null;
+}
+/**
+ * Gets aggregate and (optionally) user-specific info for a PSM vault.
+ * @param chainId - The chain/network to use.
+ * @param vaultKeyOrAddress - The vault's config key (e.g. "rpsm-sUSDS") or its deployed address.
+ * @param userAddress - When given, also returns the user's balances, allowances and redeem request.
+ * @param provider - Optional ethers.js Provider instance.
+ */
+export declare function getVaultInfo(chainId: ChainId, vaultKeyOrAddress: string, userAddress?: string, provider?: Provider): Promise<PsmVaultInfo>;

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

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Previews depositing `savingsAmount` (savings token base units) into a PSM vault.
+ * @returns The shares out, in share base units.
+ */
+export declare function previewDeposit(chainId: ChainId, vaultKeyOrAddress: string, savingsAmount: bigint, provider?: Provider): Promise<bigint>;

package/dist/types/contracts/psm/previewProportionalSplit.d.ts

@@ -0,0 +1,9 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+export interface ProportionalSplit {
+    moduleTokenOut: bigint;
+    baseAssetOut: bigint;
+    savingsTokenOut: bigint;
+}
+/** @returns The 3-way split of `entitlement` across the module token, base asset, and savings token. */
+export declare function previewProportionalSplit(chainId: ChainId, vaultKeyOrAddress: string, entitlement: bigint, provider?: Provider): Promise<ProportionalSplit>;