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

package/dist/contracts/psm/getVaultSettings.js

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

package/dist/contracts/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/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/resolveTokenInfo.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTokenInfo = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const amount_1 = require("../utils/amount");
+const rpcError_1 = require("../utils/rpcError");
+const ERC20_METADATA_ABI = ["function symbol() view returns (string)", "function decimals() view returns (uint8)"];
+/** The address Curve pools (and others) list native ETH under. */
+const NATIVE_ETH_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+/** Tokens read from the chain, keyed `chainId:address`. Holds the request, so concurrent callers share it. */
+const resolved = new Map();
+/**
+ * A token's decimals and symbol for any address: the chain config registry first, then the token itself for an address
+ * the registry does not list. An on-chain read happens once per chain and token; a failed read is not remembered, so
+ * the next call tries again.
+ *
+ * Use this wherever a method takes a token address it cannot know in advance. Methods that take an asset key keep
+ * using `toTokenAmount`, which reads only the registry.
+ *
+ * @param chainId The chain id.
+ * @param idOrAddress An asset key from the registry, or a token contract address, any casing.
+ * @param provider Optional ethers.js Provider instance.
+ * @returns The token's decimals, and its symbol when it has one: a token without a readable `symbol()` gets none.
+ * @throws If an asset key is not in the registry, or an unlisted token has no readable `decimals()`.
+ */
+const resolveTokenInfo = (chainId, idOrAddress, provider) => {
+    const known = (0, amount_1.getTokenInfo)(chainId, idOrAddress);
+    if (known)
+        return Promise.resolve(known);
+    if (!ethers_1.ethers.isAddress(idOrAddress)) {
+        return Promise.reject(new Error(`Token ${idOrAddress} is not in the asset registry of chain ${chainId}`));
+    }
+    const address = idOrAddress.toLowerCase();
+    if (address === NATIVE_ETH_PLACEHOLDER)
+        return Promise.resolve({ decimals: amount_1.WAD_DECIMALS, symbol: "ETH" });
+    const key = `${chainId}:${address}`;
+    let info = resolved.get(key);
+    if (!info) {
+        info = readTokenInfo(chainId, address, provider);
+        resolved.set(key, info);
+        info.catch(() => resolved.delete(key));
+    }
+    return info;
+};
+exports.resolveTokenInfo = resolveTokenInfo;
+const readTokenInfo = async (chainId, address, provider) => {
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    }
+    try {
+        const token = new ethers_1.ethers.Contract(address, ERC20_METADATA_ABI, provider);
+        const [decimals, symbol] = await Promise.all([
+            token.decimals(),
+            token.symbol().catch(() => undefined),
+        ]);
+        return symbol === undefined ? { decimals: Number(decimals) } : { decimals: Number(decimals), symbol };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("contracts.resolveTokenInfo", error, { chainId, address });
+    }
+};

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;