@arkade-os/sdk 0.1.4 → 0.2.1

package/dist/cjs/script/tapscript.js

@@ -39,6 +39,7 @@ const bip68 = __importStar(require("bip68"));
 const script_1 = require("@scure/btc-signer/script");
 const payment_1 = require("@scure/btc-signer/payment");
 const base_1 = require("@scure/base");
+const MinimalScriptNum = (0, script_1.ScriptNum)(undefined, true);
 var TapscriptType;
 (function (TapscriptType) {
     TapscriptType["Multisig"] = "multisig";
@@ -47,6 +48,16 @@ var TapscriptType;
     TapscriptType["ConditionMultisig"] = "condition-multisig";
     TapscriptType["CLTVMultisig"] = "cltv-multisig";
 })(TapscriptType || (exports.TapscriptType = TapscriptType = {}));
+/**
+ * decodeTapscript is a function that decodes an ark tapsript from a raw script.
+ *
+ * @throws {Error} if the script is not a valid ark tapscript
+ * @example
+ * ```typescript
+ * const arkTapscript = decodeTapscript(new Uint8Array(32));
+ * console.log("type:", arkTapscript.type);
+ * ```
+ */
 function decodeTapscript(script) {
     const types = [
         MultisigTapscript,
@@ -66,8 +77,14 @@ function decodeTapscript(script) {
     throw new Error(`Failed to decode: script ${base_1.hex.encode(script)} is not a valid tapscript`);
 }
 /**
- * Implements a multi-signature script that requires a threshold of signatures
- * from the specified pubkeys.
+ * Implements a multi-signature tapscript.
+ *
+ * <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const multisigTapscript = MultisigTapscript.encode({ pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 var MultisigTapscript;
 (function (MultisigTapscript) {
@@ -93,7 +110,6 @@ var MultisigTapscript;
                 type: TapscriptType.Multisig,
                 params,
                 script: (0, payment_1.p2tr_ms)(params.pubkeys.length, params.pubkeys).script,
-                witnessSize: () => params.pubkeys.length * 64,
             };
         }
         const asm = [];
@@ -111,7 +127,6 @@ var MultisigTapscript;
             type: TapscriptType.Multisig,
             params,
             script: script_1.Script.encode(asm),
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     MultisigTapscript.encode = encode;
@@ -182,7 +197,6 @@ var MultisigTapscript;
             type: TapscriptType.Multisig,
             params: { pubkeys, type: MultisigType.CHECKSIGADD },
             script,
-            witnessSize: () => pubkeys.length * 64,
         };
     }
     // <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
@@ -226,7 +240,6 @@ var MultisigTapscript;
             type: TapscriptType.Multisig,
             params: { pubkeys, type: MultisigType.CHECKSIG },
             script,
-            witnessSize: () => pubkeys.length * 64,
         };
     }
     function is(tapscript) {
@@ -239,6 +252,13 @@ var MultisigTapscript;
  * 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.
+ *
+ * <sequence> CHECKSEQUENCEVERIFY DROP <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const csvMultisigTapscript = CSVMultisigTapscript.encode({ timelock: { type: "blocks", value: 144 }, pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 var CSVMultisigTapscript;
 (function (CSVMultisigTapscript) {
@@ -248,10 +268,14 @@ var CSVMultisigTapscript;
                 throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
             }
         }
-        const sequence = (0, script_1.ScriptNum)().encode(BigInt(bip68.encode(params.timelock.type === "blocks"
+        const sequence = MinimalScriptNum.encode(BigInt(bip68.encode(params.timelock.type === "blocks"
             ? { blocks: Number(params.timelock.value) }
             : { seconds: Number(params.timelock.value) })));
-        const asm = [sequence, "CHECKSEQUENCEVERIFY", "DROP"];
+        const asm = [
+            sequence.length === 1 ? sequence[0] : sequence,
+            "CHECKSEQUENCEVERIFY",
+            "DROP",
+        ];
         const multisigScript = MultisigTapscript.encode(params);
         const script = new Uint8Array([
             ...script_1.Script.encode(asm),
@@ -261,7 +285,6 @@ var CSVMultisigTapscript;
             type: TapscriptType.CSVMultisig,
             params,
             script,
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     CSVMultisigTapscript.encode = encode;
@@ -288,7 +311,7 @@ var CSVMultisigTapscript;
         catch (error) {
             throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const sequenceNum = Number((0, script_1.ScriptNum)().decode(sequence));
+        const sequenceNum = Number(MinimalScriptNum.decode(sequence));
         const decodedTimelock = bip68.decode(sequenceNum);
         const timelock = decodedTimelock.blocks !== undefined
             ? { type: "blocks", value: BigInt(decodedTimelock.blocks) }
@@ -307,7 +330,6 @@ var CSVMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: () => multisig.params.pubkeys.length * 64,
         };
     }
     CSVMultisigTapscript.decode = decode;
@@ -320,6 +342,13 @@ var 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).
+ *
+ * <conditionScript> VERIFY <sequence> CHECKSEQUENCEVERIFY DROP <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const conditionCSVMultisigTapscript = ConditionCSVMultisigTapscript.encode({ conditionScript: new Uint8Array(32), pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 var ConditionCSVMultisigTapscript;
 (function (ConditionCSVMultisigTapscript) {
@@ -333,7 +362,6 @@ var ConditionCSVMultisigTapscript;
             type: TapscriptType.ConditionCSVMultisig,
             params,
             script,
-            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
         };
     }
     ConditionCSVMultisigTapscript.encode = encode;
@@ -377,7 +405,6 @@ var ConditionCSVMultisigTapscript;
                 ...csvMultisig.params,
             },
             script,
-            witnessSize: (conditionSize) => conditionSize + csvMultisig.params.pubkeys.length * 64,
         };
     }
     ConditionCSVMultisigTapscript.decode = decode;
@@ -390,6 +417,13 @@ var 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).
+ *
+ * <conditionScript> VERIFY <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const conditionMultisigTapscript = ConditionMultisigTapscript.encode({ conditionScript: new Uint8Array(32), pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 var ConditionMultisigTapscript;
 (function (ConditionMultisigTapscript) {
@@ -403,7 +437,6 @@ var ConditionMultisigTapscript;
             type: TapscriptType.ConditionMultisig,
             params,
             script,
-            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
         };
     }
     ConditionMultisigTapscript.encode = encode;
@@ -447,7 +480,6 @@ var ConditionMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: (conditionSize) => conditionSize + multisig.params.pubkeys.length * 64,
         };
     }
     ConditionMultisigTapscript.decode = decode;
@@ -460,12 +492,23 @@ var 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.
+ *
+ * <locktime> CHECKLOCKTIMEVERIFY DROP <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const cltvMultisigTapscript = CLTVMultisigTapscript.encode({ absoluteTimelock: 144, pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 var CLTVMultisigTapscript;
 (function (CLTVMultisigTapscript) {
     function encode(params) {
-        const locktime = (0, script_1.ScriptNum)().encode(params.absoluteTimelock);
-        const asm = [locktime, "CHECKLOCKTIMEVERIFY", "DROP"];
+        const locktime = MinimalScriptNum.encode(params.absoluteTimelock);
+        const asm = [
+            locktime.length === 1 ? locktime[0] : locktime,
+            "CHECKLOCKTIMEVERIFY",
+            "DROP",
+        ];
         const timelockedScript = script_1.Script.encode(asm);
         const script = new Uint8Array([
             ...timelockedScript,
@@ -475,7 +518,6 @@ var CLTVMultisigTapscript;
             type: TapscriptType.CLTVMultisig,
             params,
             script,
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     CLTVMultisigTapscript.encode = encode;
@@ -502,7 +544,7 @@ var CLTVMultisigTapscript;
         catch (error) {
             throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const absoluteTimelock = (0, script_1.ScriptNum)().decode(locktime);
+        const absoluteTimelock = MinimalScriptNum.decode(locktime);
         const reconstructed = encode({
             absoluteTimelock,
             ...multisig.params,
@@ -517,7 +559,6 @@ var CLTVMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: () => multisig.params.pubkeys.length * 64,
         };
     }
     CLTVMultisigTapscript.decode = decode;

package/dist/cjs/script/vhtlc.js

@@ -5,17 +5,38 @@ const btc_signer_1 = require("@scure/btc-signer");
 const tapscript_1 = require("./tapscript");
 const base_1 = require("@scure/base");
 const base_2 = require("./base");
-// 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)
+/**
+ * Virtual Hash Time Lock Contract (VHTLC) implementation.
+ *
+ * VHTLC is a contract that enables atomic swaps and conditional payments
+ * in the Ark protocol. It provides multiple spending paths:
+ *
+ * - **claim**: Receiver can claim funds by revealing the preimage
+ * - **refund**: Sender and receiver can collaboratively refund
+ * - **refundWithoutReceiver**: Sender can refund after locktime expires
+ * - **unilateralClaim**: Receiver can claim unilaterally after delay
+ * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
+ * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
+ *
+ * @example
+ * ```typescript
+ * const vhtlc = new VHTLC.Script({
+ *   sender: alicePubKey,
+ *   receiver: bobPubKey,
+ *   server: serverPubKey,
+ *   preimageHash: hash160(secret),
+ *   refundLocktime: BigInt(chainTip + 10),
+ *   unilateralClaimDelay: { type: 'blocks', value: 100n },
+ *   unilateralRefundDelay: { type: 'blocks', value: 102n },
+ *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
+ * });
+ * ```
+ */
 var VHTLC;
 (function (VHTLC) {
     class Script extends base_2.VtxoScript {
         constructor(options) {
+            validateOptions(options);
             const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
             const conditionScript = preimageConditionScript(preimageHash);
             const claimScript = tapscript_1.ConditionMultisigTapscript.encode({
@@ -78,6 +99,63 @@ var VHTLC;
         }
     }
     VHTLC.Script = Script;
+    function validateOptions(options) {
+        const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
+        if (!preimageHash || preimageHash.length !== 20) {
+            throw new Error("preimage hash must be 20 bytes");
+        }
+        if (!receiver || receiver.length !== 32) {
+            throw new Error("Invalid public key length (receiver)");
+        }
+        if (!sender || sender.length !== 32) {
+            throw new Error("Invalid public key length (sender)");
+        }
+        if (!server || server.length !== 32) {
+            throw new Error("Invalid public key length (server)");
+        }
+        if (typeof refundLocktime !== "bigint" || refundLocktime <= 0n) {
+            throw new Error("refund locktime must be greater than 0");
+        }
+        if (!unilateralClaimDelay ||
+            typeof unilateralClaimDelay.value !== "bigint" ||
+            unilateralClaimDelay.value <= 0n) {
+            throw new Error("unilateral claim delay must greater than 0");
+        }
+        if (unilateralClaimDelay.type === "seconds" &&
+            unilateralClaimDelay.value % 512n !== 0n) {
+            throw new Error("seconds timelock must be multiple of 512");
+        }
+        if (unilateralClaimDelay.type === "seconds" &&
+            unilateralClaimDelay.value < 512n) {
+            throw new Error("seconds timelock must be greater or equal to 512");
+        }
+        if (!unilateralRefundDelay ||
+            typeof unilateralRefundDelay.value !== "bigint" ||
+            unilateralRefundDelay.value <= 0n) {
+            throw new Error("unilateral refund delay must greater than 0");
+        }
+        if (unilateralRefundDelay.type === "seconds" &&
+            unilateralRefundDelay.value % 512n !== 0n) {
+            throw new Error("seconds timelock must be multiple of 512");
+        }
+        if (unilateralRefundDelay.type === "seconds" &&
+            unilateralRefundDelay.value < 512n) {
+            throw new Error("seconds timelock must be greater or equal to 512");
+        }
+        if (!unilateralRefundWithoutReceiverDelay ||
+            typeof unilateralRefundWithoutReceiverDelay.value !== "bigint" ||
+            unilateralRefundWithoutReceiverDelay.value <= 0n) {
+            throw new Error("unilateral refund without receiver delay must greater than 0");
+        }
+        if (unilateralRefundWithoutReceiverDelay.type === "seconds" &&
+            unilateralRefundWithoutReceiverDelay.value % 512n !== 0n) {
+            throw new Error("seconds timelock must be multiple of 512");
+        }
+        if (unilateralRefundWithoutReceiverDelay.type === "seconds" &&
+            unilateralRefundWithoutReceiverDelay.value < 512n) {
+            throw new Error("seconds timelock must be greater or equal to 512");
+        }
+    }
 })(VHTLC || (exports.VHTLC = VHTLC = {}));
 function preimageConditionScript(preimageHash) {
     return btc_signer_1.Script.encode(["HASH160", preimageHash, "EQUAL"]);

package/dist/cjs/tree/signingSession.js

@@ -33,22 +33,22 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeSignerSession = exports.ErrMissingAggregateKey = exports.ErrMissingVtxoTree = void 0;
+exports.TreeSignerSession = exports.ErrMissingAggregateKey = exports.ErrMissingVtxoGraph = 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");
+const unknownFields_1 = require("../utils/unknownFields");
+exports.ErrMissingVtxoGraph = new Error("missing vtxo graph");
 exports.ErrMissingAggregateKey = new Error("missing aggregate key");
 class TreeSignerSession {
     constructor(secretKey) {
         this.secretKey = secretKey;
         this.myNonces = null;
         this.aggregateNonces = null;
-        this.tree = null;
+        this.graph = null;
         this.scriptRoot = null;
         this.rootSharedOutputAmount = null;
     }
@@ -57,7 +57,7 @@ class TreeSignerSession {
         return new TreeSignerSession(secretKey);
     }
     init(tree, scriptRoot, rootInputAmount) {
-        this.tree = tree;
+        this.graph = tree;
         this.scriptRoot = scriptRoot;
         this.rootSharedOutputAmount = rootInputAmount;
     }
@@ -65,24 +65,16 @@ class TreeSignerSession {
         return secp256k1_1.secp256k1.getPublicKey(this.secretKey);
     }
     getNonces() {
-        if (!this.tree)
-            throw exports.ErrMissingVtxoTree;
+        if (!this.graph)
+            throw exports.ErrMissingVtxoGraph;
         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);
+        const publicNonces = new Map();
+        for (const [txid, nonces] of this.myNonces) {
+            publicNonces.set(txid, { pubNonce: nonces.pubNonce });
         }
-        return nonces;
+        return publicNonces;
     }
     setAggregatedNonces(nonces) {
         if (this.aggregateNonces)
@@ -90,71 +82,55 @@ class TreeSignerSession {
         this.aggregateNonces = nonces;
     }
     sign() {
-        if (!this.tree)
-            throw exports.ErrMissingVtxoTree;
+        if (!this.graph)
+            throw exports.ErrMissingVtxoGraph;
         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);
+        const sigs = new Map();
+        for (const g of this.graph) {
+            const sig = this.signPartial(g);
+            sigs.set(g.txid, sig);
         }
         return sigs;
     }
     generateNonces() {
-        if (!this.tree)
-            throw exports.ErrMissingVtxoTree;
-        const myNonces = [];
+        if (!this.graph)
+            throw exports.ErrMissingVtxoGraph;
+        const myNonces = new Map();
         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);
+        for (const g of this.graph) {
+            const nonces = musig2.generateNonces(publicKey);
+            myNonces.set(g.txid, nonces);
         }
         return myNonces;
     }
-    signPartial(tx, levelIndex, nodeIndex) {
-        if (!this.tree || !this.scriptRoot || !this.rootSharedOutputAmount) {
+    signPartial(g) {
+        if (!this.graph || !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];
+        const myNonce = this.myNonces.get(g.txid);
         if (!myNonce)
-            return null;
-        const aggNonce = this.aggregateNonces[levelIndex][nodeIndex];
+            throw new Error("missing private nonce");
+        const aggNonce = this.aggregateNonces.get(g.txid);
         if (!aggNonce)
             throw new Error("missing aggregate nonce");
         const prevoutAmounts = [];
         const prevoutScripts = [];
-        const cosigners = (0, vtxoTree_1.getCosignerKeys)(tx);
+        const cosigners = (0, unknownFields_1.getArkPsbtFields)(g.root, 0, unknownFields_1.CosignerPublicKey).map((c) => c.key);
         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);
+        for (let inputIndex = 0; inputIndex < g.root.inputsLength; inputIndex++) {
+            const prevout = getPrevOutput(finalKey, this.graph, this.rootSharedOutputAmount, g.root);
             prevoutAmounts.push(prevout.amount);
             prevoutScripts.push(prevout.script);
         }
-        const message = tx.preimageWitnessV1(0, // always first input
+        const message = g.root.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,
@@ -167,66 +143,47 @@ TreeSignerSession.NOT_INITIALIZED = new Error("session not initialized, call ini
 // 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");
-            }
+    for (const g of vtxoTree) {
+        // Parse the transaction
+        const input = g.root.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, g.root);
+        // Calculate the message that was signed
+        const message = g.root.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
+function getPrevOutput(finalKey, graph, sharedOutputAmount, tx) {
+    // generate P2TR script from musig2 final key
     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) {
+    const txid = base_1.hex.encode((0, utils_1.sha256x2)(tx.toBytes(true)).reverse());
+    // if the input is the root input, return the shared output amount
+    if (txid === graph.txid) {
         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)
+    // find the parent transaction
+    const parentInput = tx.getInput(0);
+    if (!parentInput.txid)
+        throw new Error("missing parent input txid");
+    const parentTxid = base_1.hex.encode(new Uint8Array(parentInput.txid));
+    const parent = graph.find(parentTxid);
+    if (!parent)
+        throw new Error("parent  tx not found");
+    if (parentInput.index === undefined)
         throw new Error("missing input index");
-    const parentOutput = parentTx.getOutput(input.index);
+    const parentOutput = parent.root.getOutput(parentInput.index);
     if (!parentOutput)
         throw new Error("parent output not found");
     if (!parentOutput.amount)