@arkade-os/sdk 0.4.52 → 0.4.54

package/dist/{chunk-AXCKRS2D.js → chunk-TEHJCEF3.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-ZK3JITHP.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-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 { __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);
 }
@@ -2279,7 +2282,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 +2297,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)) {
@@ -2681,6 +2693,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 +4920,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 +5542,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 +5615,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 +11115,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,
@@ -14083,6 +14112,12 @@ var ServiceWorkerTimeoutError = class extends Error {
     super(detail);
   }
 };
+function isMessageBusNotInitializedError(error) {
+  return error instanceof Error && error.message.includes(MESSAGE_BUS_NOT_INITIALIZED);
+}
+function isMessageBusInitializingError(error) {
+  return error instanceof Error && error.message.includes(MESSAGE_BUS_INITIALIZING);
+}
 
 // src/worker/messageBus.ts
 var LATE_DELIVERY_GRACE_MS = 5 * 6e4;
@@ -14601,6 +14636,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.
@@ -14738,27 +14792,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)
@@ -15790,47 +15824,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;
@@ -15853,12 +15855,6 @@ var WalletMessageHandler = class {
 };
 
 // src/wallet/serviceWorker/wallet.ts
-function isMessageBusNotInitializedError(error) {
-  return error instanceof Error && error.message.includes(MESSAGE_BUS_NOT_INITIALIZED);
-}
-function isMessageBusInitializingError(error) {
-  return error instanceof Error && error.message.includes(MESSAGE_BUS_INITIALIZING);
-}
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var INIT_WAIT_BACKOFF_CAP_MS = 2e3;
 var MAX_INIT_WAITS = 8;
@@ -19013,19 +19009,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 +19063,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 +19180,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);
@@ -20112,6 +20140,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 +20553,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, 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-AXCKRS2D.js.map
-//# sourceMappingURL=chunk-AXCKRS2D.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, 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