@bananapus/nana-sdk-core 3.0.0 → 3.1.0

package/dist/esm/v6/sticky.js

@@ -1,9 +1,6 @@
-import { isAddress, isAddressEqual, keccak256, zeroAddress, zeroHash, } from "viem";
-import { jbSuckerRegistryAbi, jbDirectoryAbi, jbMultiTerminalAbi, jbTokensAbi, stickyHookAbi, stickyRewardReceiverFactoryAbi, } from "../generated/juicebox.js";
-import { SPLITS_TOTAL_PERCENT } from "../pureConstants.js";
-import { buildSplit } from "./splits.js";
+import { isAddressEqual } from "viem";
 import { v6Address } from "./types.js";
-import { stickySourceCollectorDeployments } from "../generated/stickySourceCollectors.js";
+export * from "./stickyCollectors.js";
 /**
  * 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:
@@ -124,821 +121,4 @@ export function describeStickySplit(split) {
     }
     return `Sticky holders stuck ${group.minWeeks} to ${group.maxWeeks} weeks`;
 }
-/** 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 { classifySuckerTransport, jbNativeSuckerV6ProbeAbi, jbSuckerV6ViewAbi, suckerBytes32ToAddress, verifySuckerDestinationMint, } = await import("./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: 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=sticky.js.map