@raac/rpc 1.2.0-beta.4 → 1.2.0-beta.5

package/dist/contracts/zap/aladdin/zap.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zap = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Run the configured route for `fromToken → toToken`, assuming `fromToken` is already
+ * sitting in the zap contract (or msg.value covers ETH). Use `zapFrom` if the caller
+ * is the holder of the input token instead.
+ */
+const zap = async (chainId, fromToken, amountIn, toToken, minOut, signer, value = 0) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.zap(fromToken, amountIn, toToken, minOut, { value });
+    await tx.wait();
+    return tx;
+};
+exports.zap = zap;

package/dist/contracts/zap/aladdin/zapFrom.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zapFrom = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Pull `amountIn` of `fromToken` from the caller into the zap, then run the configured
+ * route to `toToken`. Caller must approve the zap on `fromToken` for ERC20 inputs,
+ * or pass `value` for ETH input.
+ */
+const zapFrom = async (chainId, fromToken, amountIn, toToken, minOut, signer, value = 0) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.zapFrom(fromToken, amountIn, toToken, minOut, { value });
+    await tx.wait();
+    return tx;
+};
+exports.zapFrom = zapFrom;

package/dist/contracts/zap/aladdin/zapWithRoutes.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zapWithRoutes = void 0;
+const _helpers_1 = require("./_helpers");
+const validateRoute_1 = require("./validateRoute");
+/**
+ * Run an explicit list of packed-uint256 routes from `fromToken` to `toToken`.
+ * Routes are validated client-side first; pass `skipValidation: true` only if you
+ * really know what you're doing.
+ */
+const zapWithRoutes = async (chainId, fromToken, amountIn, toToken, routes, minOut, signer, options = {}) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    if (!options.skipValidation) {
+        const validation = (0, validateRoute_1.validateRoutes)(routes);
+        if (!validation.allValid) {
+            const issues = validation.results
+                .flatMap((r, i) => (r.valid ? [] : [`route[${i}]: ${r.errors.join("; ")}`]))
+                .join(" | ");
+            throw new Error(`zapWithRoutes: invalid routes — ${issues}`);
+        }
+    }
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.zapWithRoutes(fromToken, amountIn, toToken, routes.map((r) => (typeof r === "bigint" ? r : BigInt(r))), minOut, { value: options.value ?? 0 });
+    await tx.wait();
+    return tx;
+};
+exports.zapWithRoutes = zapWithRoutes;

package/dist/contracts/zap/codec.js

@@ -0,0 +1,423 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpotPricePoolType = exports.Action = exports.PoolTypeV3 = exports.PoolType = void 0;
+exports.encodePoolHint = encodePoolHint;
+exports.encodePoolHintV2 = encodePoolHintV2;
+exports.encodePoolHintV3 = encodePoolHintV3;
+exports.decodePoolV2 = decodePoolV2;
+exports.decodePoolV3 = decodePoolV3;
+exports.encodeSpotPricePool = encodeSpotPricePool;
+exports.decodeSpotPricePool = decodeSpotPricePool;
+exports.encodeSpotPriceSources = encodeSpotPriceSources;
+exports.encodeChainlinkPriceFeed = encodeChainlinkPriceFeed;
+/* eslint-disable camelcase */
+/* eslint-disable no-unused-vars */
+// Ported from contracts/test/utils/codec.js — keep this file in sync with that source
+// when the encoding logic in the contracts repo changes. The original `TOKENS` lookup and
+// `ethers.formatUnits` formatting helpers are kept where they don't introduce hardhat / repo
+// dependencies; ERC4626 / Lido pool-name lookups in decodePoolV3 fall back to printing the
+// raw pool address (the contracts-repo TOKENS map is not available in this package).
+const assert_1 = __importDefault(require("assert"));
+const ethers_1 = require("ethers");
+function makeEnum(keys) {
+    const e = {};
+    for (let i = 0; i < keys.length; i += 1) {
+        const k = keys[i];
+        e[k] = i;
+        e[i] = k;
+    }
+    return Object.freeze(e);
+}
+exports.PoolType = makeEnum([
+    "UniswapV2", // with fee 0.3%, add/remove liquidity not supported
+    "UniswapV3", // add/remove liquidity not supported
+    "BalancerV2", // add/remove liquidity not supported
+    "CurveETHPool", // including Factory Pool
+    "CurveCryptoPool", // including Factory Pool
+    "CurveMetaCryptoPool",
+    "CurveTriCryptoPool",
+    "CurveBasePool",
+    "CurveAPool",
+    "CurveAPoolUnderlying",
+    "CurveYPool",
+    "CurveYPoolUnderlying",
+    "CurveMetaPool",
+    "CurveMetaPoolUnderlying",
+    "CurveFactoryPlainPool",
+    "CurveFactoryMetaPool",
+    "CurveFactoryUSDMetaPoolUnderlying",
+    "CurveFactoryBTCMetaPoolUnderlying",
+    "LidoStake", // eth to stETH
+    "LidoWrap", // stETH to wstETH or wstETH to stETH
+    "CurveFactoryFraxBPMetaPoolUnderlying",
+    "AladdinCompounder", // wrap/unrwap as aCRV/aFXS/...
+]);
+exports.PoolTypeV3 = makeEnum([
+    "UniswapV2",
+    "UniswapV3",
+    "BalancerV1",
+    "BalancerV2",
+    "CurvePlainPool",
+    "CurveAPool",
+    "CurveYPool",
+    "CurveMetaPool",
+    "CurveCryptoPool",
+    "ERC4626",
+    "Lido",
+    "ETHLSDV1",
+    "CurveStableSwapNG",
+    "CurveStableSwapMetaNG",
+    "WETH",
+]);
+exports.Action = makeEnum(["Swap", "Add", "Remove"]);
+function encodePoolHint(poolAddress, poolType, indexIn, indexOut) {
+    let encoding = (0, ethers_1.toBigInt)(poolAddress);
+    encoding |= (0, ethers_1.toBigInt)(poolType) << 160n;
+    encoding |= (0, ethers_1.toBigInt)(indexIn) << 164n;
+    encoding |= (0, ethers_1.toBigInt)(indexOut) << 166n;
+    return encoding;
+}
+function encodePoolHintV2(poolAddress, poolType, tokens, indexIn, indexOut, action) {
+    let encoding = (0, ethers_1.toBigInt)(poolAddress);
+    encoding |= (0, ethers_1.toBigInt)(poolType) << 160n;
+    encoding |= (0, ethers_1.toBigInt)(tokens - 1) << 168n;
+    encoding |= (0, ethers_1.toBigInt)(indexIn) << 170n;
+    encoding |= (0, ethers_1.toBigInt)(indexOut) << 172n;
+    encoding |= (0, ethers_1.toBigInt)(action) << 174n;
+    return encoding;
+}
+function encodePoolHintV3(poolAddress, poolType, tokens, indexIn, indexOut, action, options) {
+    let encoding = (0, ethers_1.toBigInt)(poolAddress);
+    switch (poolType) {
+        case exports.PoolTypeV3.UniswapV2:
+            (0, assert_1.default)(options && options.fee_num, "no fee_num");
+            encoding |= (0, ethers_1.toBigInt)(options.fee_num) << 160n;
+            encoding |= (0, ethers_1.toBigInt)(indexIn < indexOut ? 1 : 0) << 184n;
+            if (options && options.twamm === true) {
+                encoding |= (0, ethers_1.toBigInt)(options.twamm === true ? 1 : 0) << 185n;
+            }
+            break;
+        case exports.PoolTypeV3.UniswapV3:
+            (0, assert_1.default)(options && options.fee_num, "no fee_num");
+            encoding |= (0, ethers_1.toBigInt)(options.fee_num) << 160n;
+            encoding |= (0, ethers_1.toBigInt)(indexIn < indexOut ? 1 : 0) << 184n;
+            break;
+        case exports.PoolTypeV3.BalancerV1:
+        case exports.PoolTypeV3.BalancerV2:
+        case exports.PoolTypeV3.CurveMetaPool:
+        case exports.PoolTypeV3.CurveStableSwapNG:
+        case exports.PoolTypeV3.CurveStableSwapMetaNG:
+            encoding |= (0, ethers_1.toBigInt)(tokens - 1) << 160n;
+            encoding |= (0, ethers_1.toBigInt)(indexIn) << 163n;
+            encoding |= (0, ethers_1.toBigInt)(indexOut) << 166n;
+            break;
+        case exports.PoolTypeV3.CurvePlainPool:
+        case exports.PoolTypeV3.CurveCryptoPool:
+            encoding |= (0, ethers_1.toBigInt)(tokens - 1) << 160n;
+            encoding |= (0, ethers_1.toBigInt)(indexIn) << 163n;
+            encoding |= (0, ethers_1.toBigInt)(indexOut) << 166n;
+            if (options && options.use_eth === true) {
+                encoding |= (0, ethers_1.toBigInt)(options.use_eth === true ? 1 : 0) << 169n;
+            }
+            break;
+        case exports.PoolTypeV3.CurveAPool:
+        case exports.PoolTypeV3.CurveYPool:
+            encoding |= (0, ethers_1.toBigInt)(tokens - 1) << 160n;
+            encoding |= (0, ethers_1.toBigInt)(indexIn) << 163n;
+            encoding |= (0, ethers_1.toBigInt)(indexOut) << 166n;
+            if (options && options.use_underlying === true) {
+                encoding |= (0, ethers_1.toBigInt)(options.use_underlying === true ? 1 : 0) << 169n;
+            }
+            break;
+        case exports.PoolTypeV3.ERC4626:
+            break;
+        case exports.PoolTypeV3.Lido:
+            break;
+        case exports.PoolTypeV3.ETHLSDV1:
+            (0, assert_1.default)(options && options.protocol !== undefined, "no protocol");
+            encoding |= (0, ethers_1.toBigInt)(options.protocol) << 160n;
+            if (options.protocol === 4 || options.protocol === 6) {
+                encoding |= (0, ethers_1.toBigInt)(indexIn) << 168n;
+            }
+            break;
+        case exports.PoolTypeV3.WETH:
+            break;
+    }
+    encoding = (encoding << 2n) | (0, ethers_1.toBigInt)(action);
+    encoding = (encoding << 8n) | (0, ethers_1.toBigInt)(poolType);
+    return encoding;
+}
+function decodePoolV2(encoding) {
+    const pool = (0, ethers_1.getAddress)((encoding & (2n ** 160n - 1n)).toString(16).padStart(40, "0"));
+    const poolType = Number((encoding >> 160n) & 255n);
+    const action = Number((encoding >> 174n) & 3n);
+    const tokenIn = Number((encoding >> 170n) & 3n);
+    const tokenOut = Number((encoding >> 172n) & 3n);
+    let extra = "";
+    const actionDesc = exports.Action[Number(action)];
+    const poolName = pool;
+    if (action === exports.Action.Add) {
+        extra = `tokenIn[${tokenIn}]`;
+    }
+    else if (action === exports.Action.Remove) {
+        extra = `tokenOut[${tokenOut}]`;
+    }
+    else {
+        extra = `tokenIn[${tokenIn}] tokenOut[${tokenOut}]`;
+    }
+    return `${exports.PoolType[Number(poolType)]}[${poolName}].${actionDesc} ${extra}`;
+}
+function decodePoolV3(encoding) {
+    const poolType = Number(encoding & 255n);
+    const action = Number((encoding >> 8n) & 3n);
+    const pool = (0, ethers_1.getAddress)(((encoding >> 10n) & (2n ** 160n - 1n)).toString(16).padStart(40, "0"));
+    encoding >>= 170n;
+    let extra = "";
+    let actionDesc = exports.Action[Number(action)];
+    let poolName = pool;
+    switch (poolType) {
+        case exports.PoolTypeV3.UniswapV2:
+        case exports.PoolTypeV3.UniswapV3: {
+            const fee = encoding & (2n ** 24n - 1n);
+            const zeroForOne = (encoding >> 24n) & 1n;
+            poolName = `${pool}/${ethers_1.ethers.formatUnits(10n ** 6n - fee, 6)}`;
+            extra = `tokenIn[${zeroForOne ^ 1n}] tokenOut[${zeroForOne}]`;
+            break;
+        }
+        case exports.PoolTypeV3.BalancerV1:
+        case exports.PoolTypeV3.BalancerV2:
+        case exports.PoolTypeV3.CurveMetaPool:
+        case exports.PoolTypeV3.CurvePlainPool:
+        case exports.PoolTypeV3.CurveCryptoPool:
+        case exports.PoolTypeV3.CurveAPool:
+        case exports.PoolTypeV3.CurveYPool:
+        case exports.PoolTypeV3.CurveStableSwapNG:
+        case exports.PoolTypeV3.CurveStableSwapMetaNG: {
+            const tokenIn = (encoding >> 3n) & 7n;
+            const tokenOut = (encoding >> 6n) & 7n;
+            if (action === exports.Action.Add) {
+                extra = `tokenIn[${tokenIn}]`;
+            }
+            else if (action === exports.Action.Remove) {
+                extra = `tokenOut[${tokenOut}]`;
+            }
+            else {
+                extra = `tokenIn[${tokenIn}] tokenOut[${tokenOut}]`;
+            }
+            break;
+        }
+        case exports.PoolTypeV3.ERC4626: {
+            if (action === exports.Action.Add)
+                actionDesc = "Deposit";
+            else if (action === exports.Action.Remove)
+                actionDesc = "Withdraw";
+            break;
+        }
+        case exports.PoolTypeV3.Lido: {
+            if (action === exports.Action.Add)
+                actionDesc = "Wrap";
+            else if (action === exports.Action.Remove)
+                actionDesc = "Unwrap";
+            break;
+        }
+        case exports.PoolTypeV3.ETHLSDV1: {
+            const protocol = encoding % 256n;
+            if (protocol === 0n)
+                poolName = "wBETH";
+            else if (protocol === 1n)
+                poolName = "rETH";
+            else if (protocol === 2n)
+                poolName = "frxETH";
+            else if (protocol === 3n)
+                poolName = "pxETH";
+            else if (protocol === 4n)
+                poolName = "renzo";
+            else if (protocol === 5n)
+                poolName = "ether.fi";
+            else if (protocol === 6n)
+                poolName = "kelpdao.xyz";
+            poolName = `${poolName}/${pool}`;
+            break;
+        }
+        case exports.PoolTypeV3.WETH: {
+            poolName = "WETH";
+            actionDesc = "Unwrap";
+            break;
+        }
+    }
+    return `${exports.PoolTypeV3[Number(poolType)]}[${poolName}].${actionDesc} ${extra}`;
+}
+exports.SpotPricePoolType = makeEnum([
+    "UniswapV2",
+    "UniswapV3",
+    "BalancerV2Weighted",
+    "BalancerV2Stable",
+    "CurvePlain",
+    "CurvePlainWithOracle",
+    "CurvePlainNG",
+    "CurveCrypto",
+    "CurveTriCrypto",
+    "ERC4626",
+    "ETHLSD",
+    "BalancerV2CachedRate",
+]);
+function encodeSpotPricePool(poolAddress, poolType, options) {
+    let encoding = BigInt(poolAddress);
+    let customized = 0n;
+    switch (poolType) {
+        case exports.SpotPricePoolType.UniswapV2:
+        case exports.SpotPricePoolType.UniswapV3:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.base_scale !== undefined, "no base_scale");
+            (0, assert_1.default)(options.quote_scale !== undefined, "no quote_scale");
+            customized = (customized << 8n) | BigInt(options.quote_scale);
+            customized = (customized << 8n) | BigInt(options.base_scale);
+            customized = (customized << 1n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.BalancerV2Weighted:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.quote_index !== undefined, "no quote_index");
+            (0, assert_1.default)(options.base_scale !== undefined, "no base_scale");
+            (0, assert_1.default)(options.quote_scale !== undefined, "no quote_scale");
+            customized = (customized << 8n) | BigInt(options.quote_scale);
+            customized = (customized << 8n) | BigInt(options.base_scale);
+            customized = (customized << 3n) | BigInt(options.quote_index);
+            customized = (customized << 3n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.BalancerV2Stable:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.quote_index !== undefined, "no quote_index");
+            customized = (customized << 3n) | BigInt(options.quote_index);
+            customized = (customized << 3n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.CurvePlain:
+            (0, assert_1.default)(options.tokens !== undefined, "no tokens");
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.quote_index !== undefined, "no quote_index");
+            (0, assert_1.default)(options.has_amm_precise !== undefined, "no has_amm_precise");
+            (0, assert_1.default)(options.scales !== undefined, "no scales");
+            for (const scale of options.scales.slice().reverse()) {
+                customized = (customized << 8n) | BigInt(scale);
+            }
+            customized = (customized << 1n) | BigInt(options.has_amm_precise ? 1 : 0);
+            customized = (customized << 3n) | BigInt(options.quote_index);
+            customized = (customized << 3n) | BigInt(options.base_index);
+            customized = (customized << 3n) | BigInt(options.tokens - 1);
+            break;
+        case exports.SpotPricePoolType.CurvePlainWithOracle:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.use_cache !== undefined, "no use_cache");
+            customized = (customized << 1n) | BigInt(options.use_cache ? 1 : 0);
+            customized = (customized << 1n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.CurvePlainNG:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.quote_index !== undefined, "no quote_index");
+            (0, assert_1.default)(options.use_cache !== undefined, "no use_cache");
+            customized = (customized << 1n) | BigInt(options.use_cache ? 1 : 0);
+            customized = (customized << 3n) | BigInt(options.quote_index);
+            customized = (customized << 3n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.CurveCrypto:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            customized = (customized << 1n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.CurveTriCrypto:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            (0, assert_1.default)(options.quote_index !== undefined, "no quote_index");
+            customized = (customized << 2n) | (0, ethers_1.toBigInt)(options.quote_index);
+            customized = (customized << 2n) | BigInt(options.base_index);
+            break;
+        case exports.SpotPricePoolType.ERC4626:
+            (0, assert_1.default)(options.base_is_underlying !== undefined, "no base_is_underlying");
+            customized = (customized << 1n) | (0, ethers_1.toBigInt)(options.base_is_underlying ? 1 : 0);
+            break;
+        case exports.SpotPricePoolType.ETHLSD:
+            (0, assert_1.default)(options.base_is_ETH !== undefined, "no base_is_ETH");
+            customized = (customized << 1n) | (0, ethers_1.toBigInt)(options.base_is_ETH ? 1 : 0);
+            break;
+        case exports.SpotPricePoolType.BalancerV2CachedRate:
+            (0, assert_1.default)(options.base_index !== undefined, "no base_index");
+            customized = (customized << 3n) | (0, ethers_1.toBigInt)(options.base_index);
+            break;
+    }
+    encoding = (customized << 168n) | (encoding << 8n) | BigInt(poolType);
+    return encoding;
+}
+function decodeSpotPricePool(encoding) {
+    const poolType = Number(encoding & 255n);
+    const pool = (0, ethers_1.getAddress)(((encoding >> 8n) & (2n ** 160n - 1n)).toString(16).padStart(40, "0"));
+    encoding >>= 168n;
+    const poolName = pool;
+    let extra = "";
+    let baseIndex;
+    let quoteIndex;
+    let baseIsUnderlying;
+    let baseIsETH;
+    switch (poolType) {
+        case exports.SpotPricePoolType.UniswapV2:
+        case exports.SpotPricePoolType.UniswapV3:
+            baseIndex = encoding & 1n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${baseIndex ^ 1n}]`;
+            break;
+        case exports.SpotPricePoolType.BalancerV2Weighted:
+            baseIndex = encoding & 7n;
+            quoteIndex = (encoding >> 3n) & 7n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${quoteIndex}]`;
+            break;
+        case exports.SpotPricePoolType.BalancerV2Stable:
+            baseIndex = encoding & 7n;
+            quoteIndex = (encoding >> 3n) & 7n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${quoteIndex}]`;
+            break;
+        case exports.SpotPricePoolType.CurvePlain:
+            baseIndex = (encoding >> 3n) & 7n;
+            quoteIndex = (encoding >> 6n) & 7n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${quoteIndex}]`;
+            break;
+        case exports.SpotPricePoolType.CurvePlainWithOracle:
+            baseIndex = encoding & 1n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${baseIndex ^ 1n}]`;
+            break;
+        case exports.SpotPricePoolType.CurvePlainNG:
+            baseIndex = encoding & 7n;
+            quoteIndex = (encoding >> 3n) & 7n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${quoteIndex}]`;
+            break;
+        case exports.SpotPricePoolType.CurveCrypto:
+            baseIndex = encoding & 1n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${baseIndex ^ 1n}]`;
+            break;
+        case exports.SpotPricePoolType.CurveTriCrypto:
+            baseIndex = encoding & 3n;
+            quoteIndex = (encoding >> 2n) & 3n;
+            extra = `baseIndex[${baseIndex}] quoteIndex[${quoteIndex}]`;
+            break;
+        case exports.SpotPricePoolType.ERC4626:
+            baseIsUnderlying = encoding & 1n;
+            extra = `BaseIsUnderlying[${baseIsUnderlying === 1n}]`;
+            break;
+        case exports.SpotPricePoolType.ETHLSD:
+            baseIsETH = encoding & 1n;
+            extra = `BaseIsETH[${baseIsETH === 1n}]`;
+            break;
+        case exports.SpotPricePoolType.BalancerV2CachedRate:
+            baseIndex = encoding & 7n;
+            extra = `baseIndex[${baseIndex}]`;
+            break;
+    }
+    return `${exports.SpotPricePoolType[Number(poolType)]}[${poolName}] ${extra}`;
+}
+function encodeSpotPriceSources(sources) {
+    const encoded = sources.map((source) => {
+        const inner = source.map((x) => "0x" + x.toString(16).padStart(64, "0"));
+        return (0, ethers_1.concat)([(0, ethers_1.toBeHex)(inner.length), ...inner]);
+    });
+    return (0, ethers_1.concat)([(0, ethers_1.toBeHex)(encoded.length), ...encoded]);
+}
+function encodeChainlinkPriceFeed(feed, scale, heartbeat) {
+    return (BigInt(feed) << 96n) | (scale << 32n) | BigInt(heartbeat);
+}

package/dist/minter/_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.getMinterContract = getMinterContract;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const contracts_1 = require("../utils/contracts");
+const artifacts_1 = require("../utils/artifacts");
+async function getMinterContract(chainId, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const address = (0, contracts_1.getContractAddress)(chainId, "raacminter");
+    const abi = (0, artifacts_1.getABI)("raacminter");
+    return new ethers_1.ethers.Contract(address, abi, runner);
+}

package/dist/minter/activate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Activate the minting schedule. UPDATER_ROLE only. Reverts if already activated.
+ * After activation, `mintingStartAtTimestamp` is set to `block.timestamp` and the
+ * geometric weekly emission schedule begins counting from week 1.
+ */
+const activate = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.activate();
+    await tx.wait();
+    return tx;
+};
+exports.activate = activate;

package/dist/minter/addDistributionPool.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDistributionPool = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Register a new distribution pool with the given weight. UPDATER_ROLE only.
+ * Reverts if the pool already exists. Calls `tick()` first to clear pending emissions.
+ */
+const addDistributionPool = async (chainId, pool, weight, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.addDistributionPool(pool, weight);
+    await tx.wait();
+    return tx;
+};
+exports.addDistributionPool = addDistributionPool;

package/dist/minter/calculateScheduledMintableAmount.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateScheduledMintableAmount = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns the total RAAC scheduled to be mintable between two timestamps,
+ * applying the geometric weekly emission reduction (see EmissionSchedule.sol).
+ * Both `startPeriod` and `endPeriod` are absolute UNIX timestamps in seconds.
+ */
+const calculateScheduledMintableAmount = async (chainId, startPeriod, endPeriod, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    return contract.calculateScheduledMintableAmount(startPeriod, endPeriod);
+};
+exports.calculateScheduledMintableAmount = calculateScheduledMintableAmount;