@arkade-os/sdk 0.0.16

package/dist/esm/script/default.js

@@ -0,0 +1,37 @@
+import { VtxoScript } from './base.js';
+import { CSVMultisigTapscript, MultisigTapscript, } from './tapscript.js';
+import { hex } from "@scure/base";
+// DefaultVtxo is the default implementation of a VtxoScript.
+// it contains 1 forfeit path and 1 exit path.
+// forfeit = (Alice + Server)
+// exit = (Alice) after csvTimelock
+export var DefaultVtxo;
+(function (DefaultVtxo) {
+    class Script extends VtxoScript {
+        constructor(options) {
+            const { pubKey, serverPubKey, csvTimelock = Script.DEFAULT_TIMELOCK, } = options;
+            const forfeitScript = MultisigTapscript.encode({
+                pubkeys: [pubKey, serverPubKey],
+            }).script;
+            const exitScript = CSVMultisigTapscript.encode({
+                timelock: csvTimelock,
+                pubkeys: [pubKey],
+            }).script;
+            super([forfeitScript, exitScript]);
+            this.options = options;
+            this.forfeitScript = hex.encode(forfeitScript);
+            this.exitScript = hex.encode(exitScript);
+        }
+        forfeit() {
+            return this.findLeaf(this.forfeitScript);
+        }
+        exit() {
+            return this.findLeaf(this.exitScript);
+        }
+    }
+    Script.DEFAULT_TIMELOCK = {
+        value: 144n,
+        type: "blocks",
+    }; // 1 day in blocks
+    DefaultVtxo.Script = Script;
+})(DefaultVtxo || (DefaultVtxo = {}));

package/dist/esm/script/tapscript.js

@@ -0,0 +1,491 @@
+import * as bip68 from "bip68";
+import { Script, ScriptNum } from "@scure/btc-signer/script";
+import { p2tr_ms } from "@scure/btc-signer/payment";
+import { hex } from "@scure/base";
+export var TapscriptType;
+(function (TapscriptType) {
+    TapscriptType["Multisig"] = "multisig";
+    TapscriptType["CSVMultisig"] = "csv-multisig";
+    TapscriptType["ConditionCSVMultisig"] = "condition-csv-multisig";
+    TapscriptType["ConditionMultisig"] = "condition-multisig";
+    TapscriptType["CLTVMultisig"] = "cltv-multisig";
+})(TapscriptType || (TapscriptType = {}));
+export function decodeTapscript(script) {
+    const types = [
+        MultisigTapscript,
+        CSVMultisigTapscript,
+        ConditionCSVMultisigTapscript,
+        ConditionMultisigTapscript,
+        CLTVMultisigTapscript,
+    ];
+    for (const type of types) {
+        try {
+            return type.decode(script);
+        }
+        catch (error) {
+            continue;
+        }
+    }
+    throw new Error(`Failed to decode: script ${hex.encode(script)} is not a valid tapscript`);
+}
+/**
+ * Implements a multi-signature script that requires a threshold of signatures
+ * from the specified pubkeys.
+ */
+export var MultisigTapscript;
+(function (MultisigTapscript) {
+    let MultisigType;
+    (function (MultisigType) {
+        MultisigType[MultisigType["CHECKSIG"] = 0] = "CHECKSIG";
+        MultisigType[MultisigType["CHECKSIGADD"] = 1] = "CHECKSIGADD";
+    })(MultisigType = MultisigTapscript.MultisigType || (MultisigTapscript.MultisigType = {}));
+    function encode(params) {
+        if (params.pubkeys.length === 0) {
+            throw new Error("At least 1 pubkey is required");
+        }
+        for (const pubkey of params.pubkeys) {
+            if (pubkey.length !== 32) {
+                throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
+            }
+        }
+        if (!params.type) {
+            params.type = MultisigType.CHECKSIG;
+        }
+        if (params.type === MultisigType.CHECKSIGADD) {
+            return {
+                type: TapscriptType.Multisig,
+                params,
+                script: p2tr_ms(params.pubkeys.length, params.pubkeys).script,
+                witnessSize: () => params.pubkeys.length * 64,
+            };
+        }
+        const asm = [];
+        for (let i = 0; i < params.pubkeys.length; i++) {
+            asm.push(params.pubkeys[i]);
+            // CHECKSIGVERIFY except the last pubkey
+            if (i < params.pubkeys.length - 1) {
+                asm.push("CHECKSIGVERIFY");
+            }
+            else {
+                asm.push("CHECKSIG");
+            }
+        }
+        return {
+            type: TapscriptType.Multisig,
+            params,
+            script: Script.encode(asm),
+            witnessSize: () => params.pubkeys.length * 64,
+        };
+    }
+    MultisigTapscript.encode = encode;
+    function decode(script) {
+        if (script.length === 0) {
+            throw new Error("Failed to decode: script is empty");
+        }
+        try {
+            // Try decoding as checksigAdd first
+            return decodeChecksigAdd(script);
+        }
+        catch (error) {
+            // If checksigAdd fails, try regular checksig
+            try {
+                return decodeChecksig(script);
+            }
+            catch (error2) {
+                throw new Error(`Failed to decode script: ${error2 instanceof Error ? error2.message : String(error2)}`);
+            }
+        }
+    }
+    MultisigTapscript.decode = decode;
+    // <pubkey> CHECKSIG <pubkey> CHECKSIGADD <len_keys> NUMEQUAL
+    function decodeChecksigAdd(script) {
+        const asm = Script.decode(script);
+        const pubkeys = [];
+        let foundNumEqual = false;
+        // Parse through ASM operations
+        for (let i = 0; i < asm.length; i++) {
+            const op = asm[i];
+            // If it's a data push, it should be a 32-byte pubkey
+            if (typeof op !== "string" && typeof op !== "number") {
+                if (op.length !== 32) {
+                    throw new Error(`Invalid pubkey length: expected 32, got ${op.length}`);
+                }
+                pubkeys.push(op);
+                // Check next operation is CHECKSIGADD or CHECKSIG
+                if (i + 1 >= asm.length ||
+                    (asm[i + 1] !== "CHECKSIGADD" && asm[i + 1] !== "CHECKSIG")) {
+                    throw new Error("Expected CHECKSIGADD or CHECKSIG after pubkey");
+                }
+                i++; // Skip the CHECKSIGADD op
+                continue;
+            }
+            // Last operation should be NUMEQUAL
+            if (i === asm.length - 1) {
+                if (op !== "NUMEQUAL") {
+                    throw new Error("Expected NUMEQUAL at end of script");
+                }
+                foundNumEqual = true;
+            }
+        }
+        if (!foundNumEqual) {
+            throw new Error("Missing NUMEQUAL operation");
+        }
+        if (pubkeys.length === 0) {
+            throw new Error("Invalid script: must have at least 1 pubkey");
+        }
+        // Verify the script by re-encoding and comparing
+        const reconstructed = encode({
+            pubkeys,
+            type: MultisigType.CHECKSIGADD,
+        });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.Multisig,
+            params: { pubkeys, type: MultisigType.CHECKSIGADD },
+            script,
+            witnessSize: () => pubkeys.length * 64,
+        };
+    }
+    // <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+    function decodeChecksig(script) {
+        const asm = Script.decode(script);
+        const pubkeys = [];
+        // Parse through ASM operations
+        for (let i = 0; i < asm.length; i++) {
+            const op = asm[i];
+            // If it's a data push, it should be a 32-byte pubkey
+            if (typeof op !== "string" && typeof op !== "number") {
+                if (op.length !== 32) {
+                    throw new Error(`Invalid pubkey length: expected 32, got ${op.length}`);
+                }
+                pubkeys.push(op);
+                // Check next operation
+                if (i + 1 >= asm.length) {
+                    throw new Error("Unexpected end of script");
+                }
+                const nextOp = asm[i + 1];
+                if (nextOp !== "CHECKSIGVERIFY" && nextOp !== "CHECKSIG") {
+                    throw new Error("Expected CHECKSIGVERIFY or CHECKSIG after pubkey");
+                }
+                // Last operation must be CHECKSIG, not CHECKSIGVERIFY
+                if (i === asm.length - 2 && nextOp !== "CHECKSIG") {
+                    throw new Error("Last operation must be CHECKSIG");
+                }
+                i++; // Skip the CHECKSIG/CHECKSIGVERIFY op
+                continue;
+            }
+        }
+        if (pubkeys.length === 0) {
+            throw new Error("Invalid script: must have at least 1 pubkey");
+        }
+        // Verify the script by re-encoding and comparing
+        const reconstructed = encode({ pubkeys, type: MultisigType.CHECKSIG });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.Multisig,
+            params: { pubkeys, type: MultisigType.CHECKSIG },
+            script,
+            witnessSize: () => pubkeys.length * 64,
+        };
+    }
+    function is(tapscript) {
+        return tapscript.type === TapscriptType.Multisig;
+    }
+    MultisigTapscript.is = is;
+})(MultisigTapscript || (MultisigTapscript = {}));
+/**
+ * Implements a relative timelock script that requires all specified pubkeys to sign
+ * after the relative timelock has expired. The timelock can be specified in blocks or seconds.
+ *
+ * This is the standard exit closure and it is also used for the sweep closure in vtxo trees.
+ */
+export var CSVMultisigTapscript;
+(function (CSVMultisigTapscript) {
+    function encode(params) {
+        for (const pubkey of params.pubkeys) {
+            if (pubkey.length !== 32) {
+                throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
+            }
+        }
+        const sequence = ScriptNum().encode(BigInt(bip68.encode(params.timelock.type === "blocks"
+            ? { blocks: Number(params.timelock.value) }
+            : { seconds: Number(params.timelock.value) })));
+        const asm = [sequence, "CHECKSEQUENCEVERIFY", "DROP"];
+        const multisigScript = MultisigTapscript.encode(params);
+        const script = new Uint8Array([
+            ...Script.encode(asm),
+            ...multisigScript.script,
+        ]);
+        return {
+            type: TapscriptType.CSVMultisig,
+            params,
+            script,
+            witnessSize: () => params.pubkeys.length * 64,
+        };
+    }
+    CSVMultisigTapscript.encode = encode;
+    function decode(script) {
+        if (script.length === 0) {
+            throw new Error("Failed to decode: script is empty");
+        }
+        const asm = Script.decode(script);
+        if (asm.length < 3) {
+            throw new Error(`Invalid script: too short (expected at least 3)`);
+        }
+        const sequence = asm[0];
+        if (typeof sequence === "string" || typeof sequence === "number") {
+            throw new Error("Invalid script: expected sequence number");
+        }
+        if (asm[1] !== "CHECKSEQUENCEVERIFY" || asm[2] !== "DROP") {
+            throw new Error("Invalid script: expected CHECKSEQUENCEVERIFY DROP");
+        }
+        const multisigScript = new Uint8Array(Script.encode(asm.slice(3)));
+        let multisig;
+        try {
+            multisig = MultisigTapscript.decode(multisigScript);
+        }
+        catch (error) {
+            throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const sequenceNum = Number(ScriptNum().decode(sequence));
+        const decodedTimelock = bip68.decode(sequenceNum);
+        const timelock = decodedTimelock.blocks !== undefined
+            ? { type: "blocks", value: BigInt(decodedTimelock.blocks) }
+            : { type: "seconds", value: BigInt(decodedTimelock.seconds) };
+        const reconstructed = encode({
+            timelock,
+            ...multisig.params,
+        });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.CSVMultisig,
+            params: {
+                timelock,
+                ...multisig.params,
+            },
+            script,
+            witnessSize: () => multisig.params.pubkeys.length * 64,
+        };
+    }
+    CSVMultisigTapscript.decode = decode;
+    function is(tapscript) {
+        return tapscript.type === TapscriptType.CSVMultisig;
+    }
+    CSVMultisigTapscript.is = is;
+})(CSVMultisigTapscript || (CSVMultisigTapscript = {}));
+/**
+ * Combines a condition script with an exit closure. The resulting script requires
+ * the condition to be met, followed by the standard exit closure requirements
+ * (timelock and signatures).
+ */
+export var ConditionCSVMultisigTapscript;
+(function (ConditionCSVMultisigTapscript) {
+    function encode(params) {
+        const script = new Uint8Array([
+            ...params.conditionScript,
+            ...Script.encode(["VERIFY"]),
+            ...CSVMultisigTapscript.encode(params).script,
+        ]);
+        return {
+            type: TapscriptType.ConditionCSVMultisig,
+            params,
+            script,
+            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
+        };
+    }
+    ConditionCSVMultisigTapscript.encode = encode;
+    function decode(script) {
+        if (script.length === 0) {
+            throw new Error("Failed to decode: script is empty");
+        }
+        const asm = Script.decode(script);
+        if (asm.length < 1) {
+            throw new Error(`Invalid script: too short (expected at least 1)`);
+        }
+        let verifyIndex = -1;
+        for (let i = asm.length - 1; i >= 0; i--) {
+            if (asm[i] === "VERIFY") {
+                verifyIndex = i;
+            }
+        }
+        if (verifyIndex === -1) {
+            throw new Error("Invalid script: missing VERIFY operation");
+        }
+        const conditionScript = new Uint8Array(Script.encode(asm.slice(0, verifyIndex)));
+        const csvMultisigScript = new Uint8Array(Script.encode(asm.slice(verifyIndex + 1)));
+        let csvMultisig;
+        try {
+            csvMultisig = CSVMultisigTapscript.decode(csvMultisigScript);
+        }
+        catch (error) {
+            throw new Error(`Invalid CSV multisig script: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const reconstructed = encode({
+            conditionScript,
+            ...csvMultisig.params,
+        });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.ConditionCSVMultisig,
+            params: {
+                conditionScript,
+                ...csvMultisig.params,
+            },
+            script,
+            witnessSize: (conditionSize) => conditionSize + csvMultisig.params.pubkeys.length * 64,
+        };
+    }
+    ConditionCSVMultisigTapscript.decode = decode;
+    function is(tapscript) {
+        return tapscript.type === TapscriptType.ConditionCSVMultisig;
+    }
+    ConditionCSVMultisigTapscript.is = is;
+})(ConditionCSVMultisigTapscript || (ConditionCSVMultisigTapscript = {}));
+/**
+ * Combines a condition script with a forfeit closure. The resulting script requires
+ * the condition to be met, followed by the standard forfeit closure requirements
+ * (multi-signature).
+ */
+export var ConditionMultisigTapscript;
+(function (ConditionMultisigTapscript) {
+    function encode(params) {
+        const script = new Uint8Array([
+            ...params.conditionScript,
+            ...Script.encode(["VERIFY"]),
+            ...MultisigTapscript.encode(params).script,
+        ]);
+        return {
+            type: TapscriptType.ConditionMultisig,
+            params,
+            script,
+            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
+        };
+    }
+    ConditionMultisigTapscript.encode = encode;
+    function decode(script) {
+        if (script.length === 0) {
+            throw new Error("Failed to decode: script is empty");
+        }
+        const asm = Script.decode(script);
+        if (asm.length < 1) {
+            throw new Error(`Invalid script: too short (expected at least 1)`);
+        }
+        let verifyIndex = -1;
+        for (let i = asm.length - 1; i >= 0; i--) {
+            if (asm[i] === "VERIFY") {
+                verifyIndex = i;
+            }
+        }
+        if (verifyIndex === -1) {
+            throw new Error("Invalid script: missing VERIFY operation");
+        }
+        const conditionScript = new Uint8Array(Script.encode(asm.slice(0, verifyIndex)));
+        const multisigScript = new Uint8Array(Script.encode(asm.slice(verifyIndex + 1)));
+        let multisig;
+        try {
+            multisig = MultisigTapscript.decode(multisigScript);
+        }
+        catch (error) {
+            throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const reconstructed = encode({
+            conditionScript,
+            ...multisig.params,
+        });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.ConditionMultisig,
+            params: {
+                conditionScript,
+                ...multisig.params,
+            },
+            script,
+            witnessSize: (conditionSize) => conditionSize + multisig.params.pubkeys.length * 64,
+        };
+    }
+    ConditionMultisigTapscript.decode = decode;
+    function is(tapscript) {
+        return tapscript.type === TapscriptType.ConditionMultisig;
+    }
+    ConditionMultisigTapscript.is = is;
+})(ConditionMultisigTapscript || (ConditionMultisigTapscript = {}));
+/**
+ * Implements an absolute timelock (CLTV) script combined with a forfeit closure.
+ * The script requires waiting until a specific block height/timestamp before the
+ * forfeit closure conditions can be met.
+ */
+export var CLTVMultisigTapscript;
+(function (CLTVMultisigTapscript) {
+    function encode(params) {
+        const locktime = ScriptNum().encode(params.absoluteTimelock);
+        const asm = [locktime, "CHECKLOCKTIMEVERIFY", "DROP"];
+        const timelockedScript = Script.encode(asm);
+        const script = new Uint8Array([
+            ...timelockedScript,
+            ...MultisigTapscript.encode(params).script,
+        ]);
+        return {
+            type: TapscriptType.CLTVMultisig,
+            params,
+            script,
+            witnessSize: () => params.pubkeys.length * 64,
+        };
+    }
+    CLTVMultisigTapscript.encode = encode;
+    function decode(script) {
+        if (script.length === 0) {
+            throw new Error("Failed to decode: script is empty");
+        }
+        const asm = Script.decode(script);
+        if (asm.length < 3) {
+            throw new Error(`Invalid script: too short (expected at least 3)`);
+        }
+        const locktime = asm[0];
+        if (typeof locktime === "string" || typeof locktime === "number") {
+            throw new Error("Invalid script: expected locktime number");
+        }
+        if (asm[1] !== "CHECKLOCKTIMEVERIFY" || asm[2] !== "DROP") {
+            throw new Error("Invalid script: expected CHECKLOCKTIMEVERIFY DROP");
+        }
+        const multisigScript = new Uint8Array(Script.encode(asm.slice(3)));
+        let multisig;
+        try {
+            multisig = MultisigTapscript.decode(multisigScript);
+        }
+        catch (error) {
+            throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const absoluteTimelock = ScriptNum().decode(locktime);
+        const reconstructed = encode({
+            absoluteTimelock,
+            ...multisig.params,
+        });
+        if (hex.encode(reconstructed.script) !== hex.encode(script)) {
+            throw new Error("Invalid script format: script reconstruction mismatch");
+        }
+        return {
+            type: TapscriptType.CLTVMultisig,
+            params: {
+                absoluteTimelock,
+                ...multisig.params,
+            },
+            script,
+            witnessSize: () => multisig.params.pubkeys.length * 64,
+        };
+    }
+    CLTVMultisigTapscript.decode = decode;
+    function is(tapscript) {
+        return tapscript.type === TapscriptType.CLTVMultisig;
+    }
+    CLTVMultisigTapscript.is = is;
+})(CLTVMultisigTapscript || (CLTVMultisigTapscript = {}));

package/dist/esm/script/vhtlc.js

@@ -0,0 +1,81 @@
+import { Script } from "@scure/btc-signer";
+import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, MultisigTapscript, } from './tapscript.js';
+import { hex } from "@scure/base";
+import { VtxoScript } from './base.js';
+// VHTLC is an Hashed Timelock Contract VtxoScript implementation
+// - claim (preimage + receiver)
+// - refund (sender + receiver + server)
+// - refundWithoutReceiver (at refundLocktime, sender + receiver + server)
+// - unilateralClaim (preimage + receiver after unilateralClaimDelay)
+// - unilateralRefund (sender + receiver after unilateralRefundDelay)
+// - unilateralRefundWithoutReceiver (sender after unilateralRefundWithoutReceiverDelay)
+export var VHTLC;
+(function (VHTLC) {
+    class Script extends VtxoScript {
+        constructor(options) {
+            const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
+            const conditionScript = preimageConditionScript(preimageHash);
+            const claimScript = ConditionMultisigTapscript.encode({
+                conditionScript,
+                pubkeys: [receiver, server],
+            }).script;
+            const refundScript = MultisigTapscript.encode({
+                pubkeys: [sender, receiver, server],
+            }).script;
+            const refundWithoutReceiverScript = CLTVMultisigTapscript.encode({
+                absoluteTimelock: refundLocktime,
+                pubkeys: [sender, server],
+            }).script;
+            const unilateralClaimScript = ConditionCSVMultisigTapscript.encode({
+                conditionScript,
+                timelock: unilateralClaimDelay,
+                pubkeys: [receiver],
+            }).script;
+            const unilateralRefundScript = CSVMultisigTapscript.encode({
+                timelock: unilateralRefundDelay,
+                pubkeys: [sender, receiver],
+            }).script;
+            const unilateralRefundWithoutReceiverScript = CSVMultisigTapscript.encode({
+                timelock: unilateralRefundWithoutReceiverDelay,
+                pubkeys: [sender],
+            }).script;
+            super([
+                claimScript,
+                refundScript,
+                refundWithoutReceiverScript,
+                unilateralClaimScript,
+                unilateralRefundScript,
+                unilateralRefundWithoutReceiverScript,
+            ]);
+            this.options = options;
+            this.claimScript = hex.encode(claimScript);
+            this.refundScript = hex.encode(refundScript);
+            this.refundWithoutReceiverScript = hex.encode(refundWithoutReceiverScript);
+            this.unilateralClaimScript = hex.encode(unilateralClaimScript);
+            this.unilateralRefundScript = hex.encode(unilateralRefundScript);
+            this.unilateralRefundWithoutReceiverScript = hex.encode(unilateralRefundWithoutReceiverScript);
+        }
+        claim() {
+            return this.findLeaf(this.claimScript);
+        }
+        refund() {
+            return this.findLeaf(this.refundScript);
+        }
+        refundWithoutReceiver() {
+            return this.findLeaf(this.refundWithoutReceiverScript);
+        }
+        unilateralClaim() {
+            return this.findLeaf(this.unilateralClaimScript);
+        }
+        unilateralRefund() {
+            return this.findLeaf(this.unilateralRefundScript);
+        }
+        unilateralRefundWithoutReceiver() {
+            return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
+        }
+    }
+    VHTLC.Script = Script;
+})(VHTLC || (VHTLC = {}));
+function preimageConditionScript(preimageHash) {
+    return Script.encode(["HASH160", preimageHash, "EQUAL"]);
+}