@easy1staking/cip113-sdk-ts 0.7.0 → 0.10.0

package/dist/substandards/freeze-and-seize/index.js

@@ -8,8 +8,28 @@
 import { CIP171_METADATA_LABEL, buildCip171Metadatum } from "../../core/cip171.js";
 import { Address as EvoAddress, Assets, Data, Transaction, TransactionHash as EvoTransactionHash, TransactionInput as EvoTransactionInput, } from "@evolution-sdk/evolution";
 import { sortTxInputs, findRefInputIndex, findRegistryNode, findCoveringNode, utxoToTxInput, } from "../../core/registry.js";
-import { buildEvoScript, scriptAddress, rewardAddress, baseAddress, stakingCredentialHash, paymentCredentialHash, stringToHex, MAX_NEXT, voidData, registryNodeDatum, decodeRegistryNode, blacklistNodeDatum, mintingProofOutputIndex, mintingProofRefInput, registryInsertRedeemer, blacklistInitRedeemer, blacklistAddRedeemer, blacklistRemoveRedeemer, extractConstrBytesField, getInlineDatum, utxoUnitQty, utxoLovelace, utxoTxHash, utxoOutputIndex, outputAssets, mintAssetsFromMap, REGISTRY_NODE_MIN_ADA, Credential, KeyHash, InlineDatum, labeledAssetName, buildCIP68FTDatum, } from "../../core/evo-utils.js";
-import { baseSpendRedeemer, transferRedeemer, thirdPartyRedeemer, withdrawalIndexOf, } from "../../core/ledger-order.js";
+import { buildEvoScript, scriptAddress, rewardAddress, baseAddress, stakingCredentialHash, paymentCredentialHash, stringToHex, MAX_NEXT, voidData, registryNodeDatum, decodeRegistryNode, blacklistNodeDatum, registryInsertRedeemer, blacklistInitRedeemer, blacklistAddRedeemer, blacklistRemoveRedeemer, extractConstrBytesField, getInlineDatum, assertProtocolParamsIssuanceLogic, utxoUnitQty, utxoLovelace, utxoTxHash, utxoOutputIndex, outputAssets, mintAssetsFromMap, REGISTRY_NODE_MIN_ADA, Credential, KeyHash, InlineDatum, labeledAssetName, buildCIP68FTDatum, inlineDatumBytes, assertInlineDatumWithinBound, minUtxoAtLeast, ceilToWholeAda, } from "../../core/evo-utils.js";
+import { baseSpendRedeemer, transferRedeemer, thirdPartyRedeemer, plbWithdrawalPlan, issuancePlan, programmableLogicGlobalRedeemer, } from "../../core/ledger-order.js";
+/**
+ * The flat amounts this plugin used to hardcode, kept as FLOORS rather than as
+ * answers — see `minUtxoAtLeast`. Every output that carries caller-controlled
+ * bytes now computes its requirement from live protocol parameters and takes
+ * the larger of the two, so ordinary inputs emit exactly what they always did
+ * and only the cases that were genuinely short move.
+ *
+ * MEASURED 2026-09-01 against preview (`coinsPerUtxoByte` 4310), which is how
+ * we know these were not merely theoretical:
+ *   - the (100) reference output needed 3,021,310 with every CIP-68 field at a
+ *     consumer's own documented caps and a 12-byte asset name — the flat
+ *     3,000,000 was SHORT by 21,310. With a maximal 32-byte CIP-67 name the
+ *     same datum needs 3,111,820. Both axes are caller-controlled and this
+ *     package caps NEITHER, so the true ceiling is unbounded.
+ *   - a token output with a 32-byte CIP-67 asset name needed 1,318,860 — the
+ *     flat 1,300,000 was SHORT by 18,860, rising to 44,720 at a maximal
+ *     quantity.
+ */
+const TOKEN_OUTPUT_FLOOR = 1300000n;
+const CIP68_REFERENCE_OUTPUT_FLOOR = 3000000n;
 import { createFESScripts } from "./scripts.js";
 // ---------------------------------------------------------------------------
 // Helpers
@@ -77,14 +97,27 @@ builder, changeAddress, availableUtxos, passAdditionalUtxos = false) {
  * next run failed with 3011.
  */
 function spendableWalletUtxos(walletUtxos, deployment) {
-    const reserved = new Set([
+    const reservedRefs = [
         deployment.programmableBaseRefInput,
+        // alpha.3: the dispatcher's reference script joined the set the bootstrap
+        // publishes. Naming it here keeps the explicit list complete — the general
+        // scriptRef rule below already covers it, but a named list that silently
+        // omits a live deployment's script invites the next reader to trust it.
+        // alpha.4 adds issuance_logic and upgrade_multisig; the newest member is
+        // exactly the one least likely to be covered anywhere else.
+        deployment.programmableLogicGlobalRefInput,
         deployment.transferRefInput,
         deployment.thirdPartyRefInput,
         deployment.unfrackingRefInput,
-    ]
-        .filter(Boolean)
-        .map((r) => `${r.txHash}#${r.outputIndex}`));
+        deployment.issuanceLogicRefInput,
+        deployment.upgradeMultisigRefInput,
+    ].filter(Boolean);
+    if (reservedRefs.length !== 7) {
+        throw new Error(`spendableWalletUtxos: the named deployment reference-script reservation list must ` +
+            `contain exactly 7 entries; got ${reservedRefs.length}. A membership-only list ` +
+            `decays into a stale subset and silently stops protecting its newest member.`);
+    }
+    const reserved = new Set(reservedRefs.map((r) => `${r.txHash}#${r.outputIndex}`));
     return walletUtxos.filter((u) => {
         // ⛔ ANY UTxO CARRYING A REFERENCE SCRIPT IS OFF LIMITS, not merely the four
         // this deployment names.
@@ -133,11 +166,15 @@ function selectUtxosForAmount(utxos, unit, requiredAmount) {
 async function findProtocolParamsUtxo(client, networkId, deployment) {
     const ppUnit = deployment.protocolParams.policyId + stringToHex("ProtocolParams");
     const addr = EvoAddress.fromBech32(
-    // 0.5.x: params NFT lives at coordination_spend, not always_fail.
-    scriptAddress(networkId, deployment.coordination.scriptHash));
+    // alpha.3: protocol_params is one validator whose hash is BOTH the NFT
+    // policy and the address holding it — the minting policy naming itself.
+    scriptAddress(networkId, deployment.protocolParams.policyId));
     const utxos = await client.getUtxosWithUnit(addr, ppUnit);
-    if (utxos.length > 0)
-        return utxos[0];
+    if (utxos.length > 0) {
+        const utxo = utxos[0];
+        assertProtocolParamsIssuanceLogic(utxo, deployment.issuanceLogic.scriptHash);
+        return utxo;
+    }
     throw new Error(`Protocol params UTxO not found (unit: ${ppUnit})`);
 }
 /** Find issuance CBOR hex UTxO */
@@ -149,6 +186,28 @@ async function findIssuanceCborHexUtxo(client, networkId, deployment) {
         return utxos[0];
     throw new Error(`Issuance CBOR hex UTxO not found (unit: ${icUnit})`);
 }
+/**
+ * The `issuance_logic` reference-script UTxO.
+ *
+ * Its withdraw-0 rides on every mint and burn, making this the most
+ * load-bearing reference-script output in the deployment. Attaching the body
+ * here would hide a spent deployment output instead of naming the breakage.
+ */
+async function findIssuanceLogicRefUtxo(client, deployment) {
+    const { txHash, outputIndex } = deployment.issuanceLogicRefInput;
+    const utxos = await client.getUtxosByOutRef([
+        new EvoTransactionInput.TransactionInput({
+            transactionId: EvoTransactionHash.fromHex(txHash),
+            index: BigInt(outputIndex),
+        }),
+    ]);
+    if (utxos.length === 0) {
+        throw new Error(`issuance_logic reference script not found on-chain at ${txHash}#${outputIndex}. ` +
+            `Deployment reference scripts are load-bearing: if an earlier transaction SPENT this ` +
+            `output, the deployment is broken and must be re-published.`);
+    }
+    return utxos[0];
+}
 /** Find the NFT unit in a covering node's value that belongs to a given policy */
 function findCoveringNodeNftUnit(utxo, policyId) {
     const units = Assets.getUnits(utxo.assets);
@@ -191,14 +250,18 @@ export function freezeAndSeizeSubstandard(config) {
             // ---------------------------------------------------------------------
             //
             // The blanket refusal that D-14 installed is GONE: `register`, `mint`,
-            // `transfer`, `initCompliance`, `freeze` and `unfreeze` are migrated to
-            // CIP-113 0.5.0-alpha.2 and this plugin initialises.
+            // Every operation is migrated to CIP-113 0.5.0-alpha.3.
+            //
+            // `seize` and `burn` take the THIRD-PARTY route: the standalone
+            // `third_party` validator's withdraw-0 with a ThirdPartyRedeemer, reached
+            // through the `programmable_logic_global` dispatcher, plus a
+            // BaseSpendRedeemer on every programmable input.
             //
-            // `seize` and `burn` are migrated too (W-E S-5): both take the
-            // THIRD-PARTY route, which #110 moved off the deleted `ThirdPartyAct` and
-            // onto the standalone `third_party` validator's withdraw-0 with a
-            // ThirdPartyRedeemer, plus BaseSpendRedeemer(SpendViaThirdParty) on every
-            // programmable input.
+            // ⚠ In alpha.2 the dispatch choice lived on that BaseSpendRedeemer as
+            // `SpendViaThirdParty`. alpha.3 made the redeemer a single-constructor
+            // record and moved the choice to the dispatcher's own redeemer. The two
+            // encodings are BYTE-IDENTICAL for the transfer arm, so a stale builder
+            // is not rejected — see the guards in core/ledger-order.ts.
             //
             // ⚠ The seize/burn paths still need re-validating against upstream #79
             // (UTxO contamination), #80 (issuance delegation scope) and #115 (datum
@@ -246,9 +309,27 @@ export function freezeAndSeizeSubstandard(config) {
             // Reference token (only when CIP-68)
             const refAssetNameHex = hasCIP68 ? labeledAssetName(100, assetNameHex) : null;
             const refUnit = refAssetNameHex ? scripts.tokenPolicyId + refAssetNameHex : null;
+            let cip68Datum;
+            let cip68DatumBytes;
+            if (hasCIP68) {
+                cip68Datum = buildCIP68FTDatum(params.cip68Metadata);
+                // alpha.4's issuance_logic `no_escape` now applies
+                // is_seizable_output_shape_bounded to PLB outputs carrying the minted
+                // policy. lib/assets.ak marks CIP-68's former exemption "(expired)": a
+                // data-URI logo over the bound fails on chain with an empty trace.
+                // Refuse before selecting UTxOs or constructing the transaction so the
+                // caller gets the measured, named diagnosis instead.
+                assertInlineDatumWithinBound(cip68Datum, ctx.deployment.maxInlineDatumBytes, "the CIP-68 (100) reference datum");
+                cip68DatumBytes = inlineDatumBytes(cip68Datum);
+            }
             // 1. Find covering registry node
-            const registrySpendAddr = scriptAddress(networkId, ctx.standardScripts.registrySpend.hash);
-            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registrySpendAddr));
+            // ⚑ ONE HASH, TWO ROLES. registry_mint and registry_spend merged (#117), so
+            // the node NFT policy id and the node address's payment credential are the
+            // same value — the minting policy naming itself. The old names
+            // (registrySpendAddr / registryMintPolicyId) asserted a distinction that no
+            // longer exists and would tell a reader to look for two hashes.
+            const registryAddr = scriptAddress(networkId, ctx.standardScripts.registry.hash);
+            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registryAddr));
             const coveringNodeUtxo = findCoveringNode(registryUtxos, scripts.tokenPolicyId);
             if (!coveringNodeUtxo)
                 throw new Error("Could not find covering registry node for insertion");
@@ -258,14 +339,19 @@ export function freezeAndSeizeSubstandard(config) {
             // 2. Get reference inputs
             const protocolParamsUtxo = await findProtocolParamsUtxo(client, networkId, ctx.deployment);
             const issuanceCborHexUtxo = await findIssuanceCborHexUtxo(client, networkId, ctx.deployment);
+            const issuanceLogicRefUtxo = await findIssuanceLogicRefUtxo(client, ctx.deployment);
+            // One array supplies both the plan's index arithmetic and the transaction.
+            // Constructing either set twice would let two valid integer indices drift.
+            const refUtxos = [protocolParamsUtxo, issuanceCborHexUtxo, issuanceLogicRefUtxo];
             // 3. Build datums
-            // UNREACHABLE — this plugin refuses at init (T-D09). Retained, and made to
-            // typecheck against the 7-field layout, so the freeze-and-seize epic gets a
-            // readable diff instead of a rewrite from memory.
-            //
             // The index-based reads that used to be here (2/3/4) were silently wrong
-            // under the 7-field layout. Replaced with decodeRegistryNode, which is
+            // when RegistryNode grew. Replaced with decodeRegistryNode, which is
             // positional-safe and fails loudly on a short record.
+            //
+            // ⚑ RegistryNode is STILL SEVEN FIELDS in alpha.3 — it is the PARAMS datum
+            // that went 7 -> 4, not this one. Two adjacent records, one changed and one
+            // did not, is exactly the pairing that invites a "consistency" edit; the
+            // decoder's arity check is what stops it.
             if (!coveringDatum) {
                 throw new Error("register: the covering registry node has no inline datum. The directory " +
                     "cannot be traversed without it — a node with no datum is malformed, not empty.");
@@ -290,9 +376,32 @@ export function freezeAndSeizeSubstandard(config) {
                 unfrackingLogicScript: { type: "script", hash: scripts.issuerAdmin.hash },
                 globalStateCs: "",
             });
-            // 4. Build redeemers — registry output index shifts when CIP-68 adds an extra output
-            const registryOutputIndex = hasCIP68 ? 3 : 2;
-            const issuanceRedeemer = mintingProofOutputIndex(registryOutputIndex);
+            // The former branch-dependent registry-output literal is gone. The index
+            // now derives from the declared output set, so adding an output shifts it
+            // automatically instead of requiring a second edit in step. Its CIP-68
+            // branch has never executed on chain: no test has passed
+            // `cip68Metadata` yet; T-F04-4 owns that first execution.
+            const outputTags = [
+                "user-token",
+                ...(hasCIP68 ? ["cip68-reference"] : []),
+                "covering-node",
+                "new-node",
+            ];
+            // No plgHash: register spends a registry node and wallet funds, never a
+            // programmable_logic_base input.
+            const plan = issuancePlan({
+                issuanceLogicHash: ctx.deployment.issuanceLogic.scriptHash,
+                otherWithdrawals: [{ hash: scripts.issuerAdmin.hash, isScript: true }],
+                referenceInputs: refUtxos.map(utxoToTxInput),
+                paramsRefInput: utxoToTxInput(protocolParamsUtxo),
+                outputs: outputTags,
+                issued: [
+                    {
+                        policyId: scripts.tokenPolicyId,
+                        proof: { kind: "output", tag: "new-node" },
+                    },
+                ],
+            });
             const registryMintRedeemer = registryInsertRedeemer(scripts.issuanceMint.hash, { type: "script", hash: scripts.issuerAdmin.hash });
             const tokenDatum = voidData();
             // 5. Determine if chaining from initCompliance
@@ -300,16 +409,16 @@ export function freezeAndSeizeSubstandard(config) {
             // 6. Build addresses
             const plbHash = ctx.standardScripts.programmableLogicBase.hash;
             const recipientPlbAddr = baseAddress(networkId, plbHash, recipient);
-            const registryMintPolicyId = ctx.standardScripts.registryMint.hash;
+            const registryPolicyId = ctx.standardScripts.registry.hash;
             // 7. Build asset maps — include CIP-68 ref token in the same mint (same policy + redeemer)
             const mintEntries = new Map([[unit, quantity]]);
             if (hasCIP68 && refUnit) {
                 mintEntries.set(refUnit, 1n);
             }
             const tokenAssets = mintAssetsFromMap(mintEntries);
-            const registryNftUnit = registryMintPolicyId + scripts.tokenPolicyId;
+            const registryNftUnit = registryPolicyId + scripts.tokenPolicyId;
             const registryNftAssets = mintAssetsFromMap(new Map([[registryNftUnit, 1n]]));
-            const coveringNftUnit = findCoveringNodeNftUnit(coveringNodeUtxo, registryMintPolicyId);
+            const coveringNftUnit = findCoveringNodeNftUnit(coveringNodeUtxo, registryPolicyId);
             // 8. Build transaction
             let tx = client.newTx();
             // CIP-171 provenance, carried by the transaction that parameterises the
@@ -321,39 +430,70 @@ export function freezeAndSeizeSubstandard(config) {
                 });
             }
             tx = tx.collectFrom({ inputs: [coveringNodeUtxo], redeemer: voidData() });
-            tx = tx.withdraw({
-                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(scripts.issuerAdmin.hash, "hex"))),
-                amount: 0n,
-                redeemer: voidData(),
-            });
-            tx = tx.mintAssets({ assets: tokenAssets, redeemer: issuanceRedeemer });
+            const withdrawalSpecs = [
+                { hash: scripts.issuerAdmin.hash, redeemer: voidData() },
+                {
+                    hash: ctx.deployment.issuanceLogic.scriptHash,
+                    redeemer: plan.issuanceLogicRedeemer,
+                },
+            ];
+            if (withdrawalSpecs.length !== plan.withdrawals.length) {
+                throw new Error(`register: issuance plan declares ${plan.withdrawals.length} withdrawals but ` +
+                    `${withdrawalSpecs.length} are emitted`);
+            }
+            for (const withdrawal of withdrawalSpecs) {
+                tx = tx.withdraw({
+                    stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(withdrawal.hash, "hex"))),
+                    amount: 0n,
+                    redeemer: withdrawal.redeemer,
+                });
+            }
+            tx = tx.mintAssets({ assets: tokenAssets, redeemer: plan.issuanceRedeemer });
             tx = tx.mintAssets({ assets: registryNftAssets, redeemer: registryMintRedeemer });
-            // Output 0: user token to recipient (with label 333 prefix if CIP-68)
+            // min-UTxO is sized from live protocol parameters, not guessed: `unit`
+            // carries a caller-supplied asset name and `quantity` a caller-supplied
+            // magnitude, and both widen the serialised output.
+            const coinsPerUtxoByte = (await client.getProtocolParameters()).coinsPerUtxoByte;
+            // outputTags: "user-token" — minted supply at the recipient's PLB.
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(recipientPlbAddr),
-                assets: outputAssets(1300000n, new Map([[unit, quantity]])),
+                assets: outputAssets(minUtxoAtLeast(TOKEN_OUTPUT_FLOOR, {
+                    address: recipientPlbAddr,
+                    assets: outputAssets(0n, new Map([[unit, quantity]])),
+                    datum: tokenDatum,
+                    coinsPerUtxoByte,
+                }), new Map([[unit, quantity]])),
                 datum: new InlineDatum.InlineDatum({ data: tokenDatum }),
             });
-            // Output 1 (CIP-68 only): reference token to issuer's PLB address with metadata datum
+            // outputTags: "cip68-reference" — optional reference token and metadata.
             if (hasCIP68 && refUnit) {
                 const issuerPlbAddr = baseAddress(networkId, plbHash, feePayerAddress);
-                const cip68Datum = buildCIP68FTDatum(params.cip68Metadata);
+                // ⛔ THE ONE OUTPUT SIZED BY USER-SUPPLIED STRINGS. Rounded UP TO A
+                // WHOLE ADA deliberately: the reference implementation this SDK is
+                // diffed against does the same, and a builder-equivalence check is only
+                // useful while both sides agree. The cost is at most ~1 ADA, once, on an
+                // output that exists for the life of the token.
                 tx = tx.payToAddress({
                     address: EvoAddress.fromBech32(issuerPlbAddr),
-                    assets: outputAssets(3000000n, new Map([[refUnit, 1n]])),
+                    assets: outputAssets(ceilToWholeAda(minUtxoAtLeast(CIP68_REFERENCE_OUTPUT_FLOOR, {
+                        address: issuerPlbAddr,
+                        assets: outputAssets(0n, new Map([[refUnit, 1n]])),
+                        datum: cip68Datum,
+                        coinsPerUtxoByte,
+                    })), new Map([[refUnit, 1n]])),
                     datum: new InlineDatum.InlineDatum({ data: cip68Datum }),
                 });
             }
-            // Updated covering node (output 1 or 2)
+            // outputTags: "covering-node" — predecessor with its updated link.
             const coveringNodeTokenMap = new Map();
             if (coveringNftUnit)
                 coveringNodeTokenMap.set(coveringNftUnit, 1n);
             tx = tx.payToAddress({
-                address: EvoAddress.fromBech32(registrySpendAddr),
+                address: EvoAddress.fromBech32(registryAddr),
                 assets: outputAssets(utxoLovelace(coveringNodeUtxo), coveringNodeTokenMap),
                 datum: new InlineDatum.InlineDatum({ data: updatedCoveringDatum }),
             });
-            // New registry node (output 2 or 3).
+            // outputTags: "new-node" — the node named by the issuance proof.
             //
             // 3 ADA, not 2: the RegistryNode datum is SEVEN fields in 0.5.x and
             // min-UTxO scales with serialised output size. MEASURED at 2,038,630 for
@@ -364,17 +504,43 @@ export function freezeAndSeizeSubstandard(config) {
             // covering UTxO's OWN lovelace forward, so it inherits whatever the
             // bootstrap funded the origin with.)
             tx = tx.payToAddress({
-                address: EvoAddress.fromBech32(registrySpendAddr),
+                address: EvoAddress.fromBech32(registryAddr),
                 assets: outputAssets(REGISTRY_NODE_MIN_ADA, new Map([[registryNftUnit, 1n]])),
                 datum: new InlineDatum.InlineDatum({ data: newRegistryNodeDatum }),
             });
             // Reference inputs
-            tx = tx.readFrom({ referenceInputs: [protocolParamsUtxo, issuanceCborHexUtxo] });
+            // ⛔ THE PROTOCOL-PARAMS REFERENCE INPUT STAYS — and as of S-11 that is a
+            // MEASURED decision, not a cautious one.
+            //
+            // alpha.3's registry no longer reads it (#117). `issuance_mint` does, to
+            // pull the LIVE delegate credentials from its datum, and that locate is
+            // DELIBERATELY NON-FAILING: absent params UTxO means "no delegation",
+            // falling back to local `no_escape` custody. So removing it raises no
+            // error — it silently selects a different custody path.
+            //
+            // MEASURED ON DEVNET (S-11): removing it from BOTH substandards' register
+            // paths, the full lifecycle still passes — dummy 2/2, FES 3/3. The two
+            // custody branches do converge here, as the reasoning predicted.
+            //
+            // ⇒ AND IT STAYS ANYWAY, for a reason the measurement itself supplies:
+            // the tests pass EITHER WAY. That is precisely what makes dropping it
+            // unsafe to keep. Nothing in this suite would notice if `issuance_mint`'s
+            // delegation semantics changed and the absent input started to matter —
+            // the guard against that is the input being there, not a test. The saving
+            // is one reference input on a once-per-token transaction; the exposure is
+            // a silent custody change nobody would see.
+            // alpha.4 makes the params reference input mandatory rather than an
+            // optional custody hint: with_protocol_params_fields uses expect_at.
+            tx = tx.readFrom({ referenceInputs: refUtxos });
             // Attach scripts
-            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.registrySpend.compiledCode) });
+            // ⚑ ONE attach, not two. registry_mint and registry_spend merged into a
+            // single validator (#117): this transaction both MINTS a node NFT and
+            // SPENDS the covering node, which in alpha.2 needed two scripts. It is
+            // now one script serving both purposes — attaching it twice would put a
+            // duplicate witness in the transaction.
+            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.registry.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuerAdmin.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuanceMint.compiledCode) });
-            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.registryMint.compiledCode) });
             // Required signer
             tx = tx.addSigner({ keyHash: KeyHash.fromHex(config.deployment.adminPkh) });
             const built = await buildAndSerialize(tx, feePayerAddress, useChaining ? chainedUtxos : undefined, useChaining);
@@ -386,8 +552,12 @@ export function freezeAndSeizeSubstandard(config) {
                 metadata: {
                     issuerAdminScriptHash: scripts.issuerAdmin.hash,
                     transferScriptHash: scripts.transfer.hash,
+                    outputIndices: {
+                        OUT_NEW_NODE: plan.outputIndexOf("new-node"),
+                    },
                     ...(hasCIP68 && {
                         cip68Enabled: true,
+                        cip68DatumBytes,
                         userAssetNameHex,
                         refAssetNameHex,
                     }),
@@ -406,17 +576,30 @@ export function freezeAndSeizeSubstandard(config) {
                 throw new Error(`Token policy ${tokenPolicyId} does not match this FES instance (${scripts.tokenPolicyId})`);
             }
             // 1. Find registry node as RefInput proof
-            const registrySpendAddr = scriptAddress(networkId, ctx.standardScripts.registrySpend.hash);
-            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registrySpendAddr));
+            const registryAddr = scriptAddress(networkId, ctx.standardScripts.registry.hash);
+            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registryAddr));
             const registryUtxo = findRegistryNode(registryUtxos, tokenPolicyId);
             if (!registryUtxo)
                 throw new Error(`Registry node not found for ${tokenPolicyId}`);
-            // 2. Sort reference inputs
-            const regRef = utxoToTxInput(registryUtxo);
-            const sortedRefInputs = sortTxInputs([regRef]);
-            const registryRefIdx = findRefInputIndex(sortedRefInputs, regRef);
+            // 2. Find the two alpha.4 protocol reference inputs. The params input is
+            // NEW here: with_protocol_params_fields begins with a hard expect_at,
+            // and S-7's open mint-vs-burn inconsistency is answered at this site.
+            const protocolParamsUtxo = await findProtocolParamsUtxo(client, networkId, ctx.deployment);
+            const issuanceLogicRefUtxo = await findIssuanceLogicRefUtxo(client, ctx.deployment);
+            const refUtxos = [protocolParamsUtxo, registryUtxo, issuanceLogicRefUtxo];
+            const plan = issuancePlan({
+                issuanceLogicHash: ctx.deployment.issuanceLogic.scriptHash,
+                otherWithdrawals: [{ hash: scripts.issuerAdmin.hash, isScript: true }],
+                referenceInputs: refUtxos.map(utxoToTxInput),
+                paramsRefInput: utxoToTxInput(protocolParamsUtxo),
+                issued: [
+                    {
+                        policyId: tokenPolicyId,
+                        proof: { kind: "reference-input", input: utxoToTxInput(registryUtxo) },
+                    },
+                ],
+            });
             // 3. Build redeemers
-            const issuanceRedeemer = mintingProofRefInput(registryRefIdx);
             const tokenDatum = voidData();
             // 4. Build PLB address
             const plbHash = ctx.standardScripts.programmableLogicBase.hash;
@@ -428,18 +611,37 @@ export function freezeAndSeizeSubstandard(config) {
             let tx = client.newTx();
             const spendableUtxos = spendableWalletUtxos(walletUtxos, ctx.deployment);
             tx = tx.collectFrom({ inputs: spendableUtxos.slice(0, 2) });
-            tx = tx.withdraw({
-                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(scripts.issuerAdmin.hash, "hex"))),
-                amount: 0n,
-                redeemer: voidData(),
-            });
-            tx = tx.mintAssets({ assets: tokenAssets, redeemer: issuanceRedeemer });
+            const withdrawalSpecs = [
+                { hash: scripts.issuerAdmin.hash, redeemer: voidData() },
+                {
+                    hash: ctx.deployment.issuanceLogic.scriptHash,
+                    redeemer: plan.issuanceLogicRedeemer,
+                },
+            ];
+            if (withdrawalSpecs.length !== plan.withdrawals.length) {
+                throw new Error(`mint: issuance plan declares ${plan.withdrawals.length} withdrawals but ` +
+                    `${withdrawalSpecs.length} are emitted`);
+            }
+            for (const withdrawal of withdrawalSpecs) {
+                tx = tx.withdraw({
+                    stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(withdrawal.hash, "hex"))),
+                    amount: 0n,
+                    redeemer: withdrawal.redeemer,
+                });
+            }
+            tx = tx.mintAssets({ assets: tokenAssets, redeemer: plan.issuanceRedeemer });
+            const coinsPerUtxoByte = (await client.getProtocolParameters()).coinsPerUtxoByte;
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(recipientPlbAddr),
-                assets: outputAssets(1300000n, new Map([[unit, quantity]])),
+                assets: outputAssets(minUtxoAtLeast(TOKEN_OUTPUT_FLOOR, {
+                    address: recipientPlbAddr,
+                    assets: outputAssets(0n, new Map([[unit, quantity]])),
+                    datum: tokenDatum,
+                    coinsPerUtxoByte,
+                }), new Map([[unit, quantity]])),
                 datum: new InlineDatum.InlineDatum({ data: tokenDatum }),
             });
-            tx = tx.readFrom({ referenceInputs: [registryUtxo] });
+            tx = tx.readFrom({ referenceInputs: refUtxos });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuerAdmin.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuanceMint.compiledCode) });
             tx = tx.addSigner({ keyHash: KeyHash.fromHex(config.deployment.adminPkh) });
@@ -469,22 +671,18 @@ export function freezeAndSeizeSubstandard(config) {
                 throw new Error(`No tokens of ${unit} in UTxO`);
             // 2. Find reference inputs
             const protocolParamsUtxo = await findProtocolParamsUtxo(client, networkId, ctx.deployment);
-            const registrySpendAddr = scriptAddress(networkId, ctx.standardScripts.registrySpend.hash);
-            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registrySpendAddr));
+            const registryAddr = scriptAddress(networkId, ctx.standardScripts.registry.hash);
+            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registryAddr));
             const registryUtxo = findRegistryNode(registryUtxos, tokenPolicyId);
             if (!registryUtxo)
                 throw new Error(`Registry node not found for ${tokenPolicyId}`);
-            // 3. Sort reference inputs
-            const allRefInputRefs = [utxoToTxInput(protocolParamsUtxo), utxoToTxInput(registryUtxo)];
-            const sortedRefInputs = sortTxInputs(allRefInputRefs);
-            const registryIdx = findRefInputIndex(sortedRefInputs, utxoToTxInput(registryUtxo));
-            // 4. Build redeemers
-            const issuanceRedeemer = mintingProofRefInput(registryIdx);
-            const paramsIdx = findRefInputIndex(sortedRefInputs, utxoToTxInput(protocolParamsUtxo));
+            const issuanceLogicRefUtxo = await findIssuanceLogicRefUtxo(client, ctx.deployment);
+            const refUtxos = [protocolParamsUtxo, registryUtxo, issuanceLogicRefUtxo];
             // 0.5.x third-party route. `ThirdPartyAct` was DELETED by #110: the
             // administrative path is now the standalone `third_party` validator, and
-            // programmable_logic_base dispatches to it via SpendViaThirdParty — so
-            // this transaction never loads the `transfer` reference script at all.
+            // programmable_logic_base withdraws through the dispatcher, whose redeemer
+            // carries ThirdPartyAct — so this transaction never loads the `transfer`
+            // reference script at all.
             //
             // The withdrawal set is BOTH scripts: the framework delegate, and the
             // issuer authority the registry node names in
@@ -497,15 +695,36 @@ export function freezeAndSeizeSubstandard(config) {
                 isScript: true,
             };
             const issuerAuthorityKey = { hash: scripts.issuerAdmin.hash, isScript: true };
-            const thirdPartyWdrlIdx = withdrawalIndexOf([thirdPartyKey, issuerAuthorityKey], thirdPartyKey);
+            // One plan owns the COMPLETE four-withdrawal and three-reference-input
+            // sets. In particular, adding issuance_logic's reference script can move
+            // every reference-input index that sorts after it.
+            const plan = issuancePlan({
+                issuanceLogicHash: ctx.deployment.issuanceLogic.scriptHash,
+                plgHash: ctx.standardScripts.programmableLogicGlobal.hash,
+                otherWithdrawals: [thirdPartyKey, issuerAuthorityKey],
+                referenceInputs: refUtxos.map(utxoToTxInput),
+                paramsRefInput: utxoToTxInput(protocolParamsUtxo),
+                issued: [
+                    {
+                        policyId: tokenPolicyId,
+                        proof: { kind: "reference-input", input: utxoToTxInput(registryUtxo) },
+                    },
+                ],
+            });
+            const registryIdx = plan.referenceInputIndexOf(utxoToTxInput(registryUtxo));
             // outputs_start_idx = 0: `third_party` PAIRS each programmable input with
             // the NEXT output (same address, datum and reference script, lovelace
             // ratcheting up) and reads the seized amount as the DELTA. Destination
             // outputs must therefore sit AMONG THE LEADING ones it skips.
             // See docs/api-reference.md — getting this backwards fails with an EMPTY
             // TRACE LIST, because it is a structural expect and not a traced check.
-            const plgRedeemer = thirdPartyRedeemer(paramsIdx, registryIdx, 0);
-            const plbSpendRedeemer = baseSpendRedeemer("THIRD_PARTY", paramsIdx, thirdPartyWdrlIdx);
+            // params_idx dropped: delegates no longer read the params datum.
+            // ThirdPartyRedeemer.registry_node_idx and the issuance map's
+            // RefInput{index} MUST be the same integer: upstream
+            // third_party_covers_own_registry_node compares them. One plan computes
+            // both, so the pair cannot drift when a reference input is added.
+            const plgRedeemer = thirdPartyRedeemer(registryIdx, 0);
+            const plbSpendRedeemer = baseSpendRedeemer(plan.paramsIdx, plan.plgIdx());
             const tokenDatum = voidData();
             // 5. Compute remaining assets (remove burned token's policy)
             const remainingTokens = new Map();
@@ -528,16 +747,38 @@ export function freezeAndSeizeSubstandard(config) {
             const spendableUtxos = spendableWalletUtxos(walletUtxos, ctx.deployment);
             tx = tx.collectFrom({ inputs: spendableUtxos.slice(0, 2) });
             tx = tx.collectFrom({ inputs: [utxoToBurn], redeemer: plbSpendRedeemer });
-            tx = tx.withdraw({
-                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(scripts.issuerAdmin.hash, "hex"))),
-                amount: 0n,
-                redeemer: voidData(),
-            });
-            tx = tx.withdraw({
-                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(ctx.standardScripts.thirdParty.hash, "hex"))),
-                amount: 0n,
-                redeemer: plgRedeemer,
-            });
+            const withdrawalSpecs = [
+                { hash: scripts.issuerAdmin.hash, redeemer: voidData() },
+                {
+                    hash: ctx.standardScripts.programmableLogicGlobal.hash,
+                    redeemer: programmableLogicGlobalRedeemer("THIRD_PARTY"),
+                },
+                { hash: ctx.standardScripts.thirdParty.hash, redeemer: plgRedeemer },
+                {
+                    hash: ctx.deployment.issuanceLogic.scriptHash,
+                    redeemer: plan.issuanceLogicRedeemer,
+                },
+            ];
+            if (withdrawalSpecs.length !== plan.withdrawals.length) {
+                throw new Error(`burn: issuance plan declares ${plan.withdrawals.length} withdrawals but ` +
+                    `${withdrawalSpecs.length} are emitted`);
+            }
+            for (const withdrawal of withdrawalSpecs) {
+                tx = tx.withdraw({
+                    stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(withdrawal.hash, "hex"))),
+                    amount: 0n,
+                    redeemer: withdrawal.redeemer,
+                });
+            }
+            // ⚑ NO min-UTxO COMPUTATION HERE, AND THAT IS CORRECT — do not "fix" it to
+            // match the other outputs. This is the PAIRED CONTINUATION: `third_party`
+            // requires it to preserve the input's address, datum and reference script
+            // with lovelace only ratcheting UP, so it carries the INPUT'S OWN lovelace
+            // forward. That figure was already min-UTxO-valid when the input was
+            // created, and burning REMOVES tokens — a smaller output has a LOWER
+            // requirement. Carrying it forward is therefore always sufficient, and
+            // recomputing could only produce a smaller number, which the ratchet rule
+            // forbids.
             tx = tx.payToAddress({
                 address: utxoToBurn.address,
                 assets: outputAssets(utxoLovelace(utxoToBurn), remainingTokens.size > 0 ? remainingTokens : undefined),
@@ -548,9 +789,15 @@ export function freezeAndSeizeSubstandard(config) {
                 // coincidence rather than a guarantee.
                 datum: new InlineDatum.InlineDatum({ data: getInlineDatum(utxoToBurn) ?? tokenDatum }),
             });
-            tx = tx.mintAssets({ assets: burnAssets, redeemer: issuanceRedeemer });
-            tx = tx.readFrom({ referenceInputs: [protocolParamsUtxo, registryUtxo] });
+            tx = tx.mintAssets({ assets: burnAssets, redeemer: plan.issuanceRedeemer });
+            tx = tx.readFrom({ referenceInputs: refUtxos });
             tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicBase.compiledCode) });
+            // ⛔ THE DISPATCHER'S OWN SCRIPT WITNESS. A withdraw-0 needs the script in
+            // full, not just a redeemer — alpha.3 added the dispatcher's withdrawal to
+            // every programmable transaction, and S-6 wired the withdrawal and the
+            // redeemer but not this. The ledger says "An associated script witness is
+            // missing" on purpose=withdraw, which names the shape but not the script.
+            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicGlobal.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.thirdParty.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuerAdmin.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.issuanceMint.compiledCode) });
@@ -582,8 +829,8 @@ export function freezeAndSeizeSubstandard(config) {
             const { selected, totalTokenAmount } = selectUtxosForAmount(tokenUtxos, unit, quantity);
             const returningAmount = totalTokenAmount - quantity;
             // 4. Find registry node reference input
-            const registrySpendAddr = scriptAddress(networkId, ctx.standardScripts.registrySpend.hash);
-            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registrySpendAddr));
+            const registryAddr = scriptAddress(networkId, ctx.standardScripts.registry.hash);
+            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registryAddr));
             const registryUtxo = findRegistryNode(registryUtxos, tokenPolicyId);
             if (!registryUtxo)
                 throw new Error(`Registry node not found for ${tokenPolicyId}`);
@@ -610,6 +857,27 @@ export function freezeAndSeizeSubstandard(config) {
                 utxoToTxInput(registryUtxo),
             ];
             const sortedRefInputs = sortTxInputs(allRefInputRefs);
+            // ⚠ NOTE THE ASYMMETRY WITH `register`, WHICH S-11 MEASURED: there,
+            // removing the params reference input is behaviour-preserving. HERE it is
+            // not, and the reason has nothing to do with custody — see below. Two
+            // transactions, one shared input, two unrelated dependencies on it.
+            //
+            // ⛔ A SECOND REASON THE PROTOCOL-PARAMS REFERENCE INPUT MUST STAY, beyond
+            // the custody one recorded at `register`.
+            //
+            // Every index below — the blacklist proof indices, registryIdx, paramsIdx
+            // — is a position in THIS sorted set. FES's own transfer validator reads
+            // its blacklist nodes with `list.at(reference_inputs, node_idx)`, an
+            // INDEX, not a search. Removing the params UTxO from the set therefore
+            // shifts every proof index that sorts after it, and the failure is a
+            // blacklist proof resolving to the WRONG NODE — a well-formed proof about
+            // something else.
+            //
+            // So "the registry no longer needs this input" (#117) is true and still
+            // does not license dropping it: two unrelated consumers in this same
+            // transaction depend on it, one for custody semantics and one for index
+            // arithmetic. Requirements belong to the TRANSACTION, not to the
+            // component being edited.
             const proofIndices = selected.map(() => findRefInputIndex(sortedRefInputs, utxoToTxInput(proofUtxos[0])));
             const registryIdx = findRefInputIndex(sortedRefInputs, utxoToTxInput(registryUtxo));
             const paramsIdx = findRefInputIndex(sortedRefInputs, utxoToTxInput(protocolParamsUtxo));
@@ -618,15 +886,19 @@ export function freezeAndSeizeSubstandard(config) {
             // 9. Build redeemers — 0.5.x shapes.
             //
             // The withdrawal set must be COMPLETE and in LEDGER order: script
-            // credentials before key credentials, bytewise within each. This
-            // transaction carries two, both scripts — the framework's `transfer`
-            // delegate and this substandard's own transfer logic.
+            // credentials before key credentials, bytewise within each. alpha.3 makes
+            // it THREE, all scripts — the dispatcher, the framework's `transfer`
+            // delegate, and this substandard's own transfer logic. Every index in the
+            // transaction shifted when the dispatcher joined.
             const coreTransferKey = {
                 hash: ctx.standardScripts.transfer.hash,
                 isScript: true,
             };
             const fesLogicKey = { hash: scripts.transfer.hash, isScript: true };
-            const transferWdrlIdx = withdrawalIndexOf([coreTransferKey, fesLogicKey], coreTransferKey);
+            const transferPlan = plbWithdrawalPlan({
+                plgHash: ctx.standardScripts.programmableLogicGlobal.hash,
+                others: [coreTransferKey, fesLogicKey],
+            });
             if (process.env.DUMP_TX_STRUCTURE) {
                 // Computed indices, printed beside the artefact's own order so the two
                 // can be COMPARED rather than reasoned about. A structural expect in
@@ -639,19 +911,16 @@ export function freezeAndSeizeSubstandard(config) {
                     `  registryIdx=${registryIdx}\n` +
                     `  coreTransfer=${ctx.standardScripts.transfer.hash}\n` +
                     `  fesLogic    =${scripts.transfer.hash}\n` +
-                    `  transferWdrlIdx=${transferWdrlIdx}\n` +
+                    `  plgWdrlIdx=${transferPlan.plgIdx}\n` +
                     "=== END COMPUTED ===");
             }
             const fesTransferRedeemer = Data.list(proofIndices.map((idx) => Data.constr(0n, [Data.int(BigInt(idx))])));
-            // TransferRedeemer { params_idx, proofs } — params_idx was PREPENDED by
-            // #109; an old TransferAct encoder's bytes are not compatible.
-            const plgRedeemer = transferRedeemer(paramsIdx, [
-                { type: "exists", nodeIdx: registryIdx },
-            ]);
-            // programmable_logic_base no longer takes an untyped redeemer: it
-            // dispatches on the constructor and witnesses where its delegate's
-            // withdrawal sits.
-            const spendRdmr = baseSpendRedeemer("TRANSFER", paramsIdx, transferWdrlIdx);
+            // TransferRedeemer { proofs } — params_idx was dropped in alpha.3; the
+            // delegates stop reading the params datum entirely.
+            const plgRedeemer = transferRedeemer([{ type: "exists", nodeIdx: registryIdx }]);
+            // PLB witnesses where the DISPATCHER's withdrawal sits; the dispatch
+            // choice itself moved to the dispatcher's own redeemer.
+            const spendRdmr = baseSpendRedeemer(paramsIdx, transferPlan.plgIdx);
             const tokenDatum = voidData();
             // 10. Build transaction
             let tx = client.newTx();
@@ -660,6 +929,13 @@ export function freezeAndSeizeSubstandard(config) {
             // resolves the withdrawal at `wdrl_idx` and requires it to equal the
             // credential the params datum names for THIS dispatch arm, so withdrawing
             // the wrong delegate fails the spend with an empty trace list.
+            // The DISPATCHER's own withdraw-0 — new in alpha.3, required on every
+            // programmable transaction, and the entry PLB's wdrl_idx resolves to.
+            tx = tx.withdraw({
+                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(ctx.standardScripts.programmableLogicGlobal.hash, "hex"))),
+                amount: 0n,
+                redeemer: programmableLogicGlobalRedeemer("TRANSFER"),
+            });
             tx = tx.withdraw({
                 stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(ctx.standardScripts.transfer.hash, "hex"))),
                 amount: 0n,
@@ -670,20 +946,37 @@ export function freezeAndSeizeSubstandard(config) {
                 amount: 0n,
                 redeemer: fesTransferRedeemer,
             });
+            const coinsPerUtxoByte = (await client.getProtocolParameters()).coinsPerUtxoByte;
             if (returningAmount > 0n) {
                 tx = tx.payToAddress({
                     address: EvoAddress.fromBech32(senderPlbAddr),
-                    assets: outputAssets(1300000n, new Map([[unit, returningAmount]])),
+                    assets: outputAssets(minUtxoAtLeast(TOKEN_OUTPUT_FLOOR, {
+                        address: senderPlbAddr,
+                        assets: outputAssets(0n, new Map([[unit, returningAmount]])),
+                        datum: tokenDatum,
+                        coinsPerUtxoByte,
+                    }), new Map([[unit, returningAmount]])),
                     datum: new InlineDatum.InlineDatum({ data: tokenDatum }),
                 });
             }
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(recipientPlbAddr),
-                assets: outputAssets(1300000n, new Map([[unit, quantity]])),
+                assets: outputAssets(minUtxoAtLeast(TOKEN_OUTPUT_FLOOR, {
+                    address: recipientPlbAddr,
+                    assets: outputAssets(0n, new Map([[unit, quantity]])),
+                    datum: tokenDatum,
+                    coinsPerUtxoByte,
+                }), new Map([[unit, quantity]])),
                 datum: new InlineDatum.InlineDatum({ data: tokenDatum }),
             });
             tx = tx.readFrom({ referenceInputs: [...proofUtxos, protocolParamsUtxo, registryUtxo] });
             tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicBase.compiledCode) });
+            // ⛔ THE DISPATCHER'S OWN SCRIPT WITNESS. A withdraw-0 needs the script in
+            // full, not just a redeemer — alpha.3 added the dispatcher's withdrawal to
+            // every programmable transaction, and S-6 wired the withdrawal and the
+            // redeemer but not this. The ledger says "An associated script witness is
+            // missing" on purpose=withdraw, which names the shape but not the script.
+            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicGlobal.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.transfer.compiledCode) });
             tx = tx.attachScript({ script: buildEvoScript(scripts.transfer.compiledCode) });
             tx = tx.addSigner({ keyHash: KeyHash.fromHex(senderStakingHash) });
@@ -729,7 +1022,16 @@ export function freezeAndSeizeSubstandard(config) {
                 address: EvoAddress.fromBech32(feePayerAddress),
                 assets: outputAssets(40000000n),
             });
-            // Output: blacklist origin node
+            // Output: blacklist origin node.
+            //
+            // ✅ FLAT CONSTANT IS CORRECT HERE, AND IT IS PROVABLE RATHER THAN
+            // ASSUMED — this output carries NO caller-controlled bytes. The unit is
+            // `blacklistMint.hash + ""` (an EMPTY asset name, fixed above), and the
+            // datum is `blacklistNodeDatum("", MAX_NEXT)` — an empty key and a
+            // 30-byte sentinel, both constants. MEASURED on preview
+            // (coinsPerUtxoByte 4310): 1,198,180 required against 1,300,000 supplied,
+            // 101,820 of headroom, and the live origin node on preview sits at
+            // exactly 1,300,000. Nothing a caller types can move it.
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(blacklistSpendAddr),
                 assets: outputAssets(1300000n, new Map([[blacklistOriginUnit, 1n]])),
@@ -805,7 +1107,17 @@ export function freezeAndSeizeSubstandard(config) {
                 assets: outputAssets(utxoLovelace(coveringNode), coveringTokenMap),
                 datum: new InlineDatum.InlineDatum({ data: updatedCoveringDatum }),
             });
-            // Output 1: new blacklist node
+            // Output 1: new blacklist node.
+            //
+            // ✅ FLAT CONSTANT IS CORRECT HERE TOO, for the same provable reason. The
+            // unit is `blacklistMint.hash + targetStakingHash` — a 28-byte staking
+            // credential, fixed width — and the datum is two hashes. A blacklist entry
+            // has no user-supplied strings in it at all. MEASURED: 1,448,160 required
+            // against 2,000,000 supplied, 551,840 of headroom.
+            //
+            // ⚠ If a future node datum gains a field, this stops being true silently.
+            // That is exactly how REGISTRY_NODE_MIN_ADA went wrong when the registry
+            // datum grew from five fields to seven.
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(blacklistSpendAddr),
                 assets: outputAssets(2000000n, new Map([[nftUnit, 1n]])),
@@ -904,8 +1216,8 @@ export function freezeAndSeizeSubstandard(config) {
                 throw new Error(`No tokens of ${unit} in UTxO`);
             // 2. Find reference inputs
             const protocolParamsUtxo = await findProtocolParamsUtxo(client, networkId, ctx.deployment);
-            const registrySpendAddr = scriptAddress(networkId, ctx.standardScripts.registrySpend.hash);
-            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registrySpendAddr));
+            const registryAddr = scriptAddress(networkId, ctx.standardScripts.registry.hash);
+            const registryUtxos = await client.getUtxos(EvoAddress.fromBech32(registryAddr));
             const registryUtxo = findRegistryNode(registryUtxos, tokenPolicyId);
             if (!registryUtxo)
                 throw new Error(`Registry node not found for ${tokenPolicyId}`);
@@ -945,8 +1257,9 @@ export function freezeAndSeizeSubstandard(config) {
             const paramsIdx = findRefInputIndex(sortedRefInputs, utxoToTxInput(protocolParamsUtxo));
             // 0.5.x third-party route. `ThirdPartyAct` was DELETED by #110: the
             // administrative path is now the standalone `third_party` validator, and
-            // programmable_logic_base dispatches to it via SpendViaThirdParty — so
-            // this transaction never loads the `transfer` reference script at all.
+            // programmable_logic_base withdraws through the dispatcher, whose redeemer
+            // carries ThirdPartyAct — so this transaction never loads the `transfer`
+            // reference script at all.
             //
             // The withdrawal set is BOTH scripts: the framework delegate, and the
             // issuer authority the registry node names in
@@ -959,15 +1272,21 @@ export function freezeAndSeizeSubstandard(config) {
                 isScript: true,
             };
             const issuerAuthorityKey = { hash: scripts.issuerAdmin.hash, isScript: true };
-            const thirdPartyWdrlIdx = withdrawalIndexOf([thirdPartyKey, issuerAuthorityKey], thirdPartyKey);
+            // alpha.3: the DISPATCHER withdraws on every programmable transaction and
+            // PLB's wdrl_idx points at IT, not at the delegate.
+            const plan = plbWithdrawalPlan({
+                plgHash: ctx.standardScripts.programmableLogicGlobal.hash,
+                others: [thirdPartyKey, issuerAuthorityKey],
+            });
             // outputs_start_idx = 1: `third_party` PAIRS each programmable input with
             // the NEXT output (same address, datum and reference script, lovelace
             // ratcheting up) and reads the seized amount as the DELTA. Destination
             // outputs must therefore sit AMONG THE LEADING ones it skips.
             // See docs/api-reference.md — getting this backwards fails with an EMPTY
             // TRACE LIST, because it is a structural expect and not a traced check.
-            const plgRedeemer = thirdPartyRedeemer(paramsIdx, registryIdx, 1);
-            const plbSpendRedeemer = baseSpendRedeemer("THIRD_PARTY", paramsIdx, thirdPartyWdrlIdx);
+            // params_idx dropped: delegates no longer read the params datum.
+            const plgRedeemer = thirdPartyRedeemer(registryIdx, 1);
+            const plbSpendRedeemer = baseSpendRedeemer(paramsIdx, plan.plgIdx);
             const tokenDatum = voidData();
             // 5. Build recipient PLB address
             const recipientPlbAddr = baseAddress(networkId, plbHash, destinationAddress);
@@ -994,15 +1313,28 @@ export function freezeAndSeizeSubstandard(config) {
                 amount: 0n,
                 redeemer: voidData(),
             });
+            // The DISPATCHER's own withdraw-0 — new in alpha.3, required on every
+            // programmable transaction, and the entry PLB's wdrl_idx resolves to.
+            tx = tx.withdraw({
+                stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(ctx.standardScripts.programmableLogicGlobal.hash, "hex"))),
+                amount: 0n,
+                redeemer: programmableLogicGlobalRedeemer("THIRD_PARTY"),
+            });
             tx = tx.withdraw({
                 stakeCredential: Credential.makeScriptHash(new Uint8Array(Buffer.from(ctx.standardScripts.thirdParty.hash, "hex"))),
                 amount: 0n,
                 redeemer: plgRedeemer,
             });
+            const coinsPerUtxoByte = (await client.getProtocolParameters()).coinsPerUtxoByte;
             // Output 0: seized tokens to recipient
             tx = tx.payToAddress({
                 address: EvoAddress.fromBech32(recipientPlbAddr),
-                assets: outputAssets(1300000n, new Map([[unit, seizedAmount]])),
+                assets: outputAssets(minUtxoAtLeast(TOKEN_OUTPUT_FLOOR, {
+                    address: recipientPlbAddr,
+                    assets: outputAssets(0n, new Map([[unit, seizedAmount]])),
+                    datum: tokenDatum,
+                    coinsPerUtxoByte,
+                }), new Map([[unit, seizedAmount]])),
                 datum: new InlineDatum.InlineDatum({ data: tokenDatum }),
             });
             // Output 1: remaining value to original address
@@ -1026,6 +1358,12 @@ export function freezeAndSeizeSubstandard(config) {
                     "=== END SEIZE SCRIPTS ===");
             }
             tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicBase.compiledCode) });
+            // ⛔ THE DISPATCHER'S OWN SCRIPT WITNESS. A withdraw-0 needs the script in
+            // full, not just a redeemer — alpha.3 added the dispatcher's withdrawal to
+            // every programmable transaction, and S-6 wired the withdrawal and the
+            // redeemer but not this. The ledger says "An associated script witness is
+            // missing" on purpose=withdraw, which names the shape but not the script.
+            tx = tx.attachScript({ script: buildEvoScript(ctx.standardScripts.programmableLogicGlobal.compiledCode) });
             // ⚠ `third_party` is NOT attached here. Its withdrawal already carries the
             // script witness, and attaching it again makes the duplicate extraneous —
             // the ledger rejects the whole transaction with code 3104. MEASURED: the