@arkade-os/sdk 0.4.64 → 0.4.65

package/dist/{index-Bxe9kBFs.d.ts → index-fDDiA1-L.d.ts}

@@ -121,6 +121,51 @@ declare namespace VHTLC {
         nonInteractiveClaim?: {
             receiverPkScript: Bytes;
             emulatorPubkey: Bytes;
+            /**
+             * OPT-IN: also require the claim to pay at least these amounts.
+             *
+             * The covenant's default bound is conservation (`out >= in`) — see
+             * {@link enforcePayTo} for why a quote is normally not the
+             * covenant's business. This is the escape hatch for a consumer that
+             * wants the quote enforced in script rather than at its own
+             * admission layer.
+             *
+             * ADDITIVE, NEVER A REPLACEMENT. The conservation bound stays. On
+             * its own, `out >= quoted` leaves everything ABOVE the quote
+             * unconstrained, so an overfunded lockup's surplus could be routed
+             * anywhere by whoever assembles the spend — trading an underfunding
+             * hole for a skimming one. Both bounds together admit neither.
+             *
+             * WHAT IT COSTS, and it is not only opcodes:
+             *
+             *  - THE ADDRESS BECOMES A FUNCTION OF THE QUOTE. These amounts
+             *    compile into the leaf, hence the emulator key, hence the
+             *    pkScript. A re-quote is a different address, and cannot be
+             *    applied to a lockup already funded.
+             *  - AN UNDERFUNDED LOCKUP BECOMES UNCLAIMABLE. Its only exit is the
+             *    refund path, which waits out the CLTV. That is the intended
+             *    incentive and it lands on whoever misfunded — but it converts
+             *    "claim the short amount now and settle up" into "wait for the
+             *    timelock".
+             *
+             * Omit for the default. Omitting leaves every script byte unchanged,
+             * so contracts already funded keep their addresses.
+             */
+            strict?: {
+                /** Sats the claim must pay. Positive. */
+                amount: bigint;
+                /**
+                 * Asset base units the claim must pay.
+                 *
+                 * Required iff {@link VHTLC.Options.asset} is set, and refused
+                 * otherwise. Strict-on-sats-only against an asset-denominated
+                 * contract would pin the sat CARRIER and say nothing about the
+                 * asset that is the actual amount — half-enforcement that reads
+                 * like enforcement, which is the failure this option exists to
+                 * avoid rather than introduce.
+                 */
+                assetAmount?: bigint;
+            };
         };
         /**
          * Optional non-interactive refund leaf: `server` + `receiver` + a
@@ -141,6 +186,54 @@ declare namespace VHTLC {
             senderPkScript: Bytes;
             emulatorPubkey: Bytes;
         };
+        /**
+         * Optional: denominate this contract in an Arkade ASSET rather than in
+         * sats alone.
+         *
+         * Only the two NON-INTERACTIVE leaves change. Every other leaf is a
+         * signature path that asserts nothing about value, so an asset makes no
+         * difference to them — which is why this option reaches exactly the
+         * leaves whose covenant the emulator enforces.
+         *
+         * When set, those covenants additionally require the output to carry at
+         * least the input's amount of THIS asset, and to carry exactly one
+         * asset. The sat clause is RETAINED, not replaced: an asset-carrying
+         * VTXO carries sats too, so dropping it would let a spend satisfy the
+         * asset covenant while stripping the sats — exactly as the sat-only
+         * covenant lets a spend strip the asset.
+         *
+         * ONE ASSET IS BOUND, AND ONLY THAT ONE IS PROTECTED. If a VTXO funded to
+         * this contract carries ADDITIONAL assets alongside the bound one, those
+         * are not covered: whoever assembles a covenant spend chooses where they
+         * go, and can send them anywhere.
+         *
+         * `INSPECTOUTASSETCOUNT == 1` does not close that. It constrains the
+         * covenant's OUTPUT to exactly one asset — so the extras cannot ride
+         * along with the bound asset — but arkd's conservation rule is satisfied
+         * by routing them to a different output, which the covenant says nothing
+         * about. The bound asset arrives; the rest is the spender's to direct.
+         *
+         * So fund an asset contract with the asset it names and nothing else. A
+         * multi-asset VTXO behind this covenant is a loss waiting for whoever
+         * pushes the spend.
+         *
+         * The id is the pair the introspection opcodes take. A canonical Asset
+         * ID is `(genesis txid, group index)`, never a single blob.
+         */
+        asset?: {
+            /**
+             * The asset's genesis transaction id, 32 bytes, in CANONICAL order
+             * — exactly the leading 32 bytes of a serialized Asset ID, no flip.
+             *
+             * The covenant reverses it internally because the introspection
+             * opcodes match wire order; callers never do that themselves, and a
+             * caller who pre-reverses gets a contract that is unspendable on its
+             * covenant leaves with nothing in the error naming why.
+             */
+            txid: Bytes;
+            /** The asset group index within that genesis transaction. */
+            groupIndex: number;
+        };
     }
     /**
      * Shared construction and accessors for every VHTLC script version. The
@@ -287,10 +380,26 @@ interface VHTLCV2ContractParams {
     unilateralClaimDelay: RelativeTimelock;
     unilateralRefundDelay: RelativeTimelock;
     unilateralRefundWithoutReceiverDelay: RelativeTimelock;
+    /**
+     * The Arkade asset the covenant leaves bind, if any.
+     *
+     * @see VHTLC.Options.asset
+     */
+    asset?: {
+        /** The asset's genesis txid, 32 bytes, canonical order — as the serialized Asset ID carries it. */
+        txid: Uint8Array;
+        /** The asset group index within that genesis transaction. */
+        groupIndex: number;
+    };
     /** @see VHTLC.Options.nonInteractiveClaim */
     nonInteractiveClaim?: {
         receiverPkScript: Uint8Array;
         emulatorPubkey: Uint8Array;
+        /** @see VHTLC.Options.nonInteractiveClaim.strict */
+        strict?: {
+            amount: bigint;
+            assetAmount?: bigint;
+        };
     };
     /** @see VHTLC.Options.nonInteractiveRefund */
     nonInteractiveRefund?: {