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

package/dist/contracts/pmTreasury/getMaxMintablePMUSDWithoutBaseToken.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("./_helpers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads the most pmUSD mintable without depositing base token before the collateral ratio falls to `newCollateralRatio`.
  * @param chainId The chain id.
@@ -11,6 +13,7 @@ const _helpers_1 = require("./_helpers");
  */
 async function getMaxMintablePMUSDWithoutBaseToken(chainId, newCollateralRatio, provider) {
     (0, _helpers_1.assertCollateralRatio)(newCollateralRatio);
+    const contractAddress = (0, contracts_1.getContractAddress)(chainId, "pmtreasury");
     try {
         const runner = (0, _helpers_1.resolvePmTreasuryProvider)(chainId, provider);
         const pmTreasuryContract = (0, _helpers_1.getPmTreasuryContract)(chainId, runner);
@@ -20,8 +23,7 @@ async function getMaxMintablePMUSDWithoutBaseToken(chainId, newCollateralRatio,
         };
     }
     catch (error) {
-        console.error("Error getting max mintable PMUSD:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("pmTreasury.getMaxMintablePMUSDWithoutBaseToken", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getMaxMintablePMUSDWithoutBaseToken;

package/dist/contracts/pmTreasury/getMaxMintableXPM.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("./_helpers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads the most xPM mintable, and the base token needed, before the collateral ratio rises to `newCollateralRatio`.
  * @param chainId The chain id.
@@ -11,6 +13,7 @@ const _helpers_1 = require("./_helpers");
  */
 async function getMaxMintableXPM(chainId, newCollateralRatio, provider) {
     (0, _helpers_1.assertCollateralRatio)(newCollateralRatio);
+    const contractAddress = (0, contracts_1.getContractAddress)(chainId, "pmtreasury");
     try {
         const runner = (0, _helpers_1.resolvePmTreasuryProvider)(chainId, provider);
         const pmTreasuryContract = (0, _helpers_1.getPmTreasuryContract)(chainId, runner);
@@ -21,8 +24,7 @@ async function getMaxMintableXPM(chainId, newCollateralRatio, provider) {
         };
     }
     catch (error) {
-        console.error("Error getting max mintable XPM:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("pmTreasury.getMaxMintableXPM", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getMaxMintableXPM;

package/dist/contracts/pmTreasury/getMaxRedeemablePMUSD.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("./_helpers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads the most pmUSD redeemable, and the base token received, before the collateral ratio rises to `newCollateralRatio`.
  * @param chainId The chain id.
@@ -11,6 +13,7 @@ const _helpers_1 = require("./_helpers");
  */
 async function getMaxRedeemablePMUSD(chainId, newCollateralRatio, provider) {
     (0, _helpers_1.assertCollateralRatio)(newCollateralRatio);
+    const contractAddress = (0, contracts_1.getContractAddress)(chainId, "pmtreasury");
     try {
         const runner = (0, _helpers_1.resolvePmTreasuryProvider)(chainId, provider);
         const pmTreasuryContract = (0, _helpers_1.getPmTreasuryContract)(chainId, runner);
@@ -21,8 +24,7 @@ async function getMaxRedeemablePMUSD(chainId, newCollateralRatio, provider) {
         };
     }
     catch (error) {
-        console.error("Error getting max redeemable PMUSD:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("pmTreasury.getMaxRedeemablePMUSD", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getMaxRedeemablePMUSD;

package/dist/contracts/pmTreasury/getMaxRedeemableXPM.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("./_helpers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads the most xPM redeemable, and the base token received, before the collateral ratio falls to `newCollateralRatio`.
  * @param chainId The chain id.
@@ -11,6 +13,7 @@ const _helpers_1 = require("./_helpers");
  */
 async function getMaxRedeemableXPM(chainId, newCollateralRatio, provider) {
     (0, _helpers_1.assertCollateralRatio)(newCollateralRatio);
+    const contractAddress = (0, contracts_1.getContractAddress)(chainId, "pmtreasury");
     try {
         const runner = (0, _helpers_1.resolvePmTreasuryProvider)(chainId, provider);
         const pmTreasuryContract = (0, _helpers_1.getPmTreasuryContract)(chainId, runner);
@@ -21,8 +24,7 @@ async function getMaxRedeemableXPM(chainId, newCollateralRatio, provider) {
         };
     }
     catch (error) {
-        console.error("Error getting max redeemable XPM:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("pmTreasury.getMaxRedeemableXPM", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getMaxRedeemableXPM;

package/dist/contracts/pmTreasury/getTotalBaseToken.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("./_helpers");
+const contracts_1 = require("../../utils/contracts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads the amount of base token held by the pmTreasury.
  * @param chainId The chain id.
@@ -9,6 +11,7 @@ const _helpers_1 = require("./_helpers");
  * @returns The base token amount, with 18 decimals (fixed by the treasury math).
  */
 async function getTotalBaseToken(chainId, provider) {
+    const contractAddress = (0, contracts_1.getContractAddress)(chainId, "pmtreasury");
     try {
         const runner = (0, _helpers_1.resolvePmTreasuryProvider)(chainId, provider);
         const pmTreasuryContract = (0, _helpers_1.getPmTreasuryContract)(chainId, runner);
@@ -16,8 +19,7 @@ async function getTotalBaseToken(chainId, provider) {
         return (0, amount_1.toAmount)(totalBaseToken, _helpers_1.BASE_TOKEN_DECIMALS);
     }
     catch (error) {
-        console.error("Error getting total base token:", error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("pmTreasury.getTotalBaseToken", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getTotalBaseToken;

package/dist/contracts/psm/_helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePsmVault = resolvePsmVault;
+exports.getPsmVaultContract = getPsmVaultContract;
+exports.getPsmRateProviderContract = getPsmRateProviderContract;
+exports.getDefaultProvider = getDefaultProvider;
+exports.getTokenReaderContract = getTokenReaderContract;
+exports.getModuleContract = getModuleContract;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+/**
+ * Resolves a PSM vault entry by its config key (any casing) or its deployed
+ * address, since callers may have either on hand.
+ */
+function resolvePsmVault(chainId, vaultKeyOrAddress) {
+    const psm = chains_1.default[chainId]?.psm;
+    if (!psm)
+        throw new Error(`No PSM vaults configured for chain ${chainId}`);
+    const needle = vaultKeyOrAddress.toLowerCase();
+    let key = needle in psm ? needle : undefined;
+    if (!key) {
+        key = Object.keys(psm).find((k) => psm[k].contract.toLowerCase() === needle);
+    }
+    if (!key)
+        throw new Error(`PSM vault "${vaultKeyOrAddress}" not configured for chain ${chainId}`);
+    return { key, entry: psm[key] };
+}
+function getPsmVaultContract(chainId, vaultKeyOrAddress, providerOrSigner) {
+    const { key, entry } = resolvePsmVault(chainId, vaultKeyOrAddress);
+    const abi = (0, artifacts_1.getABI)(key);
+    return new ethers_1.ethers.Contract(entry.contract, abi, providerOrSigner);
+}
+function getPsmRateProviderContract(chainId, vaultKeyOrAddress, providerOrSigner) {
+    const { entry } = resolvePsmVault(chainId, vaultKeyOrAddress);
+    const abi = (0, artifacts_1.getABI)("rateprovider");
+    return new ethers_1.ethers.Contract(entry.rateProvider, abi, providerOrSigner);
+}
+function getDefaultProvider(chainId) {
+    const rpc = chains_1.default[chainId].rpcs[0];
+    return new ethers_1.ethers.JsonRpcProvider(rpc);
+}
+/**
+ * Minimal read-only ERC20 surface, for the vault's savings token and base
+ * asset. Neither necessarily has a compiled artifact in this library (the
+ * savings token is a third-party token) - reads only, no `approve`; use
+ * `wallet.assets.approveAsset` for approvals instead.
+ */
+const ERC20_READ_ABI = [
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+];
+function getTokenReaderContract(address, providerOrSigner) {
+    return new ethers_1.ethers.Contract(address, ERC20_READ_ABI, providerOrSigner);
+}
+/** Minimal read-only surface for a vault's base asset module (rebalancer target), when one is configured. */
+const PSM_MODULE_ABI = [
+    "function balanceOf(address) view returns (uint256)",
+    "function convertToAssets(uint256 shares) view returns (uint256)",
+];
+function getModuleContract(address, providerOrSigner) {
+    return new ethers_1.ethers.Contract(address, PSM_MODULE_ABI, providerOrSigner);
+}

package/dist/contracts/psm/cancelExit.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelExit = cancelExit;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/** Cancels a pending exit request from a PSM vault. */
+async function cancelExit(chainId, vaultKeyOrAddress, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, signer);
+        const tx = await vault.cancelExit();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.cancelExit", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/deposit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deposit = deposit;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * 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.
+ */
+async function deposit(chainId, vaultKeyOrAddress, savingsAmount, minSharesOut, receiver, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, signer);
+        const tx = await vault.deposit(savingsAmount, minSharesOut, receiver);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.deposit", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/getVaultInfo.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVaultInfo = getVaultInfo;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+const amount_1 = require("../../utils/amount");
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+ * 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.
+ */
+async function getVaultInfo(chainId, vaultKeyOrAddress, userAddress, provider) {
+    if (!provider)
+        provider = (0, _helpers_1.getDefaultProvider)(chainId);
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    const contractAddress = entry.contract;
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider);
+        const [totalAssets, totalSupply, vaultDecimals, depositCap, swapFee, computeWithdrawFee, withdrawTime, withdrawTimeLimit, dripRate, dripEnd, pendingRewards, vaultComposition, minWithdrawFee, maxWithdrawFee, rebalancer, baseAssetModule, reserveRatioFloor, rebalanceThreshold, dripDuration, paused, circuitBreakerEnabled, navFloor, savingsToken, baseAsset,] = await Promise.all([
+            vault.totalAssets(),
+            vault.totalSupply(),
+            vault.decimals(),
+            vault.depositCap(),
+            vault.swapFee(),
+            vault.computeWithdrawFee(),
+            vault.withdrawTime(),
+            vault.withdrawTimeLimit(),
+            vault.dripRate(),
+            vault.dripEnd(),
+            vault.pendingRewards(),
+            vault.vaultComposition(),
+            vault.minWithdrawFee(),
+            vault.maxWithdrawFee(),
+            vault.rebalancer(),
+            vault.baseAssetModule(),
+            vault.reserveRatioFloor(),
+            vault.rebalanceThreshold(),
+            vault.DRIP_DURATION(),
+            vault.paused(),
+            vault.circuitBreakerEnabled(),
+            vault.navFloor(),
+            vault.savingsToken(),
+            vault.asset(),
+        ]);
+        const savingsTokenContract = (0, _helpers_1.getTokenReaderContract)(savingsToken, provider);
+        const rateProvider = (0, _helpers_1.getPsmRateProviderContract)(chainId, vaultKeyOrAddress, provider);
+        const [savingsTokenRate, vaultSavingsTokenBalance] = await Promise.all([
+            rateProvider.getRate(savingsToken),
+            savingsTokenContract.balanceOf(contractAddress),
+        ]);
+        let moduleVaultBalance = null;
+        let moduleConvertToAssets = null;
+        if (baseAssetModule && baseAssetModule !== ZERO_ADDRESS) {
+            const module = (0, _helpers_1.getModuleContract)(baseAssetModule, provider);
+            const [balance, convertToAssets] = await Promise.all([
+                module.balanceOf(contractAddress),
+                module.convertToAssets(10n ** 18n),
+            ]);
+            moduleVaultBalance = balance;
+            moduleConvertToAssets = (0, amount_1.toScaled)(convertToAssets);
+        }
+        let user = null;
+        if (userAddress) {
+            const baseAssetContract = (0, _helpers_1.getTokenReaderContract)(baseAsset, provider);
+            const [shareBalance, savingsTokenBalance, baseAssetBalance, redeemRequest, savingsTokenAllowance, baseAssetAllowance] = await Promise.all([
+                vault.balanceOf(userAddress),
+                savingsTokenContract.balanceOf(userAddress),
+                baseAssetContract.balanceOf(userAddress),
+                vault.redeemRequests(userAddress),
+                savingsTokenContract.allowance(userAddress, contractAddress),
+                baseAssetContract.allowance(userAddress, contractAddress),
+            ]);
+            user = {
+                shareBalance: (0, amount_1.toAmount)(shareBalance, Number(vaultDecimals), entry.id),
+                savingsTokenBalance: (0, amount_1.toTokenAmount)(chainId, "susds", savingsTokenBalance),
+                baseAssetBalance: (0, amount_1.toTokenAmount)(chainId, "pmusd", baseAssetBalance),
+                redeemRequest: {
+                    shares: (0, amount_1.toAmount)(redeemRequest[0], Number(vaultDecimals), entry.id),
+                    exitTime: Number(redeemRequest[1]),
+                },
+                savingsTokenAllowance: (0, amount_1.toTokenAmount)(chainId, "susds", savingsTokenAllowance),
+                baseAssetAllowance: (0, amount_1.toTokenAmount)(chainId, "pmusd", baseAssetAllowance),
+            };
+        }
+        return {
+            totalAssets: (0, amount_1.toTokenAmount)(chainId, "pmusd", totalAssets),
+            totalSupply: (0, amount_1.toAmount)(totalSupply, Number(vaultDecimals), entry.id),
+            depositCap: (0, amount_1.toTokenAmount)(chainId, "susds", depositCap),
+            swapFee,
+            computeWithdrawFee,
+            withdrawTime: Number(withdrawTime),
+            withdrawTimeLimit: Number(withdrawTimeLimit),
+            dripRate: (0, amount_1.toTokenAmount)(chainId, "pmusd", dripRate),
+            dripEnd: Number(dripEnd),
+            pendingRewards: (0, amount_1.toTokenAmount)(chainId, "pmusd", pendingRewards),
+            vaultComposition: {
+                baseAssetValue: (0, amount_1.toTokenAmount)(chainId, "pmusd", vaultComposition[0]),
+                savingsTokenValue: (0, amount_1.toTokenAmount)(chainId, "pmusd", vaultComposition[1]),
+                total: (0, amount_1.toTokenAmount)(chainId, "pmusd", vaultComposition[2]),
+            },
+            minWithdrawFee,
+            maxWithdrawFee,
+            rebalancer,
+            baseAssetModule: baseAssetModule && baseAssetModule !== ZERO_ADDRESS ? baseAssetModule : null,
+            rebalanceThreshold: (0, amount_1.toTokenAmount)(chainId, "pmusd", rebalanceThreshold),
+            reserveRatioFloor: (0, amount_1.toScaled)(reserveRatioFloor),
+            dripDuration: Number(dripDuration),
+            paused,
+            circuitBreakerEnabled,
+            navFloor: (0, amount_1.toScaled)(navFloor),
+            savingsToken,
+            baseAsset,
+            savingsTokenRate: (0, amount_1.toScaled)(savingsTokenRate),
+            vaultSavingsTokenBalance: (0, amount_1.toTokenAmount)(chainId, "susds", vaultSavingsTokenBalance),
+            moduleVaultBalance,
+            moduleConvertToAssets,
+            user,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.getVaultInfo", error, { chainId, address: contractAddress });
+    }
+}

package/dist/contracts/psm/previewDeposit.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewDeposit = previewDeposit;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Previews depositing `savingsAmount` (savings token base units) into a PSM vault.
+ * @returns The shares out, in share base units.
+ */
+async function previewDeposit(chainId, vaultKeyOrAddress, savingsAmount, provider) {
+    if (!provider)
+        provider = (0, _helpers_1.getDefaultProvider)(chainId);
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider);
+        return await vault.previewDeposit(savingsAmount);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.previewDeposit", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/previewProportionalSplit.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewProportionalSplit = previewProportionalSplit;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/** @returns The 3-way split of `entitlement` across the module token, base asset, and savings token. */
+async function previewProportionalSplit(chainId, vaultKeyOrAddress, entitlement, provider) {
+    if (!provider)
+        provider = (0, _helpers_1.getDefaultProvider)(chainId);
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider);
+        const [moduleTokenOut, baseAssetOut, savingsTokenOut] = await vault.previewProportionalSplit(entitlement);
+        return { moduleTokenOut, baseAssetOut, savingsTokenOut };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.previewProportionalSplit", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/previewRedeem.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewRedeem = previewRedeem;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Previews redeeming `shares` (share base units) from a PSM vault.
+ * @returns The assets out after fee, in base asset base units.
+ */
+async function previewRedeem(chainId, vaultKeyOrAddress, shares, provider) {
+    if (!provider)
+        provider = (0, _helpers_1.getDefaultProvider)(chainId);
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider);
+        return await vault.previewRedeem(shares);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.previewRedeem", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/previewSwap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewSwap = previewSwap;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Previews swapping `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @returns The amount out, in tokenOut base units.
+ */
+async function previewSwap(chainId, vaultKeyOrAddress, tokenIn, tokenOut, amountIn, provider) {
+    if (!provider)
+        provider = (0, _helpers_1.getDefaultProvider)(chainId);
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, provider);
+        return await vault.previewSwap(tokenIn, tokenOut, amountIn);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.previewSwap", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/redeem.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeem = redeem;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Redeems `shares` (share base units) from a PSM vault, after a ready exit request.
+ * Use `previewProportionalSplit` beforehand to preview the 3-way split.
+ * @param minAssetsOut The minimum total assets to accept, in base asset base units.
+ * @param receiver The address to receive the assets.
+ */
+async function redeem(chainId, vaultKeyOrAddress, shares, receiver, minAssetsOut, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, signer);
+        const tx = await vault.redeem(shares, receiver, minAssetsOut);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.redeem", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/requestExit.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestExit = requestExit;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/** Requests an exit from a PSM vault for `shares` (share base units), starting the withdraw timelock. */
+async function requestExit(chainId, vaultKeyOrAddress, shares, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, signer);
+        const tx = await vault.requestExit(shares);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.requestExit", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/psm/swap.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swap = swap;
+const _helpers_1 = require("./_helpers");
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Swaps `amountIn` of `tokenIn` for `tokenOut` through a PSM vault.
+ * @param minAmountOut The minimum output to accept, in tokenOut base units.
+ * @param receiver The address to receive the output.
+ */
+async function swap(chainId, vaultKeyOrAddress, tokenIn, tokenOut, amountIn, minAmountOut, receiver, signer) {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const { entry } = (0, _helpers_1.resolvePsmVault)(chainId, vaultKeyOrAddress);
+    try {
+        const vault = (0, _helpers_1.getPsmVaultContract)(chainId, vaultKeyOrAddress, signer);
+        const tx = await vault.swap(tokenIn, tokenOut, amountIn, minAmountOut, receiver);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("psm.swap", error, { chainId, address: entry.contract });
+    }
+}

package/dist/contracts/tokens/veRAAC/_helpers.js

@@ -30,9 +30,7 @@ const ensureRAACAllowance = async (chainId, spender, amount, signer, label) => {
     const allowance = await new ethers_1.ethers.Contract(raacAddress, ERC20_ALLOWANCE_ABI, provider).allowance(owner, spender);
     if (allowance >= amount)
         return;
-    console.log(`[${label}] Approving RAAC for veRAAC contract...`);
     const tx = await new ethers_1.ethers.Contract(raacAddress, ERC20_ALLOWANCE_ABI, signer).approve(spender, amount);
     await tx.wait();
-    console.log(`[${label}] Approval successful`);
 };
 exports.ensureRAACAllowance = ensureRAACAllowance;

package/dist/contracts/tokens/veRAAC/claimReward.js

@@ -4,6 +4,7 @@ exports.claimReward = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Claims rewards for the caller for a specific reward token.
  *
@@ -17,18 +18,16 @@ const claimReward = async (chainId, token, maxDistributions, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.claimReward(token, maxDistributions);
         await tx.wait();
-        console.log(`Claimed rewards for token ${token} at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error claiming rewards:", error);
-        throw new Error(`Failed to claim rewards: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.claimReward", error, { chainId, address: contractAddress });
     }
 };
 exports.claimReward = claimReward;

package/dist/contracts/tokens/veRAAC/distributeRewards.js

@@ -4,6 +4,7 @@ exports.distributeRewards = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Distributes rewards for a specific reward token over a number of epochs.
  * Only callable by accounts with the REWARD_DISTRIBUTOR_ROLE.
@@ -19,18 +20,16 @@ const distributeRewards = async (chainId, rewardTokenAddress, amount, epochs, si
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.distributeRewards(rewardTokenAddress, amount, epochs);
         await tx.wait();
-        console.log(`Distributed ${amount} rewards of ${rewardTokenAddress} over ${epochs} epochs at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error distributing rewards:", error);
-        throw new Error(`Failed to distribute rewards: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.distributeRewards", error, { chainId, address: contractAddress });
     }
 };
 exports.distributeRewards = distributeRewards;

package/dist/contracts/tokens/veRAAC/extend.js

@@ -4,6 +4,7 @@ exports.extend = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Extends the duration of an existing lock by adding more epochs.
  * Increases the lock duration without changing the locked amount.
@@ -18,18 +19,16 @@ const extend = async (chainId, fromEpochEnd, addEpochs, signer) => {
     if (!signer) {
         throw new Error("Signer is required");
     }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     try {
-        const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
         const abi = (0, artifacts_1.getABI)("veraac");
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
         const tx = await contract.extend(fromEpochEnd, addEpochs);
         await tx.wait();
-        console.log(`Extended lock by ${addEpochs} epochs at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error extending lock:", error);
-        throw new Error(`Failed to extend lock: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.extend", error, { chainId, address: contractAddress });
     }
 };
 exports.extend = extend;