@arkade-os/sdk 0.4.54 → 0.4.55

package/dist/{chunk-TEHJCEF3.js → chunk-QO3IKBYL.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-ZOY5JSVA.js';
-import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, deriveDescriptorLeafPubKey, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-A37WVZ5T.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ArkAddress, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, canSpendOffchain, toVirtualStatus, ArkError, resolveTimeHeight, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-4EIKOJLD.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-ENWR2F2P.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-QMPNPZ2T.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, canSpendOffchain, toVirtualStatus, ArkError, resolveTimeHeight, parseLegacyExpiry, isExpired, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-JCJ5WFS3.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { sha256, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
 import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
@@ -517,6 +517,18 @@ var SeedIdentity = class _SeedIdentity {
     const key = this.derivePrivateKeyForDescriptor(descriptor);
     return this.signMessageWithKey(key, message, signatureType);
   }
+  /**
+   * BIP-340 sign `messageHash` with the key derived from `descriptor`,
+   * aux_rand = 0. Backs {@link DescriptorIdentity.signSchnorrDeterministic},
+   * which swap preimage derivation reads through.
+   */
+  async signSchnorrDeterministicWithDescriptor(descriptor, messageHash) {
+    if (!this.isOurs(descriptor)) {
+      throw new Error(`Descriptor ${descriptor} does not belong to this identity`);
+    }
+    const key = this.derivePrivateKeyForDescriptor(descriptor);
+    return schnorr$1.signAsync(messageHash, key, new Uint8Array(32));
+  }
   // ── internal helpers ─────────────────────────────────────────────
   derivePrivateKeyForDescriptor(descriptor) {
     const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;
@@ -803,6 +815,59 @@ function assertValidSerializedIdentity(s) {
   }
 }
 
+// src/identity/descriptorIdentity.ts
+function isHDDeterministicSignCapable(value) {
+  return typeof value === "object" && value !== null && typeof value.signSchnorrDeterministicWithDescriptor === "function";
+}
+var DescriptorIdentity = class {
+  descriptor;
+  signer;
+  base;
+  constructor({ descriptor, signer, base }) {
+    this.descriptor = descriptor;
+    this.signer = signer;
+    this.base = base;
+  }
+  async xOnlyPublicKey() {
+    return deriveDescriptorLeafPubKey(this.descriptor);
+  }
+  async compressedPublicKey() {
+    return deriveDescriptorLeafCompressedPubKey(this.descriptor);
+  }
+  async sign(tx, inputIndexes) {
+    const [signed] = await this.signer.signWithDescriptor([
+      { descriptor: this.descriptor, tx, inputIndexes }
+    ]);
+    if (!signed) {
+      throw new Error(`Descriptor signer returned no transaction for ${this.descriptor}`);
+    }
+    return signed;
+  }
+  async signMessage(message, signatureType = "schnorr") {
+    return this.signer.signMessageWithDescriptor(this.descriptor, message, signatureType);
+  }
+  /**
+   * Delegated: `TreeSignerSession.random()` consults no key material, so the
+   * session is index-independent.
+   */
+  signerSession() {
+    return this.base.signerSession();
+  }
+  /**
+   * Throws rather than falling back to the baseline key: a preimage derived
+   * from the wrong index is unrecoverable, and callers probe this member
+   * through a structural guard that cannot tell the two apart.
+   */
+  async signSchnorrDeterministic(messageHash) {
+    if (!isHDDeterministicSignCapable(this.base)) {
+      throw new Error(
+        `Identity cannot sign deterministically for descriptor ${this.descriptor}`
+      );
+    }
+    return this.base.signSchnorrDeterministicWithDescriptor(this.descriptor, messageHash);
+  }
+};
+
 // src/identity/hdCapableIdentity.ts
 function isHDCapableIdentity(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -815,6 +880,13 @@ function isBatchSignable(identity) {
   return "signMultiple" in identity && typeof identity.signMultiple === "function";
 }
 
+// src/wallet/hdWalletCapable.ts
+function isHDWalletCapable(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.getCurrentSigningDescriptor === "function" && typeof v.getUsedSigningDescriptors === "function" && typeof v.signerForDescriptor === "function";
+}
+
 // src/worker/browser/service-worker-manager.ts
 var registrations = /* @__PURE__ */ new Map();
 var handshakes = /* @__PURE__ */ new WeakSet();
@@ -1808,14 +1880,28 @@ function buildOpReturnScript(data) {
   }
   return script;
 }
-var ErrOffchainOutputNotFound = (address) => new Error(`offchain send output not found: ${address}`);
-var ErrInvalidAssetOutputAmount = (got, want, assetId) => new Error(`invalid asset output amount for ${assetId}: got ${got}, want ${want}`);
-var ErrAssetGroupNotFound = (assetId) => new Error(`asset group not found in batch leaf: ${assetId}`);
-var ErrAssetOutputNotFound = (assetId, outputIndex) => new Error(`asset output not found in asset group ${assetId} at index ${outputIndex}`);
+var ErrOffchainOutputNotFound = (address) => new ServerResponseMismatchError(`offchain send output not found: ${address}`);
+var ErrInvalidAssetOutputAmount = (got, want, assetId) => new ServerResponseMismatchError(
+  `invalid asset output amount for ${assetId}: got ${got}, want ${want}`
+);
+var ErrAssetGroupNotFound = (assetId) => new ServerResponseMismatchError(`asset group not found in batch leaf: ${assetId}`);
+var ErrAssetOutputNotFound = (assetId, outputIndex) => new ServerResponseMismatchError(
+  `asset output not found in asset group ${assetId} at index ${outputIndex}`
+);
+var ErrOnchainOutputNotFound = (address) => new ServerResponseMismatchError(`onchain output not found: ${address}`);
+var ErrUnvalidatedOffchainOutput = (address) => new ServerResponseMismatchError(
+  `offchain output ${address} cannot be validated: virtual output tree signing did not run`
+);
 var ErrInvalidOnchainOutputAmount = (address) => new Error(`invalid onchain output amount: ${address}`);
 var ErrInvalidOnchainOutputAssets = (address) => new Error(`onchain output ${address} cannot have assets`);
-var ErrOnchainOutputNotFound = (address) => new Error(`onchain output not found: ${address}`);
 var ErrInvalidOffchainOutputAmount = (address) => new Error(`invalid offchain output ${address}, missing amount`);
+function assertFinalCommitmentMatchesValidated(finalCommitmentTx, validatedCommitmentTxid, context) {
+  if (!validatedCommitmentTxid) return;
+  if (finalCommitmentTx.id === validatedCommitmentTxid) return;
+  throw new ServerResponseMismatchError(
+    `${context}: finalization commitment tx ${finalCommitmentTx.id} differs from the validated commitment tx ${validatedCommitmentTxid}`
+  );
+}
 function validateBatchRecipients(commitmentTx, vtxoTreeLeaves, recipients, network) {
   const usedOutputs = /* @__PURE__ */ new Set();
   const usedOnchainOutputs = /* @__PURE__ */ new Set();
@@ -1830,6 +1916,18 @@ function validateBatchRecipients(commitmentTx, vtxoTreeLeaves, recipients, netwo
     validateOffchainRecipient(vtxoTreeLeaves, arkAddress, recipient, usedOutputs);
   }
 }
+function validateBatchRecipientsWithoutTree(commitmentTx, recipients, network) {
+  const usedOnchainOutputs = /* @__PURE__ */ new Set();
+  for (const recipient of recipients) {
+    try {
+      ArkAddress.decode(recipient.address);
+    } catch {
+      validateOnchainRecipient(commitmentTx, recipient, network, usedOnchainOutputs);
+      continue;
+    }
+    throw ErrUnvalidatedOffchainOutput(recipient.address);
+  }
+}
 function validateOnchainRecipient(commitmentTx, recipient, network, usedOutputs) {
   const addr = Address(network).decode(recipient.address);
   const expectedPkScript = OutScript.encode(addr);
@@ -1922,8 +2020,6 @@ function validateAssetGroupOutput(packet, outputIndex, assetId, expectedAmount)
     throw ErrInvalidAssetOutputAmount(assetOutput.amount, expectedAmount, assetId);
   }
 }
-
-// src/wallet/activity.ts
 async function buildActivities(txs, resolvers) {
   const preparedResolvers = (await Promise.all(
     resolvers.map(async (r) => {
@@ -2033,9 +2129,49 @@ function boardingResolver() {
     }
   };
 }
+function collabExitResolver() {
+  return {
+    id: "collab-exit",
+    resolve(tx) {
+      if (tx.tag !== "exit" || !tx.key.commitmentTxid) return void 0;
+      return [
+        {
+          groupId: `exit:${tx.key.commitmentTxid}`,
+          label: "Collaborative exit",
+          kind: "exit"
+        }
+      ];
+    }
+  };
+}
+function assetMintResolver() {
+  return {
+    id: "asset-mint",
+    resolve(tx) {
+      if (!tx.assets?.length || !tx.key.arkTxid) return void 0;
+      const minted = tx.assets.filter((a) => {
+        try {
+          return hex.encode(AssetId.fromString(a.assetId).txid) === tx.key.arkTxid;
+        } catch {
+          return false;
+        }
+      });
+      if (minted.length === 0) return void 0;
+      const received = tx.type === "RECEIVED" /* TxReceived */;
+      return minted.map((a) => ({
+        groupId: `mint:${a.assetId}`,
+        label: received ? "Asset receive" : "Asset mint",
+        kind: received ? "asset-receive" : "asset-mint",
+        metadata: { assetId: a.assetId, amount: a.amount.toString() }
+      }));
+    }
+  };
+}
 function createDefaultActivityRegistry() {
   const registry = new ActivityRegistry();
   registry.use(boardingResolver());
+  registry.use(collabExitResolver());
+  registry.use(assetMintResolver());
   return registry;
 }
 
@@ -2395,6 +2531,70 @@ function isValidArkAddress(address) {
     return false;
   }
 }
+function matchServerCheckpoints(serverCheckpointTxs, expectedCheckpoints, context) {
+  if (serverCheckpointTxs.length !== expectedCheckpoints.length) {
+    throw new ServerResponseMismatchError(
+      `${context} returned ${serverCheckpointTxs.length} checkpoints, expected ${expectedCheckpoints.length}`
+    );
+  }
+  const byTxid = new Map(expectedCheckpoints.map((c) => [c.id, c]));
+  return serverCheckpointTxs.map((encoded, index) => {
+    const server = Transaction.fromPSBT(base64.decode(encoded));
+    const local = byTxid.get(server.id);
+    if (!local) {
+      throw new ServerResponseMismatchError(
+        `${context} checkpoint ${index} txid ${server.id} does not match any submitted checkpoint`
+      );
+    }
+    byTxid.delete(server.id);
+    return { server, local };
+  });
+}
+function assertSubmittedArkTxid(response, signedArkTx, context) {
+  if (response.arkTxid !== signedArkTx.id) {
+    throw new ServerResponseMismatchError(
+      `${context} returned ark txid ${response.arkTxid}, expected ${signedArkTx.id}`
+    );
+  }
+  if (response.finalArkTx === void 0) return;
+  const finalTxid = Transaction.fromPSBT(base64.decode(response.finalArkTx)).id;
+  if (finalTxid !== signedArkTx.id) {
+    throw new ServerResponseMismatchError(
+      `${context} returned final ark tx ${finalTxid}, expected ${signedArkTx.id}`
+    );
+  }
+}
+function assertCheckpointsMatchInputs(checkpoints, inputs, unrollCandidates, context) {
+  const byOutpoint = new Map(inputs.map((input) => [`${input.txid}:${input.vout}`, input]));
+  for (const [index, checkpoint] of checkpoints.entries()) {
+    if (checkpoint.inputsLength !== 1) {
+      throw new ServerResponseMismatchError(
+        `${context}: checkpoint ${index} spends ${checkpoint.inputsLength} inputs, expected 1`
+      );
+    }
+    const spent = checkpoint.getInput(0);
+    if (!spent.txid || spent.index === void 0) {
+      throw new ServerResponseMismatchError(
+        `${context}: checkpoint ${index} has no input outpoint`
+      );
+    }
+    const outpoint = `${hex.encode(spent.txid)}:${spent.index}`;
+    const input = byOutpoint.get(outpoint);
+    if (!input) {
+      throw new ServerResponseMismatchError(
+        `${context}: checkpoint ${index} spends ${outpoint}, which is not one of the requested virtual outputs`
+      );
+    }
+    const rebuilt = unrollCandidates.some(
+      (unroll) => buildCheckpointTx(input, unroll).tx.id === checkpoint.id
+    );
+    if (!rebuilt) {
+      throw new ServerResponseMismatchError(
+        `${context}: checkpoint ${index} txid ${checkpoint.id} differs from the checkpoint built locally for ${outpoint}`
+      );
+    }
+  }
+}
 async function submitOffchainTx(provider, offchainTx, signer, hooks) {
   const { arkTx: signedArkTx, userSignedCheckpoints } = await signer.signArkTx(
     offchainTx.arkTx,
@@ -2406,27 +2606,26 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks) {
     );
   }
   await hooks?.beforeSubmit?.();
-  const { arkTxid, signedCheckpointTxs } = await provider.submitTx(
+  const response = await provider.submitTx(
     base64.encode(signedArkTx.toPSBT()),
     offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
   );
-  if (signedCheckpointTxs.length !== offchainTx.checkpoints.length) {
-    throw new Error(
-      `submitTx returned ${signedCheckpointTxs.length} checkpoints, expected ${offchainTx.checkpoints.length}`
-    );
-  }
+  assertSubmittedArkTxid(response, signedArkTx, "submitTx");
+  const { arkTxid, signedCheckpointTxs } = response;
+  const matched = matchServerCheckpoints(signedCheckpointTxs, offchainTx.checkpoints, "submitTx");
   let finalCheckpoints;
   if (userSignedCheckpoints) {
-    finalCheckpoints = signedCheckpointTxs.map((c, i) => {
-      const serverSigned = Transaction.fromPSBT(base64.decode(c));
-      combineTapscriptSigs(userSignedCheckpoints[i], serverSigned);
-      return base64.encode(serverSigned.toPSBT());
+    const userByTxid = new Map(
+      userSignedCheckpoints.map((c, i) => [offchainTx.checkpoints[i].id, c])
+    );
+    finalCheckpoints = matched.map(({ server, local }) => {
+      combineTapscriptSigs(userByTxid.get(local.id), server);
+      return base64.encode(server.toPSBT());
     });
   } else {
     finalCheckpoints = await Promise.all(
-      signedCheckpointTxs.map(async (c) => {
-        const tx = Transaction.fromPSBT(base64.decode(c));
-        const signed = await signer.signCheckpoint(tx);
+      matched.map(async ({ server }) => {
+        const signed = await signer.signCheckpoint(server);
         return base64.encode(signed.toPSBT());
       })
     );
@@ -11952,6 +12151,51 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     return newBoarding.onchainAddress(this.network);
   }
+  /**
+   * @see HDWalletCapable.getCurrentSigningDescriptor
+   */
+  async getCurrentSigningDescriptor() {
+    const provider = this._descriptorProvider;
+    if (!(provider instanceof HDDescriptorProvider)) return void 0;
+    return provider.getCurrentSigningDescriptor();
+  }
+  /**
+   * @see HDWalletCapable.getUsedSigningDescriptors
+   *
+   * Union of the watermark band and the descriptors persisted on contracts:
+   * the band alone would miss rows a restore scan wrote, and the contracts
+   * alone would miss indices allocated for something the wallet never
+   * persisted (a swap, an externally issued invoice).
+   */
+  async getUsedSigningDescriptors() {
+    const provider = this._descriptorProvider;
+    const descriptors = /* @__PURE__ */ new Set();
+    if (provider instanceof HDDescriptorProvider) {
+      const lastIndexUsed = await provider.getLastIndexUsed();
+      for (let i = 0; i <= (lastIndexUsed ?? -1); i++) {
+        descriptors.add(provider.materializeDescriptorAt(i));
+      }
+    }
+    for (const contract of await this.contractRepository.getContracts()) {
+      const descriptor = contract.metadata?.signingDescriptor;
+      if (typeof descriptor === "string" && descriptor.length > 0) {
+        descriptors.add(descriptor);
+      }
+    }
+    return [...descriptors].sort(
+      (a, b) => signingDescriptorIndex(a) - signingDescriptorIndex(b)
+    );
+  }
+  /**
+   * @see HDWalletCapable.signerForDescriptor
+   */
+  async signerForDescriptor(descriptor) {
+    const provider = this._descriptorProvider;
+    if (!(provider instanceof HDDescriptorProvider) || !provider.isOurs(descriptor)) {
+      return this.identity;
+    }
+    return new DescriptorIdentity({ descriptor, signer: provider, base: this.identity });
+  }
   /**
    * Mid-session server-signer rotation (plan §4). When arkd rotates its
    * active signer mid-session — the case the long-lived service worker and
@@ -12762,9 +13006,17 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       console.warn("Failed to rotate boarding address after board", e);
     }
   }
-  async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, connectorsGraph) {
+  async handleSettlementFinalizationEvent(event, inputs, forfeitOutputScript, expectedRecipients, connectorsGraph, validatedCommitmentTxid) {
     const signedForfeits = [];
     let settlementPsbt = Transaction$2.fromPSBT(base64.decode(event.commitmentTx));
+    assertFinalCommitmentMatchesValidated(
+      settlementPsbt,
+      validatedCommitmentTxid,
+      "settlement finalization"
+    );
+    if (!validatedCommitmentTxid && expectedRecipients.length > 0) {
+      validateBatchRecipientsWithoutTree(settlementPsbt, expectedRecipients, this.network);
+    }
     let hasBoardingUtxos = false;
     let connectorIndex = 0;
     const connectorsLeaves = connectorsGraph?.leaves() || [];
@@ -12887,6 +13139,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
    */
   createBatchHandler(intentId, inputs, expectedRecipients, session) {
     let sweepTapTreeRoot;
+    let validatedCommitmentTxid;
     return {
       onBatchStarted: async (event) => {
         const utf8IntentId = new TextEncoder().encode(intentId);
@@ -12944,6 +13197,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         if (!sharedOutput?.amount) {
           throw new Error("Shared output not found");
         }
+        validatedCommitmentTxid = commitmentTx.id;
         await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
         const pubkey = hex.encode(await session.getPublicKey());
         const nonces = await session.getNonces();
@@ -12972,7 +13226,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           event,
           inputs,
           this.forfeitOutputScript,
-          connectorTree
+          expectedRecipients,
+          connectorTree,
+          validatedCommitmentTxid
         );
       }
     };
@@ -13131,6 +13387,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     for (let i = 0; i < vtxos.length; i += MAX_INPUTS_PER_INTENT) {
       batches.push(vtxos.slice(i, i + MAX_INPUTS_PER_INTENT));
     }
+    const unrollCandidates = this.checkpointUnrollCandidates(await this.arkProvider.getInfo());
+    const checkpointInputs = vtxos.map((vtxo) => ({
+      ...vtxo,
+      tapLeafScript: vtxo.forfeitTapLeafScript
+    }));
     const seen = /* @__PURE__ */ new Set();
     const results = await Promise.all(
       batches.map(async (batch) => {
@@ -13146,6 +13407,12 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
             const checkpointTxs = pendingTx.signedCheckpointTxs.map(
               (c) => Transaction$2.fromPSBT(base64.decode(c))
             );
+            assertCheckpointsMatchInputs(
+              checkpointTxs,
+              checkpointInputs,
+              unrollCandidates,
+              `pending tx ${pendingTx.arkTxid}`
+            );
             const checkpointJobs = checkpointTxs.map(
               (tx) => this.inputSigningJobsFromWitnessUtxos(tx)
             );
@@ -13201,6 +13468,32 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     return { finalized, pending };
   }
+  /**
+   * The server unroll scripts a pending checkpoint may legitimately have been
+   * built under: this wallet's configured one, the server's current one, and
+   * one per deprecated signer (same closure, deprecated key). A tx submitted
+   * before a signer rotation was built under the old key, so rebuilding
+   * against the current key alone would leave it pending forever.
+   */
+  checkpointUnrollCandidates(info) {
+    const current = CSVMultisigTapscript.decode(hex.decode(info.checkpointTapscript));
+    const candidates = [this._serverUnrollScript, current];
+    for (const deprecated of signerSetFromInfo(info).deprecated.keys()) {
+      candidates.push(
+        CSVMultisigTapscript.encode({
+          ...current.params,
+          pubkeys: [hex.decode(deprecated)]
+        })
+      );
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return candidates.filter((candidate) => {
+      const script = hex.encode(candidate.script);
+      if (seen.has(script)) return false;
+      seen.add(script);
+      return true;
+    });
+  }
   async hasPendingTxFlag() {
     const state = await this.walletRepository.getWalletState();
     return state?.settings?.hasPendingTx === true;
@@ -13433,12 +13726,23 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
         pendingTxs.push(pendingTx);
       }
     }
+    if (pendingTxs.length === 0) return result;
     const myPkScriptHex = hex.encode(myPkScript);
+    const unrollCandidates = this.checkpointUnrollCandidates(await this.arkProvider.getInfo());
     for (const pendingTx of pendingTxs) {
       try {
         const checkpointTxs = pendingTx.signedCheckpointTxs.map(
           (checkpoint) => Transaction$2.fromPSBT(base64.decode(checkpoint))
         );
+        assertCheckpointsMatchInputs(
+          checkpointTxs,
+          inputs.map((input) => ({
+            ...input,
+            tapLeafScript: input.forfeitTapLeafScript
+          })),
+          unrollCandidates,
+          `pending arkadeCash tx ${pendingTx.arkTxid}`
+        );
         const finalCheckpoints = await Promise.all(
           checkpointTxs.map(
             async (checkpoint) => base64.encode((await identity.sign(checkpoint)).toPSBT())
@@ -13848,28 +14152,29 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           `updateDbAfterOffchainTx: inputs length (${inputs.length}) differs from signedCheckpointTxs length (${signedCheckpointTxs.length})`
         );
       }
-      const safeLength = Math.min(inputs.length, signedCheckpointTxs.length);
+      const checkpointIdByOutpoint = /* @__PURE__ */ new Map();
+      for (const encoded of signedCheckpointTxs) {
+        const checkpoint = Transaction$2.fromPSBT(base64.decode(encoded));
+        for (let i = 0; i < checkpoint.inputsLength; i++) {
+          const input = checkpoint.getInput(i);
+          if (!input.txid) continue;
+          checkpointIdByOutpoint.set(
+            `${hex.encode(input.txid)}:${input.index}`,
+            checkpoint.id
+          );
+        }
+      }
       const cm = await this.getContractManager();
       const annotatedInputs = await cm.annotateVtxos(inputs);
-      for (const [inputIndex, vtxo] of annotatedInputs.entries()) {
+      for (const vtxo of annotatedInputs) {
         const spentFacts = { ...vtxo, isSpent: true };
-        if (inputIndex < safeLength && signedCheckpointTxs[inputIndex]) {
-          const checkpoint = Transaction$2.fromPSBT(
-            base64.decode(signedCheckpointTxs[inputIndex])
-          );
-          spentVtxos.push({
-            ...spentFacts,
-            virtualStatus: toVirtualStatus(spentFacts),
-            spentBy: checkpoint.id,
-            arkTxId: arkTxid
-          });
-        } else {
-          spentVtxos.push({
-            ...spentFacts,
-            virtualStatus: toVirtualStatus(spentFacts),
-            arkTxId: arkTxid
-          });
-        }
+        const spentBy = checkpointIdByOutpoint.get(`${vtxo.txid}:${vtxo.vout}`);
+        spentVtxos.push({
+          ...spentFacts,
+          virtualStatus: toVirtualStatus(spentFacts),
+          ...spentBy ? { spentBy } : {},
+          arkTxId: arkTxid
+        });
         for (const id of vtxo.commitmentTxIds) {
           commitmentTxIds.add(id);
         }
@@ -19528,6 +19833,7 @@ var isVtxoCoin = (input) => isVirtualCoin(input);
 function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message, session, arkProvider, emulator, network, recipients) {
   let batchId;
   let sweepTapTreeRoot;
+  let validatedCommitmentTxid;
   return {
     onBatchStarted: async (event) => {
       const utf8IntentId = new TextEncoder().encode(intentId);
@@ -19563,6 +19869,7 @@ function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message
       if (!sharedOutput?.amount) {
         throw new Error("Shared output not found");
       }
+      validatedCommitmentTxid = commitmentTx.id;
       await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
       const pubkey = hex.encode(await session.getPublicKey());
       const nonces = await session.getNonces();
@@ -19586,6 +19893,14 @@ function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message
         validateConnectorsTxGraph(event.commitmentTx, connectorTree);
       }
       let commitmentPsbt = Transaction.fromPSBT(base64.decode(event.commitmentTx));
+      assertFinalCommitmentMatchesValidated(
+        commitmentPsbt,
+        validatedCommitmentTxid,
+        "arkade batch finalization"
+      );
+      if (!validatedCommitmentTxid && recipients && recipients.length > 0) {
+        validateBatchRecipientsWithoutTree(commitmentPsbt, recipients, network);
+      }
       const signedForfeits = [];
       let connectorIndex = 0;
       const connectorLeaves = connectorTree?.leaves() || [];
@@ -20052,11 +20367,11 @@ var ArkadeTransactionBuilder = class {
       base64.encode(signedArk.toPSBT()),
       checkpoints.map((c) => base64.encode(c.toPSBT()))
     );
+    assertSubmittedArkTxid(res, signedArk, "submitTx");
+    const matched = matchServerCheckpoints(res.signedCheckpointTxs, checkpoints, "submitTx");
     const finalCps = await Promise.all(
-      res.signedCheckpointTxs.map(
-        async (b) => base64.encode(
-          (await client.identity.sign(Transaction.fromPSBT(base64.decode(b)), [0])).toPSBT()
-        )
+      matched.map(
+        async ({ server }) => base64.encode((await client.identity.sign(server, [0])).toPSBT())
       )
     );
     await client.arkProvider.finalizeTx(res.arkTxid, finalCps);
@@ -20553,6 +20868,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ARKADE_MAGIC, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkRail, arkTarget, arkade_exports, assertIntentIdUnique, assertSendableAmount, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isCooperativelyMigratable, isDiscoverable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, makeHandle, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, requiresMigration, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, tryResolveSendAmount, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-TEHJCEF3.js.map
-//# sourceMappingURL=chunk-TEHJCEF3.js.map
+export { ARKADE_MAGIC, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkRail, arkTarget, arkade_exports, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assetMintResolver, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isArkContract, isBatchSignable, isBtcAddress, isCooperativelyMigratable, isDiscoverable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, onchainRail, openDatabase, requiresMigration, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, tryResolveSendAmount, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-QO3IKBYL.js.map
+//# sourceMappingURL=chunk-QO3IKBYL.js.map