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

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/rentStreamer/_helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRentStreamerContract = getRentStreamerContract;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const getContractAddress_1 = require("../getContractAddress");
+const artifacts_1 = require("../../utils/artifacts");
+async function getRentStreamerContract(chainId, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, getContractAddress_1.getContractAddress)(chainId, "rentstreamer");
+    const abi = (0, artifacts_1.getABI)("rentstreamer");
+    return new ethers_1.ethers.Contract(address, abi, runner);
+}

package/dist/contracts/rentStreamer/getEpochProjection.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEpochProjection = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+const _helpers_1 = require("./_helpers");
+/** FeeStreamer.WEEK: buckets and the gauge controller's epochs both start on this grid. */
+const WEEK = 7n * 24n * 3600n;
+const BOUNTY_PRECISION = 10n ** BigInt(amount_1.WAD_DECIMALS);
+/** Bucket `index` of `amount` split from a start epoch, as FeeStreamer._append does: equal splits, the remainder in the last. */
+const bucketShare = (amount, numEpochs, index) => {
+    if (index >= numEpochs)
+        return 0n;
+    const split = amount / numEpochs;
+    return index < numEpochs - 1n ? split : amount - split * (numEpochs - 1n);
+};
+/**
+ * Projects what the RWA gauge system receives from the RentStreamer in the current and the next epoch, counting
+ * token sent to the streamer but not yet synced as it will be split: from the current epoch when the current epoch
+ * is not released yet, otherwise from the next one. Reads every value at one block.
+ *
+ * Assumes the current epoch is released before it ends; an unreleased bucket rolls into the next release. Rent sent
+ * after this read adds to later buckets, so the next epoch's figure can still grow.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Both epochs' deposited, pending and projected amounts in the streamed token's base units.
+ */
+const getEpochProjection = async (chainId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const block = await provider.getBlock("latest");
+    if (!block)
+        throw new Error("Could not read the latest block");
+    const overrides = { blockTag: block.number };
+    const currentEpoch = (BigInt(block.timestamp) / WEEK) * WEEK;
+    const nextEpoch = currentEpoch + WEEK;
+    const streamer = await (0, _helpers_1.getRentStreamerContract)(chainId, provider);
+    const [token, distributorAddress, numEpochs, maxBountyFee, killed, processed, lastEpochProcessed, preview, scheduledNext] = await Promise.all([
+        streamer.TOKEN(overrides),
+        streamer.GAUGE_REWARD_DISTRIBUTOR(overrides),
+        streamer.numEpochs(overrides),
+        streamer.maxBountyFee(overrides),
+        streamer.killed(overrides),
+        streamer.processed(overrides),
+        streamer.lastEpochProcessed(overrides),
+        streamer.previewRelease(overrides),
+        streamer.scheduled(nextEpoch, overrides),
+    ]);
+    const erc20 = new ethers_1.ethers.Contract(token, ["function balanceOf(address) view returns (uint256)"], provider);
+    const distributor = new ethers_1.ethers.Contract(distributorAddress, (0, artifacts_1.getABI)("gaugerewardsdistributor"), provider);
+    const [balance, depositedCurrent] = await Promise.all([
+        erc20.balanceOf(await streamer.getAddress(), overrides),
+        distributor.depositedAtEpoch(token, currentEpoch, overrides),
+    ]);
+    const epochs = BigInt(numEpochs);
+    const unsynced = balance - processed;
+    const currentReleased = lastEpochProcessed >= currentEpoch;
+    // previewRelease already counts every unreleased bucket up to now plus the first split of the unsynced amount.
+    const pendingCurrent = killed ? 0n : preview[0];
+    // Unsynced token is split from the current epoch at its release, or from the next epoch once the current one is released.
+    const pendingNext = killed ? 0n : scheduledNext + bucketShare(unsynced, epochs, currentReleased ? 0n : 1n);
+    const amount = (value) => (0, amount_1.toTokenAmount)(chainId, token, value);
+    const project = (epoch, deposited, pending) => {
+        const maxBounty = (pending * maxBountyFee) / BOUNTY_PRECISION;
+        return {
+            epoch: Number(epoch),
+            deposited: amount(deposited),
+            pending: amount(pending),
+            maxBounty: amount(maxBounty),
+            projected: amount(deposited + pending - maxBounty),
+        };
+    };
+    return {
+        token,
+        numEpochs: Number(numEpochs),
+        killed,
+        currentReleased,
+        unsynced: amount(unsynced),
+        current: project(currentEpoch, depositedCurrent, pendingCurrent),
+        next: project(nextEpoch, 0n, pendingNext),
+    };
+};
+exports.getEpochProjection = getEpochProjection;

package/dist/contracts/rentStreamer/getScheduled.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScheduled = void 0;
+const amount_1 = require("../../utils/amount");
+const _helpers_1 = require("./_helpers");
+/**
+ * Reads the amount bucketed for one epoch. Released epochs read zero.
+ *
+ * @param chainId - The chain/network to use.
+ * @param epoch - Epoch start timestamp, a multiple of one week.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The scheduled amount in the streamed token's base units.
+ */
+const getScheduled = async (chainId, epoch, provider) => {
+    const contract = await (0, _helpers_1.getRentStreamerContract)(chainId, provider);
+    const [token, amount] = await Promise.all([contract.TOKEN(), contract.scheduled(epoch)]);
+    return (0, amount_1.toTokenAmount)(chainId, token, amount);
+};
+exports.getScheduled = getScheduled;

package/dist/contracts/rentStreamer/getState.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getState = void 0;
+const amount_1 = require("../../utils/amount");
+const _helpers_1 = require("./_helpers");
+/**
+ * Reads the RentStreamer's configuration and running totals.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The streamer state; see `RentStreamerState` for the unit of each field.
+ */
+const getState = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getRentStreamerContract)(chainId, provider);
+    const [token, distributor, numEpochs, minBountyFee, maxBountyFee, bountyDuration, killed, processed, released, lastEpochProcessed] = await Promise.all([
+        contract.TOKEN(),
+        contract.GAUGE_REWARD_DISTRIBUTOR(),
+        contract.numEpochs(),
+        contract.minBountyFee(),
+        contract.maxBountyFee(),
+        contract.bountyDuration(),
+        contract.killed(),
+        contract.processed(),
+        contract.released(),
+        contract.lastEpochProcessed(),
+    ]);
+    return {
+        token,
+        distributor,
+        numEpochs: Number(numEpochs),
+        minBountyFee: (0, amount_1.toScaled)(minBountyFee, amount_1.WAD_DECIMALS),
+        maxBountyFee: (0, amount_1.toScaled)(maxBountyFee, amount_1.WAD_DECIMALS),
+        bountyDuration: Number(bountyDuration),
+        killed,
+        processed: (0, amount_1.toTokenAmount)(chainId, token, processed),
+        released: (0, amount_1.toTokenAmount)(chainId, token, released),
+        lastEpochProcessed: Number(lastEpochProcessed),
+    };
+};
+exports.getState = getState;

package/dist/contracts/rentStreamer/previewRelease.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewRelease = void 0;
+const amount_1 = require("../../utils/amount");
+const _helpers_1 = require("./_helpers");
+/**
+ * Previews what a `release` would move right now. All zero when the current epoch was already released or the
+ * streamer is killed. The bounty grows with time since the epoch start, so the real release can differ.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The release preview, in the streamed token's base units.
+ */
+const previewRelease = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getRentStreamerContract)(chainId, provider);
+    const [token, [amountToRelease, amountToDistribute, bountyFee]] = await Promise.all([contract.TOKEN(), contract.previewRelease()]);
+    return {
+        amountToRelease: (0, amount_1.toTokenAmount)(chainId, token, amountToRelease),
+        amountToDistribute: (0, amount_1.toTokenAmount)(chainId, token, amountToDistribute),
+        bountyFee: (0, amount_1.toTokenAmount)(chainId, token, bountyFee),
+    };
+};
+exports.previewRelease = previewRelease;

package/dist/contracts/rentStreamer/release.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Releases the current epoch's buckets: pays the keeper bounty and deposits the rest into the RWA
+ * GaugeRewardsDistributor. Permissionless, once per epoch; reverts while the RWA gauge system has no active gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param receiver - Address paid the bounty; the signer when omitted.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction.
+ */
+const release = async (chainId, receiver, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getRentStreamerContract)(chainId, signer);
+    const tx = receiver ? await contract["release(address)"](receiver) : await contract["release()"]();
+    await tx.wait();
+    return tx;
+};
+exports.release = release;

package/dist/contracts/rentStreamer/sync.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Splits token sent to the streamer since the last sync over the next `numEpochs` weekly buckets. Permissionless;
+ * `release` also syncs first.
+ *
+ * @param chainId - The chain/network to use.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns The transaction.
+ */
+const sync = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getRentStreamerContract)(chainId, signer);
+    const tx = await contract.sync();
+    await tx.wait();
+    return tx;
+};
+exports.sync = sync;

package/dist/contracts/resolveName.js

@@ -22,7 +22,7 @@ const ENS_TTL_MS = 60 * 60 * 1000;
 function contractInfoToAddressName(info) {
     return {
         address: info.address,
-        name: info.name,
+        name: info.label ?? info.name,
         kind: info.section === "gauges" ? "gauge" : "contract",
         source: "config",
     };

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;

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

@@ -4,6 +4,7 @@ exports.finalizeRagequit = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Finalizes an initiated ragequit after the cooldown period.
  * Transfers the net unlocked RAAC to the specified address.
@@ -17,18 +18,16 @@ const finalizeRagequit = async (chainId, toAddress, 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.finalizeRagequit(toAddress);
         await tx.wait();
-        console.log(`Finalized ragequit to ${toAddress} at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error finalizing ragequit:", error);
-        throw new Error(`Failed to finalize ragequit: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.finalizeRagequit", error, { chainId, address: contractAddress });
     }
 };
 exports.finalizeRagequit = finalizeRagequit;

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRewardTokens = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const getContractAddress_1 = require("../../getContractAddress");
+const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
+/**
+ * Gets the reward token addresses configured on the veRAAC contract.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The reward token addresses.
+ */
+const getRewardTokens = async (chainId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
+    try {
+        const abi = (0, artifacts_1.getABI)("veraac");
+        const contract = new ethers_1.ethers.Contract(contractAddress, abi, provider);
+        return Array.from(await contract.getRewardTokens());
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("veRAAC.getRewardTokens", error, { chainId, address: contractAddress });
+    }
+};
+exports.getRewardTokens = getRewardTokens;

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

@@ -24,7 +24,6 @@ const getTotalSupply = async (chainId, contractAddress, provider) => {
         const rpc = chains_1.default[chainId].rpcs[0];
         provider = new ethers_1.ethers.JsonRpcProvider(rpc);
     }
-    console.log(`Getting total supply for ${contractAddress} on ${(await provider.getNetwork()).chainId} using provider ${provider}`);
     const abi = (0, artifacts_1.getABI)("veraac");
     const contract = new ethers_1.ethers.Contract(contractAddress, abi, provider);
     const totalSupply = await contract.totalSupply();

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

@@ -25,7 +25,7 @@ const getTotalSupplyAt = async (chainId, blockNumber, provider) => {
     const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
     const abi = (0, artifacts_1.getABI)("veraac");
     const contract = new ethers_1.ethers.Contract(contractAddress, abi, provider);
-    const totalSupply = await contract.totalSupplyAt(blockNumber);
+    const [totalSupply] = await contract.totalSupplyAt(blockNumber);
     return (0, amount_1.toTokenAmount)(chainId, "veraac", totalSupply);
 };
 exports.getTotalSupplyAt = getTotalSupplyAt;

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

@@ -4,6 +4,7 @@ exports.increase = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Increases the amount of tokens in an existing lock.
  * Adds more RAAC tokens to an existing lock position without changing the unlock time.
@@ -18,18 +19,16 @@ const increase = async (chainId, amountToAdd, epochEnd, 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.increase(amountToAdd, epochEnd);
         await tx.wait();
-        console.log(`Increased lock by ${amountToAdd} at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error increasing lock:", error);
-        throw new Error(`Failed to increase lock: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.increase", error, { chainId, address: contractAddress });
     }
 };
 exports.increase = increase;

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

@@ -4,6 +4,7 @@ exports.lock = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Locks RAAC tokens for a specified duration to receive veRAAC voting power.
  *
@@ -17,18 +18,16 @@ const lock = async (chainId, amount, epochs, 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.lock(amount, epochs);
         await tx.wait();
-        console.log(`Locked ${amount} RAAC for ${epochs} epochs at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error locking tokens:", error);
-        throw new Error(`Failed to lock tokens: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.lock", error, { chainId, address: contractAddress });
     }
 };
 exports.lock = lock;

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

@@ -4,6 +4,7 @@ exports.ragequitAll = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Ragequits all locks for the caller.
  * Initiates a ragequit process with cooldown period and fees.
@@ -16,18 +17,16 @@ const ragequitAll = async (chainId, 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.ragequitAll();
         await tx.wait();
-        console.log(`Ragequit initiated at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error ragequitting:", error);
-        throw new Error(`Failed to ragequit: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.ragequitAll", error, { chainId, address: contractAddress });
     }
 };
 exports.ragequitAll = ragequitAll;

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

@@ -4,6 +4,7 @@ exports.ragequitLock = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Ragequits a specific lock by epoch end time.
  * Initiates a ragequit process for a single lock with cooldown period and fees.
@@ -17,18 +18,16 @@ const ragequitLock = async (chainId, epochEnd, 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.ragequitLock(epochEnd);
         await tx.wait();
-        console.log(`Ragequit lock initiated for epoch ${epochEnd} at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error ragequitting lock:", error);
-        throw new Error(`Failed to ragequit lock: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.ragequitLock", error, { chainId, address: contractAddress });
     }
 };
 exports.ragequitLock = ragequitLock;

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

@@ -4,6 +4,7 @@ exports.withdraw = void 0;
 const ethers_1 = require("ethers");
 const getContractAddress_1 = require("../../getContractAddress");
 const artifacts_1 = require("../../../utils/artifacts");
+const rpcError_1 = require("../../../utils/rpcError");
 /**
  * Withdraws expired tokens from all eligible lock positions.
  * Withdraws all expired tokens and transfers them to the caller, also claims rewards.
@@ -16,18 +17,16 @@ const withdraw = async (chainId, 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.withdraw();
         await tx.wait();
-        console.log(`Withdrew expired tokens at ${contractAddress}`);
         return tx;
     }
     catch (error) {
-        console.error("Error withdrawing:", error);
-        throw new Error(`Failed to withdraw: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("veRAAC.withdraw", error, { chainId, address: contractAddress });
     }
 };
 exports.withdraw = withdraw;