@arkade-os/sdk 0.4.60 → 0.4.61

package/dist/{chunk-2DINXHGQ.js → chunk-6O5OLYTZ.js}

@@ -1,4 +1,4 @@
-import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-JBULXTCC.js';
+import { VtxoScript, MultisigTapscript, CSVMultisigTapscript, timelockToSequence, sequenceToTimelock, ConditionMultisigTapscript, CLTVMultisigTapscript, ConditionCSVMultisigTapscript, SCRIPT_QUERY_CHUNK_SIZE, getNormalizedVtxos, DEFAULT_PAGE_SIZE } from './chunk-PVY6DMN5.js';
 import { __export } from './chunk-NSBPE2FW.js';
 import { hex } from '@scure/base';
 import { networks, expand } from '@bitcoinerlab/descriptors-scure';
@@ -210,6 +210,31 @@ function deriveDescriptorLeafCompressedPubKey(descriptor) {
   }
   return key.keyPath ? key.bip32.derivePath(key.keyPath.replace(/^\//, "")).publicKey : key.bip32.publicKey;
 }
+function parseHDDescriptor(descriptor) {
+  if (!isDescriptor(descriptor)) {
+    return null;
+  }
+  let expansion;
+  try {
+    const network = isMainnetDescriptor(descriptor) ? networks.bitcoin : networks.testnet;
+    expansion = expand({ descriptor, network });
+  } catch {
+    return null;
+  }
+  const key = expansion.expansionMap?.["@0"];
+  if (!key?.masterFingerprint || !key.originPath || !key.keyPath || !key.bip32) {
+    return null;
+  }
+  return {
+    fingerprint: hex.encode(key.masterFingerprint),
+    basePath: key.originPath.replace(/^\//, ""),
+    xpub: key.bip32.toBase58(),
+    derivationPath: key.keyPath.replace(/^\//, "")
+  };
+}
+async function identityDescriptor(identity) {
+  return normalizeToDescriptor(hex.encode(await identity.xOnlyPublicKey()));
+}
 
 // src/contracts/metadata.ts
 var WALLET_RECEIVE_SOURCE = "wallet-receive";
@@ -1266,22 +1291,18 @@ var ArkadeScript = wrap({
         w.byte(v);
         continue;
       } else if (typeof o === "number" || typeof o === "bigint") {
-        if (o === 0 || o === 0n) {
-          w.byte(0);
-          continue;
-        } else if (o >= 1 && o <= 16) {
-          w.byte(OP.OP_1 - 1 + Number(o));
-          continue;
-        } else if (o === -1 || o === -1n) {
-          w.byte(OP["1NEGATE"]);
-          continue;
-        }
         const big = typeof o === "number" ? BigInt(o) : o;
         o = encode(big);
       }
       if (!(o instanceof Uint8Array)) throw new Error(`Wrong Script OP=${o} (${typeof o})`);
       const len = o.length;
-      if (len < OP.PUSHDATA1) w.byte(len);
+      if (len === 1 && o[0] >= 1 && o[0] <= 16) {
+        w.byte(OP.OP_1 - 1 + o[0]);
+        continue;
+      } else if (len === 1 && o[0] === 129) {
+        w.byte(OP["1NEGATE"]);
+        continue;
+      } else if (len < OP.PUSHDATA1) w.byte(len);
       else if (len <= 255) {
         w.byte(OP.PUSHDATA1);
         w.byte(len);
@@ -1869,21 +1890,19 @@ var VHTLCContractHandler = {
    * `refundWithoutReceiver` — `CLTV[sender, server]`, the sender's OWN
    * refund, which the server rejects until `refundLocktime` matures. The
    * reasons are that an escrowed lockup must not count toward the
-   * `available` balance bucket (`computeOffchainBalance` credits `available`
-   * only where this gate is open), and that generic RENEWAL must not
-   * silently execute a refund the caller never asked for —
-   * `runPeriodicSettle` selects through `getSpendableVtxos`, which this gate
-   * filters, and it runs unprompted whenever a wallet is built without an
-   * explicit `settlementConfig`.
+   * `available` balance bucket, and that generic RENEWAL must not silently
+   * execute a refund the caller never asked for — `runPeriodicSettle` selects
+   * through `getSpendableVtxos`, which this gate filters, and it runs
+   * unprompted whenever a wallet is built without an explicit
+   * `settlementConfig`.
+   *
+   * **Inseparable from {@link deriveTapscripts}.** Deriving the leaf without
+   * closing the gate hands generic renewal an escrow it had never been
+   * offered before; before that method existed the answer here was
+   * unobservable, so the two only ever made sense together.
    *
-   * **Inseparable from {@link deriveTapscripts}.** Until that method existed
-   * a `vhtlc` row's VTXOs could not be annotated at all, so they never
-   * reached this gate and the answer here was unobservable — the previous
-   * `true` and the missing derivation were safe only by cancelling out.
-   * Deriving the leaf without closing the gate would hand generic renewal an
-   * escrow it had never been offered before. (The earlier `true` was
-   * justified as preserving selection of in-flight swaps; no such selection
-   * was ever reachable, for that same annotation reason.)
+   * Recovery is filtered on {@link assertSpendableNow}, not on this: the gate
+   * is permanent, and applying it there would strand a matured lockup.
    */
   isGenericallySpendable: () => false,
   /**
@@ -1911,7 +1930,12 @@ var VHTLCContractHandler = {
    * on this leaf is only valid once `refundLocktime` has matured, so a
    * recovery round that sweeps this VTXO early is rejected by the server.
    * Nothing in this handler can enforce that, because the annotation is
-   * derived per contract and knows no clock.
+   * derived per contract and knows no clock; `recoverVtxos` filters on
+   * {@link assertSpendableNow} for it.
+   *
+   * **Role-blind.** A receiver's row gets the same leaf, which names keys that
+   * wallet does not hold, so it is satisfiable only by the wallet holding the
+   * lockup's `sender` key and fails at intent registration for anyone else.
    */
   deriveTapscripts(script) {
     const leaf = script.refundWithoutReceiver();
@@ -2157,10 +2181,12 @@ var VHTLCV2ContractHandler = {
    * complete, or race a claim already in flight. The `vhtlc` handler now
    * answers the same, for the same reason.
    *
-   * Recovery is unaffected: the gate guards only GENERIC selection, and every
-   * way out of a lockup names its outpoints explicitly — `settle({ inputs })`,
-   * or `@arkade-os/swap`'s `pushRefundWithoutReceiver`, which builds the
-   * refund itself from `findLockupVtxos`' outpoints.
+   * The gate covers `available` and renewal. Recovery is generic and names
+   * nothing, so it is not covered here: `recoverVtxos` filters on
+   * {@link assertSpendableNow} instead, which drops a lockup only while its
+   * refund path is shut rather than forever. The explicit routes out —
+   * `settle({ inputs })`, or `@arkade-os/swap`'s `pushRefundWithoutReceiver`
+   * over `findLockupVtxos`' outpoints — are unaffected either way.
    */
   isGenericallySpendable: () => false,
   /**
@@ -2192,7 +2218,12 @@ var VHTLCV2ContractHandler = {
    * round that sweeps this VTXO early is rejected by the server. That is the
    * same constraint `packages/boltz-swap` encodes as "pre-CLTV recoverable →
    * skipped"; nothing in this handler can enforce it, because the annotation
-   * is derived per contract and knows no clock.
+   * is derived per contract and knows no clock. `recoverVtxos` filters on
+   * {@link assertSpendableNow} for it.
+   *
+   * **Role-blind.** A receiver's row gets the same leaf, which names keys that
+   * wallet does not hold, so it is satisfiable only by the wallet holding the
+   * lockup's `sender` key and fails at intent registration for anyone else.
    */
   deriveTapscripts(script) {
     const leaf = script.refundWithoutReceiver();
@@ -2763,6 +2794,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, inputName, isCltvSatisfied, isCsvSpendable, isMainnetDescriptor, parseArtifact, resolveAsm, serializeArkadeContractParams, speculativeReceiveMetadata, stringifyArtifact, toASM, validateProgram, witnessRefToBytes };
-//# sourceMappingURL=chunk-2DINXHGQ.js.map
-//# sourceMappingURL=chunk-2DINXHGQ.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, validateProgram, witnessRefToBytes };
+//# sourceMappingURL=chunk-6O5OLYTZ.js.map
+//# sourceMappingURL=chunk-6O5OLYTZ.js.map