@arkade-os/sdk 0.4.53 → 0.4.55

package/dist/{chunk-3MMUKLCI.js → chunk-QO3IKBYL.js}

@@ -1,6 +1,6 @@
-import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, rateGate, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-LHYNNDY6.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-UZLQUWYP.js';
-import { VtxoScript, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, hasTerminalSpend, getNormalizedVtxos, isVirtualCoin, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, normalizeVtxo, getSequence, toBatchExpiry, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, canSpendOffchain, toVirtualStatus, resolveTimeHeight, parseLegacyExpiry, networks as networks$1, isExpired, DEFAULT_ARKADE_SERVER_URL, isPastExpiry } from './chunk-EFNLTS6Q.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';
@@ -25,8 +25,8 @@ function aggregateNonces(pubNonces) {
   return musig2.nonceAggregate(pubNonces);
 }
 function aggregateKeys(publicKeys, sort, options = {}) {
-  {
-    publicKeys = musig2.sortKeys(publicKeys);
+  if (sort) {
+    publicKeys = musig2.sortKeys([...publicKeys]);
   }
   const { aggPublicKey: preTweakedKey } = musig2.keyAggregate(publicKeys);
   if (!options.taprootTweak) {
@@ -88,24 +88,27 @@ var PartialSig = class _PartialSig {
     return new _PartialSig(bytes, R);
   }
 };
-function sign(secNonce, privateKey, combinedNonce, publicKeys, message, options) {
+function createSession(combinedNonce, publicKeys, message, options) {
+  const keys = musig2.sortKeys([...publicKeys]) ;
   let tweakBytes;
   if (options?.taprootTweak !== void 0) {
-    const { preTweakedKey } = aggregateKeys(
-      musig2.sortKeys(publicKeys) );
+    const { preTweakedKey } = aggregateKeys(keys, false);
     tweakBytes = schnorr.utils.taggedHash(
       "TapTweak",
       preTweakedKey.subarray(1),
       options.taprootTweak
     );
   }
-  const session = new musig2.Session(
+  return new musig2.Session(
     combinedNonce,
-    musig2.sortKeys(publicKeys) ,
+    keys,
     message,
     tweakBytes ? [tweakBytes] : void 0,
     tweakBytes ? [true] : void 0
   );
+}
+function sign(secNonce, privateKey, combinedNonce, publicKeys, message, options) {
+  const session = createSession(combinedNonce, publicKeys, message, options);
   const partialSig = session.sign(secNonce, privateKey);
   return PartialSig.decode(partialSig);
 }
@@ -514,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;
@@ -800,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;
@@ -812,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();
@@ -1805,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();
@@ -1827,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);
@@ -1919,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) => {
@@ -2030,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;
 }
 
@@ -2279,7 +2418,7 @@ function hasBoardingTxExpired(coin, boardingTimelock, chainTipHeight) {
 function formatSighash(type) {
   return `0x${type.toString(16).padStart(2, "0")}`;
 }
-function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubkeys = [], allowedSighashTypes = [SigHash.DEFAULT]) {
+function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubkeys = [], allowedSighashTypes = [SigHash.DEFAULT], expectedLeafHash) {
   const input = tx.getInput(inputIndex);
   const prevoutScripts = [];
   const prevoutAmounts = [];
@@ -2294,12 +2433,21 @@ function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubke
   if (!input.tapScriptSig || input.tapScriptSig.length === 0) {
     throw new Error(`Input ${inputIndex} is missing tapScriptSig`);
   }
+  const expectedLeafHashHex = expectedLeafHash ? hex.encode(expectedLeafHash) : void 0;
   for (const [tapScriptSigData, signature] of input.tapScriptSig) {
     const pubKey = tapScriptSigData.pubKey;
     const pubKeyHex = hex.encode(pubKey);
     if (excludePubkeys.includes(pubKeyHex)) {
       continue;
     }
+    if (expectedLeafHashHex !== void 0) {
+      const signedLeafHex = hex.encode(tapScriptSigData.leafHash);
+      if (signedLeafHex !== expectedLeafHashHex) {
+        throw new Error(
+          `Input ${inputIndex}: signature from ${pubKeyHex} commits to leaf ${signedLeafHex}, expected ${expectedLeafHashHex}`
+        );
+      }
+    }
     const sighashType = signature.length === 65 ? signature[64] : SigHash.DEFAULT;
     const sig = signature.subarray(0, 64);
     if (!allowedSighashTypes.includes(sighashType)) {
@@ -2383,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,
@@ -2394,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());
       })
     );
@@ -2681,6 +2892,14 @@ function getRandomId() {
   const randomValue = crypto.getRandomValues(new Uint8Array(16));
   return hex.encode(randomValue);
 }
+function isValidArkAddress2(address) {
+  try {
+    ArkAddress.decode(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
 function validateRecipients(recipients, dustAmount) {
   const validatedRecipients = [];
   for (const recipient of recipients) {
@@ -4900,11 +5119,6 @@ function createExitChainResolver(params) {
   return new OrderedExitChainResolver(sources, params.repository);
 }
 
-// src/providers/availability.ts
-function isRetryableProviderError(error) {
-  return error instanceof ProviderUnavailableError || error instanceof FetchError || isFetchTimeoutError(error);
-}
-
 // src/utils/syncCursors.ts
 var SAFETY_LAG_MS = 3e4;
 var OVERLAP_MS = 24 * 60 * 60 * 1e3;
@@ -5527,8 +5741,20 @@ function subtractAssets(spent, change) {
   if (map.size === 0) return void 0;
   return Array.from(map, ([assetId, amount]) => ({ assetId, amount }));
 }
-async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, getTxCreatedAt) {
+function collectArkTxidsNeedingCreatedAt(vtxos) {
+  const ownTxids = new Set(vtxos.map((v) => v.txid));
+  const txids = /* @__PURE__ */ new Set();
+  for (const vtxo of vtxos) {
+    if (vtxo.isSpent && vtxo.arkTxId && !ownTxids.has(vtxo.arkTxId)) {
+      txids.add(vtxo.arkTxId);
+    }
+  }
+  return [...txids];
+}
+async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnore, resolveTxCreatedAt) {
   const fromOldestVtxo = vtxos.map(normalizeVtxo).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+  const txidsNeedingCreatedAt = resolveTxCreatedAt ? collectArkTxidsNeedingCreatedAt(fromOldestVtxo) : [];
+  const resolvedCreatedAt = resolveTxCreatedAt && txidsNeedingCreatedAt.length > 0 ? await resolveTxCreatedAt(txidsNeedingCreatedAt) : /* @__PURE__ */ new Map();
   const unmatchedSettledBoardingTxs = allBoardingTxs.filter(isSettledBoardingReceive).sort((a, b) => a.createdAt - b.createdAt);
   const sent = [];
   let received = [];
@@ -5588,7 +5814,7 @@ async function buildTransactionHistory(vtxos, allBoardingTxs, commitmentsToIgnor
           txTime = changes[0].createdAt.getTime();
         } else {
           txAmount = spentAmount;
-          txTime = getTxCreatedAt ? await getTxCreatedAt(vtxo.arkTxId) ?? vtxo.createdAt.getTime() + 1 : vtxo.createdAt.getTime() + 1;
+          txTime = resolvedCreatedAt.get(vtxo.arkTxId) ?? vtxo.createdAt.getTime() + 1;
         }
         const assets = subtractAssets(allSpent, changes);
         if (txAmount !== 0 || assets) {
@@ -11088,11 +11314,13 @@ var ReadonlyWallet = class _ReadonlyWallet {
     const response = await contractManager.getContractsWithVtxos();
     const allVtxos = response.flatMap((_) => _.vtxos);
     const { boardingTxs, commitmentsToIgnore } = await this.getBoardingTxs();
-    const getTxCreatedAt = (txid) => getNormalizedVtxos(this.indexerProvider, { outpoints: [{ txid, vout: 0 }] }).then((res) => res.vtxos[0]?.createdAt.getTime()).catch((err) => {
-      if (isRetryableProviderError(err)) return void 0;
-      throw err;
-    });
-    return buildTransactionHistory(allVtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
+    const resolveTxCreatedAt = (txids) => fetchVtxoCreatedAtByTxid(this.indexerProvider, txids);
+    return buildTransactionHistory(
+      allVtxos,
+      boardingTxs,
+      commitmentsToIgnore,
+      resolveTxCreatedAt
+    );
   }
   /**
    * Wallet history grouped by registered activity resolvers. With no resolver match,
@@ -11923,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
@@ -12733,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() || [];
@@ -12858,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);
@@ -12915,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();
@@ -12943,7 +13226,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           event,
           inputs,
           this.forfeitOutputScript,
-          connectorTree
+          expectedRecipients,
+          connectorTree,
+          validatedCommitmentTxid
         );
       }
     };
@@ -13102,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) => {
@@ -13117,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)
             );
@@ -13172,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;
@@ -13404,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())
@@ -13819,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);
         }
@@ -14607,6 +14941,25 @@ var DustChangeError = class extends Error {
     this.dustAmount = dustAmount;
   }
 };
+var offboardNetworkNames = [
+  "bitcoin",
+  "regtest",
+  "testnet",
+  "signet",
+  "mutinynet"
+];
+function offboardDestinationScript(destinationAddress) {
+  for (const networkName of offboardNetworkNames) {
+    try {
+      const network = networks$1[networkName];
+      const addr = Address(network).decode(destinationAddress);
+      return OutScript.encode(addr);
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`Failed to decode destination address: ${destinationAddress}`);
+}
 var Ramps = class {
   /**
    * Create convenience wrappers for onboarding and offboarding flows.
@@ -14744,27 +15097,7 @@ var Ramps = class {
       throw new DustChangeError(change, dustAmount);
     }
     amount = amount ?? totalAmount;
-    const networkNames = [
-      "bitcoin",
-      "regtest",
-      "testnet",
-      "signet",
-      "mutinynet"
-    ];
-    let destinationScript;
-    for (const networkName of networkNames) {
-      try {
-        const network = networks$1[networkName];
-        const addr = Address(network).decode(destinationAddress);
-        destinationScript = OutScript.encode(addr);
-        break;
-      } catch {
-        continue;
-      }
-    }
-    if (!destinationScript) {
-      throw new Error(`Failed to decode destination address: ${destinationAddress}`);
-    }
+    const destinationScript = offboardDestinationScript(destinationAddress);
     const outputFee = estimator.evalOnchainOutput({
       amount,
       script: hex.encode(destinationScript)
@@ -15796,47 +16129,15 @@ var WalletMessageHandler = class {
     return allVtxos;
   }
   /**
-   * Build transaction history from cached virtual outputs without hitting the indexer.
-   * Falls back to indexer only for uncached transaction timestamps.
+   * Build transaction history from cached virtual outputs, hitting the indexer only for
+   * uncached timestamps. Best-effort, like the plain Wallet path.
    */
   async buildTransactionHistoryFromCache(vtxos) {
     if (!this.readonlyWallet) return null;
     const { boardingTxs, commitmentsToIgnore } = await this.readonlyWallet.getBoardingTxs();
-    const vtxoCreatedAt = /* @__PURE__ */ new Map();
-    for (const vtxo of vtxos) {
-      const existing = vtxoCreatedAt.get(vtxo.txid);
-      const ts = vtxo.createdAt.getTime();
-      if (existing === void 0 || ts < existing) {
-        vtxoCreatedAt.set(vtxo.txid, ts);
-      }
-    }
-    if (this.indexerProvider) {
-      const uncachedTxids = /* @__PURE__ */ new Set();
-      for (const vtxo of vtxos) {
-        if (vtxo.isSpent && vtxo.arkTxId && !vtxoCreatedAt.has(vtxo.arkTxId) && !vtxos.some((v) => v.txid === vtxo.arkTxId)) {
-          uncachedTxids.add(vtxo.arkTxId);
-        }
-      }
-      if (uncachedTxids.size > 0) {
-        const outpoints = [...uncachedTxids].map((txid) => ({
-          txid,
-          vout: 0
-        }));
-        const BATCH_SIZE = 100;
-        for (let i = 0; i < outpoints.length; i += BATCH_SIZE) {
-          const res = await getNormalizedVtxos(this.indexerProvider, {
-            outpoints: outpoints.slice(i, i + BATCH_SIZE)
-          });
-          for (const v of res.vtxos) {
-            vtxoCreatedAt.set(v.txid, v.createdAt.getTime());
-          }
-        }
-      }
-    }
-    const getTxCreatedAt = async (txid) => {
-      return vtxoCreatedAt.get(txid);
-    };
-    return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, getTxCreatedAt);
+    const indexerProvider = this.indexerProvider;
+    const resolveTxCreatedAt = indexerProvider ? (txids) => fetchVtxoCreatedAtByTxid(indexerProvider, txids) : void 0;
+    return buildTransactionHistory(vtxos, boardingTxs, commitmentsToIgnore, resolveTxCreatedAt);
   }
   async ensureContractEventBroadcasting() {
     if (!this.readonlyWallet) return;
@@ -19013,19 +19314,48 @@ async function estimate(opts) {
 }
 
 // src/wallet/exit/executor.ts
+function abortErrorFor(signal) {
+  if (signal.reason !== void 0) return signal.reason;
+  const e = new Error("The operation was aborted");
+  e.name = "AbortError";
+  return e;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortErrorFor(signal);
+}
 var Executor = class {
   constructor(pkg, provider, opts) {
     this.pkg = pkg;
     this.provider = provider;
     this.pollIntervalMs = opts?.pollIntervalMs ?? 5e3;
     this.feeWallet = opts?.feeWallet;
+    this.signal = opts?.signal;
   }
   pkg;
   provider;
   pollIntervalMs;
   feeWallet;
+  signal;
+  /**
+   * Poll delay. Nearly all wall-clock time is spent here, so it must be the
+   * thing that reacts to abort — checking only between polls would leave
+   * cancellation up to a full interval late and the timer still pending.
+   */
   sleep() {
-    return new Promise((r) => setTimeout(r, this.pollIntervalMs));
+    const signal = this.signal;
+    if (!signal) return new Promise((r) => setTimeout(r, this.pollIntervalMs));
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) return reject(abortErrorFor(signal));
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(abortErrorFor(signal));
+      };
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, this.pollIntervalMs);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
   }
   async status(txid) {
     try {
@@ -19038,10 +19368,12 @@ var Executor = class {
     for (; ; ) {
       const s = await this.status(txid);
       if (s?.confirmed) return s;
+      throwIfAborted(this.signal);
       await this.sleep();
     }
   }
   async *[Symbol.asyncIterator]() {
+    throwIfAborted(this.signal);
     const dead = /* @__PURE__ */ new Set();
     if (this.pkg.validUntil && Date.now() / 1e3 > this.pkg.validUntil) {
       yield {
@@ -19153,6 +19485,7 @@ var Executor = class {
     while (done.size < pending.length) {
       for (const { index, step } of pending) {
         if (done.has(index)) continue;
+        throwIfAborted(this.signal);
         const swept = await this.status(step.txid);
         if (swept?.confirmed) {
           done.add(index);
@@ -19500,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);
@@ -19535,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();
@@ -19558,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() || [];
@@ -20024,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);
@@ -20112,6 +20455,360 @@ function attachExtension(tx, newPackets) {
   }
   tx.addOutput({ script: newOut.script, amount: newOut.amount });
 }
+
+// src/utils/bip21.ts
+var BIP21Error = /* @__PURE__ */ ((BIP21Error2) => {
+  BIP21Error2["INVALID_URI"] = "Invalid BIP21 URI";
+  BIP21Error2["INVALID_ADDRESS"] = "Invalid address";
+  return BIP21Error2;
+})(BIP21Error || {});
+var BIP21 = class _BIP21 {
+  /**
+   * Create a BIP21 URI from the provided parameters.
+   *
+   * @param params - BIP21 parameters to encode
+   * @returns Encoded BIP21 URI
+   */
+  static create(params) {
+    const { address, ...options } = params;
+    const queryParams = {};
+    for (const [key, value] of Object.entries(options)) {
+      if (value === void 0) continue;
+      if (key === "amount") {
+        const amount = value;
+        if (!isFinite(amount) || !Number.isSafeInteger(Math.trunc(amount))) {
+          console.warn("Invalid amount");
+          continue;
+        }
+        if (amount < 0) {
+          continue;
+        }
+        queryParams[key] = value;
+      } else if (key === "ark") {
+        if (typeof value === "string" && (value.startsWith("ark") || value.startsWith("tark"))) {
+          queryParams[key] = value;
+        } else {
+          console.warn("Invalid ARK address format");
+        }
+      } else if (key === "sp") {
+        if (typeof value === "string" && value.startsWith("sp")) {
+          queryParams[key] = value;
+        } else {
+          console.warn("Invalid Silent Payment address format");
+        }
+      } else if (typeof value === "string" || typeof value === "number") {
+        queryParams[key] = value;
+      }
+    }
+    const query = Object.keys(queryParams).length > 0 ? "?" + new URLSearchParams(
+      Object.fromEntries(
+        Object.entries(queryParams).map(([k, v]) => [k, String(v)])
+      )
+    ).toString() : "";
+    return `bitcoin:${address ? address.toLowerCase() : ""}${query}`;
+  }
+  /**
+   * Integer-sats amount encoded in a BIP21 URI (`amount=` is BTC), or
+   * `undefined` when absent or the URI is unparseable. Shared by the payment
+   * rails, which accept either a bare address or a BIP21 URI.
+   *
+   * @param uri - BIP21 URI (or bare address) to read the amount from
+   * @returns The amount in satoshis, or `undefined`
+   */
+  static amountSats(uri) {
+    try {
+      const btc = _BIP21.parse(uri).params.amount;
+      return typeof btc === "number" ? Math.round(btc * 1e8) : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Parse a BIP21 URI and return its decoded parameters.
+   *
+   * @param uri - BIP21 URI to parse
+   * @returns Parsed BIP21 URI data
+   * @throws Error if the URI does not start with the `bitcoin:` scheme
+   */
+  static parse(uri) {
+    if (!uri.toLowerCase().startsWith("bitcoin:")) {
+      throw new Error("Invalid BIP21 URI" /* INVALID_URI */);
+    }
+    const withoutPrefix = uri.slice(uri.toLowerCase().indexOf("bitcoin:") + 8);
+    const [address, query] = withoutPrefix.split("?");
+    const params = {};
+    if (address) {
+      params.address = address.toLowerCase();
+    }
+    if (query) {
+      const queryParams = new URLSearchParams(query);
+      for (const [key, value] of queryParams.entries()) {
+        if (!value) continue;
+        if (key === "amount") {
+          if (!/^(?:\d+\.?\d*|\.\d+)$/.test(value)) {
+            continue;
+          }
+          const amount = Number(value);
+          if (!isFinite(amount) || !Number.isSafeInteger(Math.trunc(amount))) {
+            continue;
+          }
+          params[key] = amount;
+        } else if (key === "ark") {
+          if (value.startsWith("ark") || value.startsWith("tark")) {
+            params[key] = value;
+          } else {
+            console.warn("Invalid ARK address format");
+          }
+        } else if (key === "sp") {
+          if (value.startsWith("sp")) {
+            params[key] = value;
+          } else {
+            console.warn("Invalid Silent Payment address format");
+          }
+        } else {
+          params[key] = value;
+        }
+      }
+    }
+    return {
+      originalString: uri,
+      params
+    };
+  }
+};
+
+// src/payment/predicates.ts
+var isLightningInvoice = (raw) => /^ln(bcrt|bc|tbs|tb|sb)[0-9a-z]+$/i.test(raw.replace(/^lightning:/i, ""));
+var isLnurl = (raw) => /^lnurl/i.test(raw) || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(raw);
+var BECH32_BTC = /^(bc1|tb1|bcrt1)[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,90}$/;
+var isBech32Btc = (raw) => (raw === raw.toLowerCase() || raw === raw.toUpperCase()) && BECH32_BTC.test(raw.toLowerCase());
+var isBtcAddress = (raw) => isBech32Btc(raw) || /^[13mn2][a-km-zA-HJ-NP-Z1-9]{25,39}$/.test(raw);
+
+// src/payment/targets.ts
+var fromBip21 = (raw, key, accept) => {
+  try {
+    const v = BIP21.parse(raw).params[key];
+    return typeof v === "string" && accept(v) ? v : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var arkTarget = (raw) => isValidArkAddress2(raw) ? raw : fromBip21(raw, "ark", isValidArkAddress2);
+var btcTarget = (raw) => isBtcAddress(raw) ? raw : fromBip21(raw, "address", isBtcAddress);
+var invoiceTarget = (raw) => {
+  const invoice = isLightningInvoice(raw) ? raw : fromBip21(raw, "lightning", isLightningInvoice);
+  return invoice?.replace(/^lightning:/i, "");
+};
+
+// src/payment/amount.ts
+function assertSendableAmount(railId, amt) {
+  if (!Number.isInteger(amt) || amt <= 0) {
+    throw new Error(`${railId}: invalid amount ${amt} sats (expected a positive integer)`);
+  }
+}
+function resolveSendAmount(railId, raw, amount) {
+  const amt = amount ?? BIP21.amountSats(raw);
+  if (amt === void 0) {
+    throw new Error(
+      `${railId}: an amount is required (none provided or encoded in the request)`
+    );
+  }
+  assertSendableAmount(railId, amt);
+  return amt;
+}
+function tryResolveSendAmount(raw, amount) {
+  const amt = amount ?? BIP21.amountSats(raw);
+  return amt !== void 0 && Number.isInteger(amt) && amt > 0 ? amt : void 0;
+}
+
+// src/payment/handle.ts
+function makeHandle(id, run) {
+  let status = "pending";
+  let last = { status };
+  const subs = /* @__PURE__ */ new Set();
+  const notify = (f, u) => {
+    try {
+      f(u);
+    } catch {
+    }
+  };
+  const isTerminal = (s) => s === "settled" || s === "failed";
+  const emit = (u) => {
+    status = u.status;
+    last = u;
+    for (const f of subs) notify(f, u);
+    if (isTerminal(u.status)) subs.clear();
+  };
+  const done = run(emit);
+  done.catch((error) => {
+    if (status !== "settled") emit({ status: "failed", error });
+  });
+  return {
+    id,
+    get status() {
+      return status;
+    },
+    subscribe(fn) {
+      notify(fn, last);
+      if (isTerminal(status)) return () => {
+      };
+      subs.add(fn);
+      return () => subs.delete(fn);
+    },
+    settled(opts) {
+      if (!opts?.timeoutMs) return done;
+      let timer;
+      return Promise.race([
+        done,
+        new Promise((_, rej) => {
+          timer = setTimeout(() => rej(new Error("settle timeout")), opts.timeoutMs);
+        })
+      ]).finally(() => clearTimeout(timer));
+    }
+  };
+}
+
+// src/payment/router.ts
+var AmbiguousRouteError = class extends Error {
+  constructor(railIds) {
+    super(`ambiguous route: ${railIds.join(", ")}`);
+    this.railIds = railIds;
+    this.name = "AmbiguousRouteError";
+  }
+  railIds;
+};
+var PaymentRouter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  rails = /* @__PURE__ */ new Map();
+  /** Register a rail (or overwrite one with the same id). */
+  use(rail) {
+    this.rails.set(rail.id, rail);
+    return this;
+  }
+  /** Remove a rail by id. */
+  remove(id) {
+    this.rails.delete(id);
+    return this;
+  }
+  /** Rails matching `req`, filtered by `disabled`/`available()`, ranked by
+   *  `priority` (unlisted rails keep insertion order, after listed ones). */
+  async options(req, prefs) {
+    const merged = { ...this.ctx.prefs, ...prefs };
+    const ctx = { ...this.ctx, prefs: merged };
+    const matched = [...this.rails.values()].filter(
+      (rail) => !merged.disabled?.includes(rail.id) && rail.match(req, ctx)
+    );
+    const available = (await Promise.all(
+      matched.map(async (rail) => {
+        try {
+          return await rail.available?.(req, ctx) ?? true ? rail : null;
+        } catch (e) {
+          console.warn(`payment rail "${rail.id}": available() threw`, e);
+          return null;
+        }
+      })
+    )).filter((rail) => rail !== null);
+    const rank = (id) => {
+      const i = merged.priority?.indexOf(id) ?? -1;
+      return i < 0 ? Number.MAX_SAFE_INTEGER : i;
+    };
+    available.sort((a, b) => rank(a.id) - rank(b.id));
+    return available.map((rail) => ({
+      railId: rail.id,
+      quote: () => rail.quote(req, ctx)
+    }));
+  }
+  /** Top-ranked option's quote. Throws when nothing routes, or
+   *  {@link AmbiguousRouteError} when `tieBreak` is `"require-choice"` and
+   *  more than one option survives. */
+  async route(req, prefs) {
+    const options = await this.options(req, prefs);
+    if (options.length === 0) {
+      throw new Error(`no rail for: ${req.raw}`);
+    }
+    const tieBreak = { ...this.ctx.prefs, ...prefs }.tieBreak ?? "first";
+    if (tieBreak === "require-choice" && options.length > 1) {
+      throw new AmbiguousRouteError(options.map((o) => o.railId));
+    }
+    return options[0].quote();
+  }
+};
+
+// src/payment/rails/ark.ts
+function arkRail() {
+  return {
+    id: "ark",
+    match: (req) => arkTarget(req.raw) !== void 0,
+    quote: async (req, ctx) => {
+      const address = arkTarget(req.raw);
+      const amt = resolveSendAmount("ark", req.raw, req.amount);
+      return {
+        railId: "ark",
+        amount: amt,
+        fee: 0,
+        total: amt,
+        send: async () => makeHandle("ark", async (emit) => {
+          const txid = await ctx.wallet.send({ address, amount: amt });
+          const result = { railId: "ark", txid };
+          emit({ status: "settled", result });
+          return result;
+        })
+      };
+    }
+  };
+}
+var GROSS_UP_MAX_ROUNDS = 8;
+function grossUpOffboard(net, feeInfo, script) {
+  const estimator = new Estimator(feeInfo?.intentFee ?? {});
+  const feeAt = (amount) => estimator.evalOnchainOutput({ amount: BigInt(amount), script }).satoshis;
+  let gross = net;
+  for (let i = 0; i < GROSS_UP_MAX_ROUNDS; i++) {
+    const next = net + feeAt(gross);
+    if (next === gross) break;
+    gross = next;
+  }
+  return { gross, fee: gross - net };
+}
+function onchainRail() {
+  return {
+    id: "onchain",
+    match: (req) => btcTarget(req.raw) !== void 0,
+    quote: async (req, ctx) => {
+      const address = btcTarget(req.raw);
+      const amt = resolveSendAmount("onchain", req.raw, req.amount);
+      const { fees } = await ctx.wallet.arkProvider.getInfo();
+      const script = hex.encode(offboardDestinationScript(address));
+      const { gross, fee } = grossUpOffboard(amt, fees, script);
+      return {
+        railId: "onchain",
+        amount: amt,
+        fee,
+        total: gross,
+        send: async () => makeHandle("onchain", async (emit) => {
+          const txid = await new Ramps(ctx.wallet).offboard(
+            address,
+            fees,
+            BigInt(gross)
+          );
+          const result = { railId: "onchain", txid };
+          emit({ status: "settled", result });
+          return result;
+        })
+      };
+    }
+  };
+}
+
+// src/payment/index.ts
+function createDefaultPaymentRouter(wallet) {
+  return new PaymentRouter({
+    wallet,
+    prefs: { priority: ["ark", "lightning", "onchain"] }
+  }).use(arkRail()).use(onchainRail());
+}
 var ARKCONTRACT_PREFIX = "arkcontract";
 function encodeArkContract(contract) {
   const params = new URLSearchParams();
@@ -20171,6 +20868,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ARKADE_MAGIC, ActivityRegistry, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, 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, 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, arkade_exports, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isMessageBusInitializingError, isMessageBusNotInitializedError, isRetryableProviderError, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-3MMUKLCI.js.map
-//# sourceMappingURL=chunk-3MMUKLCI.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