@arkade-os/sdk 0.4.67 → 0.4.69

package/README.md

@@ -346,6 +346,39 @@ if (incomingFunds.type === "vtxo") {
 }
 ```
 
+#### Cancelling a wait
+
+`waitForIncomingFunds` is **a live subscription, not a one-shot query**. It opens an onchain address watcher plus an indexer stream and holds them until it settles. Cancel it whenever you might not await it to completion — pass a `timeoutMs`, or an `AbortSignal`:
+
+```typescript
+const controller = new AbortController()
+
+try {
+  const funds = await waitForIncomingFunds(wallet, { signal: controller.signal })
+} catch (error) {
+  if ((error as Error).name !== "AbortError") throw error
+  // cancelled — watchers already released
+}
+
+// or bound the wait directly
+await waitForIncomingFunds(wallet, { timeoutMs: 30_000 })
+```
+
+Do **not** `Promise.race` an uncancelled call against a timer:
+
+```typescript
+// WRONG: race abandons the loser without stopping it. Repeat this on a
+// polling loop and the subscriptions stack until the process exits.
+await Promise.race([sleep(15_000), waitForIncomingFunds(wallet)])
+
+// Right: the signal tears the watcher down when the timer wins.
+await waitForIncomingFunds(wallet, { timeoutMs: 15_000 }).catch(() => null)
+```
+
+If you want a plain polling loop, use your own timer plus `wallet.getBalance()` — it observes new funds on the next cycle. If you want to keep a watcher across many iterations, call `wallet.notifyIncomingFunds(cb)` **once** and hold its `stop()` function, rather than resubscribing per tick.
+
+Concurrent watchers over the same address set share a single Esplora subscription, so a duplicated or leaked watcher no longer multiplies explorer traffic. That is a safety net, not a licence to skip `stop()`.
+
 ### Onboarding
 
 Onboarding allows you to swap onchain funds into virtual outputs:
@@ -574,6 +607,11 @@ const expiringVtxos = await manager.getExpiringVtxos()
 const urgentlyExpiring = await manager.getExpiringVtxos(60_000)
 ```
 
+A virtual output whose unilateral exit already happened is never offered for renewal, and the
+exported `isVtxoExpiringSoon` answers `false` for it regardless of its batch expiry: "expiring
+soon" is a renewal signal, and no batch can take an output that already lives onchain. Its remedy
+is `Unroll.completeUnroll`, and its value shows up in `balance.unrolled`.
+
 #### Boarding Input Sweep
 
 When a boarding input's CSV timelock expires, it can no longer be onboarded into Arkade cooperatively. The sweep feature detects these expired UTXOs and builds a raw onchain transaction that spends them via the unilateral exit path back to a fresh boarding address, restarting the timelock.

package/dist/adapters/expo.cjs

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkR2YAMONM_cjs = require('../chunk-R2YAMONM.cjs');
-require('../chunk-CO3KKSWM.cjs');
-require('../chunk-2JV4VQ7C.cjs');
+var chunkXQPN5YP2_cjs = require('../chunk-XQPN5YP2.cjs');
+require('../chunk-GVHUHTRH.cjs');
+require('../chunk-5MLC2HU3.cjs');
 require('../chunk-5BLDMQED.cjs');
 
 
 
 Object.defineProperty(exports, "ExpoArkProvider", {
   enumerable: true,
-  get: function () { return chunkR2YAMONM_cjs.ExpoArkProvider; }
+  get: function () { return chunkXQPN5YP2_cjs.ExpoArkProvider; }
 });
 Object.defineProperty(exports, "ExpoIndexerProvider", {
   enumerable: true,
-  get: function () { return chunkR2YAMONM_cjs.ExpoIndexerProvider; }
+  get: function () { return chunkXQPN5YP2_cjs.ExpoIndexerProvider; }
 });
 //# sourceMappingURL=expo.cjs.map
 //# sourceMappingURL=expo.cjs.map

package/dist/adapters/expo.d.cts

@@ -1,5 +1,5 @@
-import { n as RestArkProvider, k as SettlementEvent, T as TxNotificationEvent, o as RestIndexerProvider, p as SubscriptionResponse } from '../index-DU5o_hz7.cjs';
-export { q as ArkProvider, r as IndexerProvider } from '../index-DU5o_hz7.cjs';
+import { n as RestArkProvider, k as SettlementEvent, T as TxNotificationEvent, o as RestIndexerProvider, p as SubscriptionResponse } from '../index-dWRqYSdS.cjs';
+export { q as ArkProvider, r as IndexerProvider } from '../index-dWRqYSdS.cjs';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';

package/dist/adapters/expo.d.ts

@@ -1,5 +1,5 @@
-import { n as RestArkProvider, k as SettlementEvent, T as TxNotificationEvent, o as RestIndexerProvider, p as SubscriptionResponse } from '../index-DU5o_hz7.js';
-export { q as ArkProvider, r as IndexerProvider } from '../index-DU5o_hz7.js';
+import { n as RestArkProvider, k as SettlementEvent, T as TxNotificationEvent, o as RestIndexerProvider, p as SubscriptionResponse } from '../index-dWRqYSdS.js';
+export { q as ArkProvider, r as IndexerProvider } from '../index-dWRqYSdS.js';
 import '@scure/btc-signer/utils.js';
 import '@scure/btc-signer/transaction.js';
 import '@scure/btc-signer';

package/dist/adapters/expo.js

@@ -1,6 +1,6 @@
-export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-MZFUZUTQ.js';
-import '../chunk-X3VEMUVV.js';
-import '../chunk-3WIWNE4P.js';
+export { ExpoArkProvider, ExpoIndexerProvider } from '../chunk-MNMPGEK2.js';
+import '../chunk-YG7T6LI3.js';
+import '../chunk-L5SCQYHF.js';
 import '../chunk-NSBPE2FW.js';
 //# sourceMappingURL=expo.js.map
 //# sourceMappingURL=expo.js.map

package/dist/adapters/indexedDB.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkMJUTO3PY_cjs = require('../chunk-MJUTO3PY.cjs');
-require('../chunk-CO3KKSWM.cjs');
-require('../chunk-OIZ2V2VD.cjs');
-require('../chunk-2JV4VQ7C.cjs');
+var chunkEBYCTLET_cjs = require('../chunk-EBYCTLET.cjs');
+require('../chunk-GVHUHTRH.cjs');
+require('../chunk-WIFL5QYZ.cjs');
+require('../chunk-5MLC2HU3.cjs');
 require('../chunk-5BLDMQED.cjs');
 
 // src/storage/indexedDB.ts
@@ -11,7 +11,7 @@ var IndexedDBStorageAdapter = class {
   dbName;
   version;
   db = null;
-  constructor(dbName, version = chunkMJUTO3PY_cjs.DB_VERSION) {
+  constructor(dbName, version = chunkEBYCTLET_cjs.DB_VERSION) {
     this.dbName = dbName;
     this.version = version;
   }

package/dist/adapters/indexedDB.js

@@ -1,7 +1,7 @@
-import { DB_VERSION } from '../chunk-AEWJU6NZ.js';
-import '../chunk-X3VEMUVV.js';
-import '../chunk-6TAQF6EV.js';
-import '../chunk-3WIWNE4P.js';
+import { DB_VERSION } from '../chunk-TA7XLEP2.js';
+import '../chunk-YG7T6LI3.js';
+import '../chunk-2PPL3O7Z.js';
+import '../chunk-L5SCQYHF.js';
 import '../chunk-NSBPE2FW.js';
 
 // src/storage/indexedDB.ts

package/dist/{asyncStorageTaskQueue-Za-e_zMk.d.ts → asyncStorageTaskQueue-BgUJN-3X.d.ts}

@@ -1,4 +1,4 @@
-import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-DATaRQus.js';
+import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-D2fnbqYw.js';
 
 /**
  * Minimal async key-value storage interface.
@@ -46,4 +46,4 @@ declare class AsyncStorageTaskQueue implements TaskQueue {
     private writeList;
 }
 
-export { type AsyncStorageLike as A, AsyncStorageTaskQueue as a };
+export { AsyncStorageTaskQueue as A, type AsyncStorageLike as a };

package/dist/{asyncStorageTaskQueue-LTpeXYaD.d.cts → asyncStorageTaskQueue-Cstx6hS7.d.cts}

@@ -1,4 +1,4 @@
-import { c as TaskQueue, b as TaskItem, d as TaskResult } from './taskRunner-BZJMLQ6g.cjs';
+import { a as TaskQueue, c as TaskItem, d as TaskResult } from './taskRunner-CzYKyJ9c.cjs';
 
 /**
  * Minimal async key-value storage interface.
@@ -46,4 +46,4 @@ declare class AsyncStorageTaskQueue implements TaskQueue {
     private writeList;
 }
 
-export { type AsyncStorageLike as A, AsyncStorageTaskQueue as a };
+export { AsyncStorageTaskQueue as A, type AsyncStorageLike as a };

package/dist/{chunk-6TAQF6EV.js → chunk-2PPL3O7Z.js}

@@ -1,4 +1,4 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-3WIWNE4P.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-L5SCQYHF.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
@@ -1504,41 +1504,30 @@ var VHTLC;
       ];
       let arkadeScriptNic;
       let nonInteractiveClaimScript;
-      if (options.nonInteractiveClaim) {
-        arkadeScriptNic = enforcePayToMaybeAsset(
-          options.nonInteractiveClaim.receiverPkScript,
-          options.asset,
-          options.nonInteractiveClaim.strict
-        );
+      let arkadeScriptNir;
+      let nonInteractiveRefundScript;
+      let nonInteractiveRefundWithoutReceiverScript;
+      const covenants = options.nonInteractiveParameters;
+      if (covenants) {
+        arkadeScriptNic = enforcePayToMaybeAsset(covenants.receiverPkScript, options.asset);
         nonInteractiveClaimScript = ConditionMultisigTapscript.encode({
           conditionScript,
           pubkeys: [
             server,
-            computeArkadeScriptPublicKey(
-              options.nonInteractiveClaim.emulatorPubkey,
-              arkadeScriptNic
-            )
+            computeArkadeScriptPublicKey(covenants.emulatorPubkey, arkadeScriptNic)
           ]
         }).script;
         scripts.push(nonInteractiveClaimScript);
-      }
-      let arkadeScriptNir;
-      let nonInteractiveRefundScript;
-      let nonInteractiveRefundWithoutReceiverScript;
-      if (options.nonInteractiveRefund) {
-        arkadeScriptNir = enforcePayToMaybeAsset(
-          options.nonInteractiveRefund.senderPkScript,
-          options.asset
-        );
+        arkadeScriptNir = enforcePayToMaybeAsset(covenants.senderPkScript, options.asset);
         const nirCosigner = computeArkadeScriptPublicKey(
-          options.nonInteractiveRefund.emulatorPubkey,
+          covenants.emulatorPubkey,
           arkadeScriptNir
         );
         nonInteractiveRefundScript = MultisigTapscript.encode({
           pubkeys: [server, receiver, nirCosigner]
         }).script;
         scripts.push(nonInteractiveRefundScript);
-        if (options.nonInteractiveRefund.withoutReceiver) {
+        if (covenants.legacy !== "preTimelockedRefund") {
           nonInteractiveRefundWithoutReceiverScript = CLTVMultisigTapscript.encode({
             absoluteTimelock: refundLocktime,
             pubkeys: [server, nirCosigner]
@@ -1703,47 +1692,25 @@ var VHTLC;
     if (!preimageHash || preimageHash.length !== 20) {
       throw new Error("preimage hash must be 20 bytes");
     }
-    if (options.asset !== void 0 && !options.nonInteractiveClaim && !options.nonInteractiveRefund) {
-      throw new Error(
-        "asset has no effect without nonInteractiveClaim or nonInteractiveRefund"
-      );
+    if (options.asset !== void 0 && !options.nonInteractiveParameters) {
+      throw new Error("asset has no effect without nonInteractiveParameters");
     }
-    const strict = options.nonInteractiveClaim?.strict;
-    if (strict !== void 0) {
-      if (strict.amount <= 0n) {
-        throw new Error(`strict claim amount must be positive, got ${strict.amount}`);
-      }
-      if (options.asset !== void 0 && strict.assetAmount === void 0) {
-        throw new Error(
-          "strict claim needs assetAmount when the contract is denominated in an asset: bounding only the sats would leave the asset amount unenforced"
-        );
-      }
-      if (options.asset === void 0 && strict.assetAmount !== void 0) {
-        throw new Error("strict claim assetAmount has no effect without asset");
-      }
-      if (strict.assetAmount !== void 0 && strict.assetAmount <= 0n) {
-        throw new Error(
-          `strict claim assetAmount must be positive, got ${strict.assetAmount}`
-        );
-      }
-    }
-    if (options.nonInteractiveClaim) {
-      const { emulatorPubkey, receiverPkScript } = options.nonInteractiveClaim;
+    if (options.nonInteractiveParameters) {
+      const { emulatorPubkey, receiverPkScript, senderPkScript, legacy } = options.nonInteractiveParameters;
       if (!emulatorPubkey || emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33) {
         throw new Error("Invalid public key length (emulator)");
       }
       if (!receiverPkScript || !isP2trPkScript(receiverPkScript)) {
         throw new Error("Invalid P2TR script");
       }
-    }
-    if (options.nonInteractiveRefund) {
-      const { emulatorPubkey, senderPkScript } = options.nonInteractiveRefund;
-      if (!emulatorPubkey || emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33) {
-        throw new Error("Invalid public key length (emulator)");
-      }
       if (!senderPkScript || !isP2trPkScript(senderPkScript)) {
         throw new Error("Invalid P2TR script");
       }
+      if (legacy !== void 0 && legacy !== "preTimelockedRefund") {
+        throw new Error(
+          `nonInteractiveParameters.legacy must be "preTimelockedRefund" when set, got ${JSON.stringify(legacy)}`
+        );
+      }
     }
     if (!receiver || receiver.length !== 32) {
       throw new Error("Invalid public key length (receiver)");
@@ -1795,7 +1762,7 @@ function preimageConditionScriptV2(preimageHash) {
 function isP2trPkScript(pkScript) {
   return pkScript.length === 34 && pkScript[0] === 81 && pkScript[1] === 32;
 }
-function satClause(destinationPkScript, quotedSats) {
+function satClause(destinationPkScript) {
   return [
     "PUSHCURRENTINPUTINDEX",
     "DUP",
@@ -1805,21 +1772,18 @@ function satClause(destinationPkScript, quotedSats) {
     destinationPkScript.subarray(2),
     "EQUALVERIFY",
     "INSPECTOUTPUTVALUE",
-    // `DUP` because the output value is needed twice: once against the
-    // quote, once against the input.
-    ...quotedSats === void 0 ? [] : ["DUP", quotedSats, "GREATERTHANOREQUAL", "VERIFY"],
     "PUSHCURRENTINPUTINDEX",
     "INSPECTINPUTVALUE",
     "GREATERTHANOREQUAL"
   ];
 }
-function enforcePayTo(destinationPkScript, quotedSats) {
+function enforcePayTo(destinationPkScript) {
   if (!isP2trPkScript(destinationPkScript)) {
     throw new Error("invalid P2TR script");
   }
-  return ArkadeScript.encode(satClause(destinationPkScript, quotedSats));
+  return ArkadeScript.encode(satClause(destinationPkScript));
 }
-function enforcePayToAsset(destinationPkScript, asset, strict) {
+function enforcePayToAsset(destinationPkScript, asset) {
   if (!isP2trPkScript(destinationPkScript)) {
     throw new Error("invalid P2TR script");
   }
@@ -1843,10 +1807,6 @@ function enforcePayToAsset(destinationPkScript, asset, strict) {
     "INSPECTOUTASSETLOOKUP",
     "VERIFY",
     // PRESENT on the output, not merely "zero of it"
-    // The quoted bound, when the caller opted in — added to the input
-    // comparison below, not substituted for it. `DUP` because the output's
-    // asset amount is needed twice.
-    ...strict?.assetAmount === void 0 ? [] : ["DUP", strict.assetAmount, "GREATERTHANOREQUAL", "VERIFY"],
     "PUSHCURRENTINPUTINDEX",
     inspectionTxid,
     asset.groupIndex,
@@ -1861,11 +1821,11 @@ function enforcePayToAsset(destinationPkScript, asset, strict) {
     1,
     "EQUALVERIFY",
     // ...then the sat covenant, the same tokens `enforcePayTo` emits.
-    ...satClause(destinationPkScript, strict?.amount)
+    ...satClause(destinationPkScript)
   ]);
 }
-function enforcePayToMaybeAsset(destinationPkScript, asset, strict) {
-  return asset === void 0 ? enforcePayTo(destinationPkScript, strict?.amount) : enforcePayToAsset(destinationPkScript, asset, strict);
+function enforcePayToMaybeAsset(destinationPkScript, asset) {
+  return asset === void 0 ? enforcePayTo(destinationPkScript) : enforcePayToAsset(destinationPkScript, asset);
 }
 
 // src/contracts/handlers/vhtlc.ts
@@ -2137,6 +2097,7 @@ var VHTLCV2ContractHandler = {
     return new VHTLC.ScriptV2(typed);
   },
   serializeParams(params) {
+    const covenants = params.nonInteractiveParameters;
     return {
       sender: hex.encode(params.sender),
       receiver: hex.encode(params.receiver),
@@ -2148,39 +2109,31 @@ var VHTLCV2ContractHandler = {
       refundNoReceiverDelay: timelockToSequence(
         params.unilateralRefundWithoutReceiverDelay
       ).toString(),
+      // The on-disk keys keep their per-leaf names even though the typed
+      // param is ONE group: rows written by older SDKs carry exactly
+      // these keys, and changing the storage encoding would orphan them.
+      // The group maps onto them without loss — one emulator key serves
+      // both covenant destinations by construction (see the option's doc
+      // on VHTLC.Options), so the two emulator-key columns always hold
+      // the same value on a row written from here.
+      //
       // Spread rather than written as `undefined`: a `Record<string,
       // string>` round-tripped through a repository must not gain keys
       // whose value is the string "undefined".
-      ...params.nonInteractiveClaim && {
-        nonInteractiveClaimReceiverPkScript: hex.encode(
-          params.nonInteractiveClaim.receiverPkScript
-        ),
-        nonInteractiveClaimEmulatorPubkey: hex.encode(
-          params.nonInteractiveClaim.emulatorPubkey
-        ),
-        // The opt-in quoted bound. Dropping it re-derives the DEFAULT
-        // claim covenant — a strictly weaker one — and registration dies
-        // at `upsertContractRow` with an opaque `Script mismatch`. Same
-        // silent-drop class as the asset keys above.
-        ...params.nonInteractiveClaim.strict && {
-          strictClaimAmount: params.nonInteractiveClaim.strict.amount.toString(),
-          ...params.nonInteractiveClaim.strict.assetAmount !== void 0 && {
-            strictClaimAssetAmount: params.nonInteractiveClaim.strict.assetAmount.toString()
-          }
-        }
-      },
-      ...params.nonInteractiveRefund && {
-        nonInteractiveRefundSenderPkScript: hex.encode(
-          params.nonInteractiveRefund.senderPkScript
-        ),
-        nonInteractiveRefundEmulatorPubkey: hex.encode(
-          params.nonInteractiveRefund.emulatorPubkey
-        ),
-        // Spread rather than a "false"/"undefined" string: a dropped
-        // flag re-derives the EIGHT-leaf script, a different pkScript,
-        // and registration dies at `upsertContractRow` with an opaque
-        // `Script mismatch`. Same silent-drop class as the asset keys.
-        ...params.nonInteractiveRefund.withoutReceiver && {
+      ...covenants && {
+        nonInteractiveClaimReceiverPkScript: hex.encode(covenants.receiverPkScript),
+        nonInteractiveClaimEmulatorPubkey: hex.encode(covenants.emulatorPubkey),
+        nonInteractiveRefundSenderPkScript: hex.encode(covenants.senderPkScript),
+        nonInteractiveRefundEmulatorPubkey: hex.encode(covenants.emulatorPubkey),
+        // The legacy marker is precisely the ABSENCE of this key: a
+        // row carrying it re-derives the full suite (nine leaves), a
+        // row lacking it the pre-timelocked-refund eight — the same
+        // encoding older SDKs wrote for eight-leaf rows, so those rows
+        // read back unchanged. Spread rather than a "false"/"undefined"
+        // string: a dropped flag re-derives the EIGHT-leaf script, a
+        // different pkScript, and registration dies at
+        // `upsertContractRow` with an opaque `Script mismatch`.
+        ...covenants.legacy === void 0 && {
           nonInteractiveRefundWithoutReceiver: "1"
         }
       },
@@ -2212,19 +2165,29 @@ var VHTLCV2ContractHandler = {
       "nonInteractiveRefundEmulatorPubkey",
       "nonInteractiveRefund"
     );
+    if (claim === void 0 !== (refund === void 0)) {
+      throw new Error(
+        "emulator covenant params are all-or-nothing: the claim keys (nonInteractiveClaim*) and the refund keys (nonInteractiveRefund*) must both be present or both absent \u2014 a row carrying one side was written for a leaf subset this handler no longer derives"
+      );
+    }
+    if (claim && refund && hex.encode(claim.emulatorPubkey) !== hex.encode(refund.emulatorPubkey)) {
+      throw new Error(
+        "emulator covenant params name two different emulator pubkeys: the suite derives both covenant cosigners from ONE key, so this row cannot be rebuilt as a group"
+      );
+    }
     if (params.assetTxid === void 0 !== (params.assetGroupIndex === void 0)) {
       throw new Error(
         "asset params are incomplete: assetTxid and assetGroupIndex must both be present or both absent"
       );
     }
-    if (params.strictClaimAssetAmount !== void 0 && params.strictClaimAmount === void 0) {
+    if (params.strictClaimAmount !== void 0 || params.strictClaimAssetAmount !== void 0) {
       throw new Error(
-        "strictClaimAssetAmount without strictClaimAmount: reading this as 'not strict' would re-derive the default claim covenant, which is weaker than the row asked for"
+        "strict claim params on a stored row: the strict claim bound was removed and this row's lockup cannot be re-derived without it \u2014 restore it with the SDK version that wrote it"
       );
     }
     if (params.nonInteractiveRefundWithoutReceiver !== void 0 && !refund) {
       throw new Error(
-        "nonInteractiveRefundWithoutReceiver without the nonInteractiveRefund keys it extends: reading this as 'not set' would re-derive a script without the leaf"
+        "nonInteractiveRefundWithoutReceiver without the emulator covenant keys it extends: reading this as 'not set' would re-derive a script without the leaf"
       );
     }
     if (params.nonInteractiveRefundWithoutReceiver !== void 0 && params.nonInteractiveRefundWithoutReceiver !== "1") {
@@ -2248,26 +2211,15 @@ var VHTLCV2ContractHandler = {
       unilateralRefundWithoutReceiverDelay: sequenceToTimelock(
         Number(params.refundNoReceiverDelay)
       ),
-      ...claim && {
-        nonInteractiveClaim: {
+      ...claim && refund && {
+        nonInteractiveParameters: {
           receiverPkScript: claim.destination,
-          emulatorPubkey: claim.emulatorPubkey,
-          ...params.strictClaimAmount !== void 0 && {
-            strict: {
-              amount: BigInt(params.strictClaimAmount),
-              ...params.strictClaimAssetAmount !== void 0 && {
-                assetAmount: BigInt(params.strictClaimAssetAmount)
-              }
-            }
-          }
-        }
-      },
-      ...refund && {
-        nonInteractiveRefund: {
           senderPkScript: refund.destination,
-          emulatorPubkey: refund.emulatorPubkey,
-          ...params.nonInteractiveRefundWithoutReceiver === "1" && {
-            withoutReceiver: true
+          emulatorPubkey: claim.emulatorPubkey,
+          // Absence of the flag IS the legacy marker — the same
+          // encoding older SDKs wrote for eight-leaf rows.
+          ...params.nonInteractiveRefundWithoutReceiver !== "1" && {
+            legacy: "preTimelockedRefund"
           }
         }
       }
@@ -3036,5 +2988,5 @@ contractHandlers.register(BoardingContractHandler);
 contractHandlers.register(ArkadeContractHandler);
 
 export { ARKADE_OP, ARKADE_OPCODES, ARKADE_OPCODE_NAMES, ARKADE_OPCODE_VALUES, ARKADE_OPS, ArkadeContractHandler, ArkadeProgramScript, ArkadeScript, BoardingContractHandler, DefaultContractHandler, DefaultVtxo, DelegateContractHandler, DelegateVtxo, OPCODE_NAMES, OPCODE_VALUES, SUPPORTED_PROGRAM_VERSION, VHTLC, VHTLCContractHandler, VHTLCV2ContractHandler, WALLET_RECEIVE_SOURCE, arkadeScriptHash, arkadeWitnessHash, asmToBytes, bignum_exports, bytesToASM, computeArkadeScriptPublicKey, contractHandlers, deriveDescriptorLeafCompressedPubKey, deriveDescriptorLeafPubKey, descriptorIsOurs, deserializeArkadeContractParams, fromASM, getOpcodeName, getOpcodeValue, identityDescriptor, inputName, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, normalizeToDescriptor, parseArtifact, parseHDDescriptor, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, toXOnly, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-6TAQF6EV.js.map
-//# sourceMappingURL=chunk-6TAQF6EV.js.map
+//# sourceMappingURL=chunk-2PPL3O7Z.js.map
+//# sourceMappingURL=chunk-2PPL3O7Z.js.map