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

package/dist/contracts/lockers/maturityVault/getGlobalInfo.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalInfo = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Snapshot of the maturity vault's global accounting and active reward schedule.
+ */
+const getGlobalInfo = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, provider);
+    const [totalRAACInPool, totalUnrealised, totalRealised, accUnrealisedFraction, distributeIndex, lastPaidOffDistributeIndex, rewardInfoTuple,] = await Promise.all([
+        contract.totalRAACInPool(),
+        contract.totalUnrealised(),
+        contract.totalRealised(),
+        contract.accUnrealisedFraction(),
+        contract.distributeIndex(),
+        contract.lastPaidOffDistributeIndex(),
+        contract.rewardInfo(),
+    ]);
+    const ratePerSecond = rewardInfoTuple.ratePerSecond ?? rewardInfoTuple[0];
+    const periodLength = rewardInfoTuple.periodLength ?? rewardInfoTuple[1];
+    const lastUpdate = rewardInfoTuple.lastUpdate ?? rewardInfoTuple[2];
+    const finishAt = rewardInfoTuple.finishAt ?? rewardInfoTuple[3];
+    return {
+        totalRAACInPool: ethers_1.ethers.formatEther(totalRAACInPool),
+        totalUnrealised: ethers_1.ethers.formatEther(totalUnrealised),
+        totalRealised: ethers_1.ethers.formatEther(totalRealised),
+        accUnrealisedFraction,
+        distributeIndex,
+        lastPaidOffDistributeIndex,
+        rewardInfo: {
+            ratePerSecond: ethers_1.ethers.formatEther(ratePerSecond),
+            periodLength: Number(periodLength),
+            lastUpdate: Number(lastUpdate),
+            finishAt: Number(finishAt),
+            raw: { ratePerSecond, periodLength, lastUpdate, finishAt },
+        },
+        raw: {
+            totalRAACInPool,
+            totalUnrealised,
+            totalRealised,
+        },
+    };
+};
+exports.getGlobalInfo = getGlobalInfo;

package/dist/contracts/lockers/maturityVault/getUserInfo.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserInfo = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns the user's unrealised (still-earning leRAAC) and realised (claimable RAAC) totals.
+ */
+const getUserInfo = async (chainId, account, provider) => {
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, provider);
+    const [unrealised, realised] = await contract.getUserInfo(account);
+    return {
+        unrealised: ethers_1.ethers.formatEther(unrealised),
+        realised: ethers_1.ethers.formatEther(realised),
+        raw: { unrealised, realised },
+    };
+};
+exports.getUserInfo = getUserInfo;

package/dist/contracts/lockers/maturityVault/harvest.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.harvest = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Harvest free RAAC in the vault and distribute. Whitelisted callers only.
+ */
+const harvest = async (chainId, recipient, minimumOut, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, signer);
+    const tx = await contract.harvest(recipient, minimumOut);
+    await tx.wait();
+    return tx;
+};
+exports.harvest = harvest;

package/dist/contracts/lockers/maturityVault/isWhitelisted.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWhitelisted = void 0;
+const _helpers_1 = require("./_helpers");
+const isWhitelisted = async (chainId, address, provider) => {
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, provider);
+    return contract.isWhitelisted(address);
+};
+exports.isWhitelisted = isWhitelisted;

package/dist/contracts/lockers/maturityVault/updatePendingDistribution.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePendingDistribution = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Permissionlessly accrue pending linear-distribution rewards.
+ */
+const updatePendingDistribution = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, signer);
+    const tx = await contract.updatePendingDistribution();
+    await tx.wait();
+    return tx;
+};
+exports.updatePendingDistribution = updatePendingDistribution;

package/dist/contracts/lockers/maturityVault/withdraw.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdraw = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Withdraw `amount` of unrealised leRAAC to `recipient`.
+ */
+const withdraw = async (chainId, recipient, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, signer);
+    const tx = await contract.withdraw(recipient, amount);
+    await tx.wait();
+    return tx;
+};
+exports.withdraw = withdraw;

package/dist/contracts/lockers/maturityVault/withdrawAll.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawAll = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Withdraw all unrealised leRAAC to `recipient`.
+ */
+const withdrawAll = async (chainId, recipient, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMaturityVaultContract)(chainId, signer);
+    const tx = await contract.withdrawAll(recipient);
+    await tx.wait();
+    return tx;
+};
+exports.withdrawAll = withdrawAll;

package/dist/contracts/tokens/leRAAC/_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.getLeRAACContract = getLeRAACContract;
+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 getLeRAACContract(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, "leraac");
+    const abi = (0, artifacts_1.getABI)("leraac");
+    return new ethers_1.ethers.Contract(address, abi, runner);
+}

package/dist/contracts/tokens/leRAAC/approve.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approve = void 0;
+const _helpers_1 = require("./_helpers");
+const approve = async (chainId, spender, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, signer);
+    const tx = await contract.approve(spender, amount);
+    await tx.wait();
+    return tx;
+};
+exports.approve = approve;

package/dist/contracts/tokens/leRAAC/burn.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.burn = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Burn `amount` of the caller's leRAAC.
+ */
+const burn = async (chainId, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, signer);
+    const tx = await contract.burn(amount);
+    await tx.wait();
+    return tx;
+};
+exports.burn = burn;

package/dist/contracts/tokens/leRAAC/burnFrom.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.burnFrom = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Burn `amount` of `account`'s leRAAC. Caller must have ERC20 allowance from `account`.
+ */
+const burnFrom = async (chainId, account, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, signer);
+    const tx = await contract.burnFrom(account, amount);
+    await tx.wait();
+    return tx;
+};
+exports.burnFrom = burnFrom;

package/dist/contracts/tokens/leRAAC/getAllowance.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowance = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+const getAllowance = async (chainId, owner, spender, provider) => {
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, provider);
+    const allowance = await contract.allowance(owner, spender);
+    return ethers_1.ethers.formatEther(allowance);
+};
+exports.getAllowance = getAllowance;

package/dist/contracts/tokens/leRAAC/getBalance.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBalance = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+const getBalance = async (chainId, address, provider) => {
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, provider);
+    const balance = await contract.balanceOf(address);
+    return ethers_1.ethers.formatEther(balance);
+};
+exports.getBalance = getBalance;

package/dist/contracts/tokens/leRAAC/getMinterInfo.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinterInfo = void 0;
+const _helpers_1 = require("./_helpers");
+const getMinterInfo = async (chainId, minter, provider) => {
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, provider);
+    const [info, isMinter] = await Promise.all([
+        contract.minterInfo(minter),
+        contract.isMinter(minter),
+    ]);
+    const ceiling = info.ceiling ?? info[0];
+    const minted = info.minted ?? info[1];
+    return { isMinter, ceiling, minted };
+};
+exports.getMinterInfo = getMinterInfo;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalSupply = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+const getTotalSupply = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, provider);
+    const supply = await contract.totalSupply();
+    return ethers_1.ethers.formatEther(supply);
+};
+exports.getTotalSupply = getTotalSupply;

package/dist/contracts/tokens/leRAAC/transfer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transfer = void 0;
+const _helpers_1 = require("./_helpers");
+const transfer = async (chainId, to, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, signer);
+    const tx = await contract.transfer(to, amount);
+    await tx.wait();
+    return tx;
+};
+exports.transfer = transfer;

package/dist/contracts/tokens/leRAAC/transferFrom.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transferFrom = void 0;
+const _helpers_1 = require("./_helpers");
+const transferFrom = async (chainId, from, to, amount, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getLeRAACContract)(chainId, signer);
+    const tx = await contract.transferFrom(from, to, amount);
+    await tx.wait();
+    return tx;
+};
+exports.transferFrom = transferFrom;

package/dist/contracts/zap/aladdin/_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.getAladdinZapContract = getAladdinZapContract;
+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 getAladdinZapContract(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, "aladdinzap");
+    const abi = (0, artifacts_1.getABI)("aladdinzap");
+    return new ethers_1.ethers.Contract(address, abi, runner);
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AladdinAction = exports.ALADDIN_POOL_TYPE_MAX = exports.AladdinPoolType = void 0;
+// Mirrors the PoolType enum in TokenZapLogic.sol. The on-chain enum is bounded by
+// the encoding (8 bits for poolType), but only these 22 values are recognised by the
+// swap dispatch — everything else will revert at swap time.
+var AladdinPoolType;
+(function (AladdinPoolType) {
+    AladdinPoolType[AladdinPoolType["UniswapV2"] = 0] = "UniswapV2";
+    AladdinPoolType[AladdinPoolType["UniswapV3"] = 1] = "UniswapV3";
+    AladdinPoolType[AladdinPoolType["BalancerV2"] = 2] = "BalancerV2";
+    AladdinPoolType[AladdinPoolType["CurveETHPool"] = 3] = "CurveETHPool";
+    AladdinPoolType[AladdinPoolType["CurveCryptoPool"] = 4] = "CurveCryptoPool";
+    AladdinPoolType[AladdinPoolType["CurveMetaCryptoPool"] = 5] = "CurveMetaCryptoPool";
+    AladdinPoolType[AladdinPoolType["CurveTriCryptoPool"] = 6] = "CurveTriCryptoPool";
+    AladdinPoolType[AladdinPoolType["CurveBasePool"] = 7] = "CurveBasePool";
+    AladdinPoolType[AladdinPoolType["CurveAPool"] = 8] = "CurveAPool";
+    AladdinPoolType[AladdinPoolType["CurveAPoolUnderlying"] = 9] = "CurveAPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["CurveYPool"] = 10] = "CurveYPool";
+    AladdinPoolType[AladdinPoolType["CurveYPoolUnderlying"] = 11] = "CurveYPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["CurveMetaPool"] = 12] = "CurveMetaPool";
+    AladdinPoolType[AladdinPoolType["CurveMetaPoolUnderlying"] = 13] = "CurveMetaPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["CurveFactoryPlainPool"] = 14] = "CurveFactoryPlainPool";
+    AladdinPoolType[AladdinPoolType["CurveFactoryMetaPool"] = 15] = "CurveFactoryMetaPool";
+    AladdinPoolType[AladdinPoolType["CurveFactoryUSDMetaPoolUnderlying"] = 16] = "CurveFactoryUSDMetaPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["CurveFactoryBTCMetaPoolUnderlying"] = 17] = "CurveFactoryBTCMetaPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["LidoStake"] = 18] = "LidoStake";
+    AladdinPoolType[AladdinPoolType["LidoWrap"] = 19] = "LidoWrap";
+    AladdinPoolType[AladdinPoolType["CurveFactoryFraxBPMetaPoolUnderlying"] = 20] = "CurveFactoryFraxBPMetaPoolUnderlying";
+    AladdinPoolType[AladdinPoolType["AladdinCompounder"] = 21] = "AladdinCompounder";
+})(AladdinPoolType || (exports.AladdinPoolType = AladdinPoolType = {}));
+exports.ALADDIN_POOL_TYPE_MAX = AladdinPoolType.AladdinCompounder;
+var AladdinAction;
+(function (AladdinAction) {
+    AladdinAction[AladdinAction["Swap"] = 0] = "Swap";
+    AladdinAction[AladdinAction["AddLiquidity"] = 1] = "AddLiquidity";
+    AladdinAction[AladdinAction["RemoveLiquidity"] = 2] = "RemoveLiquidity";
+})(AladdinAction || (exports.AladdinAction = AladdinAction = {}));

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeRoute = exports.decodeRoute = void 0;
+const ethers_1 = require("ethers");
+const codec_1 = require("../codec");
+const ADDRESS_MASK = (1n << 160n) - 1n;
+const POOL_TYPE_MASK = 0xffn;
+const TWO_BIT_MASK = 0x3n;
+/**
+ * Decode a single Aladdin zap route uint256 into its component fields.
+ *
+ * Encoding (low → high bits):
+ *  | 160 bits     | 8 bits     | 2 bits         | 2 bits   | 2 bits    | 2 bits |
+ *  | pool address | pool type  | tokens (count-1) | index_in | index_out | action |
+ */
+const decodeRoute = (route) => {
+    const raw = typeof route === "bigint" ? route : BigInt(route);
+    const poolBig = raw & ADDRESS_MASK;
+    const pool = ethers_1.ethers.getAddress("0x" + poolBig.toString(16).padStart(40, "0"));
+    const poolType = Number((raw >> 160n) & POOL_TYPE_MASK);
+    const tokens = Number((raw >> 168n) & TWO_BIT_MASK) + 1;
+    const indexIn = Number((raw >> 170n) & TWO_BIT_MASK);
+    const indexOut = Number((raw >> 172n) & TWO_BIT_MASK);
+    const action = Number((raw >> 174n) & TWO_BIT_MASK);
+    return { pool, poolType, tokens, indexIn, indexOut, action, raw };
+};
+exports.decodeRoute = decodeRoute;
+/**
+ * Human-readable description of a route (delegates to the shared `decodePoolV2` codec).
+ * Format: `${PoolType}[${pool}].${Action} tokenIn[i] tokenOut[j]`.
+ */
+const describeRoute = (route) => {
+    const raw = typeof route === "bigint" ? route : BigInt(route);
+    return (0, codec_1.decodePoolV2)(raw);
+};
+exports.describeRoute = describeRoute;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeRoute = void 0;
+const ethers_1 = require("ethers");
+const codec_1 = require("../codec");
+/**
+ * Encode a route into the packed uint256 used by AladdinZap.updateRoute / zapWithRoutes.
+ * Delegates to the shared codec (`encodePoolHintV2`) ported from
+ * `contracts/test/utils/codec.js` so the encoding stays in lockstep with the contracts repo.
+ *
+ * Throws on out-of-range fields — pair with validateRoute before sending an admin tx.
+ */
+const encodeRoute = (params) => {
+    if (!ethers_1.ethers.isAddress(params.pool)) {
+        throw new Error(`encodeRoute: invalid pool address: ${params.pool}`);
+    }
+    if (params.poolType < 0 || params.poolType > 0xff) {
+        throw new Error(`encodeRoute: poolType out of 8-bit range: ${params.poolType}`);
+    }
+    if (params.tokens < 1 || params.tokens > 4) {
+        throw new Error(`encodeRoute: tokens must be 1–4, got ${params.tokens}`);
+    }
+    for (const [name, v] of [
+        ["indexIn", params.indexIn],
+        ["indexOut", params.indexOut],
+        ["action", params.action],
+    ]) {
+        if (v < 0 || v > 3) {
+            throw new Error(`encodeRoute: ${name} must be 0–3, got ${v}`);
+        }
+    }
+    return (0, codec_1.encodePoolHintV2)(params.pool, params.poolType, params.tokens, params.indexIn, params.indexOut, params.action);
+};
+exports.encodeRoute = encodeRoute;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurvePoolToken = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Read the LP token address registered for a Curve pool, falling back to the
+ * `pool2token` override if the registry doesn't know the pool.
+ */
+const getCurvePoolToken = async (chainId, poolType, pool, provider) => {
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, provider);
+    return contract.getCurvePoolToken(poolType, pool);
+};
+exports.getCurvePoolToken = getCurvePoolToken;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOwner = void 0;
+const _helpers_1 = require("./_helpers");
+const getOwner = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, provider);
+    return contract.owner();
+};
+exports.getOwner = getOwner;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPool2Token = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Read the manual pool→LP-token override map (`pool2token`).
+ */
+const getPool2Token = async (chainId, pool, provider) => {
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, provider);
+    return contract.pool2token(pool);
+};
+exports.getPool2Token = getPool2Token;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoutes = void 0;
+const _helpers_1 = require("./_helpers");
+const decodeRoute_1 = require("./decodeRoute");
+/**
+ * Fetch the full route list (zero-or-more packed uint256s) configured for swapping
+ * `fromToken` → `toToken` on AladdinZap. Returns both raw values and decoded
+ * descriptions for UI rendering.
+ */
+const getRoutes = async (chainId, fromToken, toToken, provider) => {
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, provider);
+    const raw = Array.from(await contract.getRoutes(fromToken, toToken));
+    return { raw, decoded: raw.map(decodeRoute_1.decodeRoute) };
+};
+exports.getRoutes = getRoutes;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVersion = void 0;
+const _helpers_1 = require("./_helpers");
+const getVersion = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, provider);
+    return contract.version();
+};
+exports.getVersion = getVersion;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rescue = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Owner-only: drain the listed tokens' balances from the zap into `recipient`.
+ */
+const rescue = async (chainId, tokens, recipient, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.rescue(tokens, recipient);
+    await tx.wait();
+    return tx;
+};
+exports.rescue = rescue;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePoolTokens = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Owner-only: register pool → LP-token overrides used by `getCurvePoolToken`.
+ */
+const updatePoolTokens = async (chainId, pools, tokens, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    if (pools.length !== tokens.length) {
+        throw new Error("updatePoolTokens: pools and tokens length mismatch");
+    }
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.updatePoolTokens(pools, tokens);
+    await tx.wait();
+    return tx;
+};
+exports.updatePoolTokens = updatePoolTokens;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateRoute = void 0;
+const _helpers_1 = require("./_helpers");
+const validateRoute_1 = require("./validateRoute");
+/**
+ * Owner-only: register the route list used to swap `fromToken → toToken`.
+ *
+ * Routes are validated client-side first (action/index/poolType invariants); set
+ * `skipValidation: true` to bypass — useful when adding routes whose pool types are
+ * deliberately outside the documented set, but normally a misencoded route here will
+ * silently make the route revert at swap time, so we default to strict checking.
+ */
+const updateRoute = async (chainId, fromToken, toToken, routes, 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(`updateRoute: refusing to set invalid routes for ${fromToken} → ${toToken} — ${issues}`);
+        }
+    }
+    const contract = await (0, _helpers_1.getAladdinZapContract)(chainId, signer);
+    const tx = await contract.updateRoute(fromToken, toToken, routes.map((r) => (typeof r === "bigint" ? r : BigInt(r))));
+    await tx.wait();
+    return tx;
+};
+exports.updateRoute = updateRoute;

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRoutes = exports.validateRoute = void 0;
+const ethers_1 = require("ethers");
+const decodeRoute_1 = require("./decodeRoute");
+const _types_1 = require("./_types");
+/**
+ * Validate a single packed-uint256 Aladdin route. Returns the decoded fields plus a list of
+ * problems. Use this before calling `updateRoute` to catch typos and impossible encodings
+ * before they get committed to a transaction.
+ *
+ * Rules enforced (matching TokenZapLogic.swap dispatch):
+ *  - poolType is within the known enum range (0..21)
+ *  - pool address is non-zero
+ *  - action ∈ {Swap, AddLiquidity, RemoveLiquidity}
+ *  - Swap requires indexIn != indexOut
+ *  - AddLiquidity / RemoveLiquidity require indexIn == indexOut
+ *  - LidoStake / LidoWrap support only `action = AddLiquidity` (1)
+ *  - UniswapV2 / UniswapV3 / BalancerV2 / AladdinCompounder only support Swap; the
+ *    `_addCurvePool` / `_removeCurvePool` paths reject these pool types at runtime.
+ *  - For non-Lido pool types, indexIn / indexOut must be < tokens
+ */
+const validateRoute = (route) => {
+    const decoded = (0, decodeRoute_1.decodeRoute)(route);
+    const errors = [];
+    if (decoded.pool === ethers_1.ZeroAddress) {
+        errors.push("pool address is zero");
+    }
+    if (decoded.poolType < 0 || decoded.poolType > _types_1.ALADDIN_POOL_TYPE_MAX) {
+        errors.push(`unknown poolType ${decoded.poolType} (max recognised is ${_types_1.ALADDIN_POOL_TYPE_MAX})`);
+    }
+    if (decoded.action < 0 || decoded.action > 2) {
+        errors.push(`invalid action ${decoded.action} — must be Swap (0), AddLiquidity (1), or RemoveLiquidity (2)`);
+    }
+    if (decoded.action === _types_1.AladdinAction.Swap && decoded.indexIn === decoded.indexOut) {
+        errors.push("swap action requires indexIn != indexOut");
+    }
+    if ((decoded.action === _types_1.AladdinAction.AddLiquidity ||
+        decoded.action === _types_1.AladdinAction.RemoveLiquidity) &&
+        decoded.indexIn !== decoded.indexOut) {
+        errors.push(`${_types_1.AladdinAction[decoded.action]} action requires indexIn == indexOut`);
+    }
+    const lidoTypes = new Set([
+        _types_1.AladdinPoolType.LidoStake,
+        _types_1.AladdinPoolType.LidoWrap,
+    ]);
+    if (lidoTypes.has(decoded.poolType) && decoded.action !== _types_1.AladdinAction.AddLiquidity) {
+        errors.push(`${_types_1.AladdinPoolType[decoded.poolType]} only supports action=AddLiquidity (1)`);
+    }
+    const swapOnlyTypes = new Set([
+        _types_1.AladdinPoolType.UniswapV2,
+        _types_1.AladdinPoolType.UniswapV3,
+        _types_1.AladdinPoolType.BalancerV2,
+        _types_1.AladdinPoolType.AladdinCompounder,
+    ]);
+    if (swapOnlyTypes.has(decoded.poolType) &&
+        decoded.action !== _types_1.AladdinAction.Swap &&
+        !lidoTypes.has(decoded.poolType)) {
+        errors.push(`${_types_1.AladdinPoolType[decoded.poolType]} only supports action=Swap (0)`);
+    }
+    if (!lidoTypes.has(decoded.poolType)) {
+        if (decoded.indexIn >= decoded.tokens) {
+            errors.push(`indexIn ${decoded.indexIn} >= tokens ${decoded.tokens}`);
+        }
+        if (decoded.indexOut >= decoded.tokens) {
+            errors.push(`indexOut ${decoded.indexOut} >= tokens ${decoded.tokens}`);
+        }
+    }
+    return { valid: errors.length === 0, errors, decoded };
+};
+exports.validateRoute = validateRoute;
+/**
+ * Validate every route in a list. Returns one validation entry per route plus an
+ * `allValid` summary so callers can short-circuit before sending a transaction.
+ */
+const validateRoutes = (routes) => {
+    const results = routes.map(exports.validateRoute);
+    return { allValid: results.every((r) => r.valid), results };
+};
+exports.validateRoutes = validateRoutes;