@arkade-os/sdk 0.4.64 → 0.4.66

package/dist/{chunk-LN2VZP63.js → chunk-CYOI4PEA.js}

@@ -1,4 +1,4 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-XJCBV4AA.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-J33ZEM3A.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));
@@ -1495,7 +1503,11 @@ var VHTLC;
       let arkadeScriptNic;
       let nonInteractiveClaimScript;
       if (options.nonInteractiveClaim) {
-        arkadeScriptNic = enforcePayTo(options.nonInteractiveClaim.receiverPkScript);
+        arkadeScriptNic = enforcePayToMaybeAsset(
+          options.nonInteractiveClaim.receiverPkScript,
+          options.asset,
+          options.nonInteractiveClaim.strict
+        );
         nonInteractiveClaimScript = ConditionMultisigTapscript.encode({
           conditionScript,
           pubkeys: [
@@ -1511,7 +1523,10 @@ var VHTLC;
       let arkadeScriptNir;
       let nonInteractiveRefundScript;
       if (options.nonInteractiveRefund) {
-        arkadeScriptNir = enforcePayTo(options.nonInteractiveRefund.senderPkScript);
+        arkadeScriptNir = enforcePayToMaybeAsset(
+          options.nonInteractiveRefund.senderPkScript,
+          options.asset
+        );
         nonInteractiveRefundScript = MultisigTapscript.encode({
           pubkeys: [
             server,
@@ -1614,6 +1629,30 @@ 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"
+      );
+    }
+    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 (!emulatorPubkey || emulatorPubkey.length !== 32 && emulatorPubkey.length !== 33) {
@@ -1682,11 +1721,8 @@ function preimageConditionScriptV2(preimageHash) {
 function isP2trPkScript(pkScript) {
   return pkScript.length === 34 && pkScript[0] === 81 && pkScript[1] === 32;
 }
-function enforcePayTo(destinationPkScript) {
-  if (!isP2trPkScript(destinationPkScript)) {
-    throw new Error("invalid P2TR script");
-  }
-  return ArkadeScript.encode([
+function satClause(destinationPkScript, quotedSats) {
+  return [
     "PUSHCURRENTINPUTINDEX",
     "DUP",
     "INSPECTOUTPUTSCRIPTPUBKEY",
@@ -1695,11 +1731,68 @@ function enforcePayTo(destinationPkScript) {
     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) {
+  if (!isP2trPkScript(destinationPkScript)) {
+    throw new Error("invalid P2TR script");
+  }
+  return ArkadeScript.encode(satClause(destinationPkScript, quotedSats));
+}
+function enforcePayToAsset(destinationPkScript, asset, strict) {
+  if (!isP2trPkScript(destinationPkScript)) {
+    throw new Error("invalid P2TR script");
+  }
+  if (asset.txid.length !== 32) {
+    throw new Error(`asset txid must be 32 bytes, got ${asset.txid.length}`);
+  }
+  if (!Number.isInteger(asset.groupIndex) || asset.groupIndex < 0 || asset.groupIndex > 65535) {
+    throw new Error(
+      `asset group index must be an integer in [0, 65535], got ${asset.groupIndex}`
+    );
+  }
+  const inspectionTxid = Uint8Array.from(asset.txid).reverse();
+  return ArkadeScript.encode([
+    // The output carries at least as much of the asset as the input did.
+    // Output index is the input's -- the same index alignment the sat
+    // covenant relies on, and the same liveness obligation on whoever
+    // assembles the spend.
+    "PUSHCURRENTINPUTINDEX",
+    inspectionTxid,
+    asset.groupIndex,
+    "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,
+    "INSPECTINASSETLOOKUP",
+    "VERIFY",
+    // ...and on the input, so the comparison means something
+    "GREATERTHANOREQUAL",
+    "VERIFY",
+    // Exactly one asset out: nothing injected alongside the one bound.
+    "PUSHCURRENTINPUTINDEX",
+    "INSPECTOUTASSETCOUNT",
+    1,
+    "EQUALVERIFY",
+    // ...then the sat covenant, the same tokens `enforcePayTo` emits.
+    ...satClause(destinationPkScript, strict?.amount)
   ]);
 }
+function enforcePayToMaybeAsset(destinationPkScript, asset, strict) {
+  return asset === void 0 ? enforcePayTo(destinationPkScript, strict?.amount) : enforcePayToAsset(destinationPkScript, asset, strict);
+}
 
 // src/contracts/handlers/vhtlc.ts
 var VHTLCContractHandler = {
@@ -1946,6 +2039,14 @@ var VHTLCContractHandler = {
     };
   }
 };
+var parseGroupIndex = (raw) => {
+  if (!/^(0|[1-9][0-9]*)$/.test(raw)) {
+    throw new Error(
+      `assetGroupIndex must be a canonical decimal integer, got ${JSON.stringify(raw)}`
+    );
+  }
+  return Number(raw);
+};
 function decodeCovenantLeaf(params, destinationKey, emulatorKey, label) {
   const destination = params[destinationKey];
   const emulator = params[emulatorKey];
@@ -1982,7 +2083,17 @@ var VHTLCV2ContractHandler = {
         ),
         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(
@@ -1991,6 +2102,19 @@ var VHTLCV2ContractHandler = {
         nonInteractiveRefundEmulatorPubkey: hex.encode(
           params.nonInteractiveRefund.emulatorPubkey
         )
+      },
+      // The asset must round-trip, and its absence here used to be silent
+      // in the worst way. `ContractManager` re-derives a contract from
+      // these params; dropping the asset derives the SAT-ONLY script, so
+      // registration died at `upsertContractRow` with a `Script mismatch`
+      // naming two hex strings and no cause. Same silent-drop class
+      // `validateOptions` refuses one layer up.
+      //
+      // Two keys rather than one blob, mirroring the script's own view of
+      // an Asset ID as a (txid, groupIndex) pair.
+      ...params.asset && {
+        assetTxid: hex.encode(params.asset.txid),
+        assetGroupIndex: params.asset.groupIndex.toString()
       }
     };
   },
@@ -2007,12 +2131,27 @@ var VHTLCV2ContractHandler = {
       "nonInteractiveRefundEmulatorPubkey",
       "nonInteractiveRefund"
     );
+    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) {
+      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"
+      );
+    }
+    const asset = params.assetTxid !== void 0 && params.assetGroupIndex !== void 0 ? {
+      txid: hex.decode(params.assetTxid),
+      groupIndex: parseGroupIndex(params.assetGroupIndex)
+    } : void 0;
     return {
       sender: hex.decode(params.sender),
       receiver: hex.decode(params.receiver),
       server: hex.decode(params.server),
       preimageHash: hex.decode(params.hash),
       refundLocktime: BigInt(params.refundLocktime),
+      ...asset && { asset },
       unilateralClaimDelay: sequenceToTimelock(Number(params.claimDelay)),
       unilateralRefundDelay: sequenceToTimelock(Number(params.refundDelay)),
       unilateralRefundWithoutReceiverDelay: sequenceToTimelock(
@@ -2021,7 +2160,15 @@ var VHTLCV2ContractHandler = {
       ...claim && {
         nonInteractiveClaim: {
           receiverPkScript: claim.destination,
-          emulatorPubkey: claim.emulatorPubkey
+          emulatorPubkey: claim.emulatorPubkey,
+          ...params.strictClaimAmount !== void 0 && {
+            strict: {
+              amount: BigInt(params.strictClaimAmount),
+              ...params.strictClaimAssetAmount !== void 0 && {
+                assetAmount: BigInt(params.strictClaimAssetAmount)
+              }
+            }
+          }
         }
       },
       ...refund && {
@@ -2794,6 +2941,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-LN2VZP63.js.map
-//# sourceMappingURL=chunk-LN2VZP63.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-CYOI4PEA.js.map
+//# sourceMappingURL=chunk-CYOI4PEA.js.map