@arkade-os/sdk 0.5.0-rc.27 → 0.5.0-rc.29

package/dist/{chunk-I4ZWKG7B.js → chunk-34G7TDUS.js}

@@ -1,6 +1,6 @@
-import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, BufferReader, BufferWriter, AssetRef, RestIndexerProvider } from './chunk-FTJ2YWJJ.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, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, speculativeReceiveMetadata, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-PO6AJUWK.js';
-import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, sequenceToCanonicalTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, timelockToSequence, assertAllowedSighashTypes, baseFetch, Intent, rateGate, DEFAULT_NETWORK_NAME, formatSighash, normalizeVtxo, assertTimerMs, getSequence, maybeArkError, isArkError, ArkErrorName, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, isEventSourceError, isEventSourceUnavailableError, getAllNormalizedVtxos, isPastExpiry, assertNonNegativeMs, isRetryableProviderError, DEFAULT_PAGE_SIZE, RestArkProvider, DEFAULT_ARKADE_SERVER_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-RUWTAAJK.js';
+import { AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, RestIndexerProvider, BufferReader, BufferWriter, AssetRef } from './chunk-CVJXASA2.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, UnsupportedProgramVersionError, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, toXOnly, ARKADE_TYPE_ENCODINGS, validateParamValue, contractHandlers, speculativeReceiveMetadata, isMainnetDescriptor, descriptorIsOurs, deriveDescriptorLeafPubKey, deriveDescriptorLeafCompressedPubKey, normalizeToDescriptor, extractPubKey, parseHDDescriptor, identityDescriptor, DefaultVtxo, DelegateVtxo, WALLET_RECEIVE_SOURCE, BoardingContractHandler } from './chunk-WNHMY5ET.js';
+import { VtxoScript, __export, Transaction, requiresForfeit, CSVMultisigTapscript, networks, getNetwork, DEFAULT_NETWORK, resolveEmulatorPubkey, timelockToSequence, isVtxoSpent, getNormalizedVtxos, setArkPsbtField, PrevArkTxField, ConditionWitness, craftToSpendTx, RestArkProvider, ArkAddress, isVirtualCoin, getArkPsbtFields, CosignerPublicKey, ServerResponseMismatchError, assertNonNegativeMs, isRetryableProviderError, getAllNormalizedVtxos, DEFAULT_PAGE_SIZE, OP_RETURN_EMPTY_PKSCRIPT, canSweepOnchain, sequenceToTimelock, DEFAULT_ARKADE_SERVER_URL, baseFetch, DEFAULT_NETWORK_NAME, sequenceToCanonicalTimelock, assertTimerMs, isEventSourceError, isEventSourceUnavailableError, normalizeVtxo, isPastExpiry, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, VtxoTaprootTree, isArkError, ArkErrorName, assertAllowedSighashTypes, Intent, rateGate, formatSighash, getSequence, maybeArkError, toOffchainInputFeeParams, canRecoverOnchain, MultisigTapscript, DEFAULT_ARKADE_EMULATOR_URL, networkFromArkadeInfo, ArkError, toBIP371TapTree, resolveTimeHeight, canSpendOffchain, INFO_FETCH_TIMEOUT_MS, PrevoutTxField, fetchVtxoCreatedAtByTxid, EXPIRY_MIN_PLAUSIBLE_MS, ProviderUnavailableError } from './chunk-44E37WPJ.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$1 } from '@scure/btc-signer';
 import { hex, base58, base64, bech32m } from '@scure/base';
@@ -9773,15 +9773,19 @@ function toWatchOnlyContract(params) {
   return { ...params, state: params.state ?? "active", createdAt: Date.now() };
 }
 var TAPSCRIPT_MEMO_MAX_ENTRIES = 1024;
+function contractKey(contract) {
+  return `${contract.type}\0${contract.script}\0${JSON.stringify(contract.params)}`;
+}
 function annotatableIn(scriptToContract, vtxos, memo) {
   const scripts = /* @__PURE__ */ new Set();
   const cache = /* @__PURE__ */ new Map();
   const failures = /* @__PURE__ */ new Map();
+  const unsupported = /* @__PURE__ */ new Map();
   for (const script of new Set(vtxos.map((vtxo) => vtxo.script))) {
     const contract = scriptToContract.get(script);
     if (!contract) continue;
     try {
-      const key = `${contract.type}\0${script}\0${JSON.stringify(contract.params)}`;
+      const key = contractKey(contract);
       const handler = contractHandlers.get(contract.type);
       const hit = memo?.get(script);
       let tapscripts;
@@ -9802,13 +9806,15 @@ function annotatableIn(scriptToContract, vtxos, memo) {
       cache.set(script, tapscripts);
       scripts.add(script);
     } catch (err) {
-      failures.set(
-        script,
-        `'${contract.type}' at ${script}: ${err instanceof Error ? err.message : String(err)}`
-      );
+      const reason = `'${contract.type}' at ${script}: ${err instanceof Error ? err.message : String(err)}`;
+      if (err instanceof UnsupportedProgramVersionError) {
+        unsupported.set(script, { key: contractKey(contract), reason });
+      } else {
+        failures.set(script, reason);
+      }
     }
   }
-  return { scripts, cache, failures };
+  return { scripts, cache, failures, unsupported };
 }
 function annotateAgainst(vtxos, byScript, tapscripts = /* @__PURE__ */ new Map()) {
   return vtxos.map(
@@ -9923,6 +9929,11 @@ var ContractManager = class _ContractManager {
   watcherStartFailure;
   /** Contracts a sync could not annotate, as `script → reason`. */
   annotationFailures = /* @__PURE__ */ new Map();
+  /**
+   * Rows in a program version this SDK cannot read, as `script → contractKey`. Kept out of
+   * {@link annotationFailures}: they are expected after an upgrade, so they must not degrade sync.
+   */
+  unsupportedContracts = /* @__PURE__ */ new Map();
   annotationDegradedReason() {
     if (this.annotationFailures.size === 0) return void 0;
     return `cannot annotate ${this.annotationFailures.size} contract(s), their vtxos are not being synced \u2014 ${[...this.annotationFailures.values()].join("; ")}`;
@@ -9931,12 +9942,39 @@ var ContractManager = class _ContractManager {
    * Fold one batch's verdict in. Merged, not replaced: a batch may cover only a subset of the
    * wallet's contracts and must not erase what a wider sync found.
    */
-  recordAnnotationFailures(annotated, failures) {
-    for (const script of annotated) this.annotationFailures.delete(script);
+  recordAnnotationFailures(annotated, failures, unsupported) {
+    for (const script of annotated) {
+      this.annotationFailures.delete(script);
+      this.unsupportedContracts.delete(script);
+    }
     for (const [script, reason] of failures) {
+      this.unsupportedContracts.delete(script);
       this.annotationFailures.set(script, reason);
       console.warn(`[contracts] cannot annotate contract ${reason}; skipping its vtxos`);
     }
+    for (const [script, { key, reason }] of unsupported) {
+      this.annotationFailures.delete(script);
+      if (this.unsupportedContracts.get(script) === key) continue;
+      this.unsupportedContracts.set(script, key);
+      console.warn(`[contracts] cannot annotate contract ${reason}; skipping its vtxos`);
+    }
+  }
+  /**
+   * Whether `contract` is in a program version this SDK cannot read. Memoized per
+   * {@link contractKey}, so a re-created row is never answered from its predecessor's verdict.
+   */
+  isUnsupported(contract) {
+    const key = contractKey(contract);
+    if (this.unsupportedContracts.get(contract.script) === key) return true;
+    if (this.tapscriptMemo.get(contract.script)?.key === key) return false;
+    try {
+      contractHandlers.get(contract.type)?.createScript(contract.params);
+      return false;
+    } catch (err) {
+      if (!(err instanceof UnsupportedProgramVersionError)) return false;
+      this.unsupportedContracts.set(contract.script, key);
+      return true;
+    }
   }
   /** A retryable failure degrades sync state instead of propagating; terminal ones still throw. */
   /** Returns the swallowed retryable error, if any. */
@@ -10317,7 +10355,13 @@ var ContractManager = class _ContractManager {
     }
     const [existing] = await this.getContracts({ script: params.script });
     if (existing) {
-      if (existing.type === params.type) return { contract: existing, persisted: false };
+      if (existing.type === params.type) {
+        if (!this.isUnsupported(existing)) return { contract: existing, persisted: false };
+        return {
+          contract: await this.replaceUnsupported(existing, params),
+          persisted: true
+        };
+      }
       if (areCoalescibleContractTypes(existing.type, params.type)) {
         return { contract: existing, persisted: false };
       }
@@ -10333,6 +10377,31 @@ var ContractManager = class _ContractManager {
     await this.config.contractRepository.saveContract(contract);
     return { contract, persisted: true };
   }
+  /**
+   * Overwrite a row this SDK cannot read with `params`, already verified to lock its script. One
+   * write, so the script never goes without a row. The row's history (`createdAt`, `state`,
+   * `watch`) survives, as do its `label` and `metadata` unless the caller passes new ones. The
+   * first writer's generic-spend gate holds: a closed one stays closed, and an open one stays
+   * open unless the caller sets the flag explicitly.
+   */
+  async replaceUnsupported(existing, params) {
+    const label = params.label ?? existing.label;
+    const given = params.metadata ?? existing.metadata;
+    const wasOpen = existing.metadata?.genericallySpendable === true;
+    const metadata = wasOpen && given?.genericallySpendable === void 0 ? { ...given, genericallySpendable: true } : given?.genericallySpendable === true && !wasOpen ? { ...given, genericallySpendable: false } : given;
+    const { watch: _, label: _label, metadata: _metadata, ...rest } = params;
+    const contract = {
+      ...rest,
+      ...label !== void 0 && { label },
+      ...metadata !== void 0 && { metadata },
+      ...existing.watch !== void 0 && { watch: existing.watch },
+      createdAt: existing.createdAt,
+      state: existing.state
+    };
+    await this.config.contractRepository.saveContract(contract);
+    this.unsupportedContracts.delete(contract.script);
+    return contract;
+  }
   /**
    * Gap-limit contract discovery (error contract: {@link IContractManager.scanContracts}).
    * Hits go through {@link persistAndWatchContract}; `Wallet.restore` then hydrates with one
@@ -10488,6 +10557,11 @@ var ContractManager = class _ContractManager {
     const dbFilter = this.buildContractsDbFilter(filter ?? {});
     return await collectContracts(this.config.contractRepository, dbFilter);
   }
+  /** @inheritdoc */
+  async getUnsupportedContracts() {
+    const contracts = await this.getContracts();
+    return contracts.filter((contract) => this.isUnsupported(contract));
+  }
   async getContractsWithVtxos(filter, pageSize, options) {
     assertNonNegativeMs("maxSyncAgeMs", options?.maxSyncAgeMs);
     const contracts = await this.getContracts(filter);
@@ -10560,11 +10634,12 @@ var ContractManager = class _ContractManager {
     const contracts = await collectContracts(this.config.contractRepository, {
       script: Array.from(new Set(vtxos.map((vtxo) => vtxo.script)))
     });
-    const { scripts, failures } = annotatableIn(
+    const { scripts, failures, unsupported } = annotatableIn(
       new Map(contracts.map((contract) => [contract.script, contract])),
       vtxos,
       this.tapscriptMemo
     );
+    for (const [script, { reason }] of unsupported) failures.set(script, reason);
     const orphans = vtxos.filter(
       (vtxo) => !scripts.has(vtxo.script) && !failures.has(vtxo.script)
     );
@@ -10806,9 +10881,10 @@ var ContractManager = class _ContractManager {
     const {
       scripts: annotatable,
       cache,
-      failures
+      failures,
+      unsupported
     } = annotatableIn(scriptToContract, vtxos, this.tapscriptMemo);
-    this.recordAnnotationFailures(annotatable, failures);
+    this.recordAnnotationFailures(annotatable, failures, unsupported);
     const owned = vtxos.filter((v) => annotatable.has(v.script));
     if (owned.length === 0) return;
     const annotated = annotateAgainst(owned, scriptToContract, cache);
@@ -10994,9 +11070,10 @@ var ContractManager = class _ContractManager {
     const {
       scripts: annotatable,
       cache,
-      failures
+      failures,
+      unsupported
     } = annotatableIn(scriptToContract, vtxos, this.tapscriptMemo);
-    this.recordAnnotationFailures(annotatable, failures);
+    this.recordAnnotationFailures(annotatable, failures, unsupported);
     const owned = vtxos.filter((v) => annotatable.has(v.script));
     const annotated = annotateAgainst(owned, scriptToContract, cache);
     const byContract = /* @__PURE__ */ new Map();
@@ -11085,9 +11162,10 @@ var ContractManager = class _ContractManager {
     const {
       scripts: annotatable,
       cache,
-      failures
+      failures,
+      unsupported
     } = annotatableIn(scriptToContract, vtxos, this.tapscriptMemo);
-    this.recordAnnotationFailures(annotatable, failures);
+    this.recordAnnotationFailures(annotatable, failures, unsupported);
     const owned = vtxos.filter((v) => annotatable.has(v.script));
     const annotated = annotateAgainst(owned, scriptToContract, cache);
     for (const vtxo of annotated) {
@@ -12009,6 +12087,164 @@ var scriptVtxoCursorOf = (row) => ({
   txid: row.vtxo.txid,
   vout: row.vtxo.vout
 });
+
+// src/providers/emulator.ts
+var RestEmulatorProvider = class {
+  constructor(serverUrl) {
+    this.serverUrl = serverUrl;
+  }
+  serverUrl;
+  async getInfo() {
+    const url = `${this.serverUrl}/v1/info`;
+    const response = await baseFetch(url);
+    if (!response.ok) {
+      const errorText2 = await response.text();
+      throw new Error(`Failed to get emulator info: ${errorText2}`);
+    }
+    const data = await response.json();
+    const signerPubkey = data.signerPubkey;
+    if (typeof signerPubkey !== "string" || !signerPubkey) {
+      throw new Error("Invalid emulator info response: missing signerPubkey");
+    }
+    return { signerPubkey };
+  }
+  async submitTx(arkTx, checkpointTxs) {
+    const url = `${this.serverUrl}/v1/tx`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        arkTx,
+        checkpointTxs
+      })
+    });
+    if (!response.ok) {
+      const errorText2 = await response.text();
+      throw new Error(`Failed to submit tx to emulator: ${errorText2}`);
+    }
+    const data = await response.json();
+    if (typeof data.signedArkTx !== "string" || !data.signedArkTx) {
+      throw new Error("Invalid emulator submitTx response: missing signedArkTx");
+    }
+    if (!Array.isArray(data.signedCheckpointTxs) || !data.signedCheckpointTxs.every((item) => typeof item === "string")) {
+      throw new Error(
+        "Invalid emulator submitTx response: signedCheckpointTxs must be an array of strings"
+      );
+    }
+    return {
+      signedArkTx: data.signedArkTx,
+      signedCheckpointTxs: data.signedCheckpointTxs
+    };
+  }
+  async submitIntent(intent) {
+    const url = `${this.serverUrl}/v1/intent`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        intent: {
+          proof: intent.proof,
+          message: JSON.stringify(intent.message)
+        }
+      })
+    });
+    if (!response.ok) {
+      const errorText2 = await response.text();
+      throw new Error(`Failed to submit intent to emulator: ${errorText2}`);
+    }
+    const data = await response.json();
+    if (typeof data.signedProof !== "string" || !data.signedProof) {
+      throw new Error("Invalid emulator submitIntent response: missing signedProof");
+    }
+    return data.signedProof;
+  }
+  async submitFinalization(intent, forfeits, connectorTree, commitmentTx) {
+    const url = `${this.serverUrl}/v1/finalization`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      // Uses "signedIntent" (not "intent") because the proof was already
+      // co-signed by the emulator via submitIntent in a prior step.
+      body: JSON.stringify({
+        signedIntent: {
+          proof: intent.proof,
+          message: JSON.stringify(intent.message)
+        },
+        forfeits,
+        connectorTree,
+        commitmentTx
+      })
+    });
+    if (!response.ok) {
+      const errorText2 = await response.text();
+      throw new Error(`Failed to submit finalization to emulator: ${errorText2}`);
+    }
+    const data = await response.json();
+    if (!Array.isArray(data.signedForfeits) || !data.signedForfeits.every((item) => typeof item === "string")) {
+      throw new Error(
+        "Invalid emulator submitFinalization response: signedForfeits must be an array of strings"
+      );
+    }
+    if ("signedCommitmentTx" in data && typeof data.signedCommitmentTx !== "string") {
+      throw new Error(
+        "Invalid emulator submitFinalization response: invalid signedCommitmentTx"
+      );
+    }
+    return {
+      signedForfeits: data.signedForfeits,
+      signedCommitmentTx: data.signedCommitmentTx
+    };
+  }
+  async submitOnchainTx(tx) {
+    const url = `${this.serverUrl}/v1/onchain-tx`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tx })
+    });
+    if (!response.ok) {
+      const errorText2 = await response.text();
+      throw new Error(`Failed to submit onchain tx to emulator: ${errorText2}`);
+    }
+    const data = await response.json();
+    if (typeof data.signedTx !== "string" || !data.signedTx) {
+      throw new Error("Invalid emulator submitOnchainTx response: missing signedTx");
+    }
+    return { signedTx: data.signedTx };
+  }
+};
+
+// src/arkade/service.ts
+function arkadeServiceUrl(service) {
+  return "operatorUrl" in service ? service.operatorUrl : DEFAULT_ARKADE_SERVER_URL;
+}
+async function resolveArkadeService(service, opts = {}) {
+  const operatorUrl = arkadeServiceUrl(service);
+  const arkProvider = opts.arkProvider ?? new RestArkProvider(operatorUrl);
+  const info = opts.info ?? await arkProvider.getInfo();
+  if ("network" in service && service.network !== info.network) {
+    throw new Error(
+      `Arkade service network mismatch: requested '${service.network}' but the operator at ${operatorUrl} reports '${info.network}'`
+    );
+  }
+  const esploraUrl = ESPLORA_URL[info.network];
+  if (!esploraUrl) {
+    throw new Error(`Arkade service: no default esplora URL for network '${info.network}'`);
+  }
+  let emulator;
+  if ("network" in service) {
+    emulator = new RestEmulatorProvider(DEFAULT_ARKADE_EMULATOR_URL);
+  } else if (service.emulatorUrl) {
+    emulator = new RestEmulatorProvider(service.emulatorUrl);
+  }
+  return {
+    arkProvider,
+    indexerProvider: new RestIndexerProvider(operatorUrl),
+    onchainProvider: new EsploraProvider(esploraUrl),
+    emulator,
+    info
+  };
+}
 var HD_SETTINGS_KEY = "hd";
 var HARDENED_INDEX_OFFSET = 2147483648;
 var HDDescriptorProvider = class _HDDescriptorProvider {
@@ -12718,6 +12954,20 @@ function extractArkProviderUrl(provider) {
   const serverUrl = provider.serverUrl;
   return typeof serverUrl === "string" && serverUrl.length > 0 ? serverUrl : void 0;
 }
+function normalizeWalletConfigSpellings(config) {
+  if (config.mode !== void 0 && config.walletMode !== void 0) {
+    throw new Error("Pass either `mode` or `walletMode`, not both");
+  }
+  if (config.settlement !== void 0 && config.settlementConfig !== void 0) {
+    throw new Error("Pass either `settlement` or `settlementConfig`, not both");
+  }
+  const { mode, settlement, ...rest } = config;
+  return {
+    ...rest,
+    ...mode !== void 0 ? { walletMode: mode } : {},
+    ...settlement !== void 0 ? { settlementConfig: settlement } : {}
+  };
+}
 var DEFAULT_LOOK_AHEAD_WINDOW = 20;
 var MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD = 1e3;
 var MAINNET_UNILATERAL_EXIT_DELAY = 605184n;
@@ -13130,9 +13380,14 @@ var ReadonlyWallet = class _ReadonlyWallet {
   }
   /** Shared setup for ReadonlyWallet.create() and Wallet.create(). */
   static async setupWalletConfig(config, pubKey) {
-    const arkProvider = config.arkProvider || new RestArkProvider();
+    if (config.service && (config.arkProvider || config.indexerProvider || config.onchainProvider)) {
+      throw new Error(
+        "Pass either `service` or `arkProvider`/`indexerProvider`/`onchainProvider`, not both"
+      );
+    }
+    const arkProvider = config.arkProvider || new RestArkProvider(config.service ? arkadeServiceUrl(config.service) : void 0);
     let indexerProvider = config.indexerProvider;
-    if (!indexerProvider) {
+    if (!indexerProvider && !config.service) {
       const derived = extractArkProviderUrl(arkProvider);
       if (!derived && config.arkProvider) {
         throw new Error(
@@ -13148,6 +13403,11 @@ var ReadonlyWallet = class _ReadonlyWallet {
       source: serverInfoSource,
       lastOnlineAt: serverInfoLastOnlineAt
     } = await resolveArkInfo(arkProvider, walletRepository);
+    const resolvedService = config.service ? await resolveArkadeService(config.service, { arkProvider, info }) : void 0;
+    if (!indexerProvider) {
+      if (!resolvedService) throw new Error("indexerProvider is unresolved");
+      indexerProvider = resolvedService.indexerProvider;
+    }
     const network = networkFromArkadeInfo(info);
     if ("descriptor" in config.identity) {
       const descriptor = config.identity.descriptor;
@@ -13164,7 +13424,7 @@ var ReadonlyWallet = class _ReadonlyWallet {
         );
       }
     }
-    const onchainProvider = typeof config.onchainProvider === "function" ? config.onchainProvider(info.network) : config.onchainProvider || new EsploraProvider(ESPLORA_URL[info.network]);
+    const onchainProvider = typeof config.onchainProvider === "function" ? config.onchainProvider(info.network) : config.onchainProvider || resolvedService?.onchainProvider || new EsploraProvider(ESPLORA_URL[info.network]);
     if (config.exitTimelock) {
       const { value, type } = config.exitTimelock;
       if (value < 512n && type !== "blocks" || value >= 512n && type !== "seconds") {
@@ -14920,6 +15180,7 @@ var Wallet2 = class extends ReadonlyWallet {
     }
   }
   static async create(config) {
+    config = normalizeWalletConfigSpellings(config);
     if (config.lookAheadWindow !== void 0 && (!Number.isInteger(config.lookAheadWindow) || config.lookAheadWindow <= 0)) {
       throw new Error(
         `lookAheadWindow must be a positive integer (got ${String(config.lookAheadWindow)})`
@@ -18735,6 +18996,15 @@ var WalletMessageHandler = class {
             payload: { paths }
           });
         }
+        case "GET_UNSUPPORTED_CONTRACTS": {
+          const manager = await this.readonlyWallet.getContractManager();
+          const contracts = await manager.getUnsupportedContracts();
+          return this.tagged({
+            id,
+            type: "UNSUPPORTED_CONTRACTS",
+            payload: { contracts }
+          });
+        }
         case "IS_CONTRACT_MANAGER_WATCHING": {
           const manager = await this.readonlyWallet.getContractManager();
           const isWatching = await manager.isWatching();
@@ -19580,6 +19850,7 @@ var DEFAULT_MESSAGE_TIMEOUTS = {
   ANNOTATE_VTXOS: 2e4,
   GET_SPENDABLE_PATHS: 2e4,
   GET_ALL_SPENDING_PATHS: 2e4,
+  GET_UNSUPPORTED_CONTRACTS: 2e4,
   GET_ASSET_DETAILS: 2e4,
   GET_EXPIRING_VTXOS: 2e4,
   GET_EXPIRED_BOARDING_UTXOS: 2e4,
@@ -19650,6 +19921,7 @@ var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
   "ANNOTATE_VTXOS",
   "GET_SPENDABLE_PATHS",
   "GET_ALL_SPENDING_PATHS",
+  "GET_UNSUPPORTED_CONTRACTS",
   "GET_ASSET_DETAILS",
   "GET_EXPIRING_VTXOS",
   "RELOAD_WALLET"
@@ -20568,6 +20840,19 @@ var ServiceWorkerReadonlyWallet = class _ServiceWorkerReadonlyWallet {
           throw new Error(`Failed to get all spending paths: ${cause}`, { cause });
         }
       },
+      async getUnsupportedContracts() {
+        const message = {
+          type: "GET_UNSUPPORTED_CONTRACTS",
+          id: getRandomId(),
+          tag: messageTag
+        };
+        try {
+          const response = await sendContractMessage(message);
+          return response.payload.contracts;
+        } catch (cause) {
+          throw new Error(`Failed to get unsupported contracts: ${cause}`, { cause });
+        }
+      },
       onContractEvent(callback) {
         const messageHandler = (event) => {
           const response = event.data;
@@ -22545,132 +22830,6 @@ function craftBIP322ToSignSimple(toSpend, pkScript) {
   });
   return tx;
 }
-
-// src/providers/emulator.ts
-var RestEmulatorProvider = class {
-  constructor(serverUrl) {
-    this.serverUrl = serverUrl;
-  }
-  serverUrl;
-  async getInfo() {
-    const url = `${this.serverUrl}/v1/info`;
-    const response = await baseFetch(url);
-    if (!response.ok) {
-      const errorText2 = await response.text();
-      throw new Error(`Failed to get emulator info: ${errorText2}`);
-    }
-    const data = await response.json();
-    const signerPubkey = data.signerPubkey;
-    if (typeof signerPubkey !== "string" || !signerPubkey) {
-      throw new Error("Invalid emulator info response: missing signerPubkey");
-    }
-    return { signerPubkey };
-  }
-  async submitTx(arkTx, checkpointTxs) {
-    const url = `${this.serverUrl}/v1/tx`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        arkTx,
-        checkpointTxs
-      })
-    });
-    if (!response.ok) {
-      const errorText2 = await response.text();
-      throw new Error(`Failed to submit tx to emulator: ${errorText2}`);
-    }
-    const data = await response.json();
-    if (typeof data.signedArkTx !== "string" || !data.signedArkTx) {
-      throw new Error("Invalid emulator submitTx response: missing signedArkTx");
-    }
-    if (!Array.isArray(data.signedCheckpointTxs) || !data.signedCheckpointTxs.every((item) => typeof item === "string")) {
-      throw new Error(
-        "Invalid emulator submitTx response: signedCheckpointTxs must be an array of strings"
-      );
-    }
-    return {
-      signedArkTx: data.signedArkTx,
-      signedCheckpointTxs: data.signedCheckpointTxs
-    };
-  }
-  async submitIntent(intent) {
-    const url = `${this.serverUrl}/v1/intent`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        intent: {
-          proof: intent.proof,
-          message: JSON.stringify(intent.message)
-        }
-      })
-    });
-    if (!response.ok) {
-      const errorText2 = await response.text();
-      throw new Error(`Failed to submit intent to emulator: ${errorText2}`);
-    }
-    const data = await response.json();
-    if (typeof data.signedProof !== "string" || !data.signedProof) {
-      throw new Error("Invalid emulator submitIntent response: missing signedProof");
-    }
-    return data.signedProof;
-  }
-  async submitFinalization(intent, forfeits, connectorTree, commitmentTx) {
-    const url = `${this.serverUrl}/v1/finalization`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      // Uses "signedIntent" (not "intent") because the proof was already
-      // co-signed by the emulator via submitIntent in a prior step.
-      body: JSON.stringify({
-        signedIntent: {
-          proof: intent.proof,
-          message: JSON.stringify(intent.message)
-        },
-        forfeits,
-        connectorTree,
-        commitmentTx
-      })
-    });
-    if (!response.ok) {
-      const errorText2 = await response.text();
-      throw new Error(`Failed to submit finalization to emulator: ${errorText2}`);
-    }
-    const data = await response.json();
-    if (!Array.isArray(data.signedForfeits) || !data.signedForfeits.every((item) => typeof item === "string")) {
-      throw new Error(
-        "Invalid emulator submitFinalization response: signedForfeits must be an array of strings"
-      );
-    }
-    if ("signedCommitmentTx" in data && typeof data.signedCommitmentTx !== "string") {
-      throw new Error(
-        "Invalid emulator submitFinalization response: invalid signedCommitmentTx"
-      );
-    }
-    return {
-      signedForfeits: data.signedForfeits,
-      signedCommitmentTx: data.signedCommitmentTx
-    };
-  }
-  async submitOnchainTx(tx) {
-    const url = `${this.serverUrl}/v1/onchain-tx`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ tx })
-    });
-    if (!response.ok) {
-      const errorText2 = await response.text();
-      throw new Error(`Failed to submit onchain tx to emulator: ${errorText2}`);
-    }
-    const data = await response.json();
-    if (typeof data.signedTx !== "string" || !data.signedTx) {
-      throw new Error("Invalid emulator submitOnchainTx response: missing signedTx");
-    }
-    return { signedTx: data.signedTx };
-  }
-};
 function finalizeVirtualTx(type, psbtBase64) {
   const tx = Transaction.fromPSBT(base64.decode(psbtBase64));
   if (type === "INDEXER_CHAINED_TX_TYPE_TREE" /* TREE */) {
@@ -23858,6 +24017,7 @@ __export(arkade_exports, {
   OPCODE_VALUES: () => OPCODE_VALUES,
   SUPPORTED_PROGRAM_VERSION: () => SUPPORTED_PROGRAM_VERSION,
   Script: () => Script,
+  UnsupportedProgramVersionError: () => UnsupportedProgramVersionError,
   arkadeScriptHash: () => arkadeScriptHash,
   arkadeWitnessHash: () => arkadeWitnessHash,
   asmToBytes: () => asmToBytes,
@@ -23871,6 +24031,7 @@ __export(arkade_exports, {
   isContractArtifact: () => isContractArtifact,
   parseArtifact: () => parseArtifact,
   programFromArtifact: () => programFromArtifact,
+  resolveArkadeService: () => resolveArkadeService,
   resolveAsm: () => resolveAsm,
   serializeArkadeContractParams: () => serializeArkadeContractParams,
   stringifyArtifact: () => stringifyArtifact,
@@ -24080,6 +24241,24 @@ var NATIVE_STRUCTS = {
   ECPoint: [
     ["x", "int"],
     ["y", "int"]
+  ],
+  ScriptPubKey: [
+    ["program", "bytes"],
+    ["version", "int"]
+  ],
+  AssetEntry: [
+    ["assetId", "AssetId"],
+    ["amount", "int"]
+  ],
+  AssetLookup: [
+    ["amount", "int"],
+    ["found", "bool"]
+  ],
+  G2Point: [
+    ["xC1", "int"],
+    ["xC0", "int"],
+    ["yC1", "int"],
+    ["yC0", "int"]
   ]
 };
 var HASH_OPCODES = /* @__PURE__ */ new Set(["OP_SHA256", "OP_HASH160", "OP_HASH256", "OP_RIPEMD160"]);
@@ -24087,7 +24266,7 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNamed(value) {
-  return isRecord(value) && typeof value.name === "string" && typeof value.type === "string" && value.type.length > 0;
+  return isRecord(value) && typeof value.name === "string" && value.name.length > 0 && typeof value.type === "string" && value.type.length > 0;
 }
 function isContractArtifact(value) {
   if (!isRecord(value) || typeof value.contractName !== "string") return false;
@@ -24095,7 +24274,7 @@ function isContractArtifact(value) {
   if (value.structs !== void 0 && !Array.isArray(value.structs)) return false;
   if (!Array.isArray(value.functions) || value.functions.length === 0) return false;
   return value.functions.every(
-    (group) => isRecord(group) && typeof group.name === "string" && Array.isArray(group.leaves) && group.leaves.length > 0
+    (group) => isRecord(group) && typeof group.name === "string" && group.name.length > 0 && Array.isArray(group.leaves) && group.leaves.length > 0
   );
 }
 function fail(detail) {
@@ -24105,33 +24284,35 @@ function claim(seen, name, kind) {
   if (seen.has(name)) fail(`duplicate ${kind} '${name}'`);
   seen.add(name);
 }
-var SCALAR_TYPES = {
-  pubkey: "pubkey",
-  signature: "sig",
-  bytes: "bytes",
-  bytes20: "hash",
-  bytes32: "hash",
-  asset: "hash",
-  int: "int",
-  bool: "int"
-};
+function inputDef(name, type) {
+  return { name, type: argType(type) };
+}
 function argType(arkType) {
-  if (!Object.hasOwn(SCALAR_TYPES, arkType)) fail(`unknown type '${arkType}'`);
-  return SCALAR_TYPES[arkType];
+  if (!Object.hasOwn(ARKADE_TYPE_ENCODINGS, arkType)) fail(`unknown type '${arkType}'`);
+  return arkType;
 }
 function arrayParts(type) {
   const open = type.indexOf("[");
   if (open < 0 || !type.endsWith("]")) return [type, 0];
   const length = Number(type.slice(open + 1, -1));
-  return Number.isInteger(length) && length > 0 ? [type.slice(0, open), length] : [type, 0];
+  return Number.isSafeInteger(length) && length > 0 && /^\d+$/.test(type.slice(open + 1, -1)) ? [type.slice(0, open), length] : [type, 0];
 }
 function flatten(param, structs, stack = []) {
   if (!isNamed(param)) fail("parameter needs a name and a type");
+  const [element, length] = arrayParts(param.type);
+  if (length > 0) {
+    return Array.from(
+      { length },
+      (_, index) => flatten({ name: `${param.name}.${index}`, type: element }, structs, stack)
+    ).flat();
+  }
+  if (param.type.includes("[") || param.type.includes("]")) {
+    fail(`invalid array type '${param.type}'`);
+  }
   if (Object.hasOwn(NATIVE_STRUCTS, param.type)) {
-    return NATIVE_STRUCTS[param.type].map(([field, type]) => ({
-      name: `${param.name}.${field}`,
-      type: argType(type)
-    }));
+    return NATIVE_STRUCTS[param.type].flatMap(
+      ([field, type]) => flatten({ name: `${param.name}.${field}`, type }, structs, stack)
+    );
   }
   const declared = structs.find((struct) => struct?.name === param.type);
   if (declared) {
@@ -24143,20 +24324,7 @@ function flatten(param, structs, stack = []) {
       ])
     );
   }
-  const [element, length] = arrayParts(param.type);
-  if (length === 0) {
-    if (param.type.includes("[") || param.type.includes("]")) {
-      fail(`invalid array type '${param.type}'`);
-    }
-    return [{ name: param.name, type: argType(param.type) }];
-  }
-  if (Object.hasOwn(NATIVE_STRUCTS, element) || structs.some((struct) => struct.name === element)) {
-    fail(`arrays of structs are not supported: '${param.type}'`);
-  }
-  return Array.from({ length }, (_, index) => ({
-    name: `${param.name}.${index}`,
-    type: argType(element)
-  }));
+  return [inputDef(param.name, param.type)];
 }
 function opcodeToken(token) {
   const base = token.slice(3);
@@ -24203,6 +24371,15 @@ function providedWitness(witness) {
   if (!Array.isArray(witness)) fail("leaf witness must be an array");
   return witness.filter((item) => {
     if (!isNamed(item)) fail("witness item needs a name and a type");
+    const type = argType(item.type);
+    if (item.injected !== void 0 && typeof item.injected !== "boolean")
+      fail(`witness '${item.name}': injected must be boolean`);
+    if (item.injected && item.type !== "signature")
+      fail(`witness '${item.name}': only infrastructure signatures can be injected`);
+    if (item.encoding !== void 0 && item.encoding !== ARKADE_TYPE_ENCODINGS[type])
+      fail(
+        `witness '${item.name}': encoding '${item.encoding}' does not match type '${item.type}'`
+      );
     return !item.injected && item.type !== "signature";
   });
 }
@@ -24218,11 +24395,12 @@ function parseLeaf(leaf, hasCovenant, instantiations, extras) {
   const asm = leaf.asm;
   let index = 0;
   let condition;
-  if (asm.length >= 4 && HASH_OPCODES.has(asm[0]) && asm[2] === "OP_EQUAL") {
-    if (asm[3] !== "OP_VERIFY")
+  const hashIndex = asm[0] === "OP_SIZE" && (asm[1] === "20" || asm[1] === "32") && asm[2] === "OP_EQUALVERIFY" ? 3 : 0;
+  if (HASH_OPCODES.has(asm[hashIndex]) && asm[hashIndex + 2] === "OP_EQUAL") {
+    if (asm[hashIndex + 3] !== "OP_VERIFY")
       fail(`leaf '${leaf.name}': hash condition must end in OP_VERIFY`);
-    condition = asm.slice(0, 3).map((token) => asmToken(token, instantiations));
-    index = 4;
+    condition = asm.slice(0, hashIndex + 3).map((token) => asmToken(token, instantiations));
+    index = hashIndex + 4;
   }
   let csv;
   let cltv;
@@ -24235,10 +24413,14 @@ function parseLeaf(leaf, hasCovenant, instantiations, extras) {
   }
   const signers = [];
   let emulator;
+  let emulatorIndex;
   while (index < asm.length) {
     const key = asm[index];
     const terminator = asm[index + 1];
     const last = terminator === "OP_CHECKSIG";
+    if (last !== (index + 2 === asm.length)) {
+      fail(`leaf '${leaf.name}': only the final signer must end in OP_CHECKSIG`);
+    }
     if (!last && terminator !== "OP_CHECKSIGVERIFY") {
       fail(`leaf '${leaf.name}': expected CHECKSIG after '${key}', found '${terminator}'`);
     }
@@ -24253,8 +24435,9 @@ function parseLeaf(leaf, hasCovenant, instantiations, extras) {
       signers.push({ tweak: `$${base}`, fn });
     } else if (inner.startsWith("EMULATOR_KEY:")) {
       if (!hasCovenant) fail(`leaf '${leaf.name}': ${key} needs a covenant`);
-      if (!last) fail(`leaf '${leaf.name}': ${key} must be the last signer`);
+      if (emulator !== void 0) fail(`leaf '${leaf.name}': duplicate emulator signer`);
       emulator = inner.slice("EMULATOR_KEY:".length);
+      emulatorIndex = signers.length;
     } else signers.push(`$${inner}`);
     index += 2;
   }
@@ -24264,10 +24447,12 @@ function parseLeaf(leaf, hasCovenant, instantiations, extras) {
       `leaf '${leaf.name}': covenant leaf must sign with the emulator or a tweaked constructor key`
     );
   }
-  if (signers.length === 0) fail(`leaf '${leaf.name}': at least one named signer is required`);
+  if (signers.length === 0 && emulator === void 0)
+    fail(`leaf '${leaf.name}': at least one named signer is required`);
   return {
     signers,
     ...emulator !== void 0 ? { emulator } : hasCovenant ? { emulator: null } : {},
+    ...emulatorIndex !== void 0 ? { emulatorIndex } : {},
     ...condition ? { asm: condition } : {},
     ...csv ? { csv } : {},
     ...cltv !== void 0 ? { cltv } : {},
@@ -24280,21 +24465,34 @@ function programFromArtifact(artifact) {
       "expected a complete arkadec artifact with contractName, constructorInputs, and non-empty functions"
     );
   }
+  if (artifact.formatVersion !== void 0 && artifact.formatVersion !== 1) {
+    fail(`unsupported artifact format version ${artifact.formatVersion}; expected 1`);
+  }
   const structs = artifact.structs ?? [];
   const structNames = /* @__PURE__ */ new Set();
   for (const struct of structs) {
-    if (!isRecord(struct) || typeof struct.name !== "string") continue;
-    if (Object.hasOwn(SCALAR_TYPES, struct.name) || Object.hasOwn(NATIVE_STRUCTS, struct.name)) {
+    if (!isRecord(struct) || typeof struct.name !== "string" || !Array.isArray(struct.fields)) {
+      fail("struct needs a name and fields array");
+    }
+    const fields = /* @__PURE__ */ new Set();
+    for (const field of struct.fields) {
+      if (!isNamed(field)) fail(`struct '${struct.name}': field needs a name and type`);
+      claim(fields, field.name, "struct field");
+    }
+    if (Object.hasOwn(ARKADE_TYPE_ENCODINGS, struct.name) || Object.hasOwn(NATIVE_STRUCTS, struct.name)) {
       fail(`struct name '${struct.name}' shadows a built-in type`);
     }
     claim(structNames, struct.name, "struct");
   }
   const instantiations = /* @__PURE__ */ new Map();
-  const functions = {};
+  const functions = /* @__PURE__ */ Object.create(null);
   const groups = /* @__PURE__ */ new Set();
   const leafNames = /* @__PURE__ */ new Set();
   for (const group of artifact.functions) {
     claim(groups, group.name, "spend group");
+    if (group.arkade !== void 0 && (!isRecord(group.arkade) || !Array.isArray(group.arkade.inputs) || !Array.isArray(group.arkade.asm) || !group.arkade.asm.every((t) => typeof t === "string"))) {
+      fail(`group '${group.name}': covenant needs inputs and string assembly arrays`);
+    }
     const covenantInputs = (group.arkade?.inputs ?? []).flatMap(
       (input) => flatten(input, structs)
     );
@@ -24303,16 +24501,49 @@ function programFromArtifact(artifact) {
       // Covenant witness is reverse declaration order.
       witness: covenantInputs.map((field) => field.name).reverse()
     } : void 0;
-    for (const [index, leaf] of group.leaves.entries()) {
-      const name = index === 0 ? group.name : `${group.name}/${index}:${leaf.name}`;
+    const covenantNames = /* @__PURE__ */ new Set();
+    for (const input of covenantInputs) claim(covenantNames, input.name, "covenant input");
+    for (const leaf of group.leaves) {
+      if (!isRecord(leaf) || typeof leaf.name !== "string" || leaf.name.length === 0 || !Array.isArray(leaf.asm) || leaf.asm.length === 0 || !leaf.asm.every((t) => typeof t === "string")) {
+        fail(`group '${group.name}': leaf needs a name and non-empty string assembly`);
+      }
+      const name = leaf.name;
       claim(leafNames, name, "function name");
       const extras = providedWitness(leaf.witness);
-      const tapscript = parseLeaf(leaf, group.arkade !== void 0, instantiations, extras);
+      for (const input of extras) {
+        if (leaf.asm.includes(`<${input.name}>`)) {
+          fail(
+            `leaf '${leaf.name}': call input '${input.name}' is a script operand; it must be a constructor binding to derive a fixed Taproot tree`
+          );
+        }
+      }
+      const witnessNames = /* @__PURE__ */ new Set();
+      for (const item of leaf.witness ?? []) claim(witnessNames, item.name, "leaf witness");
+      const scopedExtras = extras.map((item) => ({
+        ...item,
+        name: covenantNames.has(item.name) ? `tapscript:${item.name}` : item.name
+      }));
+      const tapscript = parseLeaf(
+        leaf,
+        group.arkade !== void 0,
+        instantiations,
+        scopedExtras
+      );
+      if (tapscript.emulator !== void 0 && tapscript.emulator !== null && tapscript.emulator !== group.name) {
+        fail(
+          `leaf '${leaf.name}': emulator covenant '${tapscript.emulator}' must match group '${group.name}'`
+        );
+      }
+      const signatures = (leaf.witness ?? []).filter((item) => item.type === "signature" && !item.injected).map((item) => inputDef(item.name, item.type));
+      if (signatures.length > 0) tapscript.signatures = signatures;
       const inputs = [
         ...covenantInputs,
-        ...extras.map((item) => ({ name: item.name, type: argType(item.type) }))
+        ...scopedExtras.map((item) => inputDef(item.name, item.type))
       ];
+      const inputNames = /* @__PURE__ */ new Set();
+      for (const input of inputs) claim(inputNames, input.name, "function input");
       functions[name] = {
+        group: group.name,
         ...inputs.length > 0 ? { inputs } : {},
         tapscript,
         ...arkadeScript ? { arkadeScript } : {}
@@ -24322,7 +24553,11 @@ function programFromArtifact(artifact) {
   const params = [
     ...artifact.constructorInputs.flatMap((input) => flatten(input, structs)),
     { name: "server", type: "pubkey" },
-    ...[...instantiations.keys()].map((name) => ({ name, type: "hash" }))
+    ...Object.values(functions).some((fn) => fn.tapscript.csv?.value === "$SERVER_EXIT_DELAY") ? [{ name: "SERVER_EXIT_DELAY", type: "int" }] : [],
+    ...[...instantiations.keys()].map((name) => ({
+      name,
+      type: "bytes32"
+    }))
   ];
   const paramNames = /* @__PURE__ */ new Set();
   for (const param of params) claim(paramNames, param.name, "program parameter");
@@ -24339,6 +24574,8 @@ var Arkade = class _Arkade {
   emulator;
   network;
   serverKey;
+  /** Bare protocol delay (blocks below 512, seconds otherwise), resolved only when needed. */
+  serverExitDelay;
   /**
    * The co-signer key covenants are built against (33-byte compressed), present only when an
    * emulator is configured. Resolved from the network or `emulatorPubkey`, never the emulator's
@@ -24351,62 +24588,198 @@ var Arkade = class _Arkade {
   identity;
   /** The signing identity's x-only public key, resolved at connect — identifies which inputs the wallet signs. */
   userKey;
-  /** The wallet's contract manager, when contract persistence is wired up. */
+  /** The contract manager, when contract persistence is wired up (passed in or owned). */
   contractManager;
+  /** Whether {@link connect} built {@link contractManager}, so {@link dispose} must stop it. */
+  ownsContractManager;
+  /** {@link ArkadeContract.on} handles by contract script (hex). */
+  handles = /* @__PURE__ */ new Map();
+  /** The single `onContractEvent` subscription fanning out to {@link handles}. */
+  unsubscribeEvents;
+  disposed = false;
   constructor(fields) {
     this.arkProvider = fields.arkProvider;
     this.emulator = fields.emulator;
     this.network = fields.network;
     this.serverKey = fields.serverKey;
+    this.serverExitDelay = fields.serverExitDelay;
     this.emulatorKey = fields.emulatorKey;
     this.checkpoint = fields.checkpoint;
     this.indexer = fields.indexer;
     this.identity = fields.identity;
     this.userKey = fields.userKey;
     this.contractManager = fields.contractManager;
+    this.ownsContractManager = fields.ownsContractManager ?? false;
   }
-  /** Connect and resolve the server key, checkpoint closure and (if present) the co-signer key. */
+  /**
+   * Connect and resolve the server key, checkpoint closure and (if present) the co-signer key.
+   *
+   * @example
+   * ```typescript
+   * const arkade = await Arkade.connect({
+   *     service: { network: "bitcoin" },
+   *     identity,
+   *     storage: { contractRepository },
+   * });
+   * ```
+   */
   static async connect(opts) {
-    const info = await opts.arkade.getInfo();
+    if (opts.storage && opts.contractManager) {
+      throw new Error(
+        "Arkade.connect: pass either `storage` or `contractManager`, not both \u2014 `storage` builds a second manager over another repository"
+      );
+    }
+    let arkProvider;
+    let emulator;
+    let indexer;
+    let info;
+    let resolved;
+    if (opts.service) {
+      resolved = await resolveArkadeService(opts.service);
+      ({ arkProvider, emulator, info } = resolved);
+      indexer = resolved.indexerProvider;
+    } else {
+      arkProvider = opts.arkade;
+      emulator = opts.emulator;
+      indexer = opts.indexer;
+      info = await opts.arkade.getInfo();
+    }
     const serverKey = toXOnly(hex.decode(info.signerPubkey), "ark signer key");
     const checkpoint = CSVMultisigTapscript.decode(hex.decode(info.checkpointTapscript));
     const network = opts.network ?? (Object.hasOwn(networks, info.network) ? getNetwork(info.network) : DEFAULT_NETWORK);
     let emulatorKey;
-    if (opts.emulator) {
+    if (emulator) {
       emulatorKey = hex.decode(resolveEmulatorPubkey(network, opts.emulatorPubkey));
     }
     let userKey;
     if (opts.identity) {
       userKey = toXOnly(await opts.identity.xOnlyPublicKey(), "identity key");
     }
+    let contractManager = opts.contractManager;
+    let ownsContractManager = false;
+    if (resolved && opts.storage) {
+      const { onchainProvider } = resolved;
+      contractManager = await ContractManager.create({
+        indexerProvider: resolved.indexerProvider,
+        contractRepository: opts.storage.contractRepository,
+        // Mandatory, and session-scoped: VTXOs are re-read from the indexer on reconnect.
+        walletRepository: new InMemoryWalletRepository(),
+        // Parity with the wallet-owned manager: without it every height-typed CLTV reads
+        // as unsatisfied. @see ContractManagerConfig.chainTip
+        chainTip: async () => {
+          const { height, time } = await onchainProvider.getChainTip();
+          return { height, time };
+        }
+      });
+      ownsContractManager = true;
+    }
     return new _Arkade({
-      arkProvider: opts.arkade,
-      emulator: opts.emulator,
+      arkProvider,
+      emulator,
       network,
       serverKey,
+      serverExitDelay: info.unilateralExitDelay,
       emulatorKey,
       checkpoint,
-      indexer: opts.indexer,
+      indexer,
       identity: opts.identity,
       userKey,
-      contractManager: opts.contractManager
+      contractManager,
+      ownsContractManager
     });
   }
+  /**
+   * Stop event delivery to every {@link ArkadeContract.on} handle and, when {@link connect}
+   * built the contract manager (`storage`), dispose it. A caller-passed manager keeps running.
+   */
+  dispose() {
+    this.disposed = true;
+    this.unsubscribeEvents?.();
+    this.unsubscribeEvents = void 0;
+    this.handles.clear();
+    if (this.ownsContractManager) this.contractManager?.dispose();
+  }
+  /**
+   * @internal Add a handle for `script`, subscribing to the manager on first use; the last
+   * handle's `off()` releases the subscription.
+   */
+  addEventHandle(manager, script, handle) {
+    if (this.disposed) throw new Error("ArkadeContract.on: the Arkade client is disposed");
+    let set = this.handles.get(script);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handles.set(script, set);
+    }
+    set.add(handle);
+    if (!this.unsubscribeEvents) {
+      this.unsubscribeEvents = manager.onContractEvent((event) => this.dispatch(event));
+    }
+    return () => {
+      const current = this.handles.get(script);
+      if (!current) return;
+      current.delete(handle);
+      if (current.size === 0) this.handles.delete(script);
+      if (this.handles.size === 0) {
+        this.unsubscribeEvents?.();
+        this.unsubscribeEvents = void 0;
+      }
+    };
+  }
+  dispatch(event) {
+    let targets;
+    if (event.type === "connection_reset") {
+      targets = [...this.handles.values()].flatMap((set) => [...set]).filter((h) => h.type === "connection_reset");
+    } else if (isContractVtxoEvent(event)) {
+      targets = [...this.handles.get(event.contractScript) ?? []].filter(
+        (h) => h.type === event.type
+      );
+    } else {
+      return;
+    }
+    const report = (error) => console.error("Error in ArkadeContract event handler:", error);
+    for (const handle of targets) {
+      try {
+        Promise.resolve(handle.callback(event)).catch(report);
+      } catch (error) {
+        report(error);
+      }
+    }
+  }
   /**
    * Instantiate a contract from a program and its constructor arguments. `const` inference keeps
    * the program's literal type, so `functions` is strongly typed.
    *
-   * Unbound declared `server`/`user` params default to the client's server key / identity key;
-   * explicit args win.
+   * Declared `server`/`user` params default to the client's keys. Compiler
+   * artifacts reserve the server key and exit delay to the connected server.
    */
   contract(program, args = {}) {
-    const declared = (program.params ?? []).map(inputName);
+    const declared = (program.params ?? []).map((p) => p.name);
     if (declared.includes("server") && args.server === void 0) {
       args = { ...args, server: this.serverKey };
     }
     if (declared.includes("user") && args.user === void 0 && this.userKey) {
       args = { ...args, user: this.userKey };
     }
+    if (declared.includes("SERVER_EXIT_DELAY")) {
+      const delay = this.serverExitDelay;
+      if (delay === void 0 || delay <= 0n)
+        throw new Error(
+          "compiler artifact: server must provide a positive unilateral exit delay"
+        );
+      const typed = toTimelock(delay);
+      if (typed.type === "seconds" && delay % 512n !== 0n) {
+        throw new Error(
+          `compiler artifact: server exit delay ${delay}s must be a multiple of 512 seconds`
+        );
+      }
+      const sequence = BigInt(timelockToSequence(typed));
+      if (args.SERVER_EXIT_DELAY !== void 0 && args.SERVER_EXIT_DELAY !== sequence && args.SERVER_EXIT_DELAY !== Number(sequence)) {
+        throw new Error(
+          "compiler artifact: reserved SERVER_EXIT_DELAY must match the connected server"
+        );
+      }
+      args = { ...args, SERVER_EXIT_DELAY: sequence };
+    }
     return new ArkadeContract(this, program, args);
   }
 };
@@ -24468,7 +24841,7 @@ var ArkadeContract = class _ArkadeContract {
   }
   /** Callable spending paths: `functions.<name>(...args)` (see {@link ContractFunctions}). */
   get functions() {
-    const out = {};
+    const out = /* @__PURE__ */ Object.create(null);
     for (const fn of this.compiled) {
       out[fn.name] = (...callArgs) => new ArkadeTransactionBuilder(this, fn, bindInputs(fn, callArgs));
     }
@@ -24497,18 +24870,65 @@ var ArkadeContract = class _ArkadeContract {
    * counted in balances, re-derivable via the `"arkade"` handler). Idempotent per script.
    */
   async register(options) {
-    const manager = this.client.contractManager;
-    if (!manager) {
-      throw new Error(
-        "ArkadeContract.register requires a `contractManager` on the Arkade client \u2014 pass one to Arkade.connect"
-      );
-    }
+    const manager = this.requireManager("register");
     return manager.createContract({
       ...this.toContractParams(),
       label: options?.label,
       metadata: options?.metadata
     });
   }
+  /**
+   * Report this contract's activity: `vtxo_received`/`vtxo_spent` for its script, and
+   * `connection_reset` when the manager's event stream reconnects. Registers the contract
+   * (idempotent) so it is persisted and watched; requires a contract manager (`storage` or
+   * `contractManager` on {@link Arkade.connect}).
+   *
+   * Activity is reported from subscription on — coins that predate it are not replayed. After
+   * subscribing, and on every `connection_reset` (the manager re-syncs silently), read stored
+   * state with {@link getVtxos}.
+   *
+   * @example
+   * ```typescript
+   * const spent = await htlc.on("vtxo_spent", (e) => console.log(e.vtxos));
+   * const reset = await htlc.on("connection_reset", async () => reconcile(await htlc.getVtxos()));
+   * spent.off();
+   * ```
+   */
+  async on(type, callback) {
+    const manager = this.requireManager("on");
+    const off = this.client.addEventHandle(manager, hex.encode(this.pkScript), {
+      type,
+      callback
+    });
+    try {
+      await this.register();
+    } catch (error) {
+      off();
+      throw error;
+    }
+    return { off };
+  }
+  /**
+   * Every stored VTXO of this contract, spent ones included (`getUtxos` hides those), as the
+   * contract manager last synced them. The recovery read for {@link on}. Empty when the
+   * contract is not registered.
+   */
+  async getVtxos() {
+    const manager = this.requireManager("getVtxos");
+    const [withVtxos] = await manager.getContractsWithVtxos({
+      script: hex.encode(this.pkScript)
+    });
+    return withVtxos?.vtxos ?? [];
+  }
+  requireManager(method) {
+    const manager = this.client.contractManager;
+    if (!manager) {
+      throw new Error(
+        `ArkadeContract.${method} requires a contract manager on the Arkade client \u2014 pass \`storage\` or \`contractManager\` to Arkade.connect`
+      );
+    }
+    return manager;
+  }
   /**
    * Spendable VTXOs locked by this contract: repository-backed when registered with a
    * `contractManager`, otherwise a direct indexer query. Both drop spent and unrolled outputs;
@@ -24598,6 +25018,11 @@ var ArkadeTransactionBuilder = class {
   }
   /** Assemble the unsigned ark transaction and its checkpoints. */
   async build() {
+    if (this.fn.def.tapscript.csv) {
+      throw new Error(
+        `${this.fn.name}: CSV leaves require an aged onchain output; the offchain builder creates fresh checkpoints \u2014 use the wallet's unilateral exit flow`
+      );
+    }
     if (this.outputs.length === 0) {
       throw new Error("ArkadeTransactionBuilder: at least one output is required");
     }
@@ -24676,6 +25101,22 @@ var ArkadeTransactionBuilder = class {
   }
   /** Build, submit and return the finalized transaction. */
   async send() {
+    if (this.fn.def.tapscript.signers.some(
+      (signer) => typeof signer === "object" && "tweak" in signer
+    )) {
+      throw new Error(
+        `${this.fn.name}: covenant-tweaked leaf signing is not supported by Identity; use a signer that supports the covenant tweak with build()`
+      );
+    }
+    const { serverKey } = this.contract.keys;
+    const userKey = this.contract.client.userKey;
+    if (this.fn.signerKeys.some(
+      (key) => !equalBytes(key, serverKey) && (!userKey || !equalBytes(key, userKey))
+    )) {
+      throw new Error(
+        `${this.fn.name}: external leaf signatures are required; use build() and sign the PSBT with all required signers`
+      );
+    }
     const { arkTx, checkpoints } = await this.build();
     const client = this.contract.client;
     const userInputs = this.userInputIndexes();
@@ -24727,7 +25168,7 @@ var ArkadeTransactionBuilder = class {
   /** Indexes of inputs the client owns and must sign (contract input + funded inputs). */
   userInputIndexes() {
     const idxs = [];
-    const userKey = this.contract.keys.userKey;
+    const userKey = this.contract.client.userKey;
     if (userKey && this.fn.signerKeys.some((k) => equalBytes(k, userKey))) {
       idxs.push(0);
     }
@@ -24761,12 +25202,19 @@ var ArkadeTransactionBuilder = class {
   }
 };
 function bindInputs(fn, callArgs) {
-  const names = (fn.def.inputs ?? []).map(inputName);
-  if (callArgs.length !== names.length) {
-    throw new Error(`${fn.name}: expected ${names.length} argument(s), got ${callArgs.length}`);
+  const inputs = fn.def.inputs ?? [];
+  if (callArgs.length !== inputs.length) {
+    throw new Error(
+      `${fn.name}: expected ${inputs.length} argument(s), got ${callArgs.length}`
+    );
   }
-  const bound = {};
-  names.forEach((n, i) => bound[n] = callArgs[i]);
+  const bound = /* @__PURE__ */ Object.create(null);
+  inputs.forEach((def, i) => {
+    if (Object.hasOwn(bound, def.name))
+      throw new Error(`${fn.name}: duplicate input '${def.name}'`);
+    validateParamValue(def, callArgs[i]);
+    bound[def.name] = callArgs[i];
+  });
   return bound;
 }
 function attachExtension(tx, newPackets) {
@@ -25251,6 +25699,6 @@ function createDefaultPaymentRouter(wallet) {
   }).use(arkRail()).use(arkAssetRail()).use(onchainRail({ feeInfo: walletFeeSource(wallet) }));
 }
 
-export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, ArkadeCash, ArkadeCashCreateError, ArkadeCashOperatorMismatchError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, 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, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, SendDeadlineExceededError, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, VtxoReservedError, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
-//# sourceMappingURL=chunk-I4ZWKG7B.js.map
-//# sourceMappingURL=chunk-I4ZWKG7B.js.map
+export { ARKADE_MAGIC, ARKADE_SALTED_PREIMAGE_TAG, ARKADE_SWAP_PREIMAGE_TAG, ASSET_CARRIER_SATS, AbortError, ActivityRegistry, AmbiguousRouteError, ArkNote, Arkade, ArkadeCash, ArkadeCashCreateError, ArkadeCashOperatorMismatchError, AssetManager, BIP21, BIP21Error, BIP322, BLOCKED_UPGRADE_TIMEOUT_MS, Batch, CachingArkProvider, ChainedTxType, ConnectionDisposedError, ContractManager, ContractWatcher, DEFAULT_MESSAGE_TIMEOUTS, DEFAULT_MIN_BATCH_EXPIRY_SECONDS, DEFAULT_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, DatabaseUpgradeBlockedError, DelegateManagerImpl, DelegateNotConfiguredError, 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, KeyringDescriptorProvider, MAX_PAGE_SIZE, MAX_USED_SIGNING_DESCRIPTORS_LOOK_AHEAD, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MUTINYNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, OversizedChangeError, P2A, PaymentRouter, PrevTxUnavailableError, REGTEST_MIN_BATCH_EXPIRY_SECONDS, REGTEST_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestEmulatorProvider, SIGNET_MIN_CHECKPOINT_EXIT_DELAY_SECONDS, SeedIdentity, SendDeadlineExceededError, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, StaticDescriptorProvider, TxTree, TxType, TxWeightEstimator, UnannotatableInputError, UnilateralExit, UnknownPacket, Unroll, VtxoManager, VtxoReservedError, Wallet2 as Wallet, WalletCannotAllocateAddressError, WalletCannotSignError, WalletMessageHandler, WalletNotInitializedError, WsElectrumChainSource, adoptContractDescriptor, arkAssetRail, arkRail, arkTarget, arkade_exports, assertFinalCommitmentMatchesValidated, assertHistoryPageFilter, assertIntentIdUnique, assertNoAssets, assertNoSelection, assertPageRequest, assertRecipientArkadeAddress, assertSendDeadline, assertSendableAmount, assertSubmittedArkTxid, assertValidBatchExpiry, assertValidServerUnrollScript, assetMintResolver, assetsOf, attachPrevArkTxs, attachPrevoutTxs, awaitTransaction, boardingResolver, btcTarget, buildForfeitTx, buildOffchainTx, buildPreimageMessage, buildSaltedPreimageMessage, captureSendDeadline, checkSaveVtxosForScript, claimWithPreimageIdentity, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, collabExitResolver, collectContracts, collectIntents, collectPages, collectScriptVtxos, collectTransactionHistory, collectUtxos, collectVtxos, combineTapscriptSigs, compareHistoryCursors, contractFilterMatchesNothing, contractFromArkContract, contractFromArkContractWithAddress, contractPreimage, contractSigner, createAssetPacket, createDefaultActivityRegistry, createDefaultPaymentRouter, createExitChainResolver, createManagedConnection, createdAtToIso, decodeArkContract, defaultBatchExpiryPolicy, defaultCheckpointExitDelayPolicy, deleteByIndex, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, exitObserverFor, extendVirtualCoinForContract, extractArkProviderUrl, gateExclusion, gatedContracts, getAllByIndexValues, getRandomId, hasBoardingTxExpired, hasCandidates, intentMatchesFilter, invoiceTarget, isAddressAllocationCapable, isArkContract, isBatchSignable, isBtcAddress, isContractGenericallySpendable, isContractVtxoEvent, isCooperativelyMigratable, isDeterministicSigner, isDiscoverable, isHDAllocationCapable, isHDDeterministicSignCapable, isHDWalletCapable, isLightningInvoice, isLnurl, isMessageBusInitializingError, isMessageBusNotInitializedError, isPerArtifactDescriptor, isSigningIdentity, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, iteratePages, legacyVtxoFacts, logExcludedVtxos, makeHandle, matchServerCheckpoints, mergeChainedTxType, notifyExitObserved, onchainRail, openDatabase, outpointExclusion, outpointReasons, pageResult, promisifyRequest, provisionClaimSecret, provisionRefundKey, registerWalletRestoreHook, resolveAssetAmount, resolveBatchExpiryPolicy, resolveCheckpointExitDelayPolicy, resolveDescriptorSigner, resolvePrevTxs, resolveSendAmount, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, selectionOf, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signAndSubmitOffchainTx, signerSetFromInfo, signingDescriptorIndex, strictSigningDescriptorIndex, submitViaEmulator, toXOnlySignerHex, tryResolveSendAmount, utxoEntries, validateBatchRecipients, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, walletFeeSource, warnAndFilterVtxosForScript, withPrevTxs };
+//# sourceMappingURL=chunk-34G7TDUS.js.map
+//# sourceMappingURL=chunk-34G7TDUS.js.map