@arkade-os/sdk 0.0.16

package/dist/cjs/tree/signingSession.js

@@ -0,0 +1,238 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSignerSession = exports.ErrMissingAggregateKey = exports.ErrMissingVtxoTree = void 0;
+exports.validateTreeSigs = validateTreeSigs;
+const musig2 = __importStar(require("../musig2"));
+const vtxoTree_1 = require("./vtxoTree");
+const btc_signer_1 = require("@scure/btc-signer");
+const base_1 = require("@scure/base");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const utils_1 = require("@scure/btc-signer/utils");
+exports.ErrMissingVtxoTree = new Error("missing vtxo tree");
+exports.ErrMissingAggregateKey = new Error("missing aggregate key");
+class TreeSignerSession {
+    constructor(secretKey) {
+        this.secretKey = secretKey;
+        this.myNonces = null;
+        this.aggregateNonces = null;
+        this.tree = null;
+        this.scriptRoot = null;
+        this.rootSharedOutputAmount = null;
+    }
+    static random() {
+        const secretKey = (0, utils_1.randomPrivateKeyBytes)();
+        return new TreeSignerSession(secretKey);
+    }
+    init(tree, scriptRoot, rootInputAmount) {
+        this.tree = tree;
+        this.scriptRoot = scriptRoot;
+        this.rootSharedOutputAmount = rootInputAmount;
+    }
+    getPublicKey() {
+        return secp256k1_1.secp256k1.getPublicKey(this.secretKey);
+    }
+    getNonces() {
+        if (!this.tree)
+            throw exports.ErrMissingVtxoTree;
+        if (!this.myNonces) {
+            this.myNonces = this.generateNonces();
+        }
+        const nonces = [];
+        for (const levelNonces of this.myNonces) {
+            const levelPubNonces = [];
+            for (const nonce of levelNonces) {
+                if (!nonce) {
+                    levelPubNonces.push(null);
+                    continue;
+                }
+                levelPubNonces.push({ pubNonce: nonce.pubNonce });
+            }
+            nonces.push(levelPubNonces);
+        }
+        return nonces;
+    }
+    setAggregatedNonces(nonces) {
+        if (this.aggregateNonces)
+            throw new Error("nonces already set");
+        this.aggregateNonces = nonces;
+    }
+    sign() {
+        if (!this.tree)
+            throw exports.ErrMissingVtxoTree;
+        if (!this.aggregateNonces)
+            throw new Error("nonces not set");
+        if (!this.myNonces)
+            throw new Error("nonces not generated");
+        const sigs = [];
+        for (let levelIndex = 0; levelIndex < this.tree.levels.length; levelIndex++) {
+            const levelSigs = [];
+            const level = this.tree.levels[levelIndex];
+            for (let nodeIndex = 0; nodeIndex < level.length; nodeIndex++) {
+                const node = level[nodeIndex];
+                const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(node.tx));
+                const sig = this.signPartial(tx, levelIndex, nodeIndex);
+                if (sig) {
+                    levelSigs.push(sig);
+                }
+                else {
+                    levelSigs.push(null);
+                }
+            }
+            sigs.push(levelSigs);
+        }
+        return sigs;
+    }
+    generateNonces() {
+        if (!this.tree)
+            throw exports.ErrMissingVtxoTree;
+        const myNonces = [];
+        const publicKey = secp256k1_1.secp256k1.getPublicKey(this.secretKey);
+        for (const level of this.tree.levels) {
+            const levelNonces = [];
+            for (let i = 0; i < level.length; i++) {
+                const nonces = musig2.generateNonces(publicKey);
+                levelNonces.push(nonces);
+            }
+            myNonces.push(levelNonces);
+        }
+        return myNonces;
+    }
+    signPartial(tx, levelIndex, nodeIndex) {
+        if (!this.tree || !this.scriptRoot || !this.rootSharedOutputAmount) {
+            throw TreeSignerSession.NOT_INITIALIZED;
+        }
+        if (!this.myNonces || !this.aggregateNonces) {
+            throw new Error("session not properly initialized");
+        }
+        const myNonce = this.myNonces[levelIndex][nodeIndex];
+        if (!myNonce)
+            return null;
+        const aggNonce = this.aggregateNonces[levelIndex][nodeIndex];
+        if (!aggNonce)
+            throw new Error("missing aggregate nonce");
+        const prevoutAmounts = [];
+        const prevoutScripts = [];
+        const cosigners = (0, vtxoTree_1.getCosignerKeys)(tx);
+        const { finalKey } = musig2.aggregateKeys(cosigners, true, {
+            taprootTweak: this.scriptRoot,
+        });
+        for (let inputIndex = 0; inputIndex < tx.inputsLength; inputIndex++) {
+            const prevout = getPrevOutput(finalKey, this.tree, this.rootSharedOutputAmount, tx);
+            prevoutAmounts.push(prevout.amount);
+            prevoutScripts.push(prevout.script);
+        }
+        const message = tx.preimageWitnessV1(0, // always first input
+        prevoutScripts, btc_signer_1.SigHash.DEFAULT, prevoutAmounts);
+        return musig2.sign(myNonce.secNonce, this.secretKey, aggNonce.pubNonce, cosigners, message, {
+            taprootTweak: this.scriptRoot,
+            sortKeys: true,
+        });
+    }
+}
+exports.TreeSignerSession = TreeSignerSession;
+TreeSignerSession.NOT_INITIALIZED = new Error("session not initialized, call init method");
+// Helper function to validate tree signatures
+async function validateTreeSigs(finalAggregatedKey, sharedOutputAmount, vtxoTree) {
+    // Iterate through each level of the tree
+    for (const level of vtxoTree.levels) {
+        for (const node of level) {
+            // Parse the transaction
+            const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(node.tx));
+            const input = tx.getInput(0);
+            // Check if input has signature
+            if (!input.tapKeySig) {
+                throw new Error("unsigned tree input");
+            }
+            // Get the previous output information
+            const prevout = getPrevOutput(finalAggregatedKey, vtxoTree, sharedOutputAmount, tx);
+            // Calculate the message that was signed
+            const message = tx.preimageWitnessV1(0, // always first input
+            [prevout.script], btc_signer_1.SigHash.DEFAULT, [prevout.amount]);
+            // Verify the signature
+            const isValid = secp256k1_1.schnorr.verify(input.tapKeySig, message, finalAggregatedKey);
+            if (!isValid) {
+                throw new Error("invalid signature");
+            }
+        }
+    }
+}
+function getPrevOutput(finalKey, vtxoTree, sharedOutputAmount, partial) {
+    // Generate P2TR script
+    const pkScript = btc_signer_1.Script.encode(["OP_1", finalKey.slice(1)]);
+    // Get root node
+    const rootNode = vtxoTree.levels[0][0];
+    if (!rootNode)
+        throw new Error("empty vtxo tree");
+    const input = partial.getInput(0);
+    if (!input.txid)
+        throw new Error("missing input txid");
+    const parentTxID = base_1.hex.encode(input.txid);
+    // Check if parent is root
+    if (rootNode.parentTxid === parentTxID) {
+        return {
+            amount: sharedOutputAmount,
+            script: pkScript,
+        };
+    }
+    // Search for parent in tree
+    let parent = null;
+    for (const level of vtxoTree.levels) {
+        for (const node of level) {
+            if (node.txid === parentTxID) {
+                parent = node;
+                break;
+            }
+        }
+        if (parent)
+            break;
+    }
+    if (!parent) {
+        throw new Error("parent tx not found");
+    }
+    // Parse parent tx
+    const parentTx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(parent.tx));
+    if (!input.index)
+        throw new Error("missing input index");
+    const parentOutput = parentTx.getOutput(input.index);
+    if (!parentOutput)
+        throw new Error("parent output not found");
+    if (!parentOutput.amount)
+        throw new Error("parent output amount not found");
+    return {
+        amount: parentOutput.amount,
+        script: pkScript,
+    };
+}

package/dist/cjs/tree/validation.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrInvalidNodeTransaction = exports.ErrInvalidRootTransaction = exports.ErrInvalidControlBlock = exports.ErrInternalKey = exports.ErrInvalidTaprootScript = exports.ErrLeafChildren = exports.ErrParentTxidInput = exports.ErrNodeTxidDifferent = exports.ErrNodeParentTxidEmpty = exports.ErrNodeTxidEmpty = exports.ErrNodeTxEmpty = exports.ErrNoLeaves = exports.ErrInvalidAmount = exports.ErrWrongSettlementTxid = exports.ErrNumberOfInputs = exports.ErrInvalidRootLevel = exports.ErrEmptyTree = exports.ErrInvalidSettlementTxOutputs = exports.ErrInvalidSettlementTx = void 0;
+exports.validateConnectorsTree = validateConnectorsTree;
+exports.validateVtxoTree = validateVtxoTree;
+const base_1 = require("@scure/base");
+const btc_signer_1 = require("@scure/btc-signer");
+const base_2 = require("@scure/base");
+const utils_1 = require("@scure/btc-signer/utils");
+const musig2_1 = require("../musig2");
+const vtxoTree_1 = require("./vtxoTree");
+exports.ErrInvalidSettlementTx = new vtxoTree_1.TxTreeError("invalid settlement transaction");
+exports.ErrInvalidSettlementTxOutputs = new vtxoTree_1.TxTreeError("invalid settlement transaction outputs");
+exports.ErrEmptyTree = new vtxoTree_1.TxTreeError("empty tree");
+exports.ErrInvalidRootLevel = new vtxoTree_1.TxTreeError("invalid root level");
+exports.ErrNumberOfInputs = new vtxoTree_1.TxTreeError("invalid number of inputs");
+exports.ErrWrongSettlementTxid = new vtxoTree_1.TxTreeError("wrong settlement txid");
+exports.ErrInvalidAmount = new vtxoTree_1.TxTreeError("invalid amount");
+exports.ErrNoLeaves = new vtxoTree_1.TxTreeError("no leaves");
+exports.ErrNodeTxEmpty = new vtxoTree_1.TxTreeError("node transaction empty");
+exports.ErrNodeTxidEmpty = new vtxoTree_1.TxTreeError("node txid empty");
+exports.ErrNodeParentTxidEmpty = new vtxoTree_1.TxTreeError("node parent txid empty");
+exports.ErrNodeTxidDifferent = new vtxoTree_1.TxTreeError("node txid different");
+exports.ErrParentTxidInput = new vtxoTree_1.TxTreeError("parent txid input mismatch");
+exports.ErrLeafChildren = new vtxoTree_1.TxTreeError("leaf node has children");
+exports.ErrInvalidTaprootScript = new vtxoTree_1.TxTreeError("invalid taproot script");
+exports.ErrInternalKey = new vtxoTree_1.TxTreeError("invalid internal key");
+exports.ErrInvalidControlBlock = new vtxoTree_1.TxTreeError("invalid control block");
+exports.ErrInvalidRootTransaction = new vtxoTree_1.TxTreeError("invalid root transaction");
+exports.ErrInvalidNodeTransaction = new vtxoTree_1.TxTreeError("invalid node transaction");
+const SHARED_OUTPUT_INDEX = 0;
+const CONNECTORS_OUTPUT_INDEX = 1;
+function validateConnectorsTree(settlementTxB64, connectorsTree) {
+    connectorsTree.validate();
+    const rootNode = connectorsTree.root();
+    if (!rootNode)
+        throw exports.ErrEmptyTree;
+    const rootTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(rootNode.tx));
+    if (rootTx.inputsLength !== 1)
+        throw exports.ErrNumberOfInputs;
+    const rootInput = rootTx.getInput(0);
+    const settlementTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(settlementTxB64));
+    if (settlementTx.outputsLength <= CONNECTORS_OUTPUT_INDEX)
+        throw exports.ErrInvalidSettlementTxOutputs;
+    const expectedRootTxid = base_1.hex.encode((0, utils_1.sha256x2)(settlementTx.toBytes(true)).reverse());
+    if (!rootInput.txid)
+        throw exports.ErrWrongSettlementTxid;
+    if (base_1.hex.encode(rootInput.txid) !== expectedRootTxid)
+        throw exports.ErrWrongSettlementTxid;
+    if (rootInput.index !== CONNECTORS_OUTPUT_INDEX)
+        throw exports.ErrWrongSettlementTxid;
+}
+function validateVtxoTree(settlementTx, vtxoTree, sweepTapTreeRoot) {
+    vtxoTree.validate();
+    // Parse settlement transaction
+    let settlementTransaction;
+    try {
+        settlementTransaction = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(settlementTx));
+    }
+    catch {
+        throw exports.ErrInvalidSettlementTx;
+    }
+    if (settlementTransaction.outputsLength <= SHARED_OUTPUT_INDEX) {
+        throw exports.ErrInvalidSettlementTxOutputs;
+    }
+    const sharedOutput = settlementTransaction.getOutput(SHARED_OUTPUT_INDEX);
+    if (!sharedOutput?.amount)
+        throw exports.ErrInvalidSettlementTxOutputs;
+    const sharedOutputAmount = sharedOutput.amount;
+    const nbNodes = vtxoTree.numberOfNodes();
+    if (nbNodes === 0) {
+        throw exports.ErrEmptyTree;
+    }
+    if (vtxoTree.levels[0].length !== 1) {
+        throw exports.ErrInvalidRootLevel;
+    }
+    // Check root input is connected to settlement tx
+    const rootNode = vtxoTree.levels[0][0];
+    let rootTx;
+    try {
+        rootTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(rootNode.tx));
+    }
+    catch {
+        throw exports.ErrInvalidRootTransaction;
+    }
+    if (rootTx.inputsLength !== 1) {
+        throw exports.ErrNumberOfInputs;
+    }
+    const rootInput = rootTx.getInput(0);
+    if (!rootInput.txid || rootInput.index === undefined)
+        throw exports.ErrWrongSettlementTxid;
+    const settlementTxid = base_1.hex.encode((0, utils_1.sha256x2)(settlementTransaction.toBytes(true)).reverse());
+    if (base_1.hex.encode(rootInput.txid) !== settlementTxid ||
+        rootInput.index !== SHARED_OUTPUT_INDEX) {
+        throw exports.ErrWrongSettlementTxid;
+    }
+    // Check root output amounts
+    let sumRootValue = 0n;
+    for (let i = 0; i < rootTx.outputsLength; i++) {
+        const output = rootTx.getOutput(i);
+        if (!output?.amount)
+            continue;
+        sumRootValue += output.amount;
+    }
+    if (sumRootValue >= sharedOutputAmount) {
+        throw exports.ErrInvalidAmount;
+    }
+    if (vtxoTree.leaves().length === 0) {
+        throw exports.ErrNoLeaves;
+    }
+    // Validate each node in the tree
+    for (const level of vtxoTree.levels) {
+        for (const node of level) {
+            validateNode(vtxoTree, node, sweepTapTreeRoot);
+        }
+    }
+}
+function validateNode(vtxoTree, node, tapTreeRoot) {
+    if (!node.tx)
+        throw exports.ErrNodeTxEmpty;
+    if (!node.txid)
+        throw exports.ErrNodeTxidEmpty;
+    if (!node.parentTxid)
+        throw exports.ErrNodeParentTxidEmpty;
+    // Parse node transaction
+    let tx;
+    try {
+        tx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(node.tx));
+    }
+    catch {
+        throw exports.ErrInvalidNodeTransaction;
+    }
+    const txid = base_1.hex.encode((0, utils_1.sha256x2)(tx.toBytes(true)).reverse());
+    if (txid !== node.txid) {
+        throw exports.ErrNodeTxidDifferent;
+    }
+    if (tx.inputsLength !== 1) {
+        throw exports.ErrNumberOfInputs;
+    }
+    const input = tx.getInput(0);
+    if (!input.txid)
+        throw exports.ErrParentTxidInput;
+    if (base_1.hex.encode(input.txid) !== node.parentTxid) {
+        throw exports.ErrParentTxidInput;
+    }
+    const children = vtxoTree.children(node.txid);
+    if (node.leaf && children.length >= 1) {
+        throw exports.ErrLeafChildren;
+    }
+    // Validate each child
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+        const child = children[childIndex];
+        const childTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(child.tx));
+        const parentOutput = tx.getOutput(childIndex);
+        if (!parentOutput?.script)
+            throw exports.ErrInvalidTaprootScript;
+        const previousScriptKey = parentOutput.script.slice(2);
+        if (previousScriptKey.length !== 32) {
+            throw exports.ErrInvalidTaprootScript;
+        }
+        // Get cosigner keys from input
+        const cosignerKeys = (0, vtxoTree_1.getCosignerKeys)(childTx);
+        // Aggregate keys
+        const { finalKey } = (0, musig2_1.aggregateKeys)(cosignerKeys, true, {
+            taprootTweak: tapTreeRoot,
+        });
+        if (base_1.hex.encode(finalKey) !== base_1.hex.encode(previousScriptKey.slice(2))) {
+            throw exports.ErrInternalKey;
+        }
+        // Check amounts
+        let sumChildAmount = 0n;
+        for (let i = 0; i < childTx.outputsLength; i++) {
+            const output = childTx.getOutput(i);
+            if (!output?.amount)
+                continue;
+            sumChildAmount += output.amount;
+        }
+        if (!parentOutput.amount)
+            throw exports.ErrInvalidAmount;
+        if (sumChildAmount >= parentOutput.amount) {
+            throw exports.ErrInvalidAmount;
+        }
+    }
+}

package/dist/cjs/tree/vtxoTree.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxTree = exports.ErrParentNotFound = exports.ErrLeafNotFound = exports.TxTreeError = void 0;
+exports.getVtxoTreeExpiry = getVtxoTreeExpiry;
+exports.getCosignerKeys = getCosignerKeys;
+const bip68 = __importStar(require("bip68"));
+const btc_signer_1 = require("@scure/btc-signer");
+const utils_1 = require("@scure/btc-signer/utils");
+const base_1 = require("@scure/base");
+class TxTreeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TxTreeError";
+    }
+}
+exports.TxTreeError = TxTreeError;
+exports.ErrLeafNotFound = new TxTreeError("leaf not found in tx tree");
+exports.ErrParentNotFound = new TxTreeError("parent not found");
+// TxTree is represented as a matrix of Node objects
+// the first level of the matrix is the root of the tree
+class TxTree {
+    constructor(tree) {
+        this.tree = tree;
+    }
+    get levels() {
+        return this.tree;
+    }
+    // Returns the root node of the vtxo tree
+    root() {
+        if (this.tree.length <= 0 || this.tree[0].length <= 0) {
+            throw new TxTreeError("empty vtxo tree");
+        }
+        return this.tree[0][0];
+    }
+    // Returns the leaves of the vtxo tree
+    leaves() {
+        const leaves = [...this.tree[this.tree.length - 1]];
+        // Check other levels for leaf nodes
+        for (let i = 0; i < this.tree.length - 1; i++) {
+            for (const node of this.tree[i]) {
+                if (node.leaf) {
+                    leaves.push(node);
+                }
+            }
+        }
+        return leaves;
+    }
+    // Returns all nodes that have the given node as parent
+    children(nodeTxid) {
+        const children = [];
+        for (const level of this.tree) {
+            for (const node of level) {
+                if (node.parentTxid === nodeTxid) {
+                    children.push(node);
+                }
+            }
+        }
+        return children;
+    }
+    // Returns the total number of nodes in the vtxo tree
+    numberOfNodes() {
+        return this.tree.reduce((count, level) => count + level.length, 0);
+    }
+    // Returns the branch of the given vtxo txid from root to leaf
+    branch(vtxoTxid) {
+        const branch = [];
+        const leaves = this.leaves();
+        // Check if the vtxo is a leaf
+        const leaf = leaves.find((leaf) => leaf.txid === vtxoTxid);
+        if (!leaf) {
+            throw exports.ErrLeafNotFound;
+        }
+        branch.push(leaf);
+        const rootTxid = this.root().txid;
+        while (branch[0].txid !== rootTxid) {
+            const parent = this.findParent(branch[0]);
+            branch.unshift(parent);
+        }
+        return branch;
+    }
+    // Helper method to find parent of a node
+    findParent(node) {
+        for (const level of this.tree) {
+            for (const potentialParent of level) {
+                if (potentialParent.txid === node.parentTxid) {
+                    return potentialParent;
+                }
+            }
+        }
+        throw exports.ErrParentNotFound;
+    }
+    // Validates that the tree is coherent by checking txids and parent relationships
+    validate() {
+        // Skip the root level, validate from level 1 onwards
+        for (let i = 1; i < this.tree.length; i++) {
+            for (const node of this.tree[i]) {
+                // Verify that the node's transaction matches its claimed txid
+                const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(node.tx));
+                const txid = base_1.hex.encode((0, utils_1.sha256x2)(tx.toBytes(true)).reverse());
+                if (txid !== node.txid) {
+                    throw new TxTreeError(`node ${node.txid} has txid ${node.txid}, but computed txid is ${txid}`);
+                }
+                // Verify that the node has a valid parent
+                try {
+                    this.findParent(node);
+                }
+                catch (err) {
+                    throw new TxTreeError(`node ${node.txid} has no parent: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }
+    }
+}
+exports.TxTree = TxTree;
+const COSIGNER_KEY_PREFIX = new Uint8Array("cosigner".split("").map((c) => c.charCodeAt(0)));
+const VTXO_TREE_EXPIRY_PSBT_KEY = new Uint8Array("expiry".split("").map((c) => c.charCodeAt(0)));
+function getVtxoTreeExpiry(input) {
+    if (!input.unknown)
+        return null;
+    for (const u of input.unknown) {
+        // Check if key contains the VTXO tree expiry key
+        if (u.key.length < VTXO_TREE_EXPIRY_PSBT_KEY.length)
+            continue;
+        let found = true;
+        for (let i = 0; i < VTXO_TREE_EXPIRY_PSBT_KEY.length; i++) {
+            if (u.key[i] !== VTXO_TREE_EXPIRY_PSBT_KEY[i]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            const value = (0, btc_signer_1.ScriptNum)(6, true).decode(u.value);
+            const { blocks, seconds } = bip68.decode(Number(value));
+            return {
+                type: blocks ? "blocks" : "seconds",
+                value: BigInt(blocks ?? seconds ?? 0),
+            };
+        }
+    }
+    return null;
+}
+function parsePrefixedCosignerKey(key) {
+    if (key.length < COSIGNER_KEY_PREFIX.length)
+        return false;
+    for (let i = 0; i < COSIGNER_KEY_PREFIX.length; i++) {
+        if (key[i] !== COSIGNER_KEY_PREFIX[i])
+            return false;
+    }
+    return true;
+}
+function getCosignerKeys(tx) {
+    const keys = [];
+    const input = tx.getInput(0);
+    if (!input.unknown)
+        return keys;
+    for (const unknown of input.unknown) {
+        const ok = parsePrefixedCosignerKey(new Uint8Array([unknown[0].type, ...unknown[0].key]));
+        if (!ok)
+            continue;
+        // Assuming the value is already a valid public key in compressed format
+        keys.push(unknown[1]);
+    }
+    return keys;
+}