@arkade-os/sdk 0.4.46 → 0.4.48-rc.0

package/dist/{chunk-P6VBP3CT.js → chunk-SV4PCGKM.js}

@@ -1,11 +1,12 @@
-import { craftToSpendTx, Transaction, OP_RETURN_EMPTY_PKSCRIPT, baseFetch, Intent, getArkPsbtFields, CosignerPublicKey, setArkPsbtField, VtxoTaprootTree, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, AssetId, AssetOutput, AssetGroup, AssetInput, Packet, Metadata, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError, BufferReader } from './chunk-CWJ7ZCP7.js';
-import { contractHandlers, isMainnetDescriptor, descriptorIsOurs, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, BoardingContractHandler } from './chunk-QKC2T54O.js';
-import { VtxoScript, sequenceToTimelock, timelockToSequence, DEFAULT_NETWORK, DEFAULT_NETWORK_NAME, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, ArkAddress, CSVMultisigTapscript, getSequence, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-FWG4TSPN.js';
-import { sha256, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr, equalBytes as equalBytes$1 } from '@scure/btc-signer/utils.js';
-import { SigHash, Script, p2tr, RawWitness, Address, OutScript, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
-import { hex, base58, base64 } from '@scure/base';
+import { Transaction, setArkPsbtField, PrevArkTxField, ConditionWitness, AssetId, AssetGroup, AssetInput, AssetOutput, Metadata, Packet, craftToSpendTx, getArkPsbtFields, CosignerPublicKey, BufferReader, BufferWriter, OP_RETURN_EMPTY_PKSCRIPT, VtxoTaprootTree, baseFetch, Intent, maybeArkError, isArkError, ArkErrorName, ProviderUnavailableError, FetchError, isFetchTimeoutError, AssetRef, isEventSourceError, RestArkProvider, RestIndexerProvider, ArkError } from './chunk-GM6JRQP5.js';
+import { witnessRefToBytes, validateProgram, toASM, stringifyArtifact, serializeArkadeContractParams, resolveAsm, parseArtifact, getOpcodeValue, getOpcodeName, fromASM, deserializeArkadeContractParams, computeArkadeScriptPublicKey, bytesToASM, asmToBytes, arkadeWitnessHash, arkadeScriptHash, SUPPORTED_PROGRAM_VERSION, OPCODE_VALUES, OPCODE_NAMES, bignum_exports, ArkadeScript, ArkadeProgramScript, ARKADE_OPS, ARKADE_OPCODE_VALUES, ARKADE_OPCODE_NAMES, ARKADE_OPCODES, ARKADE_OP, inputName, contractHandlers, isMainnetDescriptor, descriptorIsOurs, DefaultVtxo, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, BoardingContractHandler } from './chunk-XN3554FT.js';
+import { VtxoScript, CSVMultisigTapscript, DEFAULT_NETWORK, ArkAddress, sequenceToTimelock, decodeTapscript, scriptFromTapLeafScript, CLTVMultisigTapscript, timelockToSequence, DEFAULT_NETWORK_NAME, getSequence, getNetwork, MultisigTapscript, networks as networks$1, DEFAULT_ARKADE_SERVER_URL } from './chunk-C7TXXTMS.js';
+import { __export } from './chunk-NSBPE2FW.js';
+import { sha256, equalBytes, hash160, sha256x2, concatBytes, randomPrivateKeyBytes, pubECDSA, pubSchnorr } from '@scure/btc-signer/utils.js';
+import { SigHash, Script, OP, OutScript, Address, RawWitness, p2tr, p2wpkh, TaprootControlBlock, DEFAULT_SEQUENCE, Transaction as Transaction$2 } from '@scure/btc-signer';
+import { hex, base58, base64, bech32m } from '@scure/base';
 import * as musig2 from '@scure/btc-signer/musig2.js';
-import { equalBytes, bytesToNumberBE } from '@noble/curves/utils.js';
+import { equalBytes as equalBytes$1, bytesToNumberBE } from '@noble/curves/utils.js';
 import { signAsync, schnorr as schnorr$1, Point } from '@noble/secp256k1';
 import { secp256k1, schnorr } from '@noble/curves/secp256k1.js';
 import { Script as Script$1 } from '@scure/btc-signer/script.js';
@@ -1512,6 +1513,62 @@ var UnknownPacket = class {
   }
 };
 
+// src/extension/emulator/packet.ts
+var EmulatorPacket = class _EmulatorPacket {
+  constructor(entries) {
+    this.entries = entries;
+  }
+  entries;
+  /** PACKET_TYPE is the 1-byte TLV type tag used in the Extension envelope. */
+  static PACKET_TYPE = 1;
+  static create(entries) {
+    if (entries.length === 0) {
+      throw new Error("empty emulator packet");
+    }
+    for (const entry of entries) {
+      if (entry.script.length === 0) {
+        throw new Error(`empty script for vin ${entry.vin}`);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      if (seen.has(entry.vin)) {
+        throw new Error(`duplicate vin ${entry.vin}`);
+      }
+      seen.add(entry.vin);
+    }
+    return new _EmulatorPacket(entries);
+  }
+  static fromBytes(data) {
+    const reader = new BufferReader(data);
+    const entryCount = reader.readCompactSize();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+      const vin = reader.readUint16LE();
+      const script = reader.readCompactSlice();
+      const witness = reader.readCompactSlice();
+      entries.push({ vin, script, witness });
+    }
+    if (reader.remaining() > 0) {
+      throw new Error(`unexpected ${reader.remaining()} trailing bytes`);
+    }
+    return _EmulatorPacket.create(entries);
+  }
+  type() {
+    return _EmulatorPacket.PACKET_TYPE;
+  }
+  serialize() {
+    const writer = new BufferWriter();
+    writer.writeCompactSize(this.entries.length);
+    for (const entry of this.entries) {
+      writer.writeUint16LE(entry.vin);
+      writer.writeCompactSlice(entry.script);
+      writer.writeCompactSlice(entry.witness ?? new Uint8Array(0));
+    }
+    return writer.toBytes();
+  }
+};
+
 // src/extension/index.ts
 var ARKADE_MAGIC = new Uint8Array([65, 82, 75]);
 var ExtensionNotFoundError = class extends Error {
@@ -1531,10 +1588,14 @@ var Extension = class _Extension {
     }
     const seen = /* @__PURE__ */ new Set();
     for (const p of packets) {
-      if (seen.has(p.type())) {
-        throw new Error(`duplicate packet type ${p.type()}`);
+      const type = p.type();
+      if (!Number.isInteger(type) || type < 0 || type > 255) {
+        throw new Error(`invalid packet type ${type}: must be an integer in [0, 255]`);
       }
-      seen.add(p.type());
+      if (seen.has(type)) {
+        throw new Error(`duplicate packet type ${type}`);
+      }
+      seen.add(type);
     }
     return new _Extension(packets);
   }
@@ -1548,7 +1609,7 @@ var Extension = class _Extension {
       if (decoded.length < 2 || decoded[0] !== "RETURN") return false;
       const data = decoded[1];
       if (!(data instanceof Uint8Array)) return false;
-      return data.length >= ARKADE_MAGIC.length && equalBytes$1(data.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC);
+      return data.length >= ARKADE_MAGIC.length && equalBytes(data.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC);
     } catch {
       return false;
     }
@@ -1579,7 +1640,7 @@ var Extension = class _Extension {
       payload.set(d, offset);
       offset += d.length;
     }
-    if (payload.length < ARKADE_MAGIC.length || !equalBytes$1(payload.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC)) {
+    if (payload.length < ARKADE_MAGIC.length || !equalBytes(payload.slice(0, ARKADE_MAGIC.length), ARKADE_MAGIC)) {
       throw new Error(
         `expected magic prefix ${hex.encode(ARKADE_MAGIC)}, got ${hex.encode(payload.slice(0, Math.min(payload.length, ARKADE_MAGIC.length)))}`
       );
@@ -1664,12 +1725,45 @@ var Extension = class _Extension {
     }
     return null;
   }
+  /**
+   * getEmulatorPacket returns the embedded EmulatorPacket, or null if not present.
+   */
+  getEmulatorPacket() {
+    for (const p of this.packets) {
+      if (p instanceof EmulatorPacket) {
+        return p;
+      }
+    }
+    return null;
+  }
+  /**
+   * getPacketByType returns the first packet matching the given type tag, or null.
+   */
+  getPacketByType(packetType) {
+    for (const p of this.packets) {
+      if (p.type() === packetType) {
+        return p;
+      }
+    }
+    return null;
+  }
+  /**
+   * Returns all embedded packets in insertion order. Used when callers need
+   * to rebuild an Extension from an existing one (e.g. appending a new packet).
+   */
+  getPackets() {
+    return this.packets;
+  }
 };
 function parsePacket(packetType, data) {
-  if (packetType === Packet.PACKET_TYPE) {
-    return Packet.fromBytes(data);
+  switch (packetType) {
+    case Packet.PACKET_TYPE:
+      return Packet.fromBytes(data);
+    case EmulatorPacket.PACKET_TYPE:
+      return EmulatorPacket.fromBytes(data);
+    default:
+      return new UnknownPacket(packetType, data);
   }
-  return new UnknownPacket(packetType, data);
 }
 function encodeVarUint(value) {
   const bytes = [];
@@ -1750,7 +1844,7 @@ function validateOnchainRecipient(commitmentTx, recipient, network, usedOutputs)
     if (!output?.script || output.script.length === 0) {
       continue;
     }
-    if (equalBytes$1(output.script, expectedPkScript)) {
+    if (equalBytes(output.script, expectedPkScript)) {
       if (output.amount !== BigInt(recipient.amount)) {
         continue;
       }
@@ -1774,7 +1868,7 @@ function validateOffchainRecipient(leaves, arkAddress, recipient, usedOutputs) {
       if (!output?.script || output.script.length === 0) {
         continue;
       }
-      if (!equalBytes$1(output.script, expectedPkScript)) {
+      if (!equalBytes(output.script, expectedPkScript)) {
         continue;
       }
       if (output.amount !== expectedAmount) {
@@ -2303,6 +2397,55 @@ function isValidArkAddress(address) {
     return false;
   }
 }
+async function submitOffchainTx(provider, offchainTx, signer, hooks) {
+  const { arkTx: signedArkTx, userSignedCheckpoints } = await signer.signArkTx(
+    offchainTx.arkTx,
+    offchainTx.checkpoints
+  );
+  if (userSignedCheckpoints && userSignedCheckpoints.length !== offchainTx.checkpoints.length) {
+    throw new Error(
+      `signer returned ${userSignedCheckpoints.length} signed checkpoints, expected ${offchainTx.checkpoints.length}`
+    );
+  }
+  await hooks?.beforeSubmit?.();
+  const { arkTxid, signedCheckpointTxs } = await provider.submitTx(
+    base64.encode(signedArkTx.toPSBT()),
+    offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
+  );
+  if (signedCheckpointTxs.length !== offchainTx.checkpoints.length) {
+    throw new Error(
+      `submitTx returned ${signedCheckpointTxs.length} checkpoints, expected ${offchainTx.checkpoints.length}`
+    );
+  }
+  let finalCheckpoints;
+  if (userSignedCheckpoints) {
+    finalCheckpoints = signedCheckpointTxs.map((c, i) => {
+      const serverSigned = Transaction.fromPSBT(base64.decode(c));
+      combineTapscriptSigs(userSignedCheckpoints[i], serverSigned);
+      return base64.encode(serverSigned.toPSBT());
+    });
+  } else {
+    finalCheckpoints = await Promise.all(
+      signedCheckpointTxs.map(async (c) => {
+        const tx = Transaction.fromPSBT(base64.decode(c));
+        const signed = await signer.signCheckpoint(tx);
+        return base64.encode(signed.toPSBT());
+      })
+    );
+  }
+  await provider.finalizeTx(arkTxid, finalCheckpoints);
+  await hooks?.afterFinalize?.();
+  return { arkTxid, signedCheckpointTxs };
+}
+async function signAndSubmitOffchainTx(params) {
+  const offchainTx = buildOffchainTx(params.inputs, params.outputs, params.serverUnrollScript);
+  const signer = {
+    signArkTx: async (arkTx) => ({ arkTx: await params.identity.sign(arkTx) }),
+    signCheckpoint: (checkpoint) => params.identity.sign(checkpoint)
+  };
+  const { arkTxid } = await submitOffchainTx(params.provider, offchainTx, signer);
+  return arkTxid;
+}
 var AmountVariableName = "amount";
 var ExpiryVariableName = "expiry";
 var BirthVariableName = "birth";
@@ -2458,6 +2601,14 @@ function parseProgram(text, env) {
   }
   return { program, text };
 }
+
+// src/contracts/types.ts
+function isDiscoverable(handler) {
+  return !!handler && typeof handler.discoverAt === "function";
+}
+function isTapscriptDeriving(handler) {
+  return !!handler && typeof handler.deriveTapscripts === "function";
+}
 var DUST_AMOUNT = 546;
 var FALLBACK_WALLET_DUST_AMOUNT = 330n;
 function getDustAmount(wallet) {
@@ -2477,10 +2628,14 @@ function deriveContractTapscripts(contract) {
     throw new Error(`No handler for contract type '${contract.type}'`);
   }
   const script = handler.createScript(contract.params);
+  if (isTapscriptDeriving(handler)) {
+    return handler.deriveTapscripts(script, contract);
+  }
+  const legacy = script;
   return {
-    forfeitTapLeafScript: script.forfeit(),
-    intentTapLeafScript: script.forfeit(),
-    tapTree: script.encode()
+    forfeitTapLeafScript: legacy.forfeit(),
+    intentTapLeafScript: legacy.forfeit(),
+    tapTree: legacy.encode()
   };
 }
 function cloneTapLeafScript([
@@ -2598,6 +2753,7 @@ async function runWithCrossInstanceLock(name, fn) {
   });
 }
 var MAX_VTXOS_PER_SETTLEMENT = 50;
+var MAX_INPUTS_PER_INTENT = 20;
 function byValueDescending(vtxos) {
   return [...vtxos].sort((a, b) => b.value - a.value);
 }
@@ -4187,6 +4343,96 @@ function readUInt32BE(array, offset) {
 function noteTapscript(preimageHash) {
   return Script.encode(["SHA256", preimageHash, "EQUAL"]);
 }
+var ArkCash = class _ArkCash {
+  constructor(privateKey, serverPubKey, csvTimelock, hrp = _ArkCash.DefaultHRP) {
+    this.csvTimelock = csvTimelock;
+    this.hrp = hrp;
+    if (privateKey.length !== 32) {
+      throw new Error(
+        `Invalid private key length: expected 32 bytes, got ${privateKey.length}`
+      );
+    }
+    if (serverPubKey.length !== 32) {
+      throw new Error(
+        `Invalid server public key length: expected 32 bytes, got ${serverPubKey.length}`
+      );
+    }
+    this._privateKey = privateKey.slice();
+    this._serverPubKey = serverPubKey.slice();
+    this._publicKey = pubSchnorr(this._privateKey);
+  }
+  csvTimelock;
+  hrp;
+  static DefaultHRP = "arkcash";
+  static Version = 0;
+  static PayloadLength = 1 + 32 + 32 + 4;
+  // 69 bytes
+  // Keys are held as private copies so a caller mutating the array it passed
+  // in — or one it reads back from a getter — cannot alter this note's
+  // identity or the outputs derived from it.
+  _privateKey;
+  _serverPubKey;
+  _publicKey;
+  /** The note's private key. Returns a fresh copy; mutating it is a no-op. */
+  get privateKey() {
+    return this._privateKey.slice();
+  }
+  /** The server's public key. Returns a fresh copy; mutating it is a no-op. */
+  get serverPubKey() {
+    return this._serverPubKey.slice();
+  }
+  /** The note's public key. Returns a fresh copy; mutating it is a no-op. */
+  get publicKey() {
+    return this._publicKey.slice();
+  }
+  static generate(serverPubKey, csvTimelock, hrp) {
+    return new _ArkCash(randomPrivateKeyBytes(), serverPubKey, csvTimelock, hrp);
+  }
+  static fromString(encoded) {
+    const decoded = bech32m.decodeUnsafe(encoded.trim().toLowerCase(), 1023);
+    if (!decoded) {
+      throw new Error("Invalid arkcash string: failed to decode bech32m");
+    }
+    const data = new Uint8Array(bech32m.fromWords(decoded.words));
+    if (data.length !== _ArkCash.PayloadLength) {
+      throw new Error(
+        `Invalid arkcash data length: expected ${_ArkCash.PayloadLength} bytes, got ${data.length}`
+      );
+    }
+    const version = data[0];
+    if (version !== _ArkCash.Version) {
+      throw new Error(`Unsupported arkcash version: ${version}`);
+    }
+    const privateKey = data.slice(1, 33);
+    const serverPubKey = data.slice(33, 65);
+    const sequence = new DataView(data.buffer, data.byteOffset + 65, 4).getUint32(0, false);
+    const csvTimelock = sequenceToTimelock(sequence);
+    return new _ArkCash(privateKey, serverPubKey, csvTimelock, decoded.prefix);
+  }
+  toString() {
+    const data = new Uint8Array(_ArkCash.PayloadLength);
+    data[0] = _ArkCash.Version;
+    data.set(this._privateKey, 1);
+    data.set(this._serverPubKey, 33);
+    const sequence = timelockToSequence(this.csvTimelock);
+    new DataView(data.buffer, data.byteOffset + 65, 4).setUint32(0, sequence, false);
+    const words = bech32m.toWords(data);
+    return bech32m.encode(this.hrp, words, 1023);
+  }
+  get identity() {
+    return SingleKey.fromPrivateKey(this._privateKey);
+  }
+  get vtxoScript() {
+    return new DefaultVtxo.Script({
+      pubKey: this._publicKey,
+      serverPubKey: this._serverPubKey,
+      csvTimelock: this.csvTimelock
+    });
+  }
+  address(addressHrp) {
+    return this.vtxoScript.address(addressHrp, this._serverPubKey);
+  }
+};
 
 // src/repositories/intentRepository.ts
 var ALL_INTENT_STATES = [
@@ -5989,7 +6235,7 @@ async function makeSignedDelegateIntent(identity, coins, outputs, onchainOutputs
   };
 }
 function findDestinationOutputIndex(outputs, destinationScript) {
-  return outputs.findIndex((o) => o.script && equalBytes$1(o.script, destinationScript));
+  return outputs.findIndex((o) => o.script && equalBytes(o.script, destinationScript));
 }
 function getDayTimestamp(timestamp) {
   const date = new Date(timestamp);
@@ -7841,11 +8087,6 @@ var ContractRepositoryImpl = class {
   }
 };
 
-// src/contracts/types.ts
-function isDiscoverable(handler) {
-  return !!handler && typeof handler.discoverAt === "function";
-}
-
 // src/contracts/contractWatcher.ts
 function computeReconnectDelay(attempt, baseMs, maxMs) {
   return Math.min(baseMs * Math.pow(2, attempt - 1), maxMs);
@@ -9495,7 +9736,7 @@ var WalletReceiveRotator = class _WalletReceiveRotator {
       throw e;
     }
     if (!boot) return void 0;
-    const offchainTapscript = equalBytes$1(
+    const offchainTapscript = equalBytes(
       boot.receivePubkey,
       setup.offchainTapscript.options.pubKey
     ) ? setup.offchainTapscript : rebuildTapscript(setup.offchainTapscript, boot.receivePubkey);
@@ -9986,6 +10227,24 @@ async function spendableVtxosExcludingLocked(vtxos, intentRepository) {
   }
   return excludeLockedOutpoints(vtxos, locked);
 }
+var cashReport = (vtxo, reason) => ({
+  txid: vtxo.txid,
+  vout: vtxo.vout,
+  value: vtxo.value,
+  reason
+});
+var ArkCashCreateError = class extends Error {
+  constructor(cash, cause) {
+    super(
+      `Failed to create ArkCash: send failed after the note may have been submitted. Recover with claimCash using the token on this error's \`cash\` field.`
+    );
+    this.cash = cash;
+    this.cause = cause;
+    this.name = "ArkCashCreateError";
+  }
+  cash;
+  cause;
+};
 var ReadonlyWallet = class _ReadonlyWallet {
   constructor(identity, network, onchainProvider, indexerProvider, arkServerPublicKey, offchainTapscript, boardingTapscript, dustAmount, walletRepository, contractRepository, delegateProvider, watcherConfig, walletContractTimelocks) {
     this.identity = identity;
@@ -11342,7 +11601,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     } catch (e) {
       throw new Error("Invalid checkpointTapscript from server");
     }
-    if (equalBytes$1(xonly, this.arkServerPublicKey)) return;
+    if (equalBytes(xonly, this.arkServerPublicKey)) return;
     if (this._receiveRotator) {
       await this._receiveRotator.runExclusive(
         () => this._doRotateServerSigner(xonly, newServerUnrollScript)
@@ -11357,7 +11616,7 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     return run;
   }
   async _doRotateServerSigner(xonly, newServerUnrollScript) {
-    if (equalBytes$1(xonly, this.arkServerPublicKey)) return;
+    if (equalBytes(xonly, this.arkServerPublicKey)) return;
     const manager = await this.getContractManager();
     const [currentOffchainRow] = await manager.getContracts({
       script: this.defaultContractScript
@@ -12445,7 +12704,6 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     if (!hasPending) {
       return { finalized: [], pending: [] };
     }
-    const MAX_INPUTS_PER_INTENT = 20;
     if (!vtxos || vtxos.length === 0) {
       const scriptMap = await this.getScriptMap();
       const allExtended = [];
@@ -12555,6 +12813,265 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       settings: { ...state.settings, hasPendingTx: value }
     }));
   }
+  /**
+   * Create an ArkCash bearer instrument.
+   *
+   * Generates a fresh keypair, sends the specified amount to a DefaultVtxo
+   * controlled by the new key, and returns the encoded arkcash string.
+   * The receiver can claim the funds using `claimCash()` without ever
+   * sharing their address.
+   *
+   * ArkCash is a short-lived instrument: it carries a private key, so it is
+   * meant to be handed over and claimed promptly, not held. A note left
+   * unclaimed past its batch expiry is swept by the server and `claimCash`
+   * can only report it, not move it.
+   *
+   * @param amount - Amount in satoshis to send. Must be a whole number of
+   * sats at or above the dust threshold — a below-dust amount would mint an
+   * OP_RETURN output that is unspendable as cash.
+   * @returns The encoded arkcash string (e.g., "arkcash1...")
+   */
+  async createCash(amount) {
+    if (!Number.isSafeInteger(amount) || amount < Number(this.dustAmount)) {
+      throw new Error(
+        `Invalid ArkCash amount ${amount}: must be a whole number of sats >= dust (${this.dustAmount})`
+      );
+    }
+    const cashHrp = this.network.hrp.replace(/ark$/, "arkcash");
+    const cash = ArkCash.generate(
+      this.arkServerPublicKey,
+      this.offchainTapscript.options.csvTimelock,
+      cashHrp
+    );
+    const address = cash.address(this.network.hrp).encode();
+    const cashStr = cash.toString();
+    try {
+      await this.send({ address, amount });
+    } catch (error) {
+      throw new ArkCashCreateError(cashStr, error);
+    }
+    return cashStr;
+  }
+  /**
+   * Claim an ArkCash bearer instrument: sweep what can be swept, report the
+   * rest.
+   *
+   * Every spendable VTXO at the arkcash address is swept to this wallet in
+   * its own offchain transaction, signed with the key carried by the arkcash
+   * string. Nothing is ever persisted: no contract is imported, and the
+   * arkcash key is not stored. Anything that cannot be swept — server-swept,
+   * subdust, already claimed, or asset-bearing — is returned in `unclaimed`
+   * with a per-VTXO reason and otherwise ignored.
+   *
+   * The arkcash string is the recovery token: a claim interrupted between
+   * submit and finalize is completed by simply re-running `claimCash`, which
+   * drains any pending arkcash transaction on the server before sweeping.
+   *
+   * @param cashStr - The encoded arkcash string (e.g., "arkcash1...")
+   * @returns The swept total and the report of what was left behind. The
+   * shape is open: further buckets may be added alongside `unclaimed`.
+   */
+  async claimCash(cashStr) {
+    const cash = ArkCash.fromString(cashStr);
+    const cashScript = cash.vtxoScript;
+    const cashPkScript = hex.encode(cashScript.pkScript);
+    const scripts = [cashPkScript];
+    let vtxos = await this.fetchAllVtxos(scripts);
+    if (vtxos.length === 0) {
+      throw new Error("No VTXOs found for this arkcash");
+    }
+    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));
+    if (drainable.length > 0) {
+      let drained = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
+      try {
+        drained = await this.finalizePendingCashTxs(
+          cash,
+          drainable,
+          cashScript,
+          myPkScript
+        );
+      } catch (error) {
+        console.error("Failed to drain pending arkcash txs:", error);
+      }
+      if (drained.count > 0) {
+        vtxos = await this.fetchAllVtxos(scripts);
+        ({ spendable, unclaimed } = this.classifyCashVtxos(vtxos));
+        swept += drained.swept;
+        unclaimed = unclaimed.filter(
+          (vtxo) => !drained.claimed.has(`${vtxo.txid}:${vtxo.vout}`)
+        );
+      }
+    }
+    if (spendable.length > 0) {
+      const info = await this.arkProvider.getInfo();
+      const serverUnrollScript = CSVMultisigTapscript.decode(
+        hex.decode(info.checkpointTapscript)
+      );
+      for (const vtxo of spendable) {
+        try {
+          await signAndSubmitOffchainTx({
+            identity: cash.identity,
+            provider: this.arkProvider,
+            inputs: [
+              {
+                txid: vtxo.txid,
+                vout: vtxo.vout,
+                value: vtxo.value,
+                tapLeafScript: cashScript.forfeit(),
+                tapTree: cashScript.encode()
+              }
+            ],
+            outputs: [{ script: myPkScript, amount: BigInt(vtxo.value) }],
+            serverUnrollScript
+          });
+          swept += vtxo.value;
+        } catch (error) {
+          console.error(`Failed to sweep arkcash VTXO ${vtxo.txid}:${vtxo.vout}:`, error);
+          unclaimed.push(cashReport(vtxo, "sweep-failed"));
+        }
+      }
+    }
+    return {
+      swept,
+      unclaimed: {
+        amount: unclaimed.reduce((total, vtxo) => total + vtxo.value, 0),
+        vtxos: unclaimed
+      }
+    };
+  }
+  /**
+   * Split the VTXOs at an arkcash address into the ones the thin sweep can
+   * move and the ones it can only report.
+   */
+  classifyCashVtxos(vtxos) {
+    const spendable = [];
+    const unclaimed = [];
+    for (const vtxo of vtxos) {
+      if (!isSpendable(vtxo)) {
+        unclaimed.push(cashReport(vtxo, "already-spent"));
+      } else if (isSubdust(vtxo, this.dustAmount)) {
+        unclaimed.push(cashReport(vtxo, "subdust"));
+      } else if (isRecoverable(vtxo)) {
+        unclaimed.push(cashReport(vtxo, "swept"));
+      } else if (vtxo.assets && vtxo.assets.length > 0) {
+        unclaimed.push(cashReport(vtxo, "has-assets"));
+      } else {
+        spendable.push(vtxo);
+      }
+    }
+    return { spendable, unclaimed };
+  }
+  /** Read every page of an unfiltered VTXO query for the given scripts. */
+  async fetchAllVtxos(scripts) {
+    const pageSize = 100;
+    const all = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (let pageIndex = 0; ; pageIndex++) {
+      const { vtxos, page } = await this.indexerProvider.getVtxos({
+        scripts,
+        pageIndex,
+        pageSize
+      });
+      for (const vtxo of vtxos) {
+        const outpoint = `${vtxo.txid}:${vtxo.vout}`;
+        if (seen.has(outpoint)) continue;
+        seen.add(outpoint);
+        all.push(vtxo);
+      }
+      if (!page || vtxos.length < pageSize) return all;
+    }
+  }
+  /**
+   * Complete any sweep a previous `claimCash` registered but never finalized.
+   * A thin variant of {@link finalizePendingTxs}, scoped to the arkcash key:
+   * the intent is signed with it, and so are the returned checkpoints.
+   *
+   * A drained sweep is not automatically *ours*. Whoever registered it chose
+   * the destination, so a tx a different claimer left half-finished pays that
+   * claimer — finalizing it is still right (the input is spent either way, and
+   * completing it unsticks the funds), but only the value it actually pays to
+   * `myPkScript` may be counted as claimed here.
+   *
+   * @param vtxos - VTXOs at the arkcash contract's own pkScript, spent ones
+   * included (a registered sweep marks its input spent). Any other outpoint —
+   * subdust above all — would make the proof invalid, since it describes every
+   * input by that pkScript.
+   * @returns The number of pending txs finalized, the sats among them paid to
+   * this wallet, and the outpoints those txs consumed to pay it.
+   */
+  async finalizePendingCashTxs(cash, vtxos, cashScript, myPkScript) {
+    const result = { count: 0, swept: 0, claimed: /* @__PURE__ */ new Set() };
+    const inputs = vtxos.map((vtxo) => ({
+      ...vtxo,
+      forfeitTapLeafScript: cashScript.forfeit(),
+      intentTapLeafScript: cashScript.forfeit(),
+      tapTree: cashScript.encode()
+    }));
+    if (inputs.length === 0) return result;
+    const identity = cash.identity;
+    const seenTxids = /* @__PURE__ */ new Set();
+    const pendingTxs = [];
+    for (let i = 0; i < inputs.length; i += MAX_INPUTS_PER_INTENT) {
+      const batch = inputs.slice(i, i + MAX_INPUTS_PER_INTENT);
+      const message = { type: "get-pending-tx", expire_at: 0 };
+      const proof = Intent.create(message, batch, []);
+      const signedProof = await identity.sign(
+        proof,
+        Array.from({ length: batch.length + 1 }, (_, j) => j)
+      );
+      const batchPending = await this.arkProvider.getPendingTxs({
+        proof: base64.encode(signedProof.toPSBT()),
+        message
+      });
+      for (const pendingTx of batchPending) {
+        if (seenTxids.has(pendingTx.arkTxid)) continue;
+        seenTxids.add(pendingTx.arkTxid);
+        pendingTxs.push(pendingTx);
+      }
+    }
+    const myPkScriptHex = hex.encode(myPkScript);
+    for (const pendingTx of pendingTxs) {
+      try {
+        const checkpointTxs = pendingTx.signedCheckpointTxs.map(
+          (checkpoint) => Transaction$2.fromPSBT(base64.decode(checkpoint))
+        );
+        const finalCheckpoints = await Promise.all(
+          checkpointTxs.map(
+            async (checkpoint) => base64.encode((await identity.sign(checkpoint)).toPSBT())
+          )
+        );
+        await this.arkProvider.finalizeTx(pendingTx.arkTxid, finalCheckpoints);
+        result.count++;
+        const paidToMe = this.arkTxAmountPaidTo(pendingTx.finalArkTx, myPkScriptHex);
+        if (paidToMe === 0) continue;
+        result.swept += paidToMe;
+        for (const checkpoint of checkpointTxs) {
+          for (let i = 0; i < checkpoint.inputsLength; i++) {
+            const input = checkpoint.getInput(i);
+            if (!input.txid) continue;
+            result.claimed.add(`${hex.encode(input.txid)}:${input.index}`);
+          }
+        }
+      } catch (error) {
+        console.error(`Failed to finalize pending arkcash tx ${pendingTx.arkTxid}:`, error);
+      }
+    }
+    return result;
+  }
+  /** Sum the outputs of an ark tx PSBT that pay the given scriptPubKey. */
+  arkTxAmountPaidTo(arkTxPsbt, pkScriptHex) {
+    const arkTx = Transaction$2.fromPSBT(base64.decode(arkTxPsbt));
+    let total = 0;
+    for (let i = 0; i < arkTx.outputsLength; i++) {
+      const output = arkTx.getOutput(i);
+      if (!output.script || output.amount === void 0) continue;
+      if (hex.encode(output.script) === pkScriptHex) total += Number(output.amount);
+    }
+    return total;
+  }
   /**
    * Send BTC and/or assets to one or more recipients.
    *
@@ -12704,9 +13221,24 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
     }
     const assetInputs = selectedCoinsToAssetInputs(selectedCoins);
     const hasAssets = assetInputs.size > 0 || recipients.some((r) => r.assets && r.assets.length > 0);
+    const customExtPackets = [];
+    for (const r of args) {
+      if (r.extensions) {
+        for (const ext of r.extensions) {
+          customExtPackets.push({
+            type: () => ext.type,
+            serialize: () => ext.payload
+          });
+        }
+      }
+    }
+    const allExtPackets = [];
     if (hasAssets) {
-      const assetPacket = createAssetPacket(assetInputs, recipients, changeReceiver);
-      outputs.push(Extension.create([assetPacket]).txOut());
+      allExtPackets.push(createAssetPacket(assetInputs, recipients, changeReceiver));
+    }
+    allExtPackets.push(...customExtPackets);
+    if (allExtPackets.length > 0) {
+      outputs.push(Extension.create(allExtPackets).txOut());
     }
     const sentAmount = recipients.reduce((sum, r) => sum + r.amount, 0);
     return this._submitOffchainSpend(selectedCoins, outputs, {
@@ -12845,72 +13377,52 @@ var Wallet2 = class _Wallet extends ReadonlyWallet {
       index,
       lookupScript: VtxoScript.decode(input.tapTree).pkScript
     }));
-    const checkpointJobs = offchainTx.checkpoints.map(
-      (c) => this.inputSigningJobsFromWitnessUtxos(c)
-    );
-    let signedVirtualTx;
-    let userSignedCheckpoints;
     const identity = this.identity;
-    const batchEligible = isBatchSignable(identity) && await this._signerRouter.canBatch(arkTxJobs, ...checkpointJobs);
-    if (batchEligible) {
-      const requests = [
-        {
-          tx: offchainTx.arkTx.clone(),
-          inputIndexes: arkTxJobs.map((j) => j.index)
-        },
-        ...offchainTx.checkpoints.map((c, i) => ({
-          tx: c.clone(),
-          inputIndexes: checkpointJobs[i].map((j) => j.index)
-        }))
-      ];
-      const signed = await identity.signMultiple(requests);
-      if (signed.length !== requests.length) {
-        throw new Error(
-          `signMultiple returned ${signed.length} transactions, expected ${requests.length}`
-        );
-      }
-      const [firstSignedTx, ...signedCheckpoints] = signed;
-      signedVirtualTx = firstSignedTx;
-      userSignedCheckpoints = signedCheckpoints;
-    } else {
-      signedVirtualTx = await this._signerRouter.sign(offchainTx.arkTx, arkTxJobs);
-    }
-    await this.setPendingTxFlag(true);
-    const { arkTxid, signedCheckpointTxs } = await this.arkProvider.submitTx(
-      base64.encode(signedVirtualTx.toPSBT()),
-      offchainTx.checkpoints.map((c) => base64.encode(c.toPSBT()))
-    );
-    let finalCheckpoints;
-    if (userSignedCheckpoints) {
-      if (signedCheckpointTxs.length !== userSignedCheckpoints.length) {
-        throw new Error(
-          `submitTx returned ${signedCheckpointTxs.length} checkpoints, expected ${userSignedCheckpoints.length}`
+    const signer = {
+      signArkTx: async (arkTx, checkpoints) => {
+        const checkpointJobs = checkpoints.map(
+          (c) => this.inputSigningJobsFromWitnessUtxos(c)
         );
+        const batchEligible = isBatchSignable(identity) && await this._signerRouter.canBatch(arkTxJobs, ...checkpointJobs);
+        if (batchEligible) {
+          const requests = [
+            {
+              tx: arkTx.clone(),
+              inputIndexes: arkTxJobs.map((j) => j.index)
+            },
+            ...checkpoints.map((c, i) => ({
+              tx: c.clone(),
+              inputIndexes: checkpointJobs[i].map((j) => j.index)
+            }))
+          ];
+          const signed = await identity.signMultiple(requests);
+          if (signed.length !== requests.length) {
+            throw new Error(
+              `signMultiple returned ${signed.length} transactions, expected ${requests.length}`
+            );
+          }
+          const [firstSignedTx, ...signedCheckpoints] = signed;
+          return { arkTx: firstSignedTx, userSignedCheckpoints: signedCheckpoints };
+        }
+        return { arkTx: await this._signerRouter.sign(arkTx, arkTxJobs) };
+      },
+      signCheckpoint: (checkpoint) => this._signerRouter.sign(
+        checkpoint,
+        this.inputSigningJobsFromWitnessUtxos(checkpoint)
+      )
+    };
+    return submitOffchainTx(this.arkProvider, offchainTx, signer, {
+      // Mark pending before submitting — if we crash between submit and
+      // finalize, the next init recovers via finalizePendingTxs.
+      beforeSubmit: () => this.setPendingTxFlag(true),
+      afterFinalize: async () => {
+        try {
+          await this.setPendingTxFlag(false);
+        } catch (error) {
+          console.error("Failed to clear pending tx flag:", error);
+        }
       }
-      finalCheckpoints = signedCheckpointTxs.map((c, i) => {
-        const serverSigned = Transaction$2.fromPSBT(base64.decode(c));
-        combineTapscriptSigs(userSignedCheckpoints[i], serverSigned);
-        return base64.encode(serverSigned.toPSBT());
-      });
-    } else {
-      finalCheckpoints = await Promise.all(
-        signedCheckpointTxs.map(async (c) => {
-          const tx = Transaction$2.fromPSBT(base64.decode(c));
-          const signedCheckpoint = await this._signerRouter.sign(
-            tx,
-            this.inputSigningJobsFromWitnessUtxos(tx)
-          );
-          return base64.encode(signedCheckpoint.toPSBT());
-        })
-      );
-    }
-    await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
-    try {
-      await this.setPendingTxFlag(false);
-    } catch (error) {
-      console.error("Failed to clear pending tx flag:", error);
-    }
-    return { arkTxid, signedCheckpointTxs };
+    });
   }
   // mark virtual outputs as spent, save change outputs if any.
   // `offchainTapscript` and `serverPubKey` are the epoch snapshot the
@@ -17316,7 +17828,7 @@ function verifyP2WPKH(message, witnessItems, pkScript, addressHash) {
     return false;
   }
   const derived = p2wpkh(pubkey);
-  if (!equalBytes(derived.hash, addressHash)) {
+  if (!equalBytes$1(derived.hash, addressHash)) {
     return false;
   }
   const sighashType = sigWithHash[sigWithHash.length - 1];
@@ -17346,7 +17858,7 @@ function verifyLegacy(message, sigBytes, addressHash) {
     const sig = secp256k1.Signature.fromBytes(compactSig, "compact").addRecoveryBit(recoveryId);
     const point = sig.recoverPublicKey(msgHash);
     const pubkeyBytes = point.toBytes(compressed);
-    return equalBytes(hash160(pubkeyBytes), addressHash);
+    return equalBytes$1(hash160(pubkeyBytes), addressHash);
   } catch {
     return false;
   }
@@ -17409,6 +17921,132 @@ 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 fetch(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 */) {
@@ -18441,6 +19079,656 @@ var UnilateralExit = {
   prepare,
   Executor
 };
+
+// src/arkade/index.ts
+var arkade_exports = {};
+__export(arkade_exports, {
+  ARKADE_OP: () => ARKADE_OP,
+  ARKADE_OPCODES: () => ARKADE_OPCODES,
+  ARKADE_OPCODE_NAMES: () => ARKADE_OPCODE_NAMES,
+  ARKADE_OPCODE_VALUES: () => ARKADE_OPCODE_VALUES,
+  ARKADE_OPS: () => ARKADE_OPS,
+  Arkade: () => Arkade,
+  ArkadeContract: () => ArkadeContract,
+  ArkadeProgramScript: () => ArkadeProgramScript,
+  ArkadeScript: () => ArkadeScript,
+  ArkadeTransactionBuilder: () => ArkadeTransactionBuilder,
+  BigNum: () => bignum_exports,
+  OP: () => OP,
+  OPCODE_NAMES: () => OPCODE_NAMES,
+  OPCODE_VALUES: () => OPCODE_VALUES,
+  SUPPORTED_PROGRAM_VERSION: () => SUPPORTED_PROGRAM_VERSION,
+  Script: () => Script,
+  arkadeScriptHash: () => arkadeScriptHash,
+  arkadeWitnessHash: () => arkadeWitnessHash,
+  asmToBytes: () => asmToBytes,
+  bytesToASM: () => bytesToASM,
+  computeArkadeScriptPublicKey: () => computeArkadeScriptPublicKey,
+  createArkadeBatchHandler: () => createArkadeBatchHandler,
+  deserializeArkadeContractParams: () => deserializeArkadeContractParams,
+  fromASM: () => fromASM,
+  getOpcodeName: () => getOpcodeName,
+  getOpcodeValue: () => getOpcodeValue,
+  parseArtifact: () => parseArtifact,
+  resolveAsm: () => resolveAsm,
+  serializeArkadeContractParams: () => serializeArkadeContractParams,
+  stringifyArtifact: () => stringifyArtifact,
+  toASM: () => toASM,
+  validateProgram: () => validateProgram,
+  witnessRefToBytes: () => witnessRefToBytes
+});
+var isVtxoCoin = (input) => "virtualStatus" in input;
+function createArkadeBatchHandler(intentId, inputs, signer, signedProof, message, session, arkProvider, emulator, network, recipients) {
+  let batchId;
+  let sweepTapTreeRoot;
+  return {
+    onBatchStarted: async (event) => {
+      const utf8IntentId = new TextEncoder().encode(intentId);
+      const intentIdHash = sha256(utf8IntentId);
+      const intentIdHashStr = hex.encode(intentIdHash);
+      if (!event.intentIdHashes.includes(intentIdHashStr)) return { skip: true };
+      await arkProvider.confirmRegistration(intentId);
+      batchId = event.id;
+      const sweepTapscript = CSVMultisigTapscript.encode({
+        timelock: {
+          value: event.batchExpiry,
+          // BIP-65: values >= 512 are interpreted as seconds, below as blocks
+          type: event.batchExpiry >= 512n ? "seconds" : "blocks"
+        },
+        pubkeys: [hex.decode((await arkProvider.getInfo()).forfeitPubkey).subarray(1)]
+      }).script;
+      sweepTapTreeRoot = tapLeafHash(sweepTapscript);
+      return { skip: false };
+    },
+    onTreeSigningStarted: async (event, vtxoTree) => {
+      const signerPubKey = await session.getPublicKey();
+      const xonlySignerPubKey = signerPubKey.subarray(1);
+      const xOnlyPubkeys = event.cosignersPublicKeys.map((k) => k.slice(2));
+      if (!xOnlyPubkeys.includes(hex.encode(xonlySignerPubKey))) {
+        return { skip: true };
+      }
+      const commitmentTx = Transaction.fromPSBT(base64.decode(event.unsignedCommitmentTx));
+      validateVtxoTxGraph(vtxoTree, commitmentTx, sweepTapTreeRoot);
+      if (recipients && recipients.length > 0) {
+        validateBatchRecipients(commitmentTx, vtxoTree.leaves(), recipients, network);
+      }
+      const sharedOutput = commitmentTx.getOutput(0);
+      if (!sharedOutput?.amount) {
+        throw new Error("Shared output not found");
+      }
+      await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
+      const pubkey = hex.encode(await session.getPublicKey());
+      const nonces = await session.getNonces();
+      await arkProvider.submitTreeNonces(batchId, pubkey, nonces);
+      return { skip: false };
+    },
+    onTreeNonces: async (event) => {
+      const { hasAllNonces } = await session.aggregatedNonces(event.txid, event.nonces);
+      if (!hasAllNonces) return { fullySigned: false };
+      const signatures = await session.sign();
+      const pubkey = hex.encode(await session.getPublicKey());
+      await arkProvider.submitTreeSignatures(batchId, pubkey, signatures);
+      return { fullySigned: true };
+    },
+    onBatchFinalization: async (event, _vtxoTree, connectorTree) => {
+      const info = await arkProvider.getInfo();
+      const forfeitOutputScript = OutScript.encode(
+        Address(network).decode(info.forfeitAddress)
+      );
+      if (connectorTree) {
+        validateConnectorsTxGraph(event.commitmentTx, connectorTree);
+      }
+      let commitmentPsbt = Transaction.fromPSBT(base64.decode(event.commitmentTx));
+      const signedForfeits = [];
+      let connectorIndex = 0;
+      const connectorLeaves = connectorTree?.leaves() || [];
+      const boardingIndices = [];
+      for (const input of inputs) {
+        if (!isVtxoCoin(input)) {
+          let boardingIdx = null;
+          for (let i = 0; i < commitmentPsbt.inputsLength; i++) {
+            const psbtInput = commitmentPsbt.getInput(i);
+            if (!psbtInput.txid) continue;
+            if (hex.encode(psbtInput.txid) === input.txid && psbtInput.index === input.vout) {
+              boardingIdx = i;
+              break;
+            }
+          }
+          if (boardingIdx === null) continue;
+          commitmentPsbt.updateInput(boardingIdx, {
+            tapLeafScript: [input.forfeitTapLeafScript]
+          });
+          boardingIndices.push(boardingIdx);
+          continue;
+        }
+        if (isRecoverable(input) || isSubdust(input, info.dust)) {
+          continue;
+        }
+        if (connectorIndex >= connectorLeaves.length) {
+          throw new Error("not enough connectors received");
+        }
+        const connectorLeaf = connectorLeaves[connectorIndex++];
+        const connectorTxId = connectorLeaf.id;
+        const connectorOutput = connectorLeaf.getOutput(0);
+        if (!connectorOutput?.amount || !connectorOutput?.script) {
+          throw new Error(
+            `Invalid connector output at index ${connectorIndex - 1}: missing amount or script`
+          );
+        }
+        let forfeitTx = buildForfeitTx(
+          [
+            {
+              txid: input.txid,
+              index: input.vout,
+              witnessUtxo: {
+                amount: BigInt(input.value),
+                script: VtxoScript.decode(input.tapTree).pkScript
+              },
+              sighashType: SigHash.DEFAULT,
+              tapLeafScript: [input.forfeitTapLeafScript]
+            },
+            {
+              txid: connectorTxId,
+              index: 0,
+              witnessUtxo: {
+                amount: connectorOutput.amount,
+                script: connectorOutput.script
+              }
+            }
+          ],
+          forfeitOutputScript
+        );
+        forfeitTx = await signer.sign(forfeitTx, [0]);
+        signedForfeits.push(base64.encode(forfeitTx.toPSBT()));
+      }
+      if (boardingIndices.length > 0) {
+        commitmentPsbt = await signer.sign(commitmentPsbt, boardingIndices);
+      }
+      let connectorTreeNodes = null;
+      if (connectorTree) {
+        connectorTreeNodes = [];
+        for (const subtree of connectorTree.iterator()) {
+          const children = {};
+          for (const [outputIndex, child] of subtree.children) {
+            children[String(outputIndex)] = child.txid;
+          }
+          connectorTreeNodes.push({
+            txid: subtree.txid,
+            tx: base64.encode(subtree.root.toPSBT()),
+            children
+          });
+        }
+      }
+      const hasBoardingInputs = boardingIndices.length > 0;
+      const commitmentB64 = hasBoardingInputs ? base64.encode(commitmentPsbt.toPSBT()) : event.commitmentTx;
+      const emuResult = await emulator.submitFinalization(
+        { proof: signedProof, message },
+        signedForfeits,
+        connectorTreeNodes,
+        commitmentB64
+      );
+      await arkProvider.submitSignedForfeitTxs(
+        emuResult.signedForfeits,
+        emuResult.signedCommitmentTx || (hasBoardingInputs ? commitmentB64 : void 0)
+      );
+    }
+  };
+}
+var Arkade = class _Arkade {
+  arkProvider;
+  /** The co-signing service, or undefined for emulator-less (pure tapscript) usage. */
+  emulator;
+  network;
+  serverKey;
+  /** The co-signer's x-only key, present only when an emulator is configured. */
+  emulatorKey;
+  checkpoint;
+  indexer;
+  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. */
+  contractManager;
+  constructor(fields) {
+    this.arkProvider = fields.arkProvider;
+    this.emulator = fields.emulator;
+    this.network = fields.network;
+    this.serverKey = fields.serverKey;
+    this.emulatorKey = fields.emulatorKey;
+    this.checkpoint = fields.checkpoint;
+    this.indexer = fields.indexer;
+    this.identity = fields.identity;
+    this.userKey = fields.userKey;
+    this.contractManager = fields.contractManager;
+  }
+  /** Connect and resolve the server key, checkpoint closure and (if present) the co-signer key. */
+  static async connect(opts) {
+    const info = await opts.arkade.getInfo();
+    const serverKey = hex.decode(info.signerPubkey).slice(1);
+    const checkpoint = CSVMultisigTapscript.decode(hex.decode(info.checkpointTapscript));
+    let emulatorKey;
+    if (opts.emulator) {
+      const eInfo = await opts.emulator.getInfo();
+      emulatorKey = hex.decode(eInfo.signerPubkey);
+    }
+    let userKey;
+    if (opts.identity) {
+      const pub = await opts.identity.xOnlyPublicKey();
+      userKey = pub.length === 33 ? pub.slice(1) : pub;
+    }
+    return new _Arkade({
+      arkProvider: opts.arkade,
+      emulator: opts.emulator,
+      network: opts.network ?? DEFAULT_NETWORK,
+      serverKey,
+      emulatorKey,
+      checkpoint,
+      indexer: opts.indexer,
+      identity: opts.identity,
+      userKey,
+      contractManager: opts.contractManager
+    });
+  }
+  /**
+   * Instantiate a contract from a program and its constructor arguments. The
+   * `program`'s literal type is preserved (`const` inference) so the resulting
+   * contract's `functions` map is strongly typed — `functions.<name>(...)`
+   * knows each argument's type from the function's `inputs` descriptors.
+   *
+   * When the program declares a `server` or `user` param and the caller does
+   * not bind it, it defaults to the client's server key or the identity's
+   * key respectively; explicit args always win.
+   */
+  contract(program, args = {}) {
+    const declared = (program.params ?? []).map(inputName);
+    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 };
+    }
+    return new ArkadeContract(this, program, args);
+  }
+};
+var ArkadeContract = class _ArkadeContract {
+  constructor(client, program, args = {}, keys) {
+    this.client = client;
+    this.program = program;
+    this.args = args;
+    this.keys = keys ?? {
+      serverKey: client.serverKey,
+      userKey: client.userKey,
+      emulatorKey: client.emulatorKey
+    };
+    this.vtxoScript = new ArkadeProgramScript(program, args, this.keys);
+    this.tapTree = this.vtxoScript.encode();
+    this.compiled = this.vtxoScript.compiled;
+  }
+  client;
+  program;
+  args;
+  /** The compiled taproot tree of spending-path leaves. */
+  vtxoScript;
+  /** Encoded taproot tree (shared spend context for every path). */
+  tapTree;
+  /** The signer keys the program was compiled against. */
+  keys;
+  /** Spending paths in declaration order. */
+  compiled;
+  /**
+   * Rebuild a callable contract from a persisted `"arkade"` contract row
+   * (see {@link ArkadeContract.register}). The stored keys are used for
+   * compilation — not the client's current ones — so the derived script and
+   * address stay identical to the registered contract even after a server
+   * signer rotation.
+   */
+  static fromContract(client, contract) {
+    if (contract.type !== "arkade") {
+      throw new Error(
+        `ArkadeContract.fromContract: expected contract type 'arkade', got '${contract.type}'`
+      );
+    }
+    const typed = deserializeArkadeContractParams(contract.params);
+    return new _ArkadeContract(client, typed.program, typed.args, {
+      serverKey: typed.serverKey,
+      userKey: typed.userKey,
+      emulatorKey: typed.emulatorKey
+    });
+  }
+  /** Resolve the {@link TapLeafScript} for a spending path by its index. */
+  leafScript(index) {
+    const fn = this.compiled[index];
+    if (!fn) throw new Error(`leaf index ${index} out of range`);
+    return fn.tapLeafScript;
+  }
+  /** Arkade funding address. */
+  get address() {
+    return this.vtxoScript.address(this.client.network.hrp, this.keys.serverKey).encode();
+  }
+  /** Taproot output script. */
+  get pkScript() {
+    return this.vtxoScript.pkScript;
+  }
+  /**
+   * Callable spending paths: `contract.functions.<name>(...args)`. Strongly
+   * typed from the program's literal type — each function's argument types are
+   * derived from its `inputs` descriptors (see {@link ContractFunctions}).
+   */
+  get functions() {
+    const out = {};
+    for (const fn of this.compiled) {
+      out[fn.name] = (...callArgs) => new ArkadeTransactionBuilder(this, fn, bindInputs(fn, callArgs));
+    }
+    return out;
+  }
+  /**
+   * The `createContract` payload for this contract — the serialized program,
+   * args and keys plus the derived script/address. Useful when registering
+   * through a manager the client does not hold.
+   */
+  toContractParams() {
+    return {
+      type: "arkade",
+      params: serializeArkadeContractParams({
+        program: this.program,
+        args: this.args,
+        serverKey: this.keys.serverKey,
+        userKey: this.keys.userKey,
+        emulatorKey: this.keys.emulatorKey
+      }),
+      script: hex.encode(this.pkScript),
+      address: this.address
+    };
+  }
+  /**
+   * Persist this contract through the wallet's {@link IContractManager} so it
+   * is tracked like any other contract type: stored in the contract
+   * repository, watched for VTXO events, counted in repository-backed
+   * balances, and re-derivable offline via the `"arkade"` contract handler.
+   * Idempotent — re-registering the same script is a no-op.
+   */
+  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"
+      );
+    }
+    return manager.createContract({
+      ...this.toContractParams(),
+      label: options?.label,
+      metadata: options?.metadata
+    });
+  }
+  /**
+   * Spendable VTXOs locked by this contract.
+   *
+   * 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.
+   */
+  async getUtxos() {
+    const manager = this.client.contractManager;
+    const scriptHex = hex.encode(this.pkScript);
+    if (manager) {
+      const [registered] = await manager.getContracts({ script: scriptHex });
+      if (registered) {
+        const [withVtxos] = await manager.getContractsWithVtxos({ script: scriptHex });
+        return (withVtxos?.vtxos ?? []).filter(isSpendable);
+      }
+    }
+    if (!this.client.indexer) {
+      throw new Error("ArkadeContract.getUtxos: an indexer is required");
+    }
+    const { vtxos } = await this.client.indexer.getVtxos({
+      scripts: [scriptHex],
+      spendableOnly: true
+    });
+    return vtxos;
+  }
+  /** Total spendable balance (requires an indexer). */
+  async getBalance() {
+    const utxos = await this.getUtxos();
+    return utxos.reduce((sum, u) => sum + BigInt(u.value), 0n);
+  }
+};
+var ArkadeTransactionBuilder = class {
+  /** @internal */
+  constructor(contract, fn, args) {
+    this.contract = contract;
+    this.fn = fn;
+    this.args = args;
+  }
+  contract;
+  fn;
+  args;
+  outputs = [];
+  fundingCoins = [];
+  assetSpecs = [];
+  coin;
+  changeScript;
+  from(coin) {
+    this.coin = coin;
+    return this;
+  }
+  /**
+   * Add extra inputs the caller funds (e.g. a taker's own coins in a swap).
+   * These become inputs 1..n and are signed with the client identity.
+   */
+  fund(coins) {
+    this.fundingCoins.push(...coins);
+    return this;
+  }
+  /** Transfer an asset group: which inputs supply it and which outputs receive it. */
+  withAsset(spec) {
+    this.assetSpecs.push(spec);
+    return this;
+  }
+  /** Destination for any surplus (inputs − outputs). Required when the spend is not exact. */
+  change(script) {
+    this.changeScript = script;
+    return this;
+  }
+  to(scriptOrOutputs, amount) {
+    if (Array.isArray(scriptOrOutputs)) {
+      for (const [i, out] of scriptOrOutputs.entries()) {
+        if (out.amount === void 0) {
+          throw new Error(`to(outputs): output ${i} is missing an amount`);
+        }
+      }
+      this.outputs.push(...scriptOrOutputs);
+    } else {
+      if (amount === void 0) throw new Error("to(script, amount): amount is required");
+      this.outputs.push({ script: scriptOrOutputs, amount });
+    }
+    return this;
+  }
+  /** Assemble the unsigned ark transaction and its checkpoints. */
+  async build() {
+    if (this.outputs.length === 0) {
+      throw new Error("ArkadeTransactionBuilder: at least one output is required");
+    }
+    const outputsSum = this.outputs.reduce((s, o) => s + (o.amount ?? 0n), 0n);
+    const coin = this.coin ?? await this.selectCoin(outputsSum);
+    const def = this.fn.def;
+    const outputs = [...this.outputs];
+    const fundingSum = this.fundingCoins.reduce((s, f) => s + BigInt(f.value), 0n);
+    const surplus = BigInt(coin.value) + fundingSum - outputsSum;
+    if (surplus < 0n) {
+      throw new Error(
+        `ArkadeTransactionBuilder: insufficient inputs \u2014 outputs ${outputsSum} exceed inputs ${BigInt(coin.value) + fundingSum}`
+      );
+    }
+    if (surplus > 0n) {
+      if (!this.changeScript) {
+        throw new Error(
+          `ArkadeTransactionBuilder: ${surplus} sats surplus with no change output \u2014 call .change(script)`
+        );
+      }
+      outputs.push({ script: this.changeScript, amount: surplus });
+    }
+    const { arkTx, checkpoints } = buildOffchainTx(
+      [
+        {
+          txid: coin.txid,
+          vout: coin.vout,
+          value: coin.value,
+          tapLeafScript: this.fn.tapLeafScript,
+          tapTree: this.contract.tapTree
+        },
+        ...this.fundingCoins
+      ],
+      outputs,
+      this.contract.client.checkpoint
+    );
+    if (coin.sourceTx) {
+      setArkPsbtField(arkTx, 0, PrevArkTxField, coin.sourceTx);
+    }
+    const condition = (def.tapscript.witness ?? []).map((w) => this.witnessBytes(w));
+    if (condition.length > 0) {
+      setArkPsbtField(arkTx, 0, ConditionWitness, condition);
+      setArkPsbtField(checkpoints[0], 0, ConditionWitness, condition);
+    }
+    const packets = [];
+    if (this.assetSpecs.length > 0) {
+      packets.push(this.buildAssetPacket());
+    }
+    const arkadeScript = this.fn.arkadeScript;
+    if (arkadeScript) {
+      const stack = (def.arkadeScript?.witness ?? []).map((w) => this.witnessBytes(w));
+      packets.push(
+        EmulatorPacket.create([
+          { vin: 0, script: arkadeScript, witness: RawWitness.encode(stack) }
+        ])
+      );
+    }
+    if (packets.length > 0) {
+      attachExtension(arkTx, packets);
+    }
+    return { arkTx, checkpoints };
+  }
+  /** Build, submit and return the finalized transaction. */
+  async send() {
+    const { arkTx, checkpoints } = await this.build();
+    const client = this.contract.client;
+    const userInputs = this.userInputIndexes();
+    if (this.fn.arkadeScript) {
+      if (!client.emulator) {
+        throw new Error("covenant spends require an `emulator` on the Arkade client");
+      }
+      const signedArk2 = await this.signArk(arkTx, userInputs);
+      const signedCps = userInputs.length > 0 ? await Promise.all(
+        checkpoints.map(
+          (c, i) => userInputs.includes(i) ? client.identity.sign(c, [0]) : c
+        )
+      ) : checkpoints;
+      const res2 = await client.emulator.submitTx(
+        base64.encode(signedArk2.toPSBT()),
+        signedCps.map((c) => base64.encode(c.toPSBT()))
+      );
+      const txid = Transaction.fromPSBT(base64.decode(res2.signedArkTx)).id;
+      return {
+        txid,
+        signedArkTx: res2.signedArkTx,
+        signedCheckpointTxs: res2.signedCheckpointTxs
+      };
+    }
+    if (!client.identity) {
+      throw new Error("a signing identity is required for non-covenant spends");
+    }
+    const signedArk = await this.signArk(arkTx, userInputs);
+    const res = await client.arkProvider.submitTx(
+      base64.encode(signedArk.toPSBT()),
+      checkpoints.map((c) => base64.encode(c.toPSBT()))
+    );
+    const finalCps = await Promise.all(
+      res.signedCheckpointTxs.map(
+        async (b) => base64.encode(
+          (await client.identity.sign(Transaction.fromPSBT(base64.decode(b)), [0])).toPSBT()
+        )
+      )
+    );
+    await client.arkProvider.finalizeTx(res.arkTxid, finalCps);
+    return {
+      txid: res.arkTxid,
+      signedArkTx: res.finalArkTx,
+      signedCheckpointTxs: res.signedCheckpointTxs
+    };
+  }
+  /** Sign the client-owned inputs of the ark tx (no-op when there are none). */
+  async signArk(arkTx, userInputs) {
+    if (userInputs.length === 0) return arkTx;
+    const { identity } = this.contract.client;
+    if (!identity) {
+      throw new Error("this spend requires an `identity` to sign its user/funding inputs");
+    }
+    return identity.sign(arkTx, userInputs);
+  }
+  /** Indexes of inputs the client owns and must sign (contract input + funded inputs). */
+  userInputIndexes() {
+    const idxs = [];
+    const userKey = this.contract.keys.userKey;
+    if (userKey && this.fn.signerKeys.some((k) => equalBytes(k, userKey))) {
+      idxs.push(0);
+    }
+    for (let i = 0; i < this.fundingCoins.length; i++) {
+      idxs.push(i + 1);
+    }
+    return idxs;
+  }
+  async selectCoin(amount) {
+    const utxos = await this.contract.getUtxos();
+    if (utxos.length === 0) throw new Error("no spendable coins for this contract");
+    const covering = utxos.filter((u) => BigInt(u.value) >= amount).sort((a, b) => a.value - b.value);
+    if (covering.length > 0) return covering[0];
+    return [...utxos].sort((a, b) => b.value - a.value)[0];
+  }
+  buildAssetPacket() {
+    const groups = this.assetSpecs.map((s) => {
+      const id = typeof s.assetId === "string" ? AssetId.fromString(s.assetId) : AssetId.fromBytes(s.assetId);
+      return AssetGroup.create(
+        id,
+        null,
+        s.inputs.map((i) => AssetInput.create(i.vin, i.amount)),
+        s.outputs.map((o) => AssetOutput.create(o.vout, o.amount)),
+        (s.metadata ?? []).map((m) => Metadata.create(m.key, m.value))
+      );
+    });
+    return Packet.create(groups);
+  }
+  witnessBytes(ref) {
+    return witnessRefToBytes(ref, this.args, this.contract.args);
+  }
+};
+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 bound = {};
+  names.forEach((n, i) => bound[n] = callArgs[i]);
+  return bound;
+}
+function attachExtension(tx, newPackets) {
+  for (let i = 0; i < tx.outputsLength; i++) {
+    const out = tx.getOutput(i);
+    if (!out?.script || !Extension.isExtension(out.script)) continue;
+    const existing = Extension.fromBytes(out.script);
+    const merged = Extension.create([...existing.getPackets(), ...newPackets]);
+    tx.updateOutput(i, { script: merged.serialize(), amount: 0n });
+    return;
+  }
+  const ext = Extension.create(newPackets);
+  const newOut = ext.txOut();
+  const lastIdx = tx.outputsLength - 1;
+  const lastOut = tx.getOutput(lastIdx);
+  if (lastOut?.script && lastOut.script.length === ANCHOR_PKSCRIPT.length && lastOut.script.every((b, j) => b === ANCHOR_PKSCRIPT[j])) {
+    tx.updateOutput(lastIdx, { script: newOut.script, amount: newOut.amount });
+    tx.addOutput({ script: lastOut.script, amount: lastOut.amount ?? 0n });
+    return;
+  }
+  tx.addOutput({ script: newOut.script, amount: newOut.amount });
+}
 var ARKCONTRACT_PREFIX = "arkcontract";
 function encodeArkContract(contract) {
   const params = new URLSearchParams();
@@ -18500,6 +19788,6 @@ function isArkContract(str) {
   return str.startsWith(ARKCONTRACT_PREFIX + "=");
 }
 
-export { ActivityRegistry, ArkNote, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EsploraProvider, Estimator, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isRetryableProviderError, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
-//# sourceMappingURL=chunk-P6VBP3CT.js.map
-//# sourceMappingURL=chunk-P6VBP3CT.js.map
+export { ARKADE_MAGIC, ActivityRegistry, ArkCash, ArkCashCreateError, ArkNote, AssetManager, BIP322, Batch, ChainedTxType, ContractManager, ContractRepositoryImpl, ContractWatcher, DB_VERSION, DEFAULT_MESSAGE_TIMEOUTS, DelegateManagerImpl, DelegateNotConfiguredError, DelegatorManagerImpl, DelegatorNotConfiguredError, DescriptorSigningProviderMissingError, DustChangeError, ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ESPLORA_URL, ElectrumOnchainProvider, EmulatorPacket, EsploraProvider, Estimator, Extension, ExtensionNotFoundError, HDDescriptorProvider, INTENT_TERMINAL_STATES, InMemoryContractRepository, InMemoryIntentRepository, InMemoryVirtualTxRepository, InMemoryWalletRepository, IndexedDBContractRepository, IndexedDBIntentRepository, IndexedDBVirtualTxRepository, IndexedDBWalletRepository, MESSAGE_BUS_INITIALIZING, MESSAGE_BUS_NOT_INITIALIZED, MIGRATION_KEY, MessageBus, MessageBusInitializingError, MessageBusNotInitializedError, MissingSigningDescriptorError, MnemonicIdentity, OnchainWallet, P2A, Ramps, ReadonlyAssetManager, ReadonlyDescriptorIdentity, ReadonlySingleKey, ReadonlyWallet, ReadonlyWalletError, RestDelegateProvider, RestDelegatorProvider, RestEmulatorProvider, SeedIdentity, ServiceWorkerReadonlyWallet, ServiceWorkerTimeoutError, ServiceWorkerWallet, SingleKey, TxTree, TxType, TxWeightEstimator, UnilateralExit, UnknownPacket, Unroll, VtxoManager, Wallet2 as Wallet, WalletMessageHandler, WalletNotInitializedError, WalletRepositoryImpl, WsElectrumChainSource, arkade_exports, assertIntentIdUnique, boardingResolver, buildForfeitTx, buildOffchainTx, classifyAgainstSignerSet, classifyContractSigner, closeDatabase, combineTapscriptSigs, contractFromArkContract, contractFromArkContractWithAddress, createAssetPacket, createDefaultActivityRegistry, createExitChainResolver, decodeArkContract, deserializeAssets, deserializeExitPackage, deserializeUtxo, deserializeVtxo, encodeArkContract, extendVirtualCoinForContract, getMigrationStatus, getRandomId, hasBoardingTxExpired, intentMatchesFilter, intentPageBounds, isArkContract, isBatchSignable, isCooperativelyMigratable, isDiscoverable, isExpired, isRecoverable, isRetryableProviderError, isSpendable, isSubdust, isTerminalIntentState, isValidArkAddress, isVtxoExpiringSoon, isVtxoForScript, mergeChainedTxType, migrateWalletRepository, openDatabase, requiresMigration, rollbackMigration, saveVtxosForContract, scriptFromArkAddress, selectCoinsWithAsset, selectVirtualCoins, serializeAssets, serializeExitPackage, serializeUtxo, serializeVtxo, setupServiceWorker, signerSetFromInfo, toXOnlySignerHex, validateConnectorsTxGraph, validateVtxoTxGraph, verifyTapscriptSignatures, waitForIncomingFunds, warnAndFilterVtxosForScript };
+//# sourceMappingURL=chunk-SV4PCGKM.js.map
+//# sourceMappingURL=chunk-SV4PCGKM.js.map