@raac/rpc 2.0.0-beta.0 → 2.0.0-beta.10

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/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/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

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveName = resolveName;
+exports.resolveNames = resolveNames;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const findContract_1 = require("./findContract");
+const registry_1 = __importDefault(require("../configs/registry"));
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const BURN_ADDRESS = "0x000000000000000000000000000000000000dEaD";
+/** Universal, chain-agnostic entries that do not belong in a per-chain registry file. */
+const BUILTIN_REGISTRY = {
+    [ZERO_ADDRESS]: { name: "None", kind: "external" },
+    [ethers_1.ethers.getAddress(BURN_ADDRESS)]: { name: "Burn", kind: "external" },
+};
+/** address -> { name, expiresAt } | null (a confirmed miss, cached too so a repeat lookup does not re-hit the network). */
+const ensCache = new Map();
+const ENS_TTL_MS = 60 * 60 * 1000;
+function contractInfoToAddressName(info) {
+    return {
+        address: info.address,
+        name: info.label ?? info.name,
+        kind: info.section === "gauges" ? "gauge" : "contract",
+        source: "config",
+    };
+}
+function lookupRegistry(chainId, address) {
+    const builtin = BUILTIN_REGISTRY[address];
+    if (builtin)
+        return { address, ...builtin, source: "registry" };
+    const registry = registry_1.default[String(chainId)];
+    const entry = registry?.[address];
+    if (!entry)
+        return null;
+    return { address, ...entry, source: "registry" };
+}
+async function lookupEns(address, provider) {
+    const cached = ensCache.get(address);
+    if (cached && cached.expiresAt > Date.now()) {
+        return cached.name ? { address, name: cached.name, kind: "ens", source: "ens" } : null;
+    }
+    try {
+        const runner = provider ?? new ethers_1.ethers.JsonRpcProvider(chains_1.default[1].rpcs[0]);
+        const ensName = await runner.lookupAddress(address);
+        // Forward-verify: an ENS reverse record is set by its owner and can point anywhere,
+        // so trust it only once the name's forward resolution points back to this address.
+        const verified = ensName && ethers_1.ethers.getAddress((await runner.resolveName(ensName)) ?? "") === address;
+        const name = verified ? ensName : null;
+        ensCache.set(address, { name, expiresAt: Date.now() + ENS_TTL_MS });
+        return name ? { address, name, kind: "ens", source: "ens" } : null;
+    }
+    catch {
+        // A broken or slow ENS lookup must not fail the rest of resolution.
+        return null;
+    }
+}
+/**
+ * Resolves an address to a readable name.
+ *
+ * Checks the chain config (via `findContract`), then a curated registry of
+ * off-chain-known addresses (wallets, external protocols), then - mainnet
+ * only, and only once the first two miss - an ENS reverse lookup, forward-
+ * verified against the name it returns.
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - Any-case address.
+ * @param options - `ens: false` skips the ENS step; `provider` reuses an existing connection for it.
+ * @returns The resolved name, or null when nothing matches.
+ */
+async function resolveName(chainId, address, options) {
+    if (!ethers_1.ethers.isAddress(address))
+        return null;
+    const target = ethers_1.ethers.getAddress(address);
+    const configMatch = (0, findContract_1.findContract)(chainId, target);
+    if (configMatch)
+        return contractInfoToAddressName(configMatch);
+    const registryMatch = lookupRegistry(chainId, target);
+    if (registryMatch)
+        return registryMatch;
+    if (options?.ens === false || String(chainId) !== "1")
+        return null;
+    return lookupEns(target, options?.provider);
+}
+/**
+ * Batch form of {@link resolveName}. Config and registry lookups run
+ * synchronously per address; only addresses that fall through to ENS pay for
+ * a network round trip, and those run concurrently.
+ *
+ * @param chainId - The chain/network to use.
+ * @param addresses - Any-case addresses.
+ * @param options - Same as {@link resolveName}.
+ * @returns A map from the (checksummed) input address to its resolved name, or null.
+ */
+async function resolveNames(chainId, addresses, options) {
+    const result = {};
+    const pending = [];
+    for (const raw of addresses) {
+        if (!ethers_1.ethers.isAddress(raw))
+            continue;
+        const target = ethers_1.ethers.getAddress(raw);
+        const configMatch = (0, findContract_1.findContract)(chainId, target);
+        if (configMatch) {
+            result[target] = contractInfoToAddressName(configMatch);
+            continue;
+        }
+        const registryMatch = lookupRegistry(chainId, target);
+        if (registryMatch) {
+            result[target] = registryMatch;
+            continue;
+        }
+        if (options?.ens === false || String(chainId) !== "1") {
+            result[target] = null;
+            continue;
+        }
+        pending.push(target);
+    }
+    if (pending.length > 0) {
+        const ensResults = await Promise.all(pending.map((address) => lookupEns(address, options?.provider)));
+        pending.forEach((address, i) => {
+            result[address] = ensResults[i];
+        });
+    }
+    return result;
+}
+exports.default = resolveName;

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;