@raac/rpc 1.2.0-beta.1 → 1.2.0-beta.10

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lockWithApproval = void 0;
+const ethers_1 = require("ethers");
+const getContractAddress_1 = require("../../getContractAddress");
+const getAllowance_1 = __importDefault(require("../../../wallet/assets/getAllowance"));
+const approveAsset_1 = __importDefault(require("../../../wallet/assets/approveAsset"));
+const lock_1 = require("./lock");
+/**
+ * Locks RAAC tokens, auto-approving the veRAAC contract first if the current
+ * allowance is insufficient. Convenience wrapper so callers don't have to
+ * orchestrate the approve+lock dance themselves.
+ *
+ * @param chainId - The chain/network to use.
+ * @param amount - The amount of RAAC tokens to lock (decimal string).
+ * @param epochs - Number of epochs to lock tokens for.
+ * @param signer - An ethers.js Signer (must be connected to wallet).
+ * @returns Transaction receipt of the lock tx.
+ */
+const lockWithApproval = async (chainId, amount, epochs, signer) => {
+    if (!signer) {
+        throw new Error("Signer is required");
+    }
+    const userAddress = await signer.getAddress();
+    const veRaacAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
+    const amountWei = ethers_1.ethers.parseEther(amount);
+    // Check allowance via read-only provider to avoid needing a connected provider
+    // on the signer itself — some wrapped signers (e.g. thirdweb) don't expose one.
+    const allowance = await (0, getAllowance_1.default)(chainId, "raactoken", userAddress, veRaacAddress, signer.provider ?? undefined);
+    if (allowance < amountWei) {
+        console.log("[lockWithApproval] Approving RAAC for veRAAC contract…");
+        await (0, approveAsset_1.default)(chainId, "raactoken", veRaacAddress, amount, signer);
+        console.log("[lockWithApproval] Approval successful");
+    }
+    return (0, lock_1.lock)(chainId, amountWei, epochs, signer);
+};
+exports.lockWithApproval = lockWithApproval;

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;

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;