@arkade-os/sdk 0.1.4 → 0.2.1

package/dist/esm/script/tapscript.js

@@ -2,6 +2,7 @@ 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";
+const MinimalScriptNum = ScriptNum(undefined, true);
 export var TapscriptType;
 (function (TapscriptType) {
     TapscriptType["Multisig"] = "multisig";
@@ -10,6 +11,16 @@ export var TapscriptType;
     TapscriptType["ConditionMultisig"] = "condition-multisig";
     TapscriptType["CLTVMultisig"] = "cltv-multisig";
 })(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);
+ * ```
+ */
 export function decodeTapscript(script) {
     const types = [
         MultisigTapscript,
@@ -29,8 +40,14 @@ export function decodeTapscript(script) {
     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.
+ * Implements a multi-signature tapscript.
+ *
+ * <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
+ *
+ * @example
+ * ```typescript
+ * const multisigTapscript = MultisigTapscript.encode({ pubkeys: [new Uint8Array(32), new Uint8Array(32)] });
+ * ```
  */
 export var MultisigTapscript;
 (function (MultisigTapscript) {
@@ -56,7 +73,6 @@ export var MultisigTapscript;
                 type: TapscriptType.Multisig,
                 params,
                 script: p2tr_ms(params.pubkeys.length, params.pubkeys).script,
-                witnessSize: () => params.pubkeys.length * 64,
             };
         }
         const asm = [];
@@ -74,7 +90,6 @@ export var MultisigTapscript;
             type: TapscriptType.Multisig,
             params,
             script: Script.encode(asm),
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     MultisigTapscript.encode = encode;
@@ -145,7 +160,6 @@ export var MultisigTapscript;
             type: TapscriptType.Multisig,
             params: { pubkeys, type: MultisigType.CHECKSIGADD },
             script,
-            witnessSize: () => pubkeys.length * 64,
         };
     }
     // <pubkey> CHECKSIGVERIFY <pubkey> CHECKSIG
@@ -189,7 +203,6 @@ export var MultisigTapscript;
             type: TapscriptType.Multisig,
             params: { pubkeys, type: MultisigType.CHECKSIG },
             script,
-            witnessSize: () => pubkeys.length * 64,
         };
     }
     function is(tapscript) {
@@ -202,6 +215,13 @@ export 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)] });
+ * ```
  */
 export var CSVMultisigTapscript;
 (function (CSVMultisigTapscript) {
@@ -211,10 +231,14 @@ export var CSVMultisigTapscript;
                 throw new Error(`Invalid pubkey length: expected 32, got ${pubkey.length}`);
             }
         }
-        const sequence = 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.encode(asm),
@@ -224,7 +248,6 @@ export var CSVMultisigTapscript;
             type: TapscriptType.CSVMultisig,
             params,
             script,
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     CSVMultisigTapscript.encode = encode;
@@ -251,7 +274,7 @@ export var CSVMultisigTapscript;
         catch (error) {
             throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const sequenceNum = Number(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) }
@@ -270,7 +293,6 @@ export var CSVMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: () => multisig.params.pubkeys.length * 64,
         };
     }
     CSVMultisigTapscript.decode = decode;
@@ -283,6 +305,13 @@ export 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)] });
+ * ```
  */
 export var ConditionCSVMultisigTapscript;
 (function (ConditionCSVMultisigTapscript) {
@@ -296,7 +325,6 @@ export var ConditionCSVMultisigTapscript;
             type: TapscriptType.ConditionCSVMultisig,
             params,
             script,
-            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
         };
     }
     ConditionCSVMultisigTapscript.encode = encode;
@@ -340,7 +368,6 @@ export var ConditionCSVMultisigTapscript;
                 ...csvMultisig.params,
             },
             script,
-            witnessSize: (conditionSize) => conditionSize + csvMultisig.params.pubkeys.length * 64,
         };
     }
     ConditionCSVMultisigTapscript.decode = decode;
@@ -353,6 +380,13 @@ export 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)] });
+ * ```
  */
 export var ConditionMultisigTapscript;
 (function (ConditionMultisigTapscript) {
@@ -366,7 +400,6 @@ export var ConditionMultisigTapscript;
             type: TapscriptType.ConditionMultisig,
             params,
             script,
-            witnessSize: (conditionSize) => conditionSize + params.pubkeys.length * 64,
         };
     }
     ConditionMultisigTapscript.encode = encode;
@@ -410,7 +443,6 @@ export var ConditionMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: (conditionSize) => conditionSize + multisig.params.pubkeys.length * 64,
         };
     }
     ConditionMultisigTapscript.decode = decode;
@@ -423,12 +455,23 @@ export 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)] });
+ * ```
  */
 export var CLTVMultisigTapscript;
 (function (CLTVMultisigTapscript) {
     function encode(params) {
-        const locktime = 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.encode(asm);
         const script = new Uint8Array([
             ...timelockedScript,
@@ -438,7 +481,6 @@ export var CLTVMultisigTapscript;
             type: TapscriptType.CLTVMultisig,
             params,
             script,
-            witnessSize: () => params.pubkeys.length * 64,
         };
     }
     CLTVMultisigTapscript.encode = encode;
@@ -465,7 +507,7 @@ export var CLTVMultisigTapscript;
         catch (error) {
             throw new Error(`Invalid multisig script: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const absoluteTimelock = ScriptNum().decode(locktime);
+        const absoluteTimelock = MinimalScriptNum.decode(locktime);
         const reconstructed = encode({
             absoluteTimelock,
             ...multisig.params,
@@ -480,7 +522,6 @@ export var CLTVMultisigTapscript;
                 ...multisig.params,
             },
             script,
-            witnessSize: () => multisig.params.pubkeys.length * 64,
         };
     }
     CLTVMultisigTapscript.decode = decode;

package/dist/esm/script/vhtlc.js

@@ -2,17 +2,38 @@ 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)
+/**
+ * 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 }
+ * });
+ * ```
+ */
 export var VHTLC;
 (function (VHTLC) {
     class Script extends VtxoScript {
         constructor(options) {
+            validateOptions(options);
             const { sender, receiver, server, preimageHash, refundLocktime, unilateralClaimDelay, unilateralRefundDelay, unilateralRefundWithoutReceiverDelay, } = options;
             const conditionScript = preimageConditionScript(preimageHash);
             const claimScript = ConditionMultisigTapscript.encode({
@@ -75,6 +96,63 @@ export 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 || (VHTLC = {}));
 function preimageConditionScript(preimageHash) {
     return Script.encode(["HASH160", preimageHash, "EQUAL"]);

package/dist/esm/tree/signingSession.js

@@ -1,17 +1,17 @@
 import * as musig2 from '../musig2/index.js';
-import { getCosignerKeys } from './vtxoTree.js';
-import { Script, SigHash, Transaction } from "@scure/btc-signer";
-import { base64, hex } from "@scure/base";
+import { Script, SigHash } from "@scure/btc-signer";
+import { hex } from "@scure/base";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
-import { randomPrivateKeyBytes } from "@scure/btc-signer/utils";
-export const ErrMissingVtxoTree = new Error("missing vtxo tree");
+import { randomPrivateKeyBytes, sha256x2 } from "@scure/btc-signer/utils";
+import { CosignerPublicKey, getArkPsbtFields } from '../utils/unknownFields.js';
+export const ErrMissingVtxoGraph = new Error("missing vtxo graph");
 export const ErrMissingAggregateKey = new Error("missing aggregate key");
 export 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;
     }
@@ -20,7 +20,7 @@ export class TreeSignerSession {
         return new TreeSignerSession(secretKey);
     }
     init(tree, scriptRoot, rootInputAmount) {
-        this.tree = tree;
+        this.graph = tree;
         this.scriptRoot = scriptRoot;
         this.rootSharedOutputAmount = rootInputAmount;
     }
@@ -28,24 +28,16 @@ export class TreeSignerSession {
         return secp256k1.getPublicKey(this.secretKey);
     }
     getNonces() {
-        if (!this.tree)
-            throw ErrMissingVtxoTree;
+        if (!this.graph)
+            throw 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)
@@ -53,71 +45,55 @@ export class TreeSignerSession {
         this.aggregateNonces = nonces;
     }
     sign() {
-        if (!this.tree)
-            throw ErrMissingVtxoTree;
+        if (!this.graph)
+            throw 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 = Transaction.fromPSBT(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 ErrMissingVtxoTree;
-        const myNonces = [];
+        if (!this.graph)
+            throw ErrMissingVtxoGraph;
+        const myNonces = new Map();
         const publicKey = 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 = getCosignerKeys(tx);
+        const cosigners = getArkPsbtFields(g.root, 0, 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, SigHash.DEFAULT, prevoutAmounts);
         return musig2.sign(myNonce.secNonce, this.secretKey, aggNonce.pubNonce, cosigners, message, {
             taprootTweak: this.scriptRoot,
@@ -129,66 +105,47 @@ TreeSignerSession.NOT_INITIALIZED = new Error("session not initialized, call ini
 // Helper function to validate tree signatures
 export 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 = Transaction.fromPSBT(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], SigHash.DEFAULT, [prevout.amount]);
-            // Verify the signature
-            const isValid = 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], SigHash.DEFAULT, [prevout.amount]);
+        // Verify the signature
+        const isValid = 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 = 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 = hex.encode(input.txid);
-    // Check if parent is root
-    if (rootNode.parentTxid === parentTxID) {
+    const txid = hex.encode(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 = Transaction.fromPSBT(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 = 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)