@bananapus/nana-sdk-core 3.0.0 → 3.2.0

package/dist/cjs/v6/sticky.js

@@ -10,50 +10,20 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = exports.stickySourceCollectorAbi = exports.STICKY_MAX_CRITERIA_WEEKS = exports.STICKY_CRITERIA_BASE = exports.STICKY_DEFAULT_GROUP_ID = void 0;
+exports.STICKY_MAX_CRITERIA_WEEKS = exports.STICKY_CRITERIA_BASE = exports.STICKY_DEFAULT_GROUP_ID = void 0;
 exports.stickyDistributorAddress = stickyDistributorAddress;
 exports.isStickySplit = isStickySplit;
 exports.validateStickyGroupId = validateStickyGroupId;
 exports.stickyGroupId = stickyGroupId;
 exports.decodeStickyGroupId = decodeStickyGroupId;
 exports.describeStickySplit = describeStickySplit;
-exports.stickySourceCollectorDeployment = stickySourceCollectorDeployment;
-exports.stickySourceCollectorAt = stickySourceCollectorAt;
-exports.buildStickyReservedSplit = buildStickyReservedSplit;
-exports.getStickyCollectorPending = getStickyCollectorPending;
-exports.buildStickyCollectorSendTx = buildStickyCollectorSendTx;
-exports.buildStickyCollectorSettleTx = buildStickyCollectorSettleTx;
-exports.verifyStickySourceCollector = verifyStickySourceCollector;
-exports.verifyStickyCollectorRoute = verifyStickyCollectorRoute;
 const viem_1 = require("viem");
-const juicebox_js_1 = require("../generated/juicebox.js");
-const pureConstants_js_1 = require("../pureConstants.js");
-const splits_js_1 = require("./splits.js");
 const types_js_1 = require("./types.js");
-const stickySourceCollectors_js_1 = require("../generated/stickySourceCollectors.js");
+__exportStar(require("./stickyCollectors.js"), exports);
 /**
  * A split routes funds to Sticky holders when its `hook` is the chain's
  * `StickyDistributor`. The distributor reads the rest of the split this way:
@@ -174,821 +144,4 @@ function describeStickySplit(split) {
     }
     return `Sticky holders stuck ${group.minWeeks} to ${group.maxWeeks} weeks`;
 }
-/** The collector's public delivery, accounting and immutable identity surface. */
-exports.stickySourceCollectorAbi = [
-    {
-        name: "DESTINATION_CHAIN_ID",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        name: "DIRECTORY",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "FEE_PAYER",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "RECEIVER_FACTORY",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "REGISTRY",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "TOKENS",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "pendingOf",
-        type: "function",
-        stateMutability: "view",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        name: "totalPendingOf",
-        type: "function",
-        stateMutability: "view",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-    {
-        name: "send",
-        type: "function",
-        stateMutability: "payable",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-            },
-            {
-                type: "uint256",
-                name: "amount",
-            },
-            {
-                type: "address",
-                name: "sucker",
-            },
-            {
-                type: "address",
-                name: "backingToken",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-                name: "leafIndex",
-            },
-        ],
-    },
-    {
-        name: "settle",
-        type: "function",
-        stateMutability: "nonpayable",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-            },
-            {
-                type: "uint256",
-                name: "amount",
-            },
-        ],
-        outputs: [
-            {
-                type: "uint256",
-                name: "settled",
-            },
-        ],
-    },
-    {
-        name: "Queue",
-        type: "event",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-                indexed: true,
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-                indexed: true,
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-                indexed: true,
-            },
-            {
-                type: "address",
-                name: "receiver",
-            },
-            {
-                type: "uint256",
-                name: "amount",
-            },
-            {
-                type: "address",
-                name: "caller",
-            },
-        ],
-    },
-    {
-        name: "Send",
-        type: "event",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-                indexed: true,
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-                indexed: true,
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-                indexed: true,
-            },
-            {
-                type: "address",
-                name: "sucker",
-            },
-            {
-                type: "address",
-                name: "backingToken",
-            },
-            {
-                type: "uint256",
-                name: "index",
-            },
-            {
-                type: "uint256",
-                name: "projectTokenCount",
-            },
-            {
-                type: "uint256",
-                name: "minimumReclaimed",
-            },
-            {
-                type: "uint256",
-                name: "feeTokenCount",
-            },
-            {
-                type: "uint256",
-                name: "refundedFee",
-            },
-            {
-                type: "uint256",
-                name: "refundedTransportPayment",
-            },
-            {
-                type: "address",
-                name: "caller",
-            },
-        ],
-    },
-    {
-        name: "Settle",
-        type: "event",
-        inputs: [
-            {
-                type: "uint256",
-                name: "sourceProjectId",
-                indexed: true,
-            },
-            {
-                type: "address",
-                name: "stickyToken",
-                indexed: true,
-            },
-            {
-                type: "uint256",
-                name: "groupId",
-                indexed: true,
-            },
-            {
-                type: "uint256",
-                name: "amount",
-            },
-            {
-                type: "uint256",
-                name: "settled",
-            },
-            {
-                type: "address",
-                name: "caller",
-            },
-        ],
-    },
-];
-const stickyFeePayerIdentityAbi = [
-    {
-        name: "COLLECTOR",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-];
-const stickyTokenIdentityAbi = [
-    {
-        name: "PROJECT_ID",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "uint256",
-            },
-        ],
-    },
-];
-const stickySuckerIdentityAbi = [
-    {
-        name: "DIRECTORY",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "REGISTRY",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "TOKENS",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "address",
-            },
-        ],
-    },
-    {
-        name: "state",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [
-            {
-                type: "uint8",
-            },
-        ],
-    },
-];
-/** Verified source/home families generated from the pinned Sticky release. */
-exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = stickySourceCollectors_js_1.stickySourceCollectorDeployments;
-/**
- * Find a deployed source/home pair. Unknown or conflicting family records fail
- * closed, including different addresses for the same destination on other sources.
- */
-function stickySourceCollectorDeployment(sourceChainId, destinationChainId, deployments = exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS) {
-    const family = deployments.filter((item) => item.destinationChainId === destinationChainId);
-    const matches = family.filter((item) => item.sourceChainId === sourceChainId);
-    if (matches.length !== 1)
-        return undefined;
-    const found = matches[0];
-    if (family.some((item) => !(0, viem_1.isAddressEqual)(item.address, found.address) ||
-        item.runtimeCodeHash.toLowerCase() !==
-            found.runtimeCodeHash.toLowerCase()))
-        return undefined;
-    return found;
-}
-/** Recognize only an unambiguous deployed collector on this particular chain. */
-function stickySourceCollectorAt(sourceChainId, address, deployments = exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS) {
-    if (!(0, viem_1.isAddress)(address, { strict: false }))
-        return undefined;
-    const matches = deployments.filter((item) => item.sourceChainId === sourceChainId &&
-        (0, viem_1.isAddressEqual)(item.address, address));
-    if (matches.length !== 1)
-        return undefined;
-    return stickySourceCollectorDeployment(sourceChainId, matches[0].destinationChainId, deployments);
-}
-function assertStickyAllocation(args) {
-    if (args.sourceProjectId <= 0n ||
-        (0, viem_1.isAddressEqual)(args.stickyToken, viem_1.zeroAddress))
-        throw new Error("Sticky source project and share token must be nonzero.");
-    const reason = validateStickyGroupId(args.groupId);
-    if (reason)
-        throw new Error(reason);
-}
-/**
- * Build one reserved-token split. Place it in RESERVED_TOKEN_SPLIT_GROUP_ID (1).
- * The split projectId remains the existing reward group, not a chain encoding.
- * Call verifyStickyCollectorRoute before configuring it; this pure builder cannot
- * establish deployment, destination readiness or an actually usable transport lane.
- */
-function buildStickyReservedSplit(args) {
-    assertStickyAllocation(args);
-    if (!Number.isInteger(args.percent) ||
-        args.percent < 0 ||
-        args.percent > pureConstants_js_1.SPLITS_TOTAL_PERCENT)
-        throw new Error("Sticky split percent must be an integer from 0 to 1e9.");
-    return (0, splits_js_1.buildSplit)({
-        beneficiary: args.stickyToken,
-        hook: args.deployment.address,
-        projectId: args.groupId,
-        percent: args.percent,
-        lockedUntil: args.lockedUntil,
-    });
-}
-/** Read the queued amount, in source project-token atoms, without initiating delivery. */
-async function getStickyCollectorPending(client, args) {
-    assertStickyAllocation(args);
-    await assertStickyChain(client, args.deployment.sourceChainId);
-    return client.readContract({
-        address: args.deployment.address,
-        abi: exports.stickySourceCollectorAbi,
-        functionName: "pendingOf",
-        args: [args.sourceProjectId, args.stickyToken, args.groupId],
-    });
-}
-function assertStickyDelivery(args) {
-    assertStickyAllocation(args);
-    if (args.amount <= 0n)
-        throw new Error("Sticky delivery amount must be positive.");
-}
-/**
- * Prepare permissionless source submission, not final destination settlement.
- * Reverify identity/route and pending custody before wallet simulation. Value pays
- * the registry fee plus any native transport budget; this builder does not quote it.
- */
-function buildStickyCollectorSendTx(args) {
-    assertStickyDelivery(args);
-    if (args.deployment.sourceChainId === args.deployment.destinationChainId)
-        throw new Error("Use settle on the Sticky pool's home chain.");
-    if ((0, viem_1.isAddressEqual)(args.sucker, viem_1.zeroAddress) ||
-        (0, viem_1.isAddressEqual)(args.backingToken, viem_1.zeroAddress) ||
-        args.value < 0n)
-        throw new Error("Sticky send requires a route, backing token and nonnegative native budget.");
-    return {
-        chainId: args.deployment.sourceChainId,
-        address: args.deployment.address,
-        abi: exports.stickySourceCollectorAbi,
-        functionName: "send",
-        args: [
-            args.sourceProjectId,
-            args.stickyToken,
-            args.groupId,
-            args.amount,
-            args.sucker,
-            args.backingToken,
-        ],
-        value: args.value,
-    };
-}
-/** Prepare permissionless local settlement; the source must be the bound home chain. */
-function buildStickyCollectorSettleTx(args) {
-    assertStickyDelivery(args);
-    if (args.deployment.sourceChainId !== args.deployment.destinationChainId)
-        throw new Error("Sticky settlement must execute on the pool's home chain.");
-    return {
-        chainId: args.deployment.sourceChainId,
-        address: args.deployment.address,
-        abi: exports.stickySourceCollectorAbi,
-        functionName: "settle",
-        args: [
-            args.sourceProjectId,
-            args.stickyToken,
-            args.groupId,
-            args.amount,
-        ],
-    };
-}
-async function assertStickyChain(client, chainId) {
-    if ((await client.getChainId()) !== chainId)
-        throw new Error("Sticky RPC chain does not match the configured chain.");
-}
-async function requireStickyCode(client, address) {
-    const code = await client.getCode({ address });
-    if (!code || code === "0x")
-        throw new Error(`Sticky requires deployed code at ${address}.`);
-    return code;
-}
-/** A positive-backed claim needs a live controller and a terminal accepting that exact asset. */
-async function stickyBackingContext(client, chainId, projectId, token) {
-    const [controller, terminal] = await Promise.all([
-        client.readContract({
-            address: (0, types_js_1.v6Address)("JBDirectory", chainId),
-            abi: juicebox_js_1.jbDirectoryAbi,
-            functionName: "controllerOf",
-            args: [projectId],
-        }),
-        client.readContract({
-            address: (0, types_js_1.v6Address)("JBDirectory", chainId),
-            abi: juicebox_js_1.jbDirectoryAbi,
-            functionName: "primaryTerminalOf",
-            args: [projectId, token],
-        }),
-    ]);
-    if ((0, viem_1.isAddressEqual)(controller, viem_1.zeroAddress) ||
-        (0, viem_1.isAddressEqual)(terminal, viem_1.zeroAddress))
-        throw new Error("Sticky reward route needs a controller and backing terminal on both chains.");
-    await Promise.all([
-        requireStickyCode(client, controller),
-        requireStickyCode(client, terminal),
-    ]);
-    const context = await client.readContract({
-        address: terminal,
-        abi: juicebox_js_1.jbMultiTerminalAbi,
-        functionName: "accountingContextForTokenOf",
-        args: [projectId, token],
-    });
-    if (!(0, viem_1.isAddressEqual)(context.token, token))
-        throw new Error("Sticky backing terminal does not accept the mapped asset.");
-    return { ...context, controller };
-}
-/**
- * Verify reviewed runtime fingerprints and immutable bindings on the actual source
- * chain. This is read-only evidence at the time of the call, not execution authority.
- */
-async function verifyStickySourceCollector(client, deployment) {
-    await assertStickyChain(client, deployment.sourceChainId);
-    const [collectorCode, feeCode] = await Promise.all([
-        requireStickyCode(client, deployment.address),
-        requireStickyCode(client, deployment.feePayer),
-    ]);
-    if ((0, viem_1.keccak256)(collectorCode).toLowerCase() !==
-        deployment.runtimeCodeHash.toLowerCase() ||
-        (0, viem_1.keccak256)(feeCode).toLowerCase() !==
-            deployment.feePayerRuntimeCodeHash.toLowerCase())
-        throw new Error("Sticky collector runtime does not match the reviewed deployment.");
-    const bindings = [
-        ["DIRECTORY", deployment.directory, "JBDirectory"],
-        ["REGISTRY", deployment.registry, "JBSuckerRegistry"],
-        ["TOKENS", deployment.tokens, "JBTokens"],
-        [
-            "RECEIVER_FACTORY",
-            deployment.receiverFactory,
-            "StickyRewardReceiverFactory",
-        ],
-    ];
-    for (const [name, expected, canonical] of bindings) {
-        if (!(0, viem_1.isAddressEqual)(expected, (0, types_js_1.v6Address)(canonical, deployment.sourceChainId)))
-            throw new Error(`Sticky ${name} is not the canonical V6 binding.`);
-        const actual = await client.readContract({
-            address: deployment.address,
-            abi: exports.stickySourceCollectorAbi,
-            functionName: name,
-        });
-        if (!(0, viem_1.isAddressEqual)(actual, expected))
-            throw new Error(`Sticky collector ${name} binding changed.`);
-    }
-    const [destination, feePayer, collector] = await Promise.all([
-        client.readContract({
-            address: deployment.address,
-            abi: exports.stickySourceCollectorAbi,
-            functionName: "DESTINATION_CHAIN_ID",
-        }),
-        client.readContract({
-            address: deployment.address,
-            abi: exports.stickySourceCollectorAbi,
-            functionName: "FEE_PAYER",
-        }),
-        client.readContract({
-            address: deployment.feePayer,
-            abi: stickyFeePayerIdentityAbi,
-            functionName: "COLLECTOR",
-        }),
-    ]);
-    if (destination !== BigInt(deployment.destinationChainId) ||
-        !(0, viem_1.isAddressEqual)(feePayer, deployment.feePayer) ||
-        !(0, viem_1.isAddressEqual)(collector, deployment.address))
-        throw new Error("Sticky collector destination or fee-child binding changed.");
-}
-/**
- * Freshly qualify one local or direct remote lane before configuring a split or
- * sending. Source credits may queue before their ERC-20 exists; the home-chain
- * reward ERC-20 and registered Sticky pool must already exist. The canonical
- * registered peer determines the destination reward project, never address parity.
- * Native Arbitrum L1 sends are refused until asynchronous caller refunds are
- * supported. Identifying a CCIP transport does not certify its live router lane.
- * Re-run through the reviewed-write reverify boundary before simulation/submission.
- */
-async function verifyStickyCollectorRoute(sourceClient, destinationClient, args) {
-    assertStickyAllocation(args);
-    const { deployment, sourceProjectId, stickyToken, groupId } = args;
-    const home = deployment.destinationChainId;
-    await Promise.all([
-        verifyStickySourceCollector(sourceClient, deployment),
-        assertStickyChain(destinationClient, home),
-    ]);
-    await requireStickyCode(destinationClient, stickyToken);
-    const stickyProjectId = await destinationClient.readContract({
-        address: stickyToken,
-        abi: stickyTokenIdentityAbi,
-        functionName: "PROJECT_ID",
-    });
-    const [registered, projectToken] = await Promise.all([
-        destinationClient.readContract({
-            address: (0, types_js_1.v6Address)("StickyHook", home),
-            abi: juicebox_js_1.stickyHookAbi,
-            functionName: "tokenOf",
-            args: [stickyProjectId],
-        }),
-        destinationClient.readContract({
-            address: (0, types_js_1.v6Address)("JBTokens", home),
-            abi: juicebox_js_1.jbTokensAbi,
-            functionName: "tokenOf",
-            args: [stickyProjectId],
-        }),
-    ]);
-    if (!(0, viem_1.isAddressEqual)(registered, stickyToken) ||
-        !(0, viem_1.isAddressEqual)(projectToken, stickyToken))
-        throw new Error("Sticky share token is not the registered home-chain pool.");
-    const destinationFactory = (0, types_js_1.v6Address)("StickyRewardReceiverFactory", home);
-    const [sourceReceiver, receiver, distributor] = await Promise.all([
-        sourceClient.readContract({
-            address: deployment.receiverFactory,
-            abi: juicebox_js_1.stickyRewardReceiverFactoryAbi,
-            functionName: "predictReceiverOf",
-            args: [stickyToken, groupId],
-        }),
-        destinationClient.readContract({
-            address: destinationFactory,
-            abi: juicebox_js_1.stickyRewardReceiverFactoryAbi,
-            functionName: "predictReceiverOf",
-            args: [stickyToken, groupId],
-        }),
-        destinationClient.readContract({
-            address: destinationFactory,
-            abi: juicebox_js_1.stickyRewardReceiverFactoryAbi,
-            functionName: "DISTRIBUTOR",
-        }),
-    ]);
-    if (!(0, viem_1.isAddressEqual)(sourceReceiver, receiver) ||
-        !(0, viem_1.isAddressEqual)(distributor, (0, types_js_1.v6Address)("StickyDistributor", home)))
-        throw new Error("Sticky receiver identity differs between source and home chain.");
-    let destinationProjectId = sourceProjectId;
-    if (deployment.sourceChainId !== home) {
-        const { classifySuckerTransport, jbNativeSuckerV6ProbeAbi, jbSuckerV6ViewAbi, suckerBytes32ToAddress, verifySuckerDestinationMint, } = await Promise.resolve().then(() => __importStar(require("./suckers.js")));
-        const { sucker, backingToken } = args;
-        if (!sucker || !backingToken)
-            throw new Error("A direct Sticky source-to-home route is required.");
-        // Membership is anchored before any candidate getters are trusted.
-        if (!(await sourceClient.readContract({
-            address: deployment.registry,
-            abi: juicebox_js_1.jbSuckerRegistryAbi,
-            functionName: "isSuckerOf",
-            args: [sourceProjectId, sucker],
-        })))
-            throw new Error("Sticky source route is not registered for this project.");
-        const [projectId, peerChainId, peer, state, mapping, registry, tokens, directory,] = await Promise.all([
-            sourceClient.readContract({
-                address: sucker,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "projectId",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "peerChainId",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "peer",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: stickySuckerIdentityAbi,
-                functionName: "state",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "remoteTokenFor",
-                args: [backingToken],
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: stickySuckerIdentityAbi,
-                functionName: "REGISTRY",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: stickySuckerIdentityAbi,
-                functionName: "TOKENS",
-            }),
-            sourceClient.readContract({
-                address: sucker,
-                abi: stickySuckerIdentityAbi,
-                functionName: "DIRECTORY",
-            }),
-        ]);
-        if (projectId !== sourceProjectId ||
-            peerChainId !== BigInt(home) ||
-            peer === viem_1.zeroHash ||
-            !(0, viem_1.isAddressEqual)(registry, deployment.registry) ||
-            !(0, viem_1.isAddressEqual)(tokens, deployment.tokens) ||
-            !(0, viem_1.isAddressEqual)(directory, deployment.directory))
-            throw new Error("Sticky route does not bind this source project to the selected home chain.");
-        // JBSuckerState: ENABLED=0, DEPRECATION_PENDING=1; other states cannot send.
-        if (state !== 0 && state !== 1)
-            throw new Error("Sticky source route no longer permits sending.");
-        if (!mapping.enabled || mapping.emergencyHatch || mapping.addr === viem_1.zeroHash)
-            throw new Error("Sticky source backing mapping is unavailable.");
-        const peerAddress = suckerBytes32ToAddress(peer);
-        destinationProjectId = await destinationClient.readContract({
-            address: peerAddress,
-            abi: jbSuckerV6ViewAbi,
-            functionName: "projectId",
-        });
-        if (!(await destinationClient.readContract({
-            address: (0, types_js_1.v6Address)("JBSuckerRegistry", home),
-            abi: juicebox_js_1.jbSuckerRegistryAbi,
-            functionName: "isSuckerOf",
-            args: [destinationProjectId, peerAddress],
-        })))
-            throw new Error("Sticky destination route is not registered.");
-        const [returnChain, returnPeer] = await Promise.all([
-            destinationClient.readContract({
-                address: peerAddress,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "peerChainId",
-            }),
-            destinationClient.readContract({
-                address: peerAddress,
-                abi: jbSuckerV6ViewAbi,
-                functionName: "peer",
-            }),
-        ]);
-        if (returnChain !== BigInt(deployment.sourceChainId) ||
-            !(0, viem_1.isAddressEqual)(suckerBytes32ToAddress(returnPeer), sucker))
-            throw new Error("Sticky destination peer does not match the source route.");
-        // The fee payer can return only same-call refunds. Native Arbitrum L1
-        // retryables refund later on L2, where the fee payer cannot attribute or return
-        // that caller's payment. This is a qualification mitigation, not a contract
-        // restriction or a fix to the upstream asynchronous refund destination.
-        const transport = await classifySuckerTransport(sourceClient, sucker);
-        if (transport === "unknown")
-            throw new Error("Sticky collector bridge transport cannot be qualified.");
-        if (transport === "native") {
-            const messenger = await sourceClient
-                .readContract({
-                address: sucker,
-                abi: jbNativeSuckerV6ProbeAbi,
-                functionName: "OPMESSENGER",
-            })
-                .catch(() => viem_1.zeroAddress);
-            if ((0, viem_1.isAddressEqual)(messenger, viem_1.zeroAddress)) {
-                const layer = await sourceClient.readContract({
-                    address: sucker,
-                    abi: jbNativeSuckerV6ProbeAbi,
-                    functionName: "LAYER",
-                });
-                if (layer === 0)
-                    throw new Error("Native L1 Arbitrum collector delivery is unavailable: asynchronous refunds cannot return to the delivery caller.");
-                if (layer !== 1)
-                    throw new Error("Sticky collector bridge transport layer cannot be qualified.");
-                const gateway = await sourceClient.readContract({
-                    address: sucker,
-                    abi: jbNativeSuckerV6ProbeAbi,
-                    functionName: "GATEWAYROUTER",
-                });
-                if ((0, viem_1.isAddressEqual)(gateway, viem_1.zeroAddress))
-                    throw new Error("Sticky collector bridge transport cannot be qualified.");
-            }
-        }
-        const remoteBackingToken = suckerBytes32ToAddress(mapping.addr);
-        const [sourceContext, destinationContext] = await Promise.all([
-            stickyBackingContext(sourceClient, deployment.sourceChainId, sourceProjectId, backingToken),
-            stickyBackingContext(destinationClient, home, destinationProjectId, remoteBackingToken),
-        ]);
-        if (sourceContext.decimals !== destinationContext.decimals)
-            throw new Error("Sticky backing decimals differ between source and home chain.");
-        // Registration survives some ruleset changes that can revoke mint authority.
-        await verifySuckerDestinationMint(destinationClient, {
-            chainId: home,
-            projectId: destinationProjectId,
-            sucker: peerAddress,
-            beneficiary: receiver,
-            tokenCount: 1n,
-        });
-    }
-    const [sourceToken, rewardToken] = await Promise.all([
-        sourceClient.readContract({
-            address: deployment.tokens,
-            abi: juicebox_js_1.jbTokensAbi,
-            functionName: "tokenOf",
-            args: [sourceProjectId],
-        }),
-        destinationClient.readContract({
-            address: (0, types_js_1.v6Address)("JBTokens", home),
-            abi: juicebox_js_1.jbTokensAbi,
-            functionName: "tokenOf",
-            args: [destinationProjectId],
-        }),
-    ]);
-    await requireStickyCode(destinationClient, rewardToken);
-    return { receiver, sourceToken, rewardToken, destinationProjectId };
-}
 //# sourceMappingURL=sticky.js.map