@arkade-os/sdk 0.4.46 → 0.4.47

package/dist/{chunk-P6VBP3CT.js → chunk-OCS5S3L3.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 { 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-CDDWXBEM.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, DEFAULT_PAGE_SIZE, DelegateVtxo, WALLET_RECEIVE_SOURCE, deriveDescriptorLeafPubKey, DefaultVtxo, 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 } 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,46 @@ 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 };
+}
 var AmountVariableName = "amount";
 var ExpiryVariableName = "expiry";
 var BirthVariableName = "birth";
@@ -2458,6 +2592,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 +2619,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([
@@ -5989,7 +6135,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 +7987,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 +9636,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);
@@ -11342,7 +11483,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 +11498,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
@@ -12704,9 +12845,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 +13001,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 +17452,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 +17482,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 +17545,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 +18703,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 +19412,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, 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-OCS5S3L3.js.map
+//# sourceMappingURL=chunk-OCS5S3L3.js.map