@arkade-os/sdk 0.4.65 → 0.4.67

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

@@ -1,4 +1,4 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-TFSVXMTM.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-3WIWNE4P.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
@@ -1412,6 +1412,15 @@ function asmToBytes(asm) {
 function bytesToASM(script) {
   return toASM(ArkadeScript.decode(script));
 }
+
+// src/utils/keys.ts
+function toXOnly(key, label = "public key") {
+  if (key.length === 32) return key;
+  if (key.length === 33 && (key[0] === 2 || key[0] === 3)) return key.subarray(1);
+  throw new Error(`${label} is not a compressed or x-only public key`);
+}
+
+// src/arkade/tweak.ts
 var TAG_SCRIPT = "ArkScriptHash";
 var TAG_WITNESS = "ArkWitnessHash";
 function arkadeScriptHash(script) {
@@ -1425,8 +1434,7 @@ function arkadeWitnessHash(witness) {
 }
 function computeArkadeScriptPublicKey(pubKey, script) {
   const hash = arkadeScriptHash(script);
-  const xOnly = pubKey.length === 33 ? pubKey.subarray(1) : pubKey;
-  const point = schnorr.utils.lift_x(bytesToNumberBE(xOnly));
+  const point = schnorr.utils.lift_x(bytesToNumberBE(toXOnly(pubKey, "emulator key")));
   const scalar = bytesToNumberBE(hash) % secp256k1.Point.CURVE().n;
   const tweak = secp256k1.Point.BASE.multiply(scalar);
   return schnorr.utils.pointToBytes(point.add(tweak));
@@ -1447,6 +1455,8 @@ var VHTLC;
     nonInteractiveClaimArkadeScript;
     nonInteractiveRefundScript;
     nonInteractiveRefundArkadeScript;
+    nonInteractiveRefundWithoutReceiverScript;
+    nonInteractiveRefundWithoutReceiverArkadeScript;
     constructor(options, preimageCondition) {
       validateOptions(options);
       const {
@@ -1514,22 +1524,27 @@ var VHTLC;
       }
       let arkadeScriptNir;
       let nonInteractiveRefundScript;
+      let nonInteractiveRefundWithoutReceiverScript;
       if (options.nonInteractiveRefund) {
         arkadeScriptNir = enforcePayToMaybeAsset(
           options.nonInteractiveRefund.senderPkScript,
           options.asset
         );
+        const nirCosigner = computeArkadeScriptPublicKey(
+          options.nonInteractiveRefund.emulatorPubkey,
+          arkadeScriptNir
+        );
         nonInteractiveRefundScript = MultisigTapscript.encode({
-          pubkeys: [
-            server,
-            receiver,
-            computeArkadeScriptPublicKey(
-              options.nonInteractiveRefund.emulatorPubkey,
-              arkadeScriptNir
-            )
-          ]
+          pubkeys: [server, receiver, nirCosigner]
         }).script;
         scripts.push(nonInteractiveRefundScript);
+        if (options.nonInteractiveRefund.withoutReceiver) {
+          nonInteractiveRefundWithoutReceiverScript = CLTVMultisigTapscript.encode({
+            absoluteTimelock: refundLocktime,
+            pubkeys: [server, nirCosigner]
+          }).script;
+          scripts.push(nonInteractiveRefundWithoutReceiverScript);
+        }
       }
       super(scripts);
       this.options = options;
@@ -1549,6 +1564,12 @@ var VHTLC;
         this.nonInteractiveRefundScript = hex.encode(nonInteractiveRefundScript);
         this.nonInteractiveRefundArkadeScript = arkadeScriptNir;
       }
+      if (nonInteractiveRefundWithoutReceiverScript) {
+        this.nonInteractiveRefundWithoutReceiverScript = hex.encode(
+          nonInteractiveRefundWithoutReceiverScript
+        );
+        this.nonInteractiveRefundWithoutReceiverArkadeScript = arkadeScriptNir;
+      }
     }
     /** Return the collaborative claim tapleaf script. */
     claim() {
@@ -1594,6 +1615,67 @@ var VHTLC;
         this.nonInteractiveRefundArkadeScript
       ];
     }
+    /**
+     * Return the timelocked non-interactive refund tapleaf and its ArkadeScript.
+     *
+     * SPENDING THIS LEAF, CONCRETELY — confirmed from this SDK's own
+     * emulator client and covenant-spend builder ({@link
+     * EmulatorProvider} in `src/providers/emulator.ts`, and {@link
+     * ArkadeTransactionBuilder} in `src/arkade/contract.ts`), which is
+     * the general machinery every covenant leaf in this file goes
+     * through:
+     *
+     *  1. Build the ark tx spending this leaf (this method's {@link
+     *     TapLeafScript} as `tapLeafScript`, this script's {@link
+     *     VtxoScript.encode} as `tapTree`), plus its checkpoint tx.
+     *  2. Attach the ArkadeScript this method returns to the spent
+     *     input via an `EmulatorPacket` (type 1) — `{ vin, script:
+     *     <this ArkadeScript>, witness: <empty> }`, empty because the
+     *     script pushes its own input/output index with
+     *     `PUSHCURRENTINPUTINDEX` rather than reading one from the
+     *     witness — wrapped in an `Extension` OP_RETURN output on the
+     *     ark tx.
+     *  3. Attach the spent input's OWN creating ark tx as `PrevArkTx` on
+     *     input 0 — required so the emulator can resolve that input's
+     *     prevout pkScript/value; it does not otherwise have them.
+     *  4. POST the (base64-PSBT) ark tx and checkpoint(s) as `{ arkTx,
+     *     checkpointTxs }` to the emulator's `POST /v1/tx`.
+     *
+     * THE COVENANT CHECK the emulator runs against that ArkadeScript —
+     * `enforcePayTo(senderPkScript)`, see that function above — is: the
+     * output at this SAME input's index is a v1 P2TR output paying
+     * `senderPkScript`, with a value at least the input's. Only on that
+     * check passing does the emulator sign for `nirCosigner` (the
+     * `emulatorPubkey` tweaked by this ArkadeScript's hash); the
+     * response carries the fully co-signed `signedArkTx` and
+     * `signedCheckpointTxs` — `ArkadeTransactionBuilder.send()`'s own
+     * comment on this path: "the emulator executes the arkade script
+     * and finalizes with arkd" — no separate call to arkd is made by
+     * this SDK for a covenant spend.
+     * Neither `server` nor `receiver` play any part in that check: this
+     * leaf's tapscript still requires `server`'s own signature
+     * alongside `nirCosigner`'s (see the class doc above), but that is
+     * consensus-level multisig, not something the covenant enforces.
+     *
+     * NOT SPENDABLE UNTIL `refundLocktime` MATURES — the tapscript's
+     * `OP_CHECKLOCKTIMEVERIFY` is arkd's concern, not the emulator's;
+     * the emulator will happily co-sign an immature spend and arkd will
+     * then refuse it. A block-height-typed `refundLocktime` (below the
+     * standard height/timestamp boundary this SDK names
+     * `CLTV_HEIGHT_THRESHOLD`, 500,000,000, in
+     * `src/contracts/handlers/helpers.ts`) is refused by arkd for a
+     * forfeit-eligible leaf independent of maturity — use a
+     * seconds-typed (absolute Unix timestamp) value.
+     */
+    nonInteractiveRefundWithoutReceiver() {
+      if (!this.nonInteractiveRefundWithoutReceiverScript || !this.nonInteractiveRefundWithoutReceiverArkadeScript) {
+        throw new Error("VHTLC has no non-interactive refund-without-receiver leaf");
+      }
+      return [
+        this.findLeaf(this.nonInteractiveRefundWithoutReceiverScript),
+        this.nonInteractiveRefundWithoutReceiverArkadeScript
+      ];
+    }
   }
   class Script3 extends BaseScript {
     constructor(options) {
@@ -2093,7 +2175,14 @@ var VHTLCV2ContractHandler = {
         ),
         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 && {
+          nonInteractiveRefundWithoutReceiver: "1"
+        }
       },
       // The asset must round-trip, and its absence here used to be silent
       // in the worst way. `ContractManager` re-derives a contract from
@@ -2133,6 +2222,16 @@ var VHTLCV2ContractHandler = {
         "strictClaimAssetAmount without strictClaimAmount: reading this as 'not strict' would re-derive the default claim covenant, which is weaker than the row asked for"
       );
     }
+    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"
+      );
+    }
+    if (params.nonInteractiveRefundWithoutReceiver !== void 0 && params.nonInteractiveRefundWithoutReceiver !== "1") {
+      throw new Error(
+        `nonInteractiveRefundWithoutReceiver must be "1" when present, got ` + JSON.stringify(params.nonInteractiveRefundWithoutReceiver)
+      );
+    }
     const asset = params.assetTxid !== void 0 && params.assetGroupIndex !== void 0 ? {
       txid: hex.decode(params.assetTxid),
       groupIndex: parseGroupIndex(params.assetGroupIndex)
@@ -2166,7 +2265,10 @@ var VHTLCV2ContractHandler = {
       ...refund && {
         nonInteractiveRefund: {
           senderPkScript: refund.destination,
-          emulatorPubkey: refund.emulatorPubkey
+          emulatorPubkey: refund.emulatorPubkey,
+          ...params.nonInteractiveRefundWithoutReceiver === "1" && {
+            withoutReceiver: true
+          }
         }
       }
     };
@@ -2933,6 +3035,6 @@ contractHandlers.register(VHTLCV2ContractHandler);
 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, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-XMOIRDLF.js.map
-//# sourceMappingURL=chunk-XMOIRDLF.js.map
+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