@kaspacom/kcc20-tx-builder 0.4.0 → 0.5.0

package/src/snapshot-operation.ts

@@ -130,9 +130,6 @@ export interface Kcc20SnapshotBuilderOptions {
   transactionWithCalculatedFeeChange: (...args: any[]) => any;
 }
 
-export const SNAPSHOT_CANCEL_SINK_P2SH =
-  "d379e50f3e2203f9a92584916335bb7cd014b237ceaa8b36f1d3d80d0cc88b32";
-
 export function createKcc20SnapshotPsktBuilder(
   options: Kcc20SnapshotBuilderOptions,
 ): (input: unknown) => Promise<Record<string, unknown>> {
@@ -686,1246 +683,68 @@ export function createKcc20SnapshotPsktBuilder(
       ...common,
       shard,
       deploymentGuardCommitment: "01".repeat(32),
-    });
-    const peerPlans = allShards.slice(1).map((peer) => {
-      if (!peer.controllerId)
-        throw new Error(
-          "deploy shard zero only after every peer controller is indexed",
-        );
-      const plan = createSignerlessControllerPlan({
-        ...common,
-        shard: peer,
-        deploymentGuardCommitment: ZERO_HASH,
-      });
-      return { controllerId: peer.controllerId, state: plan.controllerState };
-    });
-    const guard = snapshotPeerPlanCommitment({
-      migrationCommitment: common.migrationCommitment,
-      manifestCommitment: common.manifestCommitment,
-      shards: [
-        { controllerId: "01".repeat(32), state: provisional.controllerState },
-        ...peerPlans,
-      ],
-    });
-    return createSignerlessControllerPlan({
-      ...common,
-      shard,
-      deploymentGuardCommitment: guard,
-    });
-  }
-
-  function normalizedSignerlessShards(values) {
-    if (!Array.isArray(values) || values.length < 1 || values.length > 8) {
-      throw new Error("signerless snapshot requires 1..8 ordered shards");
-    }
-    const shards = values.map((value) => ({
-      ...snapshotShard(value),
-      controllerId: value?.controllerId
-        ? requireHex32(value.controllerId, "controller id")
-        : undefined,
-      controllerSource: value?.controllerSource,
-    }));
-    shards.sort((left, right) => left.shardIndex - right.shardIndex);
-    if (shards.some((shard, index) => shard.shardIndex !== index)) {
-      throw new Error(
-        "signerless snapshot shards must be contiguous from zero",
-      );
-    }
-    return shards;
-  }
-
-  function portableInput(entry, network, script) {
-    return {
-      previousOutpoint: entry.outpoint,
-      utxo: entry,
-      networkId: network,
-      ...(script ? { script } : {}),
-    };
-  }
-
-  function outpointOfSource(source, label) {
-    return {
-      transactionId: requireHex32(source?.txidHex, `${label} txid`),
-      index: unsignedInteger(source?.vout, `${label} vout`),
-    };
-  }
-
-  async function buildBootstrapCancellation(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const artifacts = await readPinnedArtifacts(
-      params.artifactPins,
-      false,
-      true,
-    );
-    const template = templateParts(artifacts.kcc20);
-    const base = bootstrapBaseState(params, template);
-    const migrationId = requireHex32(params.migrationId, "migration ID");
-    const bootstrapId = requireHex32(params.bootstrapId, "bootstrap ID");
-    const phase = String(params.bootstrapPhase || "").toUpperCase();
-    if (!["UNBOUND", "TOKEN_BOUND", "SEALED"].includes(phase)) {
-      throw new Error(
-        "bootstrap cancellation phase is not terminally cancellable",
-      );
-    }
-    const bound = phase !== "UNBOUND";
-    const tokenId = bound
-      ? requireHex32(params.tokenId, "token ID")
-      : ZERO_HASH;
-    const beforeState = {
-      ...base,
-      phase: phase === "UNBOUND" ? 0n : phase === "TOKEN_BOUND" ? 1n : 2n,
-      tokenId: hexToBytes(tokenId),
-      shardPlanCommitment:
-        phase === "SEALED"
-          ? hexToBytes(
-              requireHex32(
-                params.bootstrapShardPlanCommitment,
-                "bootstrap shard plan commitment",
-              ),
-            )
-          : hexToBytes(ZERO_HASH),
-      activationDigest:
-        phase === "SEALED"
-          ? hexToBytes(
-              requireHex32(
-                params.bootstrapActivationDigest,
-                "bootstrap activation digest",
-              ),
-            )
-          : hexToBytes(ZERO_HASH),
-      shardCount:
-        phase === "SEALED"
-          ? positiveI64(params.bootstrapShardCount, "bootstrap shard count")
-          : 0n,
-    };
-    if (beforeState.shardCount > 8n) {
-      throw new Error("bootstrap cancellation shard count exceeds policy");
-    }
-    const bootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      beforeState,
-    );
-    const bootstrapSource = sourceDescriptor(
-      params.bootstrapSource,
-      "bootstrap source",
-      scriptAddress(bootstrapScript, network),
-    );
-    const tokenState = bound
-      ? kcc20State(params.tokenSource?.state)
-      : undefined;
-    if (
-      tokenState &&
-      (tokenState.amount !== base.totalSupply ||
-        tokenState.ownerScheme !== 4 ||
-        bytesToHex(tokenState.owner) !== bootstrapId ||
-        bytesToHex(tokenState.extensionCommitment) !==
-          bytesToHex(base.holderExtensionCommitment))
-    ) {
-      throw new Error("bootstrap cancellation token source does not match");
-    }
-    const tokenScript = tokenState
-      ? buildKcc20ScriptForState(artifacts.kcc20, tokenState)
-      : undefined;
-    const tokenSource = tokenScript
-      ? sourceDescriptor(
-          params.tokenSource,
-          "token source",
-          scriptAddress(tokenScript, network),
-        )
-      : undefined;
-    if (!bound && params.tokenSource != null) {
-      throw new Error(
-        "unbound bootstrap cancellation must not include a token",
-      );
-    }
-    const sinkTokenState = tokenState
-      ? {
-          amount: base.totalSupply,
-          owner: hexToBytes(SNAPSHOT_CANCEL_SINK_P2SH),
-          ownerScheme: 3,
-          borrowScheme: 0,
-          borrowGuard: hexToBytes(ZERO_HASH),
-          extensionCommitment: base.holderExtensionCommitment,
-        }
-      : undefined;
-    const sinkTokenScript = sinkTokenState
-      ? buildKcc20ScriptForState(artifacts.kcc20, sinkTokenState)
-      : undefined;
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const bootstrapPromise = rpc.getUtxosByAddresses({
-        addresses: [bootstrapSource.address],
-      });
-      const tokenPromise = tokenSource
-        ? rpc.getUtxosByAddresses({ addresses: [tokenSource.address] })
-        : Promise.resolve({ entries: [] });
-      const [bootstrapUtxos, tokenUtxos, walletUtxos] = await Promise.all([
-        bootstrapPromise,
-        tokenPromise,
-        rpc.getUtxosByAddresses({ addresses: [walletAddress] }),
-      ]);
-      const bootstrapEntry = findExactEntry(
-        bootstrapUtxos.entries,
-        bootstrapSource,
-      );
-      assertCovenantSource(bootstrapEntry, {
-        covenantId: bootstrapId,
-        script: bootstrapScript,
-        amount: base.bootstrapCellKas,
-        label: "bootstrap cancellation source",
-      });
-      const tokenEntry = tokenSource
-        ? findExactEntry(tokenUtxos.entries, tokenSource)
-        : undefined;
-      if (tokenEntry) {
-        assertCovenantSource(tokenEntry, {
-          covenantId: tokenId,
-          script: tokenScript,
-          amount: base.tokenCellKas,
-          label: "bootstrap cancellation token",
-        });
-      }
-      const consumed = [bootstrapEntry, ...(tokenEntry ? [tokenEntry] : [])];
-      const fundingEntry = selectFundingEntry(
-        withoutOutpoints(
-          walletUtxos.entries,
-          consumed.map(({ outpoint }) => outpoint),
-        ),
-        priorityFee() + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = [];
-      if (sinkTokenScript) {
-        outputs.push(
-          new kaspaWasm.TransactionOutput(
-            base.tokenCellKas,
-            kaspaWasm.payToScriptHashScript(sinkTokenScript),
-            new kaspaWasm.CovenantBinding(1, new kaspaWasm.Hash(tokenId)),
-          ),
-        );
-      }
-      const sinkOutputIndex = outputs.length;
-      outputs.push(
-        new kaspaWasm.TransactionOutput(
-          base.bootstrapCellKas,
-          kaspaWasm.payToScriptHashScript(Uint8Array.of(0x6a)),
-        ),
-      );
-      const fundingChangeOutputIndex = appendFundingChange(
-        outputs,
-        [...consumed, fundingEntry],
-        walletAddress,
-        base.bootstrapCellKas + (bound ? base.tokenCellKas : 0n),
-        priorityFee(),
-      );
-      const inputs = [
-        covenantInput(bootstrapEntry, BOOTSTRAP_COMPUTE_BUDGET),
-        ...(tokenEntry
-          ? [covenantInput(tokenEntry, KCC20_COMPUTE_BUDGET)]
-          : []),
-        publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET),
-      ];
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs,
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: "",
-      });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.inputs[0].computeBudget = BOOTSTRAP_COMPUTE_BUDGET;
-      if (tokenEntry) {
-        transaction.inputs[1].computeBudget = KCC20_COMPUTE_BUDGET;
-      }
-      const recipes = bootstrapApprovalRecipes(
-        bytesToHex(bootstrapScript),
-        bootstrapCancellationArgs(
-          artifacts,
-          bound,
-          sinkOutputIndex,
-          sinkTokenState,
-        ),
-      );
-      transaction.inputs[0].signatureScript = encodeP2sh(
-        signatureScriptArgsBytes(recipes.placeholder.args),
-        bootstrapScript,
-      );
-      if (tokenEntry && tokenScript && sinkTokenState) {
-        transaction.inputs[1].signatureScript = encodeP2sh(
-          buildKcc20TransferSigScript(kaspaWasm, artifacts.kcc20, {
-            nextStates: [sinkTokenState],
-            witness: Uint8Array.of(0),
-          }),
-          tokenScript,
-        );
-      }
-      const fundingInputIndex = inputs.length - 1;
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        fundingChangeOutputIndex,
-        network,
-        "snapshot bootstrap cancellation",
-        [recipes.approval],
-      );
-      return outputEnvelope(
-        adjusted,
-        [{ index: fundingInputIndex }],
-        [recipes.approval],
-        {
-          migrationId,
-          stage: "bootstrap-cancel",
-          bootstrapId,
-          ...(bound ? { tokenId } : {}),
-          cancellationMode: bound ? "BOUND" : "UNBOUND",
-          cancellationSinkP2sh: SNAPSHOT_CANCEL_SINK_P2SH,
-          bootstrapState: {
-            ...bootstrapStateReceipt(beforeState),
-            phase,
-          },
-          bootstrapOutcome: "CANCELLED",
-          maximumFeeSompi: feeOf(adjusted).toString(),
-          intentInputs: [
-            {
-              role: "snapshot-bootstrap",
-              index: 0,
-              covenantId: bootstrapId,
-              revealScriptHex: bytesToHex(bootstrapScript),
-            },
-            ...(tokenEntry && tokenScript
-              ? [
-                  {
-                    role: "fixed-supply-token",
-                    index: 1,
-                    covenantId: tokenId,
-                    revealScriptHex: bytesToHex(tokenScript),
-                    staticSignatureScriptHex: signatureScriptHex(adjusted, 1),
-                  },
-                ]
-              : []),
-            { role: "creator-funding", index: fundingInputIndex },
-          ],
-          intentOutputs: [
-            ...(sinkTokenScript && sinkTokenState
-              ? [
-                  {
-                    role: "cancelled-token",
-                    index: 0,
-                    covenantId: tokenId,
-                    revealScriptHex: bytesToHex(sinkTokenScript),
-                    owner: SNAPSHOT_CANCEL_SINK_P2SH,
-                    ownerScheme: 3,
-                    borrowScheme: 0,
-                    borrowGuard: ZERO_HASH,
-                    extensionCommitment: bytesToHex(
-                      sinkTokenState.extensionCommitment,
-                    ),
-                    tokenAmount: sinkTokenState.amount.toString(),
-                  },
-                ]
-              : []),
-            {
-              role: "cancellation-sink",
-              index: sinkOutputIndex,
-              revealScriptHex: "6a",
-            },
-          ],
-        },
-      );
-    } finally {
-      await rpc.disconnect();
-    }
-  }
-
-  async function buildBootstrapBind(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const artifacts = await readPinnedArtifacts(
-      params.artifactPins,
-      false,
-      true,
-    );
-    const template = templateParts(artifacts.kcc20);
-    const base = bootstrapBaseState(params, template);
-    const bootstrapId = requireHex32(params.bootstrapId, "bootstrap ID");
-    const tokenId = requireHex32(params.tokenId, "token ID");
-    const tokenState = kcc20State(params.tokenSource?.state);
-    if (
-      tokenState.amount !== base.totalSupply ||
-      tokenState.ownerScheme !== 4 ||
-      bytesToHex(tokenState.owner) !== bootstrapId ||
-      bytesToHex(tokenState.extensionCommitment) !==
-        bytesToHex(base.holderExtensionCommitment)
-    ) {
-      throw new Error(
-        "bootstrap bind token source does not match the migration",
-      );
-    }
-    const beforeState = {
-      ...base,
-      phase: 0n,
-      tokenId: hexToBytes(ZERO_HASH),
-      shardPlanCommitment: hexToBytes(ZERO_HASH),
-      activationDigest: hexToBytes(ZERO_HASH),
-      shardCount: 0n,
-    };
-    const afterState = {
-      ...base,
-      phase: 1n,
-      tokenId: hexToBytes(tokenId),
-      shardPlanCommitment: hexToBytes(ZERO_HASH),
-      activationDigest: hexToBytes(ZERO_HASH),
-      shardCount: 0n,
-    };
-    const bootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      beforeState,
-    );
-    const nextBootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      afterState,
-    );
-    const tokenScript = buildKcc20ScriptForState(artifacts.kcc20, tokenState);
-    const bootstrapSource = sourceDescriptor(
-      params.bootstrapSource,
-      "bootstrap source",
-      scriptAddress(bootstrapScript, network),
-    );
-    const tokenSource = sourceDescriptor(
-      params.tokenSource,
-      "token source",
-      scriptAddress(tokenScript, network),
-    );
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const [bootstrapUtxos, tokenUtxos, walletUtxos] = await Promise.all([
-        rpc.getUtxosByAddresses({ addresses: [bootstrapSource.address] }),
-        rpc.getUtxosByAddresses({ addresses: [tokenSource.address] }),
-        rpc.getUtxosByAddresses({ addresses: [walletAddress] }),
-      ]);
-      const bootstrapEntry = findExactEntry(
-        bootstrapUtxos.entries,
-        bootstrapSource,
-      );
-      assertCovenantSource(bootstrapEntry, {
-        covenantId: bootstrapId,
-        script: bootstrapScript,
-        amount: base.bootstrapCellKas,
-        label: "bootstrap bind source",
-      });
-      const tokenEntry = findExactEntry(tokenUtxos.entries, tokenSource);
-      assertCovenantSource(tokenEntry, {
-        covenantId: tokenId,
-        script: tokenScript,
-        amount: base.tokenCellKas,
-        label: "bootstrap bind token source",
-      });
-      const fundingEntry = selectFundingEntry(
-        withoutOutpoints(walletUtxos.entries, [
-          bootstrapEntry.outpoint,
-          tokenEntry.outpoint,
-        ]),
-        priorityFee() + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = [
-        new kaspaWasm.TransactionOutput(
-          base.tokenCellKas,
-          kaspaWasm.payToScriptHashScript(tokenScript),
-          new kaspaWasm.CovenantBinding(1, new kaspaWasm.Hash(tokenId)),
-        ),
-        new kaspaWasm.TransactionOutput(
-          base.bootstrapCellKas,
-          kaspaWasm.payToScriptHashScript(nextBootstrapScript),
-          new kaspaWasm.CovenantBinding(0, new kaspaWasm.Hash(bootstrapId)),
-        ),
-      ];
-      const fundingChangeOutputIndex = appendFundingChange(
-        outputs,
-        [bootstrapEntry, tokenEntry, fundingEntry],
-        walletAddress,
-        base.tokenCellKas + base.bootstrapCellKas,
-        priorityFee(),
-      );
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs: [
-          covenantInput(bootstrapEntry, BOOTSTRAP_COMPUTE_BUDGET),
-          covenantInput(tokenEntry, KCC20_COMPUTE_BUDGET),
-          publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET),
-        ],
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: "",
-      });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.inputs[0].computeBudget = BOOTSTRAP_COMPUTE_BUDGET;
-      transaction.inputs[1].computeBudget = KCC20_COMPUTE_BUDGET;
-      const recipes = bootstrapApprovalRecipes(
-        bytesToHex(bootstrapScript),
-        bootstrapBindArgs(artifacts, afterState, tokenState),
-      );
-      transaction.inputs[0].signatureScript = encodeP2sh(
-        signatureScriptArgsBytes(recipes.placeholder.args),
-        bootstrapScript,
-      );
-      transaction.inputs[1].signatureScript = encodeP2sh(
-        buildKcc20TransferSigScript(kaspaWasm, artifacts.kcc20, {
-          nextStates: [tokenState],
-          witness: Uint8Array.of(0),
-        }),
-        tokenScript,
-      );
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        fundingChangeOutputIndex,
-        network,
-        "snapshot bootstrap bind",
-        [recipes.approval],
-      );
-      return outputEnvelope(adjusted, [{ index: 2 }], [recipes.approval], {
-        migrationId: requireHex32(params.migrationId, "migration ID"),
-        stage: "bootstrap-bind",
-        tokenId,
-        bootstrapId,
-        bootstrapState: {
-          ...bootstrapStateReceipt(afterState),
-          phase: "TOKEN_BOUND",
-        },
-        maximumFeeSompi: feeOf(adjusted).toString(),
-        intentInputs: [
-          {
-            role: "snapshot-bootstrap",
-            index: 0,
-            covenantId: bootstrapId,
-            revealScriptHex: bytesToHex(bootstrapScript),
-          },
-          {
-            role: "fixed-supply-token",
-            index: 1,
-            covenantId: tokenId,
-            revealScriptHex: bytesToHex(tokenScript),
-            staticSignatureScriptHex: signatureScriptHex(adjusted, 1),
-          },
-          { role: "creator-funding", index: 2 },
-        ],
-        intentOutputs: [
-          {
-            role: "fixed-supply-token",
-            index: 0,
-            covenantId: tokenId,
-            revealScriptHex: bytesToHex(tokenScript),
-            owner: bootstrapId,
-            ownerScheme: 4,
-            borrowScheme: 0,
-            borrowGuard: bytesToHex(tokenState.borrowGuard),
-            extensionCommitment: bytesToHex(tokenState.extensionCommitment),
-            tokenAmount: tokenState.amount.toString(),
-          },
-          {
-            role: "snapshot-bootstrap",
-            index: 1,
-            covenantId: bootstrapId,
-            revealScriptHex: bytesToHex(nextBootstrapScript),
-          },
-        ],
-      });
-    } finally {
-      await rpc.disconnect();
-    }
-  }
-
-  async function buildBootstrapSeal(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const artifacts = await readPinnedArtifacts(
-      params.artifactPins,
-      false,
-      true,
-    );
-    const template = templateParts(artifacts.kcc20);
-    const base = bootstrapBaseState(params, template);
-    const migrationId = requireHex32(params.migrationId, "migration ID");
-    const bootstrapId = requireHex32(params.bootstrapId, "bootstrap ID");
-    const tokenId = requireHex32(params.tokenId, "token ID");
-    const shards = reserveShards(params.shards, base.totalSupply);
-    const shardPlanCommitment = snapshotShardPlanCommitment({
-      migrationCommitment: migrationId,
-      manifestCommitment: bytesToHex(base.manifestCommitment),
-      tokenId,
-      totalSupply: base.totalSupply,
-      shards,
-    });
-    const beforeState = {
-      ...base,
-      phase: 1n,
-      tokenId: hexToBytes(tokenId),
-      shardPlanCommitment: hexToBytes(ZERO_HASH),
-      activationDigest: hexToBytes(ZERO_HASH),
-      shardCount: 0n,
-    };
-    const afterState = {
-      ...base,
-      phase: 2n,
-      tokenId: hexToBytes(tokenId),
-      shardPlanCommitment: hexToBytes(shardPlanCommitment),
-      activationDigest: hexToBytes(
-        requireHex32(params.activationDigest, "activation digest"),
-      ),
-      shardCount: BigInt(shards.length),
-    };
-    const bootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      beforeState,
-    );
-    const nextBootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      afterState,
-    );
-    const bootstrapSource = sourceDescriptor(
-      params.bootstrapSource,
-      "bootstrap source",
-      scriptAddress(bootstrapScript, network),
-    );
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const [bootstrapUtxos, walletUtxos] = await Promise.all([
-        rpc.getUtxosByAddresses({ addresses: [bootstrapSource.address] }),
-        rpc.getUtxosByAddresses({ addresses: [walletAddress] }),
-      ]);
-      const bootstrapEntry = findExactEntry(
-        bootstrapUtxos.entries,
-        bootstrapSource,
-      );
-      assertCovenantSource(bootstrapEntry, {
-        covenantId: bootstrapId,
-        script: bootstrapScript,
-        amount: base.bootstrapCellKas,
-        label: "bootstrap seal source",
-      });
-      const fundingEntry = selectFundingEntry(
-        withoutOutpoints(walletUtxos.entries, [bootstrapEntry.outpoint]),
-        priorityFee() + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = [
-        new kaspaWasm.TransactionOutput(
-          base.bootstrapCellKas,
-          kaspaWasm.payToScriptHashScript(nextBootstrapScript),
-          new kaspaWasm.CovenantBinding(0, new kaspaWasm.Hash(bootstrapId)),
-        ),
-      ];
-      const fundingChangeOutputIndex = appendFundingChange(
-        outputs,
-        [bootstrapEntry, fundingEntry],
-        walletAddress,
-        base.bootstrapCellKas,
-        priorityFee(),
-      );
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs: [
-          covenantInput(bootstrapEntry, BOOTSTRAP_COMPUTE_BUDGET),
-          publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET),
-        ],
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: "",
-      });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.inputs[0].computeBudget = BOOTSTRAP_COMPUTE_BUDGET;
-      const recipes = bootstrapApprovalRecipes(
-        bytesToHex(bootstrapScript),
-        bootstrapSealArgs(artifacts, afterState),
-      );
-      transaction.inputs[0].signatureScript = encodeP2sh(
-        signatureScriptArgsBytes(recipes.placeholder.args),
-        bootstrapScript,
-      );
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        fundingChangeOutputIndex,
-        network,
-        "snapshot bootstrap seal",
-        [recipes.approval],
-      );
-      return outputEnvelope(adjusted, [{ index: 1 }], [recipes.approval], {
-        migrationId,
-        stage: "bootstrap-seal",
-        tokenId,
-        bootstrapId,
-        bootstrapState: {
-          ...bootstrapStateReceipt(afterState),
-          phase: "SEALED",
-        },
-        shardPlanCommitment,
-        activationDigest: bytesToHex(afterState.activationDigest),
-        shards: shards.map((shard) => shard.shardIndex),
-        maximumFeeSompi: feeOf(adjusted).toString(),
-        intentInputs: [
-          {
-            role: "snapshot-bootstrap",
-            index: 0,
-            covenantId: bootstrapId,
-            revealScriptHex: bytesToHex(bootstrapScript),
-          },
-          { role: "creator-funding", index: 1 },
-        ],
-        intentOutputs: [
-          {
-            role: "snapshot-bootstrap",
-            index: 0,
-            covenantId: bootstrapId,
-            revealScriptHex: bytesToHex(nextBootstrapScript),
-          },
-        ],
-      });
-    } finally {
-      await rpc.disconnect();
-    }
-  }
-
-  async function buildBootstrapGenesis(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const [kcc20, bootstrap] = await Promise.all([
-      readPinnedArtifact(
-        KCC20_ARTIFACT_PATH,
-        params.artifactPins?.kcc20ArtifactSha256,
-        "KCC20",
-      ),
-      readPinnedArtifact(
-        BOOTSTRAP_ARTIFACT_PATH,
-        params.artifactPins?.bootstrapArtifactSha256,
-        "KCC20SnapshotBootstrap",
-      ),
-    ]);
-    const template = templateParts(kcc20);
-    const expectedTemplateHash = requireHex32(
-      params.expectedKcc20TemplateHash,
-      "KCC20 template hash",
-    );
-    if (bytesToHex(template.hash) !== expectedTemplateHash) {
-      throw new Error("KCC20 template hash does not match the migration pin");
-    }
-    const approvalKey = requireHex32(
-      params.approvalKey ?? params.approvalKeyA,
-      "approval key",
-    );
-    if (approvalKey === ZERO_HASH) {
-      throw new Error("bootstrap approval key must be nonzero");
-    }
-    const state = {
-      migrationCommitment: hexToBytes(
-        requireHex32(params.migrationCommitment, "migration commitment"),
-      ),
-      manifestCommitment: hexToBytes(
-        requireHex32(params.manifestCommitment, "manifest commitment"),
-      ),
-      holderExtensionCommitment: hexToBytes(
-        requireHex32(
-          params.holderExtensionCommitment,
-          "holder extension commitment",
-        ),
-      ),
-      totalSupply: positiveI64(params.totalSupply, "total supply"),
-      claimNotBeforeDaaScore: positiveI64(
-        params.claimNotBeforeDaaScore,
-        "claim-not-before DAA score",
-      ),
-      kcc20TemplateHash: hexToBytes(expectedTemplateHash),
-      kcc20TemplatePrefixLen: BigInt(template.prefix.length),
-      kcc20TemplateSuffixLen: BigInt(template.suffix.length),
-      tokenCellKas: minimumCell(params.tokenCellKas, "token cell KAS"),
-      reserveCellKas: minimumCell(params.reserveCellKas, "reserve cell KAS"),
-      bootstrapCellKas: minimumCell(
-        params.bootstrapCellKas,
-        "bootstrap cell KAS",
-      ),
-      approvalKey: hexToBytes(approvalKey),
-      phase: 0n,
-      tokenId: hexToBytes(ZERO_HASH),
-      shardPlanCommitment: hexToBytes(ZERO_HASH),
-      activationDigest: hexToBytes(ZERO_HASH),
-      shardCount: 0n,
-    };
-    if (state.claimNotBeforeDaaScore >= 500_000_000_000n) {
-      throw new Error("claim-not-before must use DAA-score locktime mode");
-    }
-    const bootstrapScript = buildSnapshotBootstrapScriptForState(
-      bootstrap,
-      state,
-    );
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const walletUtxos = await rpc.getUtxosByAddresses({
-        addresses: [walletAddress],
-      });
-      const fundingEntry = selectFundingEntry(
-        walletUtxos.entries,
-        state.bootstrapCellKas + priorityFee() + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = [
-        new kaspaWasm.TransactionOutput(
-          state.bootstrapCellKas,
-          kaspaWasm.payToScriptHashScript(bootstrapScript),
-        ),
-      ];
-      const changeIndex = appendFundingChange(
-        outputs,
-        [fundingEntry],
-        walletAddress,
-        state.bootstrapCellKas,
-        priorityFee(),
-      );
-      const stateReceipt = bootstrapStateReceipt(state);
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs: [publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET)],
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: bytesToHex(
-          new TextEncoder().encode(
-            JSON.stringify({
-              tn10: {
-                v: 1,
-                tmpl: "KCC20SnapshotBootstrap",
-                args: [
-                  {
-                    name: "bootstrapState",
-                    type: "object",
-                    value: stateReceipt,
-                  },
-                ],
-              },
-            }),
-          ),
-        ),
-      });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.populateGenesisCovenants([
-        new kaspaWasm.GenesisCovenantGroup(0, [0]),
-      ]);
-      transaction.finalize();
-      const covenantId = requireHex32(
-        transaction.outputs[0]?.covenant?.covenantId?.toString(),
-        "bootstrap covenant id",
-      );
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        changeIndex,
-        network,
-        "snapshot bootstrap genesis",
-      );
-      return outputEnvelope(adjusted, [{ index: 0 }], [], {
-        migrationId: requireHex32(params.migrationId, "migration id"),
-        stage: "bootstrap-deploy",
-        covenantId,
-        bootstrapState: { ...stateReceipt, phase: "UNBOUND" },
-        maximumFeeSompi: feeOf(adjusted).toString(),
-        intentInputs: [{ role: "creator-funding", index: 0 }],
-        intentOutputs: [
-          {
-            role: "snapshot-bootstrap",
-            index: 0,
-            covenantId,
-            revealScriptHex: bytesToHex(bootstrapScript),
-          },
-        ],
-      });
-    } finally {
-      await rpc.disconnect();
-    }
-  }
-
-  async function buildControllerGenesis(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const artifacts = await readPinnedArtifacts(params.artifactPins, true);
-    const definition = snapshotDefinition(params, artifacts);
-    const controllerState = initialControllerState(definition);
-    const controllerScript = buildSnapshotControllerScriptForState(
-      artifacts.controller,
-      controllerState,
-    );
-    const outputSompi = definition.controllerCellKas;
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const walletUtxos = await rpc.getUtxosByAddresses({
-        addresses: [walletAddress],
-      });
-      const fundingEntry = selectFundingEntry(
-        walletUtxos.entries,
-        outputSompi + priorityFee() + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = [
-        new kaspaWasm.TransactionOutput(
-          outputSompi,
-          kaspaWasm.payToScriptHashScript(controllerScript),
-        ),
-      ];
-      const fundingChangeOutputIndex = appendFundingChange(
-        outputs,
-        [fundingEntry],
-        walletAddress,
-        outputSompi,
-        priorityFee(),
-      );
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs: [publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET)],
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: controllerDeploymentPayload(definition, controllerState),
-      });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.populateGenesisCovenants([
-        new kaspaWasm.GenesisCovenantGroup(0, [0]),
-      ]);
-      transaction.finalize();
-      const controllerId = requireHex32(
-        transaction.outputs[0]?.covenant?.covenantId?.toString(),
-        "controller covenant id",
-      );
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        fundingChangeOutputIndex,
-        network,
-        "snapshot controller genesis",
-      );
-      return outputEnvelope(adjusted, [{ index: 0 }], [], {
-        migrationId: definition.migrationId,
-        stage: "controller-deploy",
-        controllerId,
-        shard: definition.shard.shardIndex,
-        controllerStateCommitment:
-          snapshotControllerStateCommitment(controllerState),
-        holderExtensionCommitment: definition.holderExtensionCommitment,
-        maximumFeeSompi: feeOf(adjusted).toString(),
-        intentInputs: [{ role: "creator-funding", index: 0 }],
-        intentOutputs: [
-          {
-            role: "snapshot-controller",
-            index: 0,
-            shard: definition.shard.shardIndex,
-            covenantId: controllerId,
-            revealScriptHex: bytesToHex(controllerScript),
-          },
-        ],
-      });
-    } finally {
-      await rpc.disconnect();
-    }
-  }
-
-  async function buildReserveHandoff(input) {
-    const request = input.request || {};
-    const params = request.params || {};
-    const network = networkOf(request);
-    const walletAddress = walletAddressOf(request);
-    const migrationId = requireHex32(params.migrationId, "migration id");
-    const artifacts = await readPinnedArtifacts(
-      params.artifactPins,
-      false,
-      true,
-    );
-    const bootstrapId = requireHex32(
-      params.bootstrapId,
-      "bootstrap covenant id",
-    );
-    const tokenId = requireHex32(params.tokenId, "token covenant id");
-    const extensionCommitment = requireHex32(
-      params.holderExtensionCommitment,
-      "holder extension commitment",
-    );
-    const totalSupply = positiveI64(params.totalSupply, "total supply");
-    const tokenState = kcc20State(params.tokenSource?.state);
-    if (
-      tokenState.amount !== totalSupply ||
-      tokenState.ownerScheme !== 4 ||
-      bytesToHex(tokenState.owner) !== bootstrapId ||
-      bytesToHex(tokenState.extensionCommitment) !== extensionCommitment
-    ) {
-      throw new Error(
-        "reserve handoff token source does not match the migration",
-      );
-    }
-    const shards = reserveShards(params.shards, totalSupply);
-    const template = templateParts(artifacts.kcc20);
-    const expectedTemplateHash = requireHex32(
-      params.kcc20TemplateHash,
-      "KCC20 template hash",
-    );
-    if (bytesToHex(template.hash) !== expectedTemplateHash) {
-      throw new Error("KCC20 template hash does not match the migration pin");
-    }
-    const shardPlanCommitment = snapshotShardPlanCommitment({
-      migrationCommitment: migrationId,
-      manifestCommitment: requireHex32(
-        params.manifestCommitment,
-        "manifest commitment",
-      ),
-      tokenId,
-      totalSupply,
-      shards,
-    });
-    if (
-      shardPlanCommitment !==
-      requireHex32(
-        params.bootstrapShardPlanCommitment,
-        "bootstrap shard plan commitment",
-      )
-    ) {
-      throw new Error("activation shards do not match the sealed bootstrap");
-    }
-    const bootstrapState = {
-      migrationCommitment: hexToBytes(migrationId),
-      manifestCommitment: hexToBytes(
-        requireHex32(params.manifestCommitment, "manifest commitment"),
-      ),
-      holderExtensionCommitment: hexToBytes(extensionCommitment),
-      totalSupply,
-      claimNotBeforeDaaScore: positiveI64(
-        params.claimNotBeforeDaaScore,
-        "claim-not-before DAA score",
-      ),
-      kcc20TemplateHash: hexToBytes(expectedTemplateHash),
-      kcc20TemplatePrefixLen: BigInt(template.prefix.length),
-      kcc20TemplateSuffixLen: BigInt(template.suffix.length),
-      tokenCellKas: minimumCell(params.tokenCellKas, "token cell KAS"),
-      reserveCellKas: minimumCell(params.reserveCellKas, "reserve cell KAS"),
-      bootstrapCellKas: minimumCell(
-        params.bootstrapCellKas,
-        "bootstrap cell KAS",
-      ),
-      approvalKey: hexToBytes(
-        requireHex32(params.approvalKey ?? params.approvalKeyA, "approval key"),
-      ),
-      phase: 2n,
-      tokenId: hexToBytes(tokenId),
-      shardPlanCommitment: hexToBytes(shardPlanCommitment),
-      activationDigest: hexToBytes(
-        requireHex32(
-          params.bootstrapActivationDigest,
-          "bootstrap activation digest",
-        ),
-      ),
-      shardCount: BigInt(shards.length),
-    };
-    const bootstrapScript = buildSnapshotBootstrapScriptForState(
-      artifacts.bootstrap,
-      bootstrapState,
-    );
-    const bootstrapAddress = scriptAddress(bootstrapScript, network);
-    const bootstrapSource = sourceDescriptor(
-      params.bootstrapSource,
-      "bootstrap source",
-      bootstrapAddress,
-    );
-    const tokenScript = buildKcc20ScriptForState(artifacts.kcc20, tokenState);
-    const tokenAddress = scriptAddress(tokenScript, network);
-    const tokenSource = sourceDescriptor(
-      params.tokenSource,
-      "token source",
-      tokenAddress,
-    );
-    const nextStates = shards.map((shard) => ({
-      amount: shard.allocationTotal,
-      owner: hexToBytes(shard.controllerId),
-      ownerScheme: 4,
-      borrowScheme: 0,
-      borrowGuard: hexToBytes(ZERO_HASH),
-      extensionCommitment: hexToBytes(extensionCommitment),
-    }));
-    const rpc = rpcFor(network);
-    await rpc.connect();
-    try {
-      const [bootstrapUtxos, tokenUtxos, walletUtxos] = await Promise.all([
-        rpc.getUtxosByAddresses({ addresses: [bootstrapAddress] }),
-        rpc.getUtxosByAddresses({ addresses: [tokenAddress] }),
-        rpc.getUtxosByAddresses({ addresses: [walletAddress] }),
-      ]);
-      const bootstrapEntry = findExactEntry(
-        bootstrapUtxos.entries,
-        bootstrapSource,
-      );
-      assertCovenantSource(bootstrapEntry, {
-        covenantId: bootstrapId,
-        script: bootstrapScript,
-        amount: bootstrapState.bootstrapCellKas,
-        label: "reserve activation bootstrap source",
-      });
-      const tokenEntry = findExactEntry(tokenUtxos.entries, tokenSource);
-      assertCovenantSource(tokenEntry, {
-        covenantId: tokenId,
-        script: tokenScript,
-        amount: bootstrapState.tokenCellKas,
-        label: "reserve handoff token source",
-      });
-      const fundingEntry = selectFundingEntry(
-        withoutOutpoints(walletUtxos.entries, [
-          bootstrapEntry.outpoint,
-          tokenEntry.outpoint,
-        ]),
-        priorityFee() + DEFAULT_CELL_SOMPI * BigInt(shards.length) + 10_000n,
-        [],
-        params.fundingOutpoint,
-      );
-      const outputs = nextStates.map(
-        (state) =>
-          new kaspaWasm.TransactionOutput(
-            positiveI64(
-              params.reserveCellKas ?? DEFAULT_CELL_SOMPI,
-              "reserve cell KAS",
-            ),
-            kaspaWasm.payToScriptHashScript(
-              buildKcc20ScriptForState(artifacts.kcc20, state),
-            ),
-            new kaspaWasm.CovenantBinding(1, new kaspaWasm.Hash(tokenId)),
-          ),
-      );
-      const outputSompi = outputs.reduce(
-        (sum, output) => sum + BigInt(output.value),
-        0n,
-      );
-      const fundingChangeOutputIndex = appendFundingChange(
-        outputs,
-        [bootstrapEntry, tokenEntry, fundingEntry],
-        walletAddress,
-        outputSompi,
-        priorityFee(),
-      );
-      const transaction = new kaspaWasm.Transaction({
-        version: 1,
-        lockTime: 0n,
-        inputs: [
-          covenantInput(bootstrapEntry, BOOTSTRAP_COMPUTE_BUDGET),
-          covenantInput(tokenEntry, KCC20_COMPUTE_BUDGET),
-          publicInput(fundingEntry, PUBLIC_INPUT_COMPUTE_BUDGET),
-        ],
-        outputs,
-        subnetworkId: NATIVE_SUBNETWORK_ID,
-        gas: 0n,
-        payload: "",
+    });
+    const peerPlans = allShards.slice(1).map((peer) => {
+      if (!peer.controllerId)
+        throw new Error(
+          "deploy shard zero only after every peer controller is indexed",
+        );
+      const plan = createSignerlessControllerPlan({
+        ...common,
+        shard: peer,
+        deploymentGuardCommitment: ZERO_HASH,
       });
-      setVersionOneInputMassFields(transaction, PUBLIC_INPUT_COMPUTE_BUDGET);
-      transaction.inputs[0].computeBudget = BOOTSTRAP_COMPUTE_BUDGET;
-      transaction.inputs[1].computeBudget = KCC20_COMPUTE_BUDGET;
-      const bootstrapPrefix = new kaspaWasm.ScriptBuilder();
-      for (const field of encodeKcc20StateRecordArrays(nextStates)) {
-        bootstrapPrefix.addData(field);
-      }
-      bootstrapPrefix.addData(template.prefix);
-      bootstrapPrefix.addData(template.suffix);
-      bootstrapPrefix.addData(dispatchTagFor(artifacts.bootstrap, "activate"));
-      transaction.inputs[0].signatureScript = encodeP2sh(
-        bootstrapPrefix.drain(),
-        bootstrapScript,
-      );
-      transaction.inputs[1].signatureScript = encodeP2sh(
-        buildKcc20TransferSigScript(kaspaWasm, artifacts.kcc20, {
-          nextStates,
-          witness: Uint8Array.of(0),
-        }),
-        tokenScript,
-      );
-      const scripts = [];
-      const adjusted = transactionWithCalculatedFeeChange(
-        kaspaWasm,
-        transaction,
-        fundingChangeOutputIndex,
-        network,
-        "snapshot reserve handoff",
-        scripts,
+      return { controllerId: peer.controllerId, state: plan.controllerState };
+    });
+    const guard = snapshotPeerPlanCommitment({
+      migrationCommitment: common.migrationCommitment,
+      manifestCommitment: common.manifestCommitment,
+      shards: [
+        { controllerId: "01".repeat(32), state: provisional.controllerState },
+        ...peerPlans,
+      ],
+    });
+    return createSignerlessControllerPlan({
+      ...common,
+      shard,
+      deploymentGuardCommitment: guard,
+    });
+  }
+
+  function normalizedSignerlessShards(values) {
+    if (!Array.isArray(values) || values.length < 1 || values.length > 8) {
+      throw new Error("signerless snapshot requires 1..8 ordered shards");
+    }
+    const shards = values.map((value) => ({
+      ...snapshotShard(value),
+      controllerId: value?.controllerId
+        ? requireHex32(value.controllerId, "controller id")
+        : undefined,
+      controllerSource: value?.controllerSource,
+    }));
+    shards.sort((left, right) => left.shardIndex - right.shardIndex);
+    if (shards.some((shard, index) => shard.shardIndex !== index)) {
+      throw new Error(
+        "signerless snapshot shards must be contiguous from zero",
       );
-      return outputEnvelope(adjusted, [{ index: 2 }], scripts, {
-        migrationId,
-        stage: "reserve-handoff",
-        tokenId,
-        bootstrapId,
-        bootstrapState: {
-          ...bootstrapStateReceipt(bootstrapState),
-          phase: "ACTIVATED",
-        },
-        shardPlanCommitment,
-        activationDigest: bytesToHex(bootstrapState.activationDigest),
-        shards: shards.map((shard) => shard.shardIndex),
-        maximumFeeSompi: feeOf(adjusted).toString(),
-        intentInputs: [
-          {
-            role: "snapshot-bootstrap",
-            index: 0,
-            covenantId: bootstrapId,
-            revealScriptHex: bytesToHex(bootstrapScript),
-            staticSignatureScriptHex: signatureScriptHex(adjusted, 0),
-          },
-          {
-            role: "fixed-supply-token",
-            index: 1,
-            covenantId: tokenId,
-            revealScriptHex: bytesToHex(tokenScript),
-            staticSignatureScriptHex: signatureScriptHex(adjusted, 1),
-          },
-          { role: "creator-funding", index: 2 },
-        ],
-        intentOutputs: shards.map((shard, index) => ({
-          role: "shard-reserve",
-          index,
-          shard: shard.shardIndex,
-          covenantId: tokenId,
-          revealScriptHex: bytesToHex(
-            buildKcc20ScriptForState(artifacts.kcc20, nextStates[index]),
-          ),
-          owner: shard.controllerId,
-          ownerScheme: 4,
-          borrowScheme: 0,
-          borrowGuard: ZERO_HASH,
-          extensionCommitment: bytesToHex(
-            bootstrapState.holderExtensionCommitment,
-          ),
-          tokenAmount: shard.allocationTotal.toString(),
-        })),
-      });
-    } finally {
-      await rpc.disconnect();
     }
+    return shards;
+  }
+
+  function portableInput(entry, network, script) {
+    return {
+      previousOutpoint: entry.outpoint,
+      utxo: entry,
+      networkId: network,
+      ...(script ? { script } : {}),
+    };
+  }
+
+  function outpointOfSource(source, label) {
+    return {
+      transactionId: requireHex32(source?.txidHex, `${label} txid`),
+      index: unsignedInteger(source?.vout, `${label} vout`),
+    };
   }
 
   async function buildClaim(input) {
@@ -2413,278 +1232,6 @@ export function createKcc20SnapshotPsktBuilder(
     };
   }
 
-  function initialControllerState(definition) {
-    return {
-      tokenId: hexToBytes(definition.tokenId),
-      holderExtensionCommitment: hexToBytes(
-        definition.holderExtensionCommitment,
-      ),
-      manifestCommitment: hexToBytes(definition.manifestCommitment),
-      snapshotContext: hexToBytes(definition.snapshotContext),
-      kcc20TemplateHash: hexToBytes(definition.kcc20TemplateHash),
-      claimNotBeforeDaaScore: definition.claimNotBeforeDaaScore,
-      shardIndex: BigInt(definition.shard.shardIndex),
-      globalIndexStart: BigInt(definition.shard.globalIndexStart),
-      holderCount: BigInt(definition.shard.holderCount),
-      treeDepth: BigInt(definition.shard.depth),
-      kcc20TemplatePrefixLen: BigInt(definition.kcc20TemplatePrefixLen),
-      kcc20TemplateSuffixLen: BigInt(definition.kcc20TemplateSuffixLen),
-      controllerCellKas: definition.controllerCellKas,
-      reserveCellKas: definition.reserveCellKas,
-      recipientMinCellKas: definition.recipientMinCellKas,
-      remainingRoot: hexToBytes(definition.shard.initialRoot),
-      remainingAmount: definition.shard.allocationTotal,
-      claimsProcessed: 0n,
-    };
-  }
-
-  function buildSnapshotControllerScriptForState(artifact, state) {
-    const normalized = normalizeSilverScriptArtifact(artifact);
-    const encoded = encodeControllerState(state);
-    const start = normalized.state_layout?.start;
-    const length = normalized.state_layout?.len;
-    if (
-      !Number.isInteger(start) ||
-      !Number.isInteger(length) ||
-      encoded.length !== length
-    ) {
-      throw new Error("snapshot controller artifact state layout is invalid");
-    }
-    return concatBytes(
-      Uint8Array.from(normalized.script).slice(0, start),
-      encoded,
-      Uint8Array.from(normalized.script).slice(start + length),
-    );
-  }
-
-  function buildSnapshotBootstrapScriptForState(artifact, state) {
-    const normalized = normalizeSilverScriptArtifact(artifact);
-    const encoded = encodeBootstrapState(state);
-    const start = normalized.state_layout?.start;
-    const length = normalized.state_layout?.len;
-    if (
-      normalized.contract_name !== "KCC20SnapshotBootstrap" ||
-      !Number.isInteger(start) ||
-      !Number.isInteger(length) ||
-      encoded.length !== length
-    ) {
-      throw new Error("snapshot bootstrap artifact state layout is invalid");
-    }
-    return concatBytes(
-      Uint8Array.from(normalized.script).slice(0, start),
-      encoded,
-      Uint8Array.from(normalized.script).slice(start + length),
-    );
-  }
-
-  function encodeBootstrapState(state) {
-    return concatBytes(
-      pushData(state.migrationCommitment),
-      pushData(state.manifestCommitment),
-      pushData(state.holderExtensionCommitment),
-      pushData(i64(state.totalSupply)),
-      pushData(i64(state.claimNotBeforeDaaScore)),
-      pushData(state.kcc20TemplateHash),
-      pushData(i64(state.kcc20TemplatePrefixLen)),
-      pushData(i64(state.kcc20TemplateSuffixLen)),
-      pushData(i64(state.tokenCellKas)),
-      pushData(i64(state.reserveCellKas)),
-      pushData(i64(state.bootstrapCellKas)),
-      pushData(state.approvalKey),
-      pushData(i64(state.phase)),
-      pushData(state.tokenId),
-      pushData(state.shardPlanCommitment),
-      pushData(state.activationDigest),
-      pushData(i64(state.shardCount)),
-    );
-  }
-
-  function bootstrapStateReceipt(state) {
-    return {
-      migrationCommitment: bytesToHex(state.migrationCommitment),
-      manifestCommitment: bytesToHex(state.manifestCommitment),
-      holderExtensionCommitment: bytesToHex(state.holderExtensionCommitment),
-      totalSupply: state.totalSupply.toString(),
-      claimNotBeforeDaaScore: state.claimNotBeforeDaaScore.toString(),
-      kcc20TemplateHash: bytesToHex(state.kcc20TemplateHash),
-      kcc20TemplatePrefixLen: state.kcc20TemplatePrefixLen.toString(),
-      kcc20TemplateSuffixLen: state.kcc20TemplateSuffixLen.toString(),
-      tokenCellKas: state.tokenCellKas.toString(),
-      reserveCellKas: state.reserveCellKas.toString(),
-      bootstrapCellKas: state.bootstrapCellKas.toString(),
-      approvalKey: bytesToHex(state.approvalKey),
-      phase: state.phase.toString(),
-      tokenId: bytesToHex(state.tokenId),
-      shardPlanCommitment: bytesToHex(state.shardPlanCommitment),
-      activationDigest: bytesToHex(state.activationDigest),
-      shardCount: state.shardCount.toString(),
-    };
-  }
-
-  function bootstrapBaseState(params, template) {
-    const approvalKey = requireHex32(
-      params.approvalKey ?? params.approvalKeyA,
-      "approval key",
-    );
-    if (approvalKey === ZERO_HASH) {
-      throw new Error("bootstrap approval key must be nonzero");
-    }
-    const expectedTemplateHash = requireHex32(
-      params.kcc20TemplateHash,
-      "KCC20 template hash",
-    );
-    if (bytesToHex(template.hash) !== expectedTemplateHash) {
-      throw new Error("KCC20 template hash does not match the migration pin");
-    }
-    const claimNotBeforeDaaScore = positiveI64(
-      params.claimNotBeforeDaaScore,
-      "claim-not-before DAA score",
-    );
-    if (claimNotBeforeDaaScore >= 500_000_000_000n) {
-      throw new Error("claim-not-before must use DAA-score locktime mode");
-    }
-    return {
-      migrationCommitment: hexToBytes(
-        requireHex32(params.migrationId, "migration ID"),
-      ),
-      manifestCommitment: hexToBytes(
-        requireHex32(params.manifestCommitment, "manifest commitment"),
-      ),
-      holderExtensionCommitment: hexToBytes(
-        requireHex32(
-          params.holderExtensionCommitment,
-          "holder extension commitment",
-        ),
-      ),
-      totalSupply: positiveI64(params.totalSupply, "total supply"),
-      claimNotBeforeDaaScore,
-      kcc20TemplateHash: hexToBytes(expectedTemplateHash),
-      kcc20TemplatePrefixLen: BigInt(template.prefix.length),
-      kcc20TemplateSuffixLen: BigInt(template.suffix.length),
-      tokenCellKas: minimumCell(params.tokenCellKas, "token cell KAS"),
-      reserveCellKas: minimumCell(params.reserveCellKas, "reserve cell KAS"),
-      bootstrapCellKas: minimumCell(
-        params.bootstrapCellKas,
-        "bootstrap cell KAS",
-      ),
-      approvalKey: hexToBytes(approvalKey),
-    };
-  }
-
-  function bootstrapStateArgs(state) {
-    return [
-      dataArg(state.migrationCommitment),
-      dataArg(state.manifestCommitment),
-      dataArg(state.holderExtensionCommitment),
-      i64Arg(state.totalSupply),
-      i64Arg(state.claimNotBeforeDaaScore),
-      dataArg(state.kcc20TemplateHash),
-      i64Arg(state.kcc20TemplatePrefixLen),
-      i64Arg(state.kcc20TemplateSuffixLen),
-      i64Arg(state.tokenCellKas),
-      i64Arg(state.reserveCellKas),
-      i64Arg(state.bootstrapCellKas),
-      dataArg(state.approvalKey),
-      i64Arg(state.phase),
-      dataArg(state.tokenId),
-      dataArg(state.shardPlanCommitment),
-      dataArg(state.activationDigest),
-      i64Arg(state.shardCount),
-    ];
-  }
-
-  function bootstrapBindArgs(artifacts, nextBootstrapState, tokenState) {
-    const template = templateParts(artifacts.kcc20);
-    return [
-      ...bootstrapStateArgs(nextBootstrapState),
-      i64Arg(1),
-      i64Arg(0),
-      i64Arg(1),
-      { type: "approval" },
-      dataArg(template.prefix),
-      dataArg(template.suffix),
-      ...kcc20StateArgs(tokenState),
-      dataArg(dispatchTagFor(artifacts.bootstrap, "bindToken")),
-    ];
-  }
-
-  function bootstrapSealArgs(artifacts, nextBootstrapState) {
-    return [
-      ...bootstrapStateArgs(nextBootstrapState),
-      i64Arg(0),
-      { type: "approval" },
-      dataArg(dispatchTagFor(artifacts.bootstrap, "seal")),
-    ];
-  }
-
-  function bootstrapCancellationArgs(
-    artifacts,
-    bound,
-    sinkOutputIndex,
-    sinkTokenState,
-  ) {
-    return [
-      { type: "approval" },
-      i64Arg(sinkOutputIndex),
-      ...(bound
-        ? [
-            i64Arg(0),
-            dataArg(templateParts(artifacts.kcc20).prefix),
-            dataArg(templateParts(artifacts.kcc20).suffix),
-            ...kcc20StateArgs(sinkTokenState),
-          ]
-        : []),
-      dataArg(
-        dispatchTagFor(
-          artifacts.bootstrap,
-          bound ? "cancelBound" : "cancelUnbound",
-        ),
-      ),
-    ];
-  }
-
-  function bootstrapApprovalRecipes(scriptHex, args) {
-    const zeroSignature = "00".repeat(65);
-    const replace = (dynamicSlot) =>
-      args.map((arg) => {
-        if (arg.type === dynamicSlot) return { type: "signature" };
-        if (arg.type === "approval") {
-          return { type: "data", hex: zeroSignature };
-        }
-        return arg;
-      });
-    const script = (normalizedArgs) => ({
-      inputIndex: 0,
-      scriptHex,
-      signatureScript: { mode: "ordered-args", args: normalizedArgs },
-    });
-    return {
-      placeholder: { args: replace("none") },
-      approval: script(replace("approval")),
-    };
-  }
-
-  function signatureScriptArgsBytes(args, signature = new Uint8Array(65)) {
-    const builder = new kaspaWasm.ScriptBuilder({
-      flags: { covenantsEnabled: true },
-    });
-    for (const arg of args || []) {
-      if (arg.type === "i64") {
-        builder.addI64(BigInt(arg.value));
-      } else if (arg.type === "byte") {
-        builder.addData(Uint8Array.of(arg.value));
-      } else if (arg.type === "data") {
-        builder.addData(hexToBytes(arg.hex));
-      } else if (arg.type === "signature") {
-        const prefix = hexToBytes(arg.prefixHex || "");
-        builder.addData(concatBytes(prefix, signature));
-      } else {
-        throw new Error(`unsupported snapshot signature argument ${arg.type}`);
-      }
-    }
-    return builder.drain();
-  }
-
   function encodeControllerState(state) {
     return concatBytes(
       pushData(state.tokenId),
@@ -2892,62 +1439,6 @@ export function createKcc20SnapshotPsktBuilder(
     return normalized;
   }
 
-  function reserveShards(values, totalSupply) {
-    if (!Array.isArray(values) || values.length < 1 || values.length > 8) {
-      throw new Error("atomic reserve handoff requires 1..8 shards");
-    }
-    const indexes = new Set<number>();
-    const controllerIds = new Set<string>();
-    const shards = values.map((value) => {
-      const shardIndex = unsignedInteger(value?.shardIndex, "shard index");
-      const controllerId = requireHex32(value?.controllerId, "controller id");
-      const allocationTotal = positiveI64(
-        value?.allocationTotal,
-        "shard allocation total",
-      );
-      if (indexes.has(shardIndex) || controllerIds.has(controllerId)) {
-        throw new Error("reserve handoff shard identities must be unique");
-      }
-      indexes.add(shardIndex);
-      controllerIds.add(controllerId);
-      return { shardIndex, controllerId, allocationTotal };
-    });
-    if (
-      shards.reduce((sum, shard) => sum + shard.allocationTotal, 0n) !==
-      totalSupply
-    ) {
-      throw new Error("reserve handoff allocations do not equal total supply");
-    }
-    return shards.sort((left, right) => left.shardIndex - right.shardIndex);
-  }
-
-  function snapshotShardPlanCommitment({
-    migrationCommitment,
-    manifestCommitment,
-    tokenId,
-    totalSupply,
-    shards,
-  }) {
-    return bytesToHex(
-      blake2b(
-        concatBytes(
-          Uint8Array.of(0x20),
-          hexToBytes(migrationCommitment),
-          hexToBytes(manifestCommitment),
-          hexToBytes(tokenId),
-          i64(totalSupply),
-          i64(BigInt(shards.length)),
-          ...shards.flatMap((shard, index) => [
-            i64(BigInt(index)),
-            hexToBytes(shard.controllerId),
-            i64(shard.allocationTotal),
-          ]),
-        ),
-        { dkLen: 32 },
-      ),
-    );
-  }
-
   function claimProof(value, shard) {
     const proof = value || {};
     const normalized = {
@@ -3270,52 +1761,6 @@ export function createKcc20SnapshotPsktBuilder(
     return value.toLowerCase();
   }
 
-  function controllerDeploymentPayload(definition, state) {
-    return bytesToHex(
-      new TextEncoder().encode(
-        JSON.stringify({
-          tn10: {
-            v: 1,
-            tmpl: "KCC20SnapshotController",
-            migrationId: definition.migrationId,
-            manifestCommitment: definition.manifestCommitment,
-            shardIndex: definition.shard.shardIndex,
-            args: [
-              {
-                name: "controllerState",
-                type: "object",
-                value: jsonControllerState(state),
-              },
-            ],
-          },
-        }),
-      ),
-    );
-  }
-
-  function jsonControllerState(state) {
-    return Object.fromEntries(
-      Object.entries(state).map(([key, value]) => [
-        key,
-        value instanceof Uint8Array
-          ? bytesToHex(value)
-          : controllerInteger(value, key),
-      ]),
-    );
-  }
-
-  function controllerInteger(value: unknown, key: string): string {
-    if (
-      typeof value !== "string" &&
-      typeof value !== "number" &&
-      typeof value !== "bigint" &&
-      typeof value !== "boolean"
-    ) {
-      throw new Error(`controller state ${key} is not an integer`);
-    }
-    return BigInt(value).toString();
-  }
-
   function scriptAddress(script, network) {
     return kaspaWasm
       .addressFromScriptPublicKey(
@@ -3473,120 +1918,3 @@ export function createKcc20SnapshotPsktBuilder(
 
   return buildSnapshotMigrationPskt;
 }
-
-/** Pure script constructors shared by browser verification and server projections. */
-function buildSnapshotControllerScriptForState(artifact, state) {
-  const normalized = normalizeSilverScriptArtifact(artifact);
-  const encoded = encodePortableControllerState(state);
-  const start = normalized.state_layout?.start;
-  const length = normalized.state_layout?.len;
-  if (
-    !Number.isInteger(start) ||
-    !Number.isInteger(length) ||
-    encoded.length !== length
-  ) {
-    throw new Error("snapshot controller artifact state layout is invalid");
-  }
-  return portableConcatBytes(
-    Uint8Array.from(normalized.script).slice(0, start),
-    encoded,
-    Uint8Array.from(normalized.script).slice(start + length),
-  );
-}
-
-function buildSnapshotBootstrapScriptForState(artifact, state) {
-  const normalized = normalizeSilverScriptArtifact(artifact);
-  const encoded = encodePortableBootstrapState(state);
-  const start = normalized.state_layout?.start;
-  const length = normalized.state_layout?.len;
-  if (
-    normalized.contract_name !== "KCC20SnapshotBootstrap" ||
-    !Number.isInteger(start) ||
-    !Number.isInteger(length) ||
-    encoded.length !== length
-  ) {
-    throw new Error("snapshot bootstrap artifact state layout is invalid");
-  }
-  return portableConcatBytes(
-    Uint8Array.from(normalized.script).slice(0, start),
-    encoded,
-    Uint8Array.from(normalized.script).slice(start + length),
-  );
-}
-
-function encodePortableControllerState(state) {
-  return portableConcatBytes(
-    portablePushData(state.tokenId),
-    portablePushData(state.holderExtensionCommitment),
-    portablePushData(state.manifestCommitment),
-    portablePushData(state.snapshotContext),
-    portablePushData(state.kcc20TemplateHash),
-    portablePushData(portableI64(state.claimNotBeforeDaaScore)),
-    portablePushData(portableI64(state.shardIndex)),
-    portablePushData(portableI64(state.globalIndexStart)),
-    portablePushData(portableI64(state.holderCount)),
-    portablePushData(portableI64(state.treeDepth)),
-    portablePushData(portableI64(state.kcc20TemplatePrefixLen)),
-    portablePushData(portableI64(state.kcc20TemplateSuffixLen)),
-    portablePushData(portableI64(state.controllerCellKas)),
-    portablePushData(portableI64(state.reserveCellKas)),
-    portablePushData(portableI64(state.recipientMinCellKas)),
-    portablePushData(state.remainingRoot),
-    portablePushData(portableI64(state.remainingAmount)),
-    portablePushData(portableI64(state.claimsProcessed)),
-  );
-}
-
-function encodePortableBootstrapState(state) {
-  return portableConcatBytes(
-    portablePushData(state.migrationCommitment),
-    portablePushData(state.manifestCommitment),
-    portablePushData(state.holderExtensionCommitment),
-    portablePushData(portableI64(state.totalSupply)),
-    portablePushData(portableI64(state.claimNotBeforeDaaScore)),
-    portablePushData(state.kcc20TemplateHash),
-    portablePushData(portableI64(state.kcc20TemplatePrefixLen)),
-    portablePushData(portableI64(state.kcc20TemplateSuffixLen)),
-    portablePushData(portableI64(state.tokenCellKas)),
-    portablePushData(portableI64(state.reserveCellKas)),
-    portablePushData(portableI64(state.bootstrapCellKas)),
-    portablePushData(state.approvalKey ?? state.approvalKeyA),
-    portablePushData(portableI64(state.phase)),
-    portablePushData(state.tokenId),
-    portablePushData(state.shardPlanCommitment),
-    portablePushData(state.activationDigest),
-    portablePushData(portableI64(state.shardCount)),
-  );
-}
-
-function portablePushData(value) {
-  const bytes = Uint8Array.from(value);
-  if (bytes.length > 75) throw new Error("snapshot state push is too large");
-  return portableConcatBytes(Uint8Array.of(bytes.length), bytes);
-}
-
-function portableI64(value) {
-  let cursor = BigInt(value);
-  if (cursor < 0n || cursor > 9_223_372_036_854_775_807n) {
-    throw new Error("snapshot state integer is outside signed i64 range");
-  }
-  const bytes = new Uint8Array(8);
-  for (let index = 0; index < bytes.length; index += 1) {
-    bytes[index] = Number(cursor & 0xffn);
-    cursor >>= 8n;
-  }
-  return bytes;
-}
-
-function portableConcatBytes(...values) {
-  const arrays = values.map((value) => Uint8Array.from(value));
-  const output = new Uint8Array(
-    arrays.reduce((sum, value) => sum + value.length, 0),
-  );
-  let offset = 0;
-  for (const value of arrays) {
-    output.set(value, offset);
-    offset += value.length;
-  }
-  return output;
-}