@arkade-os/sdk 0.4.27 → 0.4.29

package/dist/esm/script/base.js

@@ -1,179 +0,0 @@
-import { Script, Address, p2tr, taprootListToTree, TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer";
-import { TAP_LEAF_VERSION } from "@scure/btc-signer/payment.js";
-import { PSBTOutput } from "@scure/btc-signer/psbt.js";
-import { hex } from "@scure/base";
-import { ArkAddress } from "./address.js";
-import { timelockToSequence } from "../utils/timelock.js";
-import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from "./tapscript.js";
-export const TapTreeCoder = PSBTOutput.tapTree[2];
-export function scriptFromTapLeafScript(leaf) {
-    return leaf[1].subarray(0, leaf[1].length - 1); // remove the version byte
-}
-/**
- * VtxoScript is a script that contains a list of tapleaf scripts.
- * It is used to create virtual output scripts.
- *
- * @see ArkAddress
- *
- * @example
- * ```typescript
- * const vtxoScript = new VtxoScript([new Uint8Array(32), new Uint8Array(32)]);
- * ```
- */
-export class VtxoScript {
-    /**
-     * Decode a virtual output script from an encoded TapTree.
-     *
-     * @param tapTree - Encoded TapTree bytes
-     * @returns Decoded virtual output script
-     * @throws Error if the TapTree cannot be decoded into a valid script set
-     * @see encode
-     */
-    static decode(tapTree) {
-        const leaves = TapTreeCoder.decode(tapTree);
-        const scripts = leaves.map((leaf) => leaf.script);
-        return new VtxoScript(scripts);
-    }
-    /**
-     * Create a virtual output script from its tapleaf scripts.
-     *
-     * @param scripts - Raw tapscript bytes for each leaf
-     * @throws Error if the provided leaves cannot produce a valid Taproot tree
-     */
-    constructor(scripts) {
-        this.scripts = scripts;
-        // reverse the scripts if the number of scripts is odd
-        // this is to be compatible with arkd algorithm computing taproot tree from list of tapscripts
-        // the scripts must be reversed only HERE while we compute the tweaked public key
-        // but the original order should be preserved while encoding as taptree
-        // note: .slice().reverse() is used instead of .reverse() to avoid mutating the original array
-        const list = scripts.length % 2 !== 0 ? scripts.slice().reverse() : scripts;
-        const tapTree = taprootListToTree(list.map((script) => ({
-            script,
-            leafVersion: TAP_LEAF_VERSION,
-        })));
-        const payment = p2tr(TAPROOT_UNSPENDABLE_KEY, tapTree, undefined, true);
-        if (!payment.tapLeafScript ||
-            payment.tapLeafScript.length !== scripts.length) {
-            throw new Error("invalid scripts");
-        }
-        this.leaves = payment.tapLeafScript;
-        this.tweakedPublicKey = payment.tweakedPubkey;
-    }
-    /**
-     * Encode the virtual output script to a TapTree byte representation.
-     *
-     * @returns Encoded TapTree bytes
-     * @see decode
-     */
-    encode() {
-        const tapTree = TapTreeCoder.encode(this.scripts.map((script) => ({
-            depth: 1,
-            version: TAP_LEAF_VERSION,
-            script,
-        })));
-        return tapTree;
-    }
-    /**
-     * Build the Arkade address corresponding to this virtual output script.
-     *
-     * @param prefix - Bech32 human-readable prefix
-     * @param serverPubKey - 32-byte Arkade server public key
-     * @returns Arkade address for this script
-     * @see ArkAddress
-     */
-    address(prefix, serverPubKey) {
-        return new ArkAddress(serverPubKey, this.tweakedPublicKey, prefix);
-    }
-    get pkScript() {
-        return Script.encode(["OP_1", this.tweakedPublicKey]);
-    }
-    /**
-     * Build the Taproot onchain address corresponding to this virtual output script.
-     *
-     * @param network - Bitcoin network descriptor
-     * @returns Taproot onchain address
-     * @see address
-     */
-    onchainAddress(network) {
-        return Address(network).encode({
-            type: "tr",
-            pubkey: this.tweakedPublicKey,
-        });
-    }
-    /**
-     * Look up a tapleaf script by its hex-encoded tapscript body.
-     *
-     * @param scriptHex - Hex-encoded tapscript body without the leaf version byte
-     * @returns Matching tapleaf script
-     * @throws Error if no matching leaf exists
-     */
-    findLeaf(scriptHex) {
-        const leaf = this.leaves.find((leaf) => hex.encode(scriptFromTapLeafScript(leaf)) === scriptHex);
-        if (!leaf) {
-            throw new Error(`leaf '${scriptHex}' not found`);
-        }
-        return leaf;
-    }
-    /**
-     * Return all unilateral exit paths embedded in the virtual output script.
-     *
-     * @returns CSV-based exit paths found in the leaves
-     * @see getSequence
-     */
-    exitPaths() {
-        const paths = [];
-        for (const leaf of this.leaves) {
-            try {
-                const script = scriptFromTapLeafScript(leaf);
-                if (CSVMultisigTapscript.isScriptValid(script) === true) {
-                    const tapScript = CSVMultisigTapscript.decode(script);
-                    paths.push(tapScript);
-                }
-                else if (ConditionCSVMultisigTapscript.isScriptValid(script) === true) {
-                    const tapScript = ConditionCSVMultisigTapscript.decode(script);
-                    paths.push(tapScript);
-                }
-            }
-            catch (e) {
-                console.debug("Failed to decode script", e);
-            }
-        }
-        return paths;
-    }
-}
-/**
- * Extract the timelock value encoded in a timelocked tapleaf, if any.
- *
- * The return value is unit-ambiguous: for a CSV leaf it is a BIP-68
- * nSequence (relative timelock); for a CLTV leaf it is an absolute
- * nLockTime. Callers must know which leaf shape they are inspecting to
- * interpret the number correctly, and must not copy a CSV result into
- * `Transaction.lockTime` (or vice versa).
- *
- * @param tapLeafScript - Tapleaf script to inspect
- * @returns The encoded timelock value, or `undefined` when neither a CSV
- *          nor CLTV path is present
- * @see VtxoScript.exitPaths
- */
-// TODO(next-major): return a discriminated union
-// (`{ kind: "relative", nSequence } | { kind: "absolute", lockTime }`)
-// so callers can't conflate the two. Deferred because changing the
-// return type is a breaking change.
-export function getSequence(tapLeafScript) {
-    let sequence = undefined;
-    try {
-        const scriptWithLeafVersion = tapLeafScript[1];
-        const script = scriptWithLeafVersion.subarray(0, scriptWithLeafVersion.length - 1);
-        try {
-            const params = CSVMultisigTapscript.decode(script).params;
-            sequence = timelockToSequence(params.timelock);
-        }
-        catch {
-            const params = CLTVMultisigTapscript.decode(script).params;
-            sequence = Number(params.absoluteTimelock);
-        }
-    }
-    catch { }
-    return sequence;
-}

package/dist/esm/script/default.js

@@ -1,54 +0,0 @@
-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) {
-    /**
-     * DefaultVtxo.Script is the class letting to create the vtxo script.
-     * @example
-     * ```typescript
-     * const vtxoScript = new DefaultVtxo.Script({
-     *     pubKey: new Uint8Array(32),
-     *     serverPubKey: new Uint8Array(32),
-     * });
-     *
-     * console.log("script pub key:", vtxoScript.pkScript)
-     * ```
-     */
-    class Script extends VtxoScript {
-        /** Create the default virtual output script with one forfeit path and one exit path. */
-        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);
-        }
-        /** Return the forfeit tapleaf script. */
-        forfeit() {
-            return this.findLeaf(this.forfeitScript);
-        }
-        /** Return the unilateral exit tapleaf script. */
-        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/delegate.js

@@ -1,50 +0,0 @@
-import { DefaultVtxo } from "./default.js";
-import { MultisigTapscript } from "./tapscript.js";
-import { VtxoScript } from "./base.js";
-import { hex } from "@scure/base";
-/**
- * DelegateVtxo extends DefaultVtxo with an extra delegator path
- */
-export var DelegateVtxo;
-(function (DelegateVtxo) {
-    /**
-     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
-     * @example
-     * ```typescript
-     * const vtxoScript = new DelegateVtxo.Script({
-     *     pubKey: new Uint8Array(32),
-     *     serverPubKey: new Uint8Array(32),
-     *     delegatePubKey: new Uint8Array(32),
-     * });
-     *
-     * console.log("script pub key:", vtxoScript.pkScript)
-     * ```
-     */
-    class Script extends VtxoScript {
-        /** Create a delegated virtual output script with forfeit, exit, and delegate paths. */
-        constructor(options) {
-            const defaultVtxo = new DefaultVtxo.Script(options);
-            const { delegatePubKey, pubKey, serverPubKey } = options;
-            const delegateScript = MultisigTapscript.encode({
-                pubkeys: [pubKey, delegatePubKey, serverPubKey],
-            }).script;
-            super([...defaultVtxo.scripts, delegateScript]);
-            this.options = options;
-            this.defaultVtxo = defaultVtxo;
-            this.delegateScript = hex.encode(delegateScript);
-        }
-        /** Return the forfeit tapleaf script. */
-        forfeit() {
-            return this.findLeaf(this.defaultVtxo.forfeitScript);
-        }
-        /** Return the unilateral exit tapleaf script. */
-        exit() {
-            return this.findLeaf(this.defaultVtxo.exitScript);
-        }
-        /** Return the delegate tapleaf script. */
-        delegate() {
-            return this.findLeaf(this.delegateScript);
-        }
-    }
-    DelegateVtxo.Script = Script;
-})(DelegateVtxo || (DelegateVtxo = {}));