@arkade-os/sdk 0.4.68 → 0.4.70

package/dist/{chunk-VBHXBI7F.js → chunk-JVHO6XHG.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-33Q2RFET.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, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-45FKMOJH.js';
-import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, PrevoutTxField, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-4CMXV5SF.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-F5E7LI6G.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, toXOnly, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-6UM55KPZ.js';
+import { VtxoScript, Transaction, isRecoverable, CSVMultisigTapscript, DEFAULT_NETWORK, resolveEmulatorPubkey, hasTerminalSpend, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, getSequence, toBatchExpiry, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, getNetwork, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, RestArkProvider, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, PrevoutTxField, DEFAULT_ARKADE_SERVER_URL, ProviderUnavailableError, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-TXSF2DKX.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { sha256 as sha256$1, 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';
@@ -1649,6 +1649,16 @@ var EsploraProvider = class {
   baseUrl;
   pollingInterval;
   forcePolling;
+  /**
+   * Live {@link watchAddresses} subscriptions, keyed by their address set.
+   *
+   * Concurrent watchers over the same addresses share one transport, so a
+   * caller that opens watchers in a loop — or leaks them by abandoning
+   * {@link waitForIncomingFunds} — costs one entry in a `Set` rather than
+   * another WebSocket plus another full-history polling loop. Entries are
+   * dropped once their last subscriber stops.
+   */
+  addressWatches = /* @__PURE__ */ new Map();
   async getCoins(address) {
     const response = await baseFetch(`${this.baseUrl}/address/${address}/utxo`);
     if (!response.ok) {
@@ -1693,6 +1703,18 @@ var EsploraProvider = class {
     }
     return response.json();
   }
+  /**
+   * Activity counts for an address, without its transactions — orders of
+   * magnitude smaller than `/address/{addr}/txs`, which is what makes it
+   * usable as a change probe for the polling fallback.
+   */
+  async getAddressStats(address) {
+    const response = await baseFetch(`${this.baseUrl}/address/${address}`);
+    if (!response.ok) {
+      throw new Error(`Failed to get address stats: ${response.statusText}`);
+    }
+    return response.json();
+  }
   async getRawTransaction(txid) {
     const response = await baseFetch(`${this.baseUrl}/tx/${txid}/hex`);
     if (!response.ok) {
@@ -1724,50 +1746,227 @@ var EsploraProvider = class {
       blockHeight: data.block_height
     };
   }
+  /**
+   * Watch a set of addresses over the explorer's WebSocket, degrading to HTTP
+   * polling whenever the socket is unavailable and returning to the socket as
+   * soon as it can be re-established.
+   *
+   * Concurrent calls covering the same address set share one transport. The
+   * returned function releases **this** subscription only; the transport is
+   * torn down when the last subscriber releases it. Calling it more than once
+   * is a no-op.
+   *
+   * @param addresses - Addresses to monitor; order is not significant
+   * @param callback - Invoked with transactions seen after the watch started
+   * @returns A function releasing this subscription
+   * @remarks
+   * The HTTP fallback fetches full address history per address per cycle,
+   * which is dramatically more expensive than the socket — so callers should
+   * release watches they no longer need rather than relying on sharing.
+   * @see {@link waitForIncomingFunds} for the cancellation-aware wallet-level helper
+   */
   async watchAddresses(addresses, callback) {
-    let intervalId = null;
+    const key = [...addresses].sort().join("\0");
+    let watch = this.addressWatches.get(key);
+    if (!watch) {
+      watch = this.createAddressWatch(addresses, () => this.addressWatches.delete(key));
+      this.addressWatches.set(key, watch);
+    }
+    const subscriber = { callback };
+    watch.subscribers.add(subscriber);
+    const shared = watch;
+    await shared.started;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      shared.subscribers.delete(subscriber);
+      if (shared.subscribers.size === 0) shared.teardown();
+    };
+  }
+  /**
+   * Bring up one shared address watch: a WebSocket subscription where the
+   * explorer supports it, degrading to HTTP polling when it doesn't.
+   *
+   * @param addresses - Addresses this watch covers
+   * @param onTeardown - Invoked when the watch retires, to drop the registry entry
+   */
+  createAddressWatch(addresses, onTeardown) {
+    const subscribers = /* @__PURE__ */ new Set();
     const wsUrl = this.baseUrl.replace(/^http(s)?:/, "ws$1:") + "/v1/ws";
-    const poll = async () => {
-      const getAllTxs = async () => {
-        const txArrays = await Promise.all(
-          addresses.map((address) => this.getTransactions(address))
-        );
-        return txArrays.flat();
+    let stopped = false;
+    let timer = null;
+    let pollStarted = false;
+    let ws = null;
+    let reconnectTimer = null;
+    let reconnectFailures = 0;
+    let pollSession = 0;
+    const emit = (txs) => {
+      if (stopped || txs.length === 0) return;
+      for (const subscriber of [...subscribers]) {
+        try {
+          subscriber.callback(txs);
+        } catch (error) {
+          console.error("Address watch subscriber threw:", error);
+        }
+      }
+    };
+    const txKey2 = (tx) => `${tx.txid}_${tx.status.block_time}`;
+    const getAllTxs = async () => {
+      const txArrays = await Promise.all(
+        addresses.map((address) => this.getTransactions(address))
+      );
+      return txArrays.flat();
+    };
+    const seen = /* @__PURE__ */ new Set();
+    let baselined = false;
+    let anchorHeight;
+    const baseline = (async () => {
+      const [history, tip] = await Promise.allSettled([getAllTxs(), this.getChainTip()]);
+      if (history.status === "fulfilled") {
+        for (const tx of history.value) seen.add(txKey2(tx));
+        baselined = true;
+        return;
+      }
+      console.warn(
+        "Could not baseline watched addresses; the first poll pass will establish it instead:",
+        history.reason
+      );
+      if (tip.status === "fulfilled") anchorHeight = tip.value.height;
+    })();
+    const report = (txs) => {
+      const fresh = [];
+      for (const tx of txs) {
+        const key = txKey2(tx);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        fresh.push(tx);
+      }
+      if (fresh.length === 0) return;
+      emit(fresh);
+    };
+    const startPolling = async () => {
+      if (stopped || pollStarted) return;
+      pollStarted = true;
+      console.warn(
+        `Esplora websocket unavailable (${wsUrl}); falling back to HTTP polling every ${this.pollingInterval}ms for ${addresses.length} address(es) while retrying the socket`
+      );
+      let failures = 0;
+      const activityFingerprint = async () => {
+        try {
+          const stats = await Promise.all(
+            addresses.map((address) => this.getAddressStats(address))
+          );
+          const counted = (activity) => typeof activity?.tx_count === "number" && typeof activity.funded_txo_count === "number" && typeof activity.spent_txo_count === "number";
+          const usable = stats.every(
+            (s) => counted(s?.chain_stats) && counted(s?.mempool_stats)
+          );
+          if (!usable) return void 0;
+          if (stats.some((s) => s.mempool_stats.tx_count > 0)) return void 0;
+          return stats.map(
+            ({ chain_stats: chain }) => `${chain.tx_count}:${chain.funded_txo_count}:${chain.spent_txo_count}`
+          ).join(",");
+        } catch {
+          return void 0;
+        }
+      };
+      let lastFingerprint;
+      const session = pollSession;
+      const isCurrentLoop = () => !stopped && session === pollSession;
+      const schedule = () => {
+        if (!isCurrentLoop()) return;
+        timer = setTimeout(tick, this.pollingInterval * 2 ** failures);
       };
-      const initialTxs = await getAllTxs();
-      const txKey2 = (tx) => `${tx.txid}_${tx.status.block_time}`;
-      const existingTxs = new Set(initialTxs.map(txKey2));
-      intervalId = setInterval(async () => {
+      const tick = async () => {
         try {
+          const fingerprint = await activityFingerprint();
+          if (!isCurrentLoop()) return;
+          if (fingerprint !== void 0 && fingerprint === lastFingerprint) {
+            failures = 0;
+            schedule();
+            return;
+          }
           const currentTxs = await getAllTxs();
-          const newTxs = currentTxs.filter((tx) => !existingTxs.has(txKey2(tx)));
-          if (newTxs.length > 0) {
-            newTxs.forEach((tx) => existingTxs.add(txKey2(tx)));
-            callback(newTxs);
+          if (!isCurrentLoop()) return;
+          lastFingerprint = fingerprint;
+          if (baselined) {
+            report(currentTxs);
+          } else if (anchorHeight !== void 0) {
+            const arrivedAfterStart = (tx) => !tx.status.confirmed || tx.status.block_height === void 0 || tx.status.block_height > anchorHeight;
+            for (const tx of currentTxs) {
+              if (!arrivedAfterStart(tx)) seen.add(txKey2(tx));
+            }
+            baselined = true;
+            report(currentTxs);
+          } else {
+            console.warn(
+              `Esplora address watch established its baseline late for ${addresses.length} address(es); deposits arriving before now may not have been reported`
+            );
+            for (const tx of currentTxs) seen.add(txKey2(tx));
+            baselined = true;
           }
+          failures = 0;
         } catch (error) {
-          console.error("Error in polling mechanism:", error);
+          failures = Math.min(failures + 1, MAX_POLL_BACKOFF_EXPONENT);
+          console.error("Error polling watched addresses:", error);
         }
-      }, this.pollingInterval);
+        schedule();
+      };
+      await baseline;
+      if (!isCurrentLoop()) return;
+      await tick();
     };
-    let ws = null;
-    const stopFunc = () => {
-      if (ws) ws.close();
-      if (intervalId) clearInterval(intervalId);
+    const stopPolling = () => {
+      pollSession++;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      pollStarted = false;
     };
-    if (this.forcePolling) {
-      await poll();
-      return stopFunc;
-    }
-    try {
-      ws = new WebSocket(wsUrl);
-      ws.addEventListener("open", () => {
+    const handleSocketFailure = () => {
+      if (stopped) return Promise.resolve();
+      scheduleReconnect();
+      return startPolling();
+    };
+    const scheduleReconnect = () => {
+      if (stopped || reconnectTimer !== null) return;
+      const delay = RECONNECT_BASE_DELAY_MS * 2 ** Math.min(reconnectFailures, MAX_RECONNECT_BACKOFF_EXPONENT);
+      reconnectFailures++;
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        connect();
+      }, delay);
+    };
+    const connect = () => {
+      if (stopped) return Promise.resolve();
+      const previous = ws;
+      ws = null;
+      if (previous) {
+        try {
+          previous.close();
+        } catch {
+        }
+      }
+      let socket;
+      try {
+        socket = new WebSocket(wsUrl);
+      } catch {
+        return handleSocketFailure();
+      }
+      ws = socket;
+      const isCurrent = () => !stopped && ws === socket;
+      socket.addEventListener("open", () => {
+        if (!isCurrent()) return;
+        reconnectFailures = 0;
         const subscribeMsg = {
           "track-addresses": addresses
         };
-        ws.send(JSON.stringify(subscribeMsg));
+        socket.send(JSON.stringify(subscribeMsg));
+        stopPolling();
       });
-      ws.addEventListener("message", (event) => {
+      socket.addEventListener("message", (event) => {
+        if (!isCurrent()) return;
         try {
           const newTxs = [];
           const message = JSON.parse(event.data.toString());
@@ -1779,22 +1978,48 @@ var EsploraProvider = class {
               newTxs.push(...aux[address][type].filter(isExplorerTransaction));
             }
           }
-          if (newTxs.length > 0) callback(newTxs);
+          report(newTxs);
         } catch (error) {
           console.error("Failed to process WebSocket message:", error);
         }
       });
-      ws.addEventListener("error", async () => {
-        await poll();
+      socket.addEventListener("error", () => {
+        if (isCurrent()) void handleSocketFailure();
       });
-    } catch {
-      if (intervalId) clearInterval(intervalId);
-      await poll();
-    }
-    return stopFunc;
+      socket.addEventListener("close", () => {
+        if (isCurrent()) void handleSocketFailure();
+      });
+      return Promise.resolve();
+    };
+    const teardown = () => {
+      if (stopped) return;
+      stopped = true;
+      onTeardown();
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (reconnectTimer !== null) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+        ws = null;
+      }
+      subscribers.clear();
+    };
+    const started = this.forcePolling ? startPolling() : connect().then(() => baseline);
+    return { subscribers, teardown, started };
   }
   async getChainTip() {
-    const tipBlocks = await baseFetch(`${this.baseUrl}/blocks`);
+    let tipBlocks = await baseFetch(`${this.baseUrl}/blocks`);
+    if (tipBlocks.status === 404) {
+      tipBlocks = await baseFetch(`${this.baseUrl}/v1/blocks`);
+    }
     if (!tipBlocks.ok) {
       throw new Error(`Failed to get chain tip: ${tipBlocks.statusText}`);
     }
@@ -1808,6 +2033,8 @@ var EsploraProvider = class {
     const hash = tip[0].id;
     return {
       height: tip[0].height,
+      // `mediantime`, never `timestamp`: the latter is the header's own
+      // `nTime`, and this field is specified as MTP.
       time: tip[0].mediantime,
       hash
     };
@@ -1873,6 +2100,9 @@ var isExplorerTransaction = (tx) => {
     (vout) => typeof vout.scriptpubkey_address === "string" && typeof vout.value === "number"
   ) && typeof tx.status === "object" && typeof tx.status.confirmed === "boolean";
 };
+var MAX_POLL_BACKOFF_EXPONENT = 4;
+var RECONNECT_BASE_DELAY_MS = 1e3;
+var MAX_RECONNECT_BACKOFF_EXPONENT = 5;
 var getVarIntSize = (n) => {
   if (n < 253) return 1;
   if (n <= 65535) return 3;
@@ -16278,19 +16508,53 @@ function selectVirtualCoins(coins, targetAmount) {
     changeAmount
   };
 }
-async function waitForIncomingFunds(wallet) {
+var AbortError = class extends Error {
+  constructor(message = "Operation aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+function abortReason(signal) {
+  const { reason } = signal;
+  if (reason instanceof Error) return reason;
+  return new AbortError(typeof reason === "string" ? reason : void 0);
+}
+async function waitForIncomingFunds(wallet, options) {
+  const { signal, timeoutMs } = options ?? {};
+  if (signal?.aborted) throw abortReason(signal);
   let stopFunc;
   let settled = false;
-  return new Promise((resolve) => {
+  let timeoutId;
+  let onAbort;
+  return new Promise((resolve, reject) => {
+    const settle = (deliver) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId !== void 0) clearTimeout(timeoutId);
+      if (onAbort) signal?.removeEventListener("abort", onAbort);
+      stopFunc?.();
+      deliver();
+    };
+    const cancel = (reason) => settle(() => reject(reason));
+    if (signal) {
+      onAbort = () => cancel(abortReason(signal));
+      signal.addEventListener("abort", onAbort);
+    }
+    if (timeoutMs !== void 0) {
+      timeoutId = setTimeout(
+        () => cancel(new AbortError(`waitForIncomingFunds timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+    }
     wallet.notifyIncomingFunds((funds) => {
       const hasFunds = funds.type === "utxo" ? funds.coins.length > 0 : funds.newVtxos.length > 0;
       if (settled || !hasFunds) return;
-      settled = true;
-      resolve(funds);
-      stopFunc?.();
+      settle(() => resolve(funds));
     }).then((stop) => {
       stopFunc = stop;
       if (settled) stop();
+    }).catch((error) => {
+      cancel(error);
     });
   });
 }
@@ -20120,6 +20384,7 @@ var ListUnspentMethod = "blockchain.scripthash.listunspent";
 var MISSING_TRANSACTION = "missingtransaction";
 var MAX_FETCH_TRANSACTIONS_ATTEMPTS = 5;
 var BLOCK_HEADER_SIZE = 80;
+var MTP_WINDOW = 11;
 function parseBlockHeader(headerHex) {
   const headerBytes = hex.decode(headerHex);
   if (headerBytes.length !== BLOCK_HEADER_SIZE) {
@@ -20426,6 +20691,8 @@ var ElectrumOnchainProvider = class {
   ws;
   network;
   chain;
+  mtpCache;
+  mtpInflight;
   async getCoins(address) {
     const script = this.encodeAddress(address);
     const scriptHash = toScriptHash(script);
@@ -20681,15 +20948,58 @@ var ElectrumOnchainProvider = class {
       blockTime
     };
   }
+  /** `time` is median-time-past, per {@link OnchainProvider.getChainTip};
+   *  Electrum serves raw headers and no MTP, so it is computed here. */
   async getChainTip() {
     const tip = await this.chain.subscribeHeaders();
     const { hash, timestamp } = parseBlockHeader(tip.hex);
     return {
       height: tip.height,
-      time: timestamp,
+      time: await this.medianTimePast(tip.height, timestamp, hash),
       hash
     };
   }
+  /**
+   * Consensus's `GetMedianTimePast`, ending at and including `height`.
+   *
+   * Cached per tip HASH, not height: this runs on every balance read, and
+   * hashing means a reorg at the same height recomputes rather than serving
+   * the orphaned chain's median.
+   */
+  async medianTimePast(height, tipTime, hash) {
+    if (this.mtpCache?.hash === hash) return this.mtpCache.mtp;
+    if (this.mtpInflight?.hash === hash) return this.mtpInflight.mtp;
+    const mtp = this.readMedianTimePast(height, tipTime, hash).finally(() => {
+      this.mtpInflight = void 0;
+    });
+    this.mtpInflight = { hash, mtp };
+    return mtp;
+  }
+  /** Degrades to the tip's `nTime` rather than throwing — a caller that
+   *  cannot read the tip at all is worse off. */
+  async readMedianTimePast(height, tipTime, hash) {
+    const heights = [];
+    for (let h = height - 1; h >= 0 && heights.length < MTP_WINDOW - 1; h--) heights.push(h);
+    if (heights.length === 0) return tipTime;
+    let timestamps;
+    try {
+      const headers = await this.chain.fetchBlockHeaders(heights);
+      timestamps = [
+        tipTime,
+        ...headers.map((header) => parseBlockHeader(header.hex).timestamp)
+      ];
+    } catch (e) {
+      console.warn(
+        "Failed to fetch the median-time-past window; using the tip's own time",
+        e
+      );
+      return tipTime;
+    }
+    timestamps.sort((a, b) => a - b);
+    const mtp = timestamps[Math.floor(timestamps.length / 2)];
+    this.mtpCache = { hash, mtp };
+    return mtp;
+  }
   async watchAddresses(addresses, eventCallback) {
     const scripts = addresses.map((addr) => this.encodeAddress(addr));
     const scriptHashes = scripts.map(toScriptHash);
@@ -23313,6 +23623,33 @@ function tryResolveSendAmount(raw, amount) {
   const amt = amount ?? BIP21.amountSats(raw);
   return amt !== void 0 && Number.isInteger(amt) && amt > 0 ? amt : void 0;
 }
+function assetsOf(req) {
+  return req.assets ?? [];
+}
+function assertNoAssets(railId, req) {
+  const assets = assetsOf(req);
+  if (assets.length > 0) {
+    throw new Error(
+      `${railId}: cannot deliver ${assets.map((a) => a.assetId).join(", ")} \u2014 this rail moves BTC only`
+    );
+  }
+}
+function resolveAssetAmount(railId, req) {
+  const assets = assetsOf(req);
+  if (assets.length !== 1) {
+    throw new Error(`${railId}: expected exactly one asset to pay, got ${assets.length}`);
+  }
+  const [asset] = assets;
+  if (typeof asset.amount !== "bigint" || asset.amount <= 0n) {
+    throw new Error(
+      `${railId}: invalid amount ${String(asset.amount)} of ${asset.assetId} (expected a positive bigint of atomic units)`
+    );
+  }
+  if (typeof asset.assetId !== "string" || asset.assetId.length === 0) {
+    throw new Error(`${railId}: an asset amount must name an asset`);
+  }
+  return asset;
+}
 
 // src/payment/handle.ts
 function makeHandle(id, run) {
@@ -23435,8 +23772,10 @@ function arkRail() {
   return {
     id: "ark",
     match: (req) => arkTarget(req.raw) !== void 0,
+    available: (req) => assetsOf(req).length === 0,
     quote: async (req, ctx) => {
       const address = arkTarget(req.raw);
+      assertNoAssets("ark", req);
       const amt = resolveSendAmount("ark", req.raw, req.amount);
       return {
         railId: "ark",
@@ -23453,6 +23792,41 @@ function arkRail() {
     }
   };
 }
+
+// src/payment/rails/arkAsset.ts
+var ASSET_CARRIER_SATS = 330;
+function arkAssetRail() {
+  return {
+    id: "ark-asset",
+    match: (req) => arkTarget(req.raw) !== void 0,
+    // A malformed asset is `quote()`'s to name, not this rail's to drop.
+    available: (req) => assetsOf(req).length > 0,
+    quote: async (req, ctx) => {
+      const address = arkTarget(req.raw);
+      const asset = resolveAssetAmount("ark-asset", req);
+      if (req.amount !== void 0) assertSendableAmount("ark-asset", req.amount);
+      const carrier = tryResolveSendAmount(req.raw, req.amount) ?? ASSET_CARRIER_SATS;
+      return {
+        railId: "ark-asset",
+        amount: carrier,
+        fee: 0,
+        total: carrier,
+        assets: { delivered: asset, spent: asset },
+        send: async () => makeHandle("ark-asset", async (emit) => {
+          const txid = await ctx.wallet.send({
+            address,
+            amount: carrier,
+            assets: [asset]
+          });
+          const result = { railId: "ark-asset", txid };
+          emit({ status: "settled", result });
+          return result;
+        })
+      };
+    }
+  };
+}
+var walletFeeSource = (wallet) => async () => (await wallet.arkProvider.getInfo()).fees;
 var GROSS_UP_MAX_ROUNDS = 8;
 function grossUpOffboard(net, feeInfo, script) {
   const estimator = new Estimator(feeInfo?.intentFee ?? {});
@@ -23465,14 +23839,20 @@ function grossUpOffboard(net, feeInfo, script) {
   }
   return { gross, fee: gross - net };
 }
-function onchainRail() {
+function onchainRail(deps) {
+  if (typeof deps?.feeInfo !== "function") {
+    throw new Error("onchain rail: a feeInfo source is required");
+  }
   return {
     id: "onchain",
     match: (req) => btcTarget(req.raw) !== void 0,
+    // BTC only: an Arkade asset has no L1 representation to offboard to.
+    available: (req) => assetsOf(req).length === 0,
     quote: async (req, ctx) => {
+      assertNoAssets("onchain", req);
       const address = btcTarget(req.raw);
       const amt = resolveSendAmount("onchain", req.raw, req.amount);
-      const { fees } = await ctx.wallet.arkProvider.getInfo();
+      const fees = await deps.feeInfo();
       const script = hex.encode(offboardDestinationScript(address));
       const { gross, fee } = grossUpOffboard(amt, fees, script);
       return {
@@ -23499,8 +23879,8 @@ function onchainRail() {
 function createDefaultPaymentRouter(wallet) {
   return new PaymentRouter({
     wallet,
-    prefs: { priority: ["ark", "lightning", "onchain"] }
-  }).use(arkRail()).use(onchainRail());
+    prefs: { priority: ["ark", "ark-asset", "lightning", "onchain"] }
+  }).use(arkRail()).use(arkAssetRail()).use(onchainRail({ feeInfo: walletFeeSource(wallet) }));
 }
 /*! Bundled license information:
 
@@ -23508,6 +23888,6 @@ function createDefaultPaymentRouter(wallet) {
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-VBHXBI7F.js.map
-//# sourceMappingURL=chunk-VBHXBI7F.js.map
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorIdentity, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, ForeignDescriptorError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertIntentIdUnique, assertNoAssets, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getMigrationStatus, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, intentPageBounds, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, isWatchedContract, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, migrateWalletRepository, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, promisifyRequest, provisionClaimSecret, provisionRefundKey, requiresMigration, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, toXOnlySignerHex, tryResolveSendAmount, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
+//# sourceMappingURL=chunk-JVHO6XHG.js.map
+//# sourceMappingURL=chunk-JVHO6XHG.js.map