@arkade-os/sdk 0.4.67 → 0.5.0-rc.0

package/dist/{chunk-AEWJU6NZ.js → chunk-6F2Q32KA.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-X3VEMUVV.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-6TAQF6EV.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, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, 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-3WIWNE4P.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-FVTJJQNM.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-KTU44AEH.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, networkFromArkadeInfo, toVirtualStatus, ArkError, TapTreeCoder, resolveTimeHeight, canSpendOffchain, parseLegacyExpiry, isExpired, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, ProviderUnavailableError, DEFAULT_ARKADE_SERVER_URL, networks as networks$1, isPastExpiry, fetchVtxoCreatedAtByTxid } from './chunk-PPG6W34P.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';
@@ -272,7 +272,7 @@ function getPrevOutput(finalKey, graph, sharedOutputAmount, tx) {
     script: pkScript
   };
 }
-var ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
+var ALLOWED_SIGHASH = [SigHash.DEFAULT, SigHash.ALL, SigHash.ALL_ANYONECANPAY];
 var SingleKey = class _SingleKey {
   key;
   constructor(key) {
@@ -301,8 +301,9 @@ var SingleKey = class _SingleKey {
   async sign(tx, inputIndexes) {
     const txCpy = tx.clone();
     if (!inputIndexes) {
+      assertAllowedSighashTypes(txCpy, ALLOWED_SIGHASH);
       try {
-        if (!txCpy.sign(this.key, ALL_SIGHASH)) {
+        if (!txCpy.sign(this.key, ALLOWED_SIGHASH)) {
           throw new Error("Failed to sign transaction");
         }
       } catch (e) {
@@ -313,7 +314,7 @@ var SingleKey = class _SingleKey {
       return txCpy;
     }
     for (const inputIndex of inputIndexes) {
-      if (!txCpy.signIdx(this.key, inputIndex, ALL_SIGHASH)) {
+      if (!txCpy.signIdx(this.key, inputIndex, ALLOWED_SIGHASH)) {
         throw new Error(`Failed to sign input #${inputIndex}`);
       }
     }
@@ -378,7 +379,7 @@ var ReadonlySingleKey = class _ReadonlySingleKey {
     return Promise.resolve(this.publicKey);
   }
 };
-var ALL_SIGHASH2 = Object.values(SigHash).filter((x) => typeof x === "number");
+var ALLOWED_SIGHASH2 = [SigHash.DEFAULT, SigHash.ALL, SigHash.ALL_ANYONECANPAY];
 var seedBytes = /* @__PURE__ */ new WeakMap();
 var mnemonicMeta = /* @__PURE__ */ new WeakMap();
 var SeedIdentity = class _SeedIdentity {
@@ -581,8 +582,9 @@ var SeedIdentity = class _SeedIdentity {
   signTxWithKey(tx, key, inputIndexes) {
     const txCpy = tx.clone();
     if (!inputIndexes) {
+      assertAllowedSighashTypes(txCpy, ALLOWED_SIGHASH2);
       try {
-        if (!txCpy.sign(key, ALL_SIGHASH2)) {
+        if (!txCpy.sign(key, ALLOWED_SIGHASH2)) {
           throw new Error("Failed to sign transaction");
         }
       } catch (e) {
@@ -592,7 +594,7 @@ var SeedIdentity = class _SeedIdentity {
       }
     } else {
       for (const idx of inputIndexes) {
-        if (!txCpy.signIdx(key, idx, ALL_SIGHASH2)) {
+        if (!txCpy.signIdx(key, idx, ALLOWED_SIGHASH2)) {
           throw new Error(`Failed to sign input #${idx}`);
         }
       }
@@ -3085,9 +3087,6 @@ function hasBoardingTxExpired(coin, boardingTimelock, chainTipHeight) {
   const blockTime = BigInt(Math.floor(coin.status.block_time));
   return blockTime + boardingTimelock.value <= now;
 }
-function formatSighash(type) {
-  return `0x${type.toString(16).padStart(2, "0")}`;
-}
 function verifyTapscriptSignatures(tx, inputIndex, requiredSigners, excludePubkeys = [], allowedSighashTypes = [SigHash.DEFAULT], expectedLeafHash) {
   const input = tx.getInput(inputIndex);
   const prevoutScripts = [];
@@ -3305,6 +3304,15 @@ async function submitOffchainTx(provider, offchainTx, signer, hooks, options) {
   assertSubmittedArkTxid(response, signedArkTx, "submitTx");
   const { arkTxid, signedCheckpointTxs } = response;
   const matched = matchServerCheckpoints(signedCheckpointTxs, offchainTx.checkpoints, "submitTx");
+  matched.forEach(({ server }, index) => {
+    try {
+      assertAllowedSighashTypes(server);
+    } catch (error) {
+      throw new ServerResponseMismatchError(
+        `submitTx checkpoint ${index}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
   const verify = options?.verifyServerSignatures;
   if (verify) {
     if (response.finalArkTx === void 0) {
@@ -3643,7 +3651,7 @@ function isValidArkAddress2(address) {
     return false;
   }
 }
-function assertRecipientArkAddress(encoded, address, context) {
+function assertRecipientArkadeAddress(encoded, address, context) {
   if (address.hrp !== context.hrp) {
     throw new Error(
       `Invalid Arkade address ${encoded}: expected prefix "${context.hrp}", got "${address.hrp}"`
@@ -3686,7 +3694,7 @@ function validateRecipients(recipients, dustAmount, context) {
     } catch (e) {
       throw new Error(`Invalid Arkade address: ${recipient.address}`);
     }
-    assertRecipientArkAddress(recipient.address, address, context);
+    assertRecipientArkadeAddress(recipient.address, address, context);
     const amount = recipient.amount || dustAmount;
     if (amount <= 0) {
       throw new Error("Amount must be positive");
@@ -3906,6 +3914,7 @@ function getRecoverableWithSubdust(vtxos, dustAmount, now) {
   };
 }
 function isVtxoExpiringSoon(vtxo, thresholdMs) {
+  if (vtxo.isUnrolled) return false;
   const realThresholdMs = thresholdMs <= 100 ? DEFAULT_THRESHOLD_MS : thresholdMs;
   const expiresAt = normalizeVtxo(vtxo).expiresAt;
   if (expiresAt === void 0) return false;
@@ -3916,7 +3925,9 @@ function isVtxoExpiringSoon(vtxo, thresholdMs) {
 }
 function getExpiringAndRecoverableVtxos(vtxos, thresholdMs, dustAmount, now) {
   return vtxos.filter(
-    (vtxo) => isVtxoExpiringSoon(vtxo, thresholdMs) || canRecoverOnchain(vtxo, now) || isSubdust(vtxo, dustAmount)
+    // The leading exclusion covers the `isSubdust` arm too, which is a value
+    // property and would otherwise re-admit an exited coin on its own.
+    (vtxo) => !vtxo.isUnrolled && (isVtxoExpiringSoon(vtxo, thresholdMs) || canRecoverOnchain(vtxo, now) || isSubdust(vtxo, dustAmount))
   );
 }
 function isMigrationCapable(wallet) {
@@ -4574,7 +4585,7 @@ var VtxoManager = class _VtxoManager {
   }
   /**
    * Core migration routine shared by the manual API and the automatic poll
-   * pass. Fetches a fresh {@link ArkInfo}, applies a mid-session signer
+   * pass. Fetches a fresh {@link ArkadeInfo}, applies a mid-session signer
    * rotation when the wallet's own snapshot signer has been deprecated,
    * selects spendable VTXOs under deprecated-signer contracts (cutoff-first),
    * and settles them to the active-signer Ark address.
@@ -6357,12 +6368,12 @@ async function saveArkInfoSnapshot(repo, info, savedAt) {
     }
   }));
 }
-async function resolveArkInfo(arkProvider, walletRepository) {
+async function resolveArkInfo(arkProvider, walletRepository, opts) {
   let info;
   try {
     info = await arkProvider.getInfo();
   } catch (err) {
-    if (!isRetryableProviderError(err)) throw err;
+    if (opts?.requireLive || !isRetryableProviderError(err)) throw err;
     const snapshot = await loadArkInfoSnapshot(walletRepository);
     if (!snapshot) {
       throw new ProviderUnavailableError(
@@ -6448,6 +6459,13 @@ var TxTree = class {
     if (nbOfInputs !== 1) {
       throw new Error(`unexpected number of inputs: ${nbOfInputs}, expected 1`);
     }
+    if (this.root.lockTime !== 0) {
+      throw new Error(`unexpected locktime: ${this.root.lockTime}, expected 0`);
+    }
+    const sequence = this.root.getInput(0).sequence;
+    if (sequence !== void 0 && sequence !== DEFAULT_SEQUENCE) {
+      throw new Error(`unexpected sequence: ${sequence}, expected ${DEFAULT_SEQUENCE}`);
+    }
     if (this.children.size > nbOfOutputs - 1) {
       throw new Error(
         `unexpected number of children: ${this.children.size}, expected maximum ${nbOfOutputs - 1}`
@@ -12079,6 +12097,7 @@ function filterSnapshotVtxos(snapshot, filter, pendingSpendOutpoints) {
   });
 }
 var PENDING_RECOVERY_REASON = "is past its operator signer's rotation cutoff \u2014 the operator will not co-sign it until it recovers";
+var UNROLLED_REASON = "was unilaterally exited and lives onchain \u2014 `Unroll.completeUnroll` is the only spend that reaches it";
 function omittedOutpoints(before, after) {
   if (before.length === after.length) return /* @__PURE__ */ new Set();
   const kept = new Set(after.map((vtxo) => `${vtxo.txid}:${vtxo.vout}`));
@@ -12121,10 +12140,11 @@ var ArkadeCashCreateError = class extends Error {
   cause;
 };
 var ReadonlyWallet = class _ReadonlyWallet {
-  constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, walletContractTimelocks) {
+  constructor(identity, network, onchainProvider, arkProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, walletContractTimelocks) {
     this.identity = identity;
     this.network = network;
     this.onchainProvider = onchainProvider;
+    this.arkProvider = arkProvider;
     this.indexerProvider = indexerProvider;
     this.dustAmount = dustAmount;
     this.walletRepository = walletRepository;
@@ -12150,6 +12170,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   identity;
   network;
   onchainProvider;
+  arkProvider;
   indexerProvider;
   dustAmount;
   walletRepository;
@@ -12217,14 +12238,19 @@ var ReadonlyWallet = class _ReadonlyWallet {
    */
   _arkServerPublicKey;
   /**
-   * Whether this wallet was constructed from live operator server-info
-   * (`"live"`) or from a cached snapshot because the operator was unreachable
-   * (`"cache"`). Freshness signal for {@link getProviderConnectionState}.
+   * Whether the LATEST server-info resolution answered live (`"live"`) or
+   * from the cached snapshot because the operator was unreachable
+   * (`"cache"`). Seeded at construction and updated by every
+   * {@link getArkadeInfo} read, so a wallet that booted offline and
+   * recovered stops reporting degraded — and one that just fell back stops
+   * claiming online. Freshness signal for
+   * {@link getProviderConnectionState}.
    */
   _serverInfoSource = "live";
   /**
-   * Epoch-ms of the last known live operator contact: construction time on the
-   * `live` boot path, the cached snapshot's `savedAt` on the `cache` path.
+   * Epoch-ms of the last known live operator contact: the most recent live
+   * resolution (construction or a later {@link getArkadeInfo}), or the
+   * cached snapshot's `savedAt` when the latest resolution fell back.
    */
   _serverInfoLastOnlineAt;
   /** @see {@link _serverInfoSource} */
@@ -12232,13 +12258,15 @@ var ReadonlyWallet = class _ReadonlyWallet {
     return this._serverInfoSource;
   }
   /**
-   * Composed provider-connection freshness: the boot server-info source
-   * (Arkade) combined with the contract-manager's indexer-sync health, if the
-   * manager has been initialized. Reads no live provider state — it never
-   * forces a `ContractManager` to construct — so it is safe for readonly
-   * callers that only use address/balance APIs.
+   * Composed provider-connection freshness: the LATEST server-info
+   * resolution (boot, or any later {@link getArkadeInfo} read) combined with
+   * the contract-manager's indexer-sync health, if the manager has been
+   * initialized. Reads no live provider state — it never forces a
+   * `ContractManager` to construct — so it is safe for readonly callers
+   * that only use address/balance APIs.
    *
-   *  - Boot fell back to a cached snapshot → degraded on `arkade` (`cache`).
+   *  - Latest resolution fell back to the cached snapshot → degraded on
+   *    `arkade` (`cache`).
    *  - Otherwise, if the contract manager has degraded to repository data →
    *    degraded on `indexer` (`repository`).
    *  - Otherwise online.
@@ -12284,7 +12312,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
   }
   /**
    * x-only hex of the operator's deprecated signer keys (from
-   * `ArkInfo.deprecatedSigners`), cached for the OFFLINE read/watch paths.
+   * `ArkadeInfo.deprecatedSigners`), cached for the OFFLINE read/watch paths.
    * The boarding watch/history surfaces ({@link getBoardingAddresses},
    * {@link getBoardingTxs}) fan out over {current} ∪ this set so a deposit at
    * a boarding address minted under a now-rotated operator signer keeps being
@@ -12359,6 +12387,64 @@ var ReadonlyWallet = class _ReadonlyWallet {
   get arkServerPublicKey() {
     return this._arkServerPublicKey;
   }
+  /**
+   * Server info for the Arkade server this wallet is connected to, resolved
+   * exactly as construction resolves it: live wins, a retryable failure
+   * falls back to the snapshot persisted at boot, a terminal one propagates.
+   *
+   * Live rather than the pinned boot snapshot because the fields callers
+   * come here for — `signerPubkey`, `checkpointTapscript`, `fees` — are the
+   * ones a mid-session rotation moves, and a covenant built against a
+   * superseded signer is unspendable.
+   *
+   * One rotation caveat: reading does NOT re-pin the wallet —
+   * {@link arkServerPublicKey}, {@link dustAmount} and the tapscripts move
+   * only through `handleServerInfoChanged`/`rotateServerSigner` — so inside
+   * a rotation window this can report epoch N+1 while the wallet still
+   * spends on N. The window closes on its own: a read that observes a moved
+   * digest makes the provider emit `onServerInfoChanged`, which is what
+   * drives that rotation. A caller about to bind the answer into a covenant
+   * passes `{ requireLive: true }` and fails closed instead of receiving
+   * the boot snapshot.
+   *
+   * @returns The Arkade server's info
+   * @see ArkadeInfo
+   */
+  async getArkadeInfo(opts) {
+    const { info, source, lastOnlineAt } = await resolveArkInfo(
+      this.arkProvider,
+      this.walletRepository,
+      opts
+    );
+    this._serverInfoSource = source;
+    if (source === "live") {
+      this._serverInfoLastOnlineAt = Date.now();
+    } else if (lastOnlineAt !== void 0) {
+      this._serverInfoLastOnlineAt = lastOnlineAt;
+    }
+    return info;
+  }
+  /**
+   * Chain reads against this wallet's server for scripts it does not own.
+   *
+   * Binds the wallet's own `indexerProvider` — which may be an Expo or
+   * injected one that a caller's hand-built `RestIndexerProvider` would
+   * silently bypass. `getVtxos` goes through
+   * {@link getNormalizedVtxos}, which is what makes every VTXO leaving the
+   * seam carry its canonical facts.
+   *
+   * A bound object rather than the provider itself, so an `IReadonlyWallet`
+   * holder gets `getVtxos`/`getVirtualTxs` and nothing else at runtime.
+   * (`indexerProvider` is still public on the concrete classes, unlike
+   * `arkProvider`, so this narrows the interface rather than the field.)
+   */
+  async getArkadeReader() {
+    const indexer = this.indexerProvider;
+    return {
+      getVtxos: (opts) => getNormalizedVtxos(indexer, opts),
+      getVirtualTxs: (txids, opts) => indexer.getVirtualTxs(txids, opts)
+    };
+  }
   /**
    * The wallet's current boarding tapscript (the on-chain onboarding
    * target). Read-only from the outside; mutated only via
@@ -12437,7 +12523,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       source: serverInfoSource,
       lastOnlineAt: serverInfoLastOnlineAt
     } = await resolveArkInfo(arkProvider, walletRepository);
-    const network = getNetwork(info.network);
+    const network = networkFromArkadeInfo(info);
     if ("descriptor" in config.identity) {
       const descriptor = config.identity.descriptor;
       const identityIsMainnet = !descriptor.includes("tpub");
@@ -12527,6 +12613,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
       config.identity,
       setup.network,
       setup.onchainProvider,
+      setup.arkProvider,
       setup.indexerProvider,
       setup.serverPubKey,
       setup.offchainTapscript,
@@ -12651,6 +12738,13 @@ var ReadonlyWallet = class _ReadonlyWallet {
         "is locked by an in-flight settlement intent"
       )
     ]);
+    if (!filter?.withUnrolled) {
+      logExcludedVtxos(
+        "getSpendableVtxos",
+        snapshot.flatMap((contract) => contract.vtxos).filter((vtxo) => vtxo.isUnrolled && !hasTerminalSpend(vtxo)),
+        [() => UNROLLED_REASON]
+      );
+    }
     return unlocked;
   }
   /**
@@ -13367,6 +13461,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       identity,
       network,
       onchainProvider,
+      arkProvider,
       indexerProvider,
       arkServerPublicKey,
       offchainTapscript,
@@ -13378,7 +13473,6 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       watcherConfig,
       walletContractTimelocks
     );
-    this.arkProvider = arkProvider;
     this.forfeitOutputScript = forfeitOutputScript;
     this.forfeitPubkey = forfeitPubkey;
     this.batchExpiryPolicy = batchExpiryPolicy;
@@ -13412,7 +13506,6 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       boardingPkScript: boardingTapscript.pkScript
     });
   }
-  arkProvider;
   forfeitOutputScript;
   forfeitPubkey;
   batchExpiryPolicy;
@@ -13575,7 +13668,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   /**
    * Output script for checkpoint transactions, decoded from the server's
    * `checkpointTapscript`. Server-controlled state: pinned at construction
-   * and re-sourced from a fresh `ArkInfo` on server-signer rotation. Read it
+   * and re-sourced from a fresh `ArkadeInfo` on server-signer rotation. Read it
    * through {@link serverUnrollScript}; write it only through
    * {@link setServerUnrollScriptForRotation}.
    */
@@ -13586,7 +13679,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   /**
    * @internal Sole write path for `serverUnrollScript` after construction.
    * Called by {@link Wallet._doRotateServerSigner} with the checkpoint script
-   * sourced from the fresh `ArkInfo` that triggered the rotation, so the send
+   * sourced from the fresh `ArkadeInfo` that triggered the rotation, so the send
    * path builds checkpoints against the new server epoch. External code must
    * treat `serverUnrollScript` as read-only.
    */
@@ -14218,6 +14311,21 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
   /** @deprecated Use settlementConfig instead */
   renewalConfig;
   settlementConfig;
+  /**
+   * Broadcast access bound to this wallet's server, so a plugin needs only
+   * the wallet.
+   *
+   * Defined here and not on {@link ReadonlyWallet} for the same reason
+   * `arkProvider` is protected there: a readonly wallet, and every
+   * `toReadonly()` view, must not be able to submit.
+   */
+  async getArkadeBroadcaster() {
+    const ark = this.arkProvider;
+    return {
+      submitTx: (signedArkTx, checkpointTxs) => ark.submitTx(signedArkTx, checkpointTxs),
+      finalizeTx: (arkTxid, finalCheckpointTxs) => ark.finalizeTx(arkTxid, finalCheckpointTxs)
+    };
+  }
   get assetManager() {
     this._walletAssetManager ??= new AssetManager(this);
     return this._walletAssetManager;
@@ -14397,6 +14505,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       readonlyIdentity,
       this.network,
       this.onchainProvider,
+      this.arkProvider,
       this.indexerProvider,
       this.arkServerPublicKey,
       this.offchainTapscript,
@@ -14449,7 +14558,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           changeAmount: BigInt(changeAmount)
         };
         const outputAddress = ArkAddress.decode(params.address);
-        assertRecipientArkAddress(
+        assertRecipientArkadeAddress(
           params.address,
           outputAddress,
           this.recipientAddressContext(serverPubKey)
@@ -14602,7 +14711,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       }
       if (arkAddress) {
         recipientContext ??= this.recipientAddressContext();
-        assertRecipientArkAddress(output.address, arkAddress, recipientContext);
+        assertRecipientArkadeAddress(output.address, arkAddress, recipientContext);
         script = arkAddress.pkScript;
         hasOffchainOutputs = true;
       } else {
@@ -15203,9 +15312,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
           seen.add(pendingTx.arkTxid);
           batchPending.push(pendingTx.arkTxid);
           try {
-            const checkpointTxs = pendingTx.signedCheckpointTxs.map(
-              (c) => Transaction$2.fromPSBT(base64.decode(c))
-            );
+            const checkpointTxs = pendingTx.signedCheckpointTxs.map((c) => {
+              const tx = Transaction$2.fromPSBT(base64.decode(c));
+              assertAllowedSighashTypes(tx);
+              return tx;
+            });
             assertCheckpointsMatchInputs(
               checkpointTxs,
               checkpointInputs,
@@ -15373,7 +15484,9 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     const myPkScript = ArkAddress.decode(await this.getAddress()).pkScript;
     let { spendable, unclaimed } = this.classifyCashVtxos(vtxos);
     let swept = 0;
-    const drainable = vtxos.filter((vtxo) => !isSubdust(vtxo, this.dustAmount));
+    const drainable = vtxos.filter(
+      (vtxo) => !isSubdust(vtxo, this.dustAmount) && !vtxo.isUnrolled
+    );
     if (drainable.length > 0) {
       let drained = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
       try {
@@ -15533,9 +15646,11 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     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))
-        );
+        const checkpointTxs = pendingTx.signedCheckpointTxs.map((checkpoint) => {
+          const tx = Transaction$2.fromPSBT(base64.decode(checkpoint));
+          assertAllowedSighashTypes(tx);
+          return tx;
+        });
         assertCheckpointsMatchInputs(
           checkpointTxs,
           inputs.map((input) => ({
@@ -16800,6 +16915,9 @@ var MessageBus = class {
         });
       return;
     }
+    if (response.error instanceof Error && !response.errorName) {
+      response.errorName = response.error.name;
+    }
     source.postMessage(response);
   }
   /**
@@ -17393,6 +17511,49 @@ var WalletMessageHandler = class {
             payload: { address }
           });
         }
+        case "GET_ARKADE_INFO": {
+          const { payload } = message;
+          const info = await this.readonlyWallet.getArkadeInfo(payload);
+          return this.tagged({
+            id,
+            type: "ARKADE_INFO",
+            payload: { info }
+          });
+        }
+        case "INDEXER_GET_VTXOS": {
+          const { opts } = message.payload;
+          const reader = await this.readonlyWallet.getArkadeReader();
+          return this.tagged({
+            id,
+            type: "INDEXER_VTXOS",
+            payload: await reader.getVtxos(opts)
+          });
+        }
+        case "INDEXER_GET_VIRTUAL_TXS": {
+          const { txids, opts } = message.payload;
+          const reader = await this.readonlyWallet.getArkadeReader();
+          return this.tagged({
+            id,
+            type: "INDEXER_VIRTUAL_TXS",
+            payload: await reader.getVirtualTxs(txids, opts)
+          });
+        }
+        case "SUBMIT_TX": {
+          const { signedArkTx, checkpointTxs } = message.payload;
+          const broadcaster = await this.requireWallet().getArkadeBroadcaster();
+          const result = await broadcaster.submitTx(signedArkTx, checkpointTxs);
+          return this.tagged({
+            id,
+            type: "SUBMIT_TX_SUCCESS",
+            payload: result
+          });
+        }
+        case "FINALIZE_TX": {
+          const { arkTxid, finalCheckpointTxs } = message.payload;
+          const broadcaster = await this.requireWallet().getArkadeBroadcaster();
+          await broadcaster.finalizeTx(arkTxid, finalCheckpointTxs);
+          return this.tagged({ id, type: "FINALIZE_TX_SUCCESS" });
+        }
         case "GET_BALANCE": {
           const balance = await this.handleGetBalance();
           return this.tagged({
@@ -18284,6 +18445,13 @@ var WalletMessageHandler = class {
 
 // src/wallet/serviceWorker/wallet.ts
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var restoreErrorName = (response) => {
+  const error = response.error;
+  if (response.errorName && error instanceof Error && error.name !== response.errorName) {
+    error.name = response.errorName;
+  }
+  return error;
+};
 var INIT_WAIT_BACKOFF_CAP_MS = 2e3;
 var MAX_INIT_WAITS = 8;
 var initWaitBackoffMs = (attempt) => Math.min(100 * 2 ** attempt, INIT_WAIT_BACKOFF_CAP_MS);
@@ -18306,6 +18474,14 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   GET_USED_SIGNING_DESCRIPTORS: 2e4,
   ADVANCE_SIGNING_DESCRIPTOR_WATERMARK: 1e4,
   // Medium reads — may involve indexer queries
+  // A live `/v1/info` fetch queued behind the same per-origin rate gate as
+  // the indexer, not a repository read. Derived from the fetch's own abort
+  // budget so the worker's snapshot fallback stays reachable before this
+  // page deadline fires — lowering it below the budget would time the page
+  // out while the worker is still seconds from answering from cache.
+  GET_ARKADE_INFO: INFO_FETCH_TIMEOUT_MS + 8e3,
+  INDEXER_GET_VTXOS: 2e4,
+  INDEXER_GET_VIRTUAL_TXS: 2e4,
   GET_VTXOS: 2e4,
   GET_SPENDABLE_VTXOS: 2e4,
   GET_BOARDING_UTXOS: 2e4,
@@ -18328,6 +18504,10 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   SEND_BITCOIN: 5e4,
   SEND: 5e4,
   SETTLE: 5e4,
+  // Broadcast: the server round-trip a spend ends in, so it belongs
+  // with the writes rather than the reads above.
+  SUBMIT_TX: 5e4,
+  FINALIZE_TX: 5e4,
   ISSUE: 5e4,
   REISSUE: 5e4,
   BURN: 5e4,
@@ -18354,6 +18534,9 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
 };
 var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
   "GET_ADDRESS",
+  "GET_ARKADE_INFO",
+  "INDEXER_GET_VTXOS",
+  "INDEXER_GET_VIRTUAL_TXS",
   "GET_BALANCE",
   "GET_BOARDING_ADDRESS",
   "GET_BOARDING_UTXOS",
@@ -18445,7 +18628,7 @@ var initializeMessageBus = (serviceWorker, config, timeoutMs = 2e3) => {
       if (response?.id !== initCmd.id) return;
       cleanup();
       if (response.error) {
-        reject(response.error);
+        reject(restoreErrorName(response));
       } else {
         resolve();
       }
@@ -18617,7 +18800,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         }
         cleanup();
         if (response.error) {
-          reject(response.error);
+          reject(restoreErrorName(response));
         } else {
           resolve(response);
         }
@@ -18643,7 +18826,7 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
         if (request.id !== response.id) return;
         if (response.error) {
           cleanup();
-          reject(response.error);
+          reject(restoreErrorName(response));
           return;
         }
         if (isComplete(response)) {
@@ -18869,6 +19052,68 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
       throw new Error(`Failed to get boarding address: ${error}`);
     }
   }
+  /**
+   * Delegated to the worker, which holds the wallet that owns the connection.
+   * The payload crosses raw — see {@link ResponseGetArkadeInfo} for why.
+   */
+  async getArkadeInfo(opts) {
+    const message = {
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "GET_ARKADE_INFO",
+      // omitted entirely for the default read: wire-shape hygiene
+      // toward workers built before the option existed. (Dedup is
+      // unaffected either way — the key is JSON.stringify, which drops
+      // undefined-valued properties.)
+      ...opts?.requireLive ? { payload: { requireLive: true } } : {}
+    };
+    try {
+      const response = await this.sendMessage(message);
+      return response.payload.info;
+    } catch (error) {
+      throw new Error(`Failed to get arkade info: ${error}`, { cause: error });
+    }
+  }
+  /**
+   * An {@link ArkadeReader} that speaks to the worker rather than to the
+   * server. The page holds no provider, so a caller that built its own from a
+   * URL would open a second connection outside the worker's rate gate and
+   * caches — this proxy is what keeps chain reads in one place.
+   */
+  async getArkadeReader() {
+    return {
+      getVtxos: async (opts) => {
+        const message = {
+          id: getRandomId(),
+          tag: this.messageTag,
+          type: "INDEXER_GET_VTXOS",
+          payload: { opts }
+        };
+        try {
+          const response = await this.sendMessage(message);
+          const { vtxos, page } = response.payload;
+          return { vtxos: vtxos.map(normalizeVtxo), page: page && { ...page } };
+        } catch (error) {
+          throw new Error(`Failed to get vtxos: ${error}`, { cause: error });
+        }
+      },
+      getVirtualTxs: async (txids, opts) => {
+        const message = {
+          id: getRandomId(),
+          tag: this.messageTag,
+          type: "INDEXER_GET_VIRTUAL_TXS",
+          payload: { txids, opts }
+        };
+        try {
+          const response = await this.sendMessage(message);
+          const { txs, page } = response.payload;
+          return { txs: [...txs], page: page && { ...page } };
+        } catch (error) {
+          throw new Error(`Failed to get virtual txs: ${error}`, { cause: error });
+        }
+      }
+    };
+  }
   async getBalance() {
     const message = {
       id: getRandomId(),
@@ -19525,6 +19770,43 @@ var ServiceWorkerWallet = class _ServiceWorkerWallet extends ServiceWorkerReadon
   async signerForDescriptor(descriptor) {
     return resolveDescriptorSigner(descriptor, this.identity);
   }
+  /**
+   * An {@link ArkadeBroadcaster} proxied to the worker, which holds the
+   * provider. Only `ServiceWorkerWallet` offers one: a readonly worker
+   * refuses `SUBMIT_TX`/`FINALIZE_TX` outright, so exposing it on the
+   * readonly class would promise something the boundary rejects.
+   */
+  async getArkadeBroadcaster() {
+    return {
+      submitTx: async (signedArkTx, checkpointTxs) => {
+        const message = {
+          id: getRandomId(),
+          tag: this.messageTag,
+          type: "SUBMIT_TX",
+          payload: { signedArkTx, checkpointTxs }
+        };
+        try {
+          const response = await this.sendMessage(message);
+          return response.payload;
+        } catch (error) {
+          throw new Error(`Failed to submit tx: ${error}`, { cause: error });
+        }
+      },
+      finalizeTx: async (arkTxid, finalCheckpointTxs) => {
+        const message = {
+          id: getRandomId(),
+          tag: this.messageTag,
+          type: "FINALIZE_TX",
+          payload: { arkTxid, finalCheckpointTxs }
+        };
+        try {
+          await this.sendMessage(message);
+        } catch (error) {
+          throw new Error(`Failed to finalize tx: ${error}`, { cause: error });
+        }
+      }
+    };
+  }
   async sendBitcoin(params) {
     const message = {
       id: getRandomId(),
@@ -22834,6 +23116,10 @@ var ArkadeContract = class _ArkadeContract {
    * When a `contractManager` is configured and this contract is registered,
    * reads the repository-backed state (offline-first, kept fresh by the
    * contract watcher). Otherwise falls back to a direct indexer query.
+   *
+   * Both branches refuse a spent or unilaterally exited output. They are not
+   * otherwise interchangeable: the fallback asks `spendableOnly`, which also
+   * drops swept coins — the manager branch keeps those.
    */
   async getUtxos() {
     const manager = this.client.contractManager;
@@ -22854,7 +23140,7 @@ var ArkadeContract = class _ArkadeContract {
       scripts: [scriptHex],
       spendableOnly: true
     });
-    return vtxos;
+    return vtxos.filter((v) => !hasTerminalSpend(v) && !v.isUnrolled);
   }
   /** Total spendable balance (requires an indexer). */
   async getBalance() {
@@ -23019,8 +23305,14 @@ var ArkadeTransactionBuilder = class {
     if (!client.identity) {
       throw new Error("a signing identity is required for non-covenant spends");
     }
+    const ark = client.arkProvider;
+    if (!ark.submitTx || !ark.finalizeTx) {
+      throw new Error(
+        "broadcasting requires an `arkade` provider with `submitTx`/`finalizeTx` on the Arkade client"
+      );
+    }
     const signedArk = await this.signArk(arkTx, userInputs);
-    const res = await client.arkProvider.submitTx(
+    const res = await ark.submitTx(
       base64.encode(signedArk.toPSBT()),
       checkpoints.map((c) => base64.encode(c.toPSBT()))
     );
@@ -23031,7 +23323,7 @@ var ArkadeTransactionBuilder = class {
         async ({ server }) => base64.encode((await client.identity.sign(server, [0])).toPSBT())
       )
     );
-    await client.arkProvider.finalizeTx(res.arkTxid, finalCps);
+    await ark.finalizeTx(res.arkTxid, finalCps);
     return {
       txid: res.arkTxid,
       signedArkTx: res.finalArkTx,
@@ -23119,6 +23411,7 @@ var BIP21Error = /* @__PURE__ */ ((BIP21Error2) => {
   BIP21Error2["INVALID_ADDRESS"] = "Invalid address";
   return BIP21Error2;
 })(BIP21Error || {});
+var ARK_HRP = /^(?:t?ark|T?ARK)/;
 var BIP21 = class _BIP21 {
   /**
    * Create a BIP21 URI from the provided parameters.
@@ -23142,7 +23435,7 @@ var BIP21 = class _BIP21 {
         }
         queryParams[key] = value;
       } else if (key === "ark") {
-        if (typeof value === "string" && (value.startsWith("ark") || value.startsWith("tark"))) {
+        if (typeof value === "string" && ARK_HRP.test(value)) {
           queryParams[key] = value;
         } else {
           console.warn("Invalid ARK address format");
@@ -23162,7 +23455,7 @@ var BIP21 = class _BIP21 {
         Object.entries(queryParams).map(([k, v]) => [k, String(v)])
       )
     ).toString() : "";
-    return `bitcoin:${address ? address.toLowerCase() : ""}${query}`;
+    return `bitcoin:${address ?? ""}${query}`;
   }
   /**
    * Integer-sats amount encoded in a BIP21 URI (`amount=` is BTC), or
@@ -23195,7 +23488,7 @@ var BIP21 = class _BIP21 {
     const [address, query] = withoutPrefix.split("?");
     const params = {};
     if (address) {
-      params.address = address.toLowerCase();
+      params.address = address;
     }
     if (query) {
       const queryParams = new URLSearchParams(query);
@@ -23211,7 +23504,7 @@ var BIP21 = class _BIP21 {
           }
           params[key] = amount;
         } else if (key === "ark") {
-          if (value.startsWith("ark") || value.startsWith("tark")) {
+          if (ARK_HRP.test(value)) {
             params[key] = value;
           } else {
             console.warn("Invalid ARK address format");
@@ -23463,7 +23756,7 @@ function onchainRail() {
 function createDefaultPaymentRouter(wallet) {
   return new PaymentRouter({
     wallet,
-    prefs: { priority: ["ark", "lightning", "onchain"] }
+    prefs: { priority: ["ark", "onchain"] }
   }).use(arkRail()).use(onchainRail());
 }
 /*! Bundled license information:
@@ -23472,6 +23765,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-AEWJU6NZ.js.map
-//# sourceMappingURL=chunk-AEWJU6NZ.js.map
+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, assertRecipientArkadeAddress, 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-6F2Q32KA.js.map
+//# sourceMappingURL=chunk-6F2Q32KA.js.map