@bananapus/nana-sdk-core 3.0.0 → 3.2.0

package/dist/cjs/v6/stickyCollectors.js

@@ -0,0 +1,843 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = exports.stickySourceCollectorAbi = void 0;
+exports.stickySourceCollectorDeployment = stickySourceCollectorDeployment;
+exports.stickySourceCollectorAt = stickySourceCollectorAt;
+exports.buildStickyReservedSplit = buildStickyReservedSplit;
+exports.getStickyCollectorPending = getStickyCollectorPending;
+exports.buildStickyCollectorSendTx = buildStickyCollectorSendTx;
+exports.buildStickyCollectorSettleTx = buildStickyCollectorSettleTx;
+exports.verifyStickySourceCollector = verifyStickySourceCollector;
+exports.verifyStickyCollectorRoute = verifyStickyCollectorRoute;
+/**
+ * Sticky source collectors: the deployed collector families, their ABI, and
+ * the builders and checks for routing a source chain's reserved tokens to a
+ * Sticky pool on its home chain. Re-exported from `./sticky.ts`; a module of
+ * its own so a page that only reads Sticky splits does not load the
+ * collector table and ABI.
+ */
+const viem_1 = require("viem");
+const juicebox_js_1 = require("../generated/juicebox.js");
+const stickySourceCollectors_js_1 = require("../generated/stickySourceCollectors.js");
+const pureConstants_js_1 = require("../pureConstants.js");
+const splits_js_1 = require("./splits.js");
+const sticky_js_1 = require("./sticky.js");
+const suckers_js_1 = require("./suckers.js");
+const types_js_1 = require("./types.js");
+/** 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 = (0, sticky_js_1.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 { 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: suckers_js_1.jbSuckerV6ViewAbi,
+                functionName: "projectId",
+            }),
+            sourceClient.readContract({
+                address: sucker,
+                abi: suckers_js_1.jbSuckerV6ViewAbi,
+                functionName: "peerChainId",
+            }),
+            sourceClient.readContract({
+                address: sucker,
+                abi: suckers_js_1.jbSuckerV6ViewAbi,
+                functionName: "peer",
+            }),
+            sourceClient.readContract({
+                address: sucker,
+                abi: stickySuckerIdentityAbi,
+                functionName: "state",
+            }),
+            sourceClient.readContract({
+                address: sucker,
+                abi: suckers_js_1.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 = (0, suckers_js_1.suckerBytes32ToAddress)(peer);
+        destinationProjectId = await destinationClient.readContract({
+            address: peerAddress,
+            abi: suckers_js_1.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: suckers_js_1.jbSuckerV6ViewAbi,
+                functionName: "peerChainId",
+            }),
+            destinationClient.readContract({
+                address: peerAddress,
+                abi: suckers_js_1.jbSuckerV6ViewAbi,
+                functionName: "peer",
+            }),
+        ]);
+        if (returnChain !== BigInt(deployment.sourceChainId) ||
+            !(0, viem_1.isAddressEqual)((0, suckers_js_1.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 (0, suckers_js_1.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: suckers_js_1.jbNativeSuckerV6ProbeAbi,
+                functionName: "OPMESSENGER",
+            })
+                .catch(() => viem_1.zeroAddress);
+            if ((0, viem_1.isAddressEqual)(messenger, viem_1.zeroAddress)) {
+                const layer = await sourceClient.readContract({
+                    address: sucker,
+                    abi: suckers_js_1.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: suckers_js_1.jbNativeSuckerV6ProbeAbi,
+                    functionName: "GATEWAYROUTER",
+                });
+                if ((0, viem_1.isAddressEqual)(gateway, viem_1.zeroAddress))
+                    throw new Error("Sticky collector bridge transport cannot be qualified.");
+            }
+        }
+        const remoteBackingToken = (0, suckers_js_1.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 (0, suckers_js_1.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=stickyCollectors.js.map