@bananapus/nana-sdk-core 2.25.0 → 2.26.0

package/dist/cjs/v6/sticky.js

@@ -1,13 +1,57 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    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;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STICKY_MAX_CRITERIA_WEEKS = exports.STICKY_CRITERIA_BASE = exports.STICKY_DEFAULT_GROUP_ID = void 0;
+exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = exports.stickySourceCollectorAbi = 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");
 /**
  * A split routes funds to Sticky holders when its `hook` is the chain's
@@ -129,4 +173,786 @@ 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",
+            },
+        ],
+    },
+];
+/** No new collector family has been published as a verified live deployment yet. */
+exports.STICKY_SOURCE_COLLECTOR_DEPLOYMENTS = [];
+/**
+ * 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.
+ * 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 { jbSuckerV6ViewAbi, suckerBytes32ToAddress } = 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.");
+        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.
+        // Probe the actual current controller as the peer; this eth_call mints no live tokens.
+        await destinationClient.simulateContract({
+            address: destinationContext.controller,
+            abi: juicebox_js_1.jbControllerAbi,
+            functionName: "mintTokensOf",
+            args: [destinationProjectId, 1n, receiver, "", false],
+            account: peerAddress,
+        });
+    }
+    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