@bananapus/nana-sdk-core 2.41.3 → 3.1.0

package/dist/esm/v6/stickyCollectors.js

@@ -0,0 +1,832 @@
+/**
+ * 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.
+ */
+import { isAddress, isAddressEqual, keccak256, zeroAddress, zeroHash, } from "viem";
+import { jbSuckerRegistryAbi, jbDirectoryAbi, jbMultiTerminalAbi, jbTokensAbi, stickyHookAbi, stickyRewardReceiverFactoryAbi, } from "../generated/juicebox.js";
+import { stickySourceCollectorDeployments } from "../generated/stickySourceCollectors.js";
+import { SPLITS_TOTAL_PERCENT } from "../pureConstants.js";
+import { buildSplit } from "./splits.js";
+import { validateStickyGroupId } from "./sticky.js";
+import { classifySuckerTransport, jbNativeSuckerV6ProbeAbi, jbSuckerV6ViewAbi, suckerBytes32ToAddress, verifySuckerDestinationMint, } from "./suckers.js";
+import { v6Address } from "./types.js";
+/** The collector's public delivery, accounting and immutable identity surface. */
+export const 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. */
+export const STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = stickySourceCollectorDeployments;
+/**
+ * Find a deployed source/home pair. Unknown or conflicting family records fail
+ * closed, including different addresses for the same destination on other sources.
+ */
+export function stickySourceCollectorDeployment(sourceChainId, destinationChainId, deployments = 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) => !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. */
+export function stickySourceCollectorAt(sourceChainId, address, deployments = STICKY_SOURCE_COLLECTOR_DEPLOYMENTS) {
+    if (!isAddress(address, { strict: false }))
+        return undefined;
+    const matches = deployments.filter((item) => item.sourceChainId === sourceChainId &&
+        isAddressEqual(item.address, address));
+    if (matches.length !== 1)
+        return undefined;
+    return stickySourceCollectorDeployment(sourceChainId, matches[0].destinationChainId, deployments);
+}
+function assertStickyAllocation(args) {
+    if (args.sourceProjectId <= 0n ||
+        isAddressEqual(args.stickyToken, 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.
+ */
+export function buildStickyReservedSplit(args) {
+    assertStickyAllocation(args);
+    if (!Number.isInteger(args.percent) ||
+        args.percent < 0 ||
+        args.percent > SPLITS_TOTAL_PERCENT)
+        throw new Error("Sticky split percent must be an integer from 0 to 1e9.");
+    return 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. */
+export async function getStickyCollectorPending(client, args) {
+    assertStickyAllocation(args);
+    await assertStickyChain(client, args.deployment.sourceChainId);
+    return client.readContract({
+        address: args.deployment.address,
+        abi: 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.
+ */
+export 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 (isAddressEqual(args.sucker, zeroAddress) ||
+        isAddressEqual(args.backingToken, 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: 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. */
+export 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: 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: v6Address("JBDirectory", chainId),
+            abi: jbDirectoryAbi,
+            functionName: "controllerOf",
+            args: [projectId],
+        }),
+        client.readContract({
+            address: v6Address("JBDirectory", chainId),
+            abi: jbDirectoryAbi,
+            functionName: "primaryTerminalOf",
+            args: [projectId, token],
+        }),
+    ]);
+    if (isAddressEqual(controller, zeroAddress) ||
+        isAddressEqual(terminal, 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: jbMultiTerminalAbi,
+        functionName: "accountingContextForTokenOf",
+        args: [projectId, token],
+    });
+    if (!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.
+ */
+export 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 (keccak256(collectorCode).toLowerCase() !==
+        deployment.runtimeCodeHash.toLowerCase() ||
+        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 (!isAddressEqual(expected, v6Address(canonical, deployment.sourceChainId)))
+            throw new Error(`Sticky ${name} is not the canonical V6 binding.`);
+        const actual = await client.readContract({
+            address: deployment.address,
+            abi: stickySourceCollectorAbi,
+            functionName: name,
+        });
+        if (!isAddressEqual(actual, expected))
+            throw new Error(`Sticky collector ${name} binding changed.`);
+    }
+    const [destination, feePayer, collector] = await Promise.all([
+        client.readContract({
+            address: deployment.address,
+            abi: stickySourceCollectorAbi,
+            functionName: "DESTINATION_CHAIN_ID",
+        }),
+        client.readContract({
+            address: deployment.address,
+            abi: stickySourceCollectorAbi,
+            functionName: "FEE_PAYER",
+        }),
+        client.readContract({
+            address: deployment.feePayer,
+            abi: stickyFeePayerIdentityAbi,
+            functionName: "COLLECTOR",
+        }),
+    ]);
+    if (destination !== BigInt(deployment.destinationChainId) ||
+        !isAddressEqual(feePayer, deployment.feePayer) ||
+        !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.
+ */
+export 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: v6Address("StickyHook", home),
+            abi: stickyHookAbi,
+            functionName: "tokenOf",
+            args: [stickyProjectId],
+        }),
+        destinationClient.readContract({
+            address: v6Address("JBTokens", home),
+            abi: jbTokensAbi,
+            functionName: "tokenOf",
+            args: [stickyProjectId],
+        }),
+    ]);
+    if (!isAddressEqual(registered, stickyToken) ||
+        !isAddressEqual(projectToken, stickyToken))
+        throw new Error("Sticky share token is not the registered home-chain pool.");
+    const destinationFactory = v6Address("StickyRewardReceiverFactory", home);
+    const [sourceReceiver, receiver, distributor] = await Promise.all([
+        sourceClient.readContract({
+            address: deployment.receiverFactory,
+            abi: stickyRewardReceiverFactoryAbi,
+            functionName: "predictReceiverOf",
+            args: [stickyToken, groupId],
+        }),
+        destinationClient.readContract({
+            address: destinationFactory,
+            abi: stickyRewardReceiverFactoryAbi,
+            functionName: "predictReceiverOf",
+            args: [stickyToken, groupId],
+        }),
+        destinationClient.readContract({
+            address: destinationFactory,
+            abi: stickyRewardReceiverFactoryAbi,
+            functionName: "DISTRIBUTOR",
+        }),
+    ]);
+    if (!isAddressEqual(sourceReceiver, receiver) ||
+        !isAddressEqual(distributor, 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: 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 === zeroHash ||
+            !isAddressEqual(registry, deployment.registry) ||
+            !isAddressEqual(tokens, deployment.tokens) ||
+            !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 === 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: v6Address("JBSuckerRegistry", home),
+            abi: 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) ||
+            !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(() => zeroAddress);
+            if (isAddressEqual(messenger, 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 (isAddressEqual(gateway, 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: jbTokensAbi,
+            functionName: "tokenOf",
+            args: [sourceProjectId],
+        }),
+        destinationClient.readContract({
+            address: v6Address("JBTokens", home),
+            abi: jbTokensAbi,
+            functionName: "tokenOf",
+            args: [destinationProjectId],
+        }),
+    ]);
+    await requireStickyCode(destinationClient, rewardToken);
+    return { receiver, sourceToken, rewardToken, destinationProjectId };
+}
+//# sourceMappingURL=stickyCollectors.js.map