@arkade-os/sdk 0.4.26 → 0.4.28

package/dist/esm/script/vhtlc.js

@@ -1,167 +0,0 @@
-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";
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-export var VHTLC;
-(function (VHTLC) {
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade 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 }
-     * });
-     * ```
-     */
-    class Script extends VtxoScript {
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options) {
-            validateOptions(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);
-        }
-        /** Return the collaborative claim tapleaf script. */
-        claim() {
-            return this.findLeaf(this.claimScript);
-        }
-        /** Return the collaborative refund tapleaf script. */
-        refund() {
-            return this.findLeaf(this.refundScript);
-        }
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver() {
-            return this.findLeaf(this.refundWithoutReceiverScript);
-        }
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim() {
-            return this.findLeaf(this.unilateralClaimScript);
-        }
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund() {
-            return this.findLeaf(this.unilateralRefundScript);
-        }
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver() {
-            return this.findLeaf(this.unilateralRefundWithoutReceiverScript);
-        }
-    }
-    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/storage/asyncStorage.js

@@ -1,46 +0,0 @@
-/**
- * @deprecated Use repositories instead
- * Note: This requires @react-native-async-storage/async-storage to be installed
- */
-export class AsyncStorageAdapter {
-    constructor() {
-        try {
-            // Dynamic import to avoid errors in non-React Native environments
-            this.AsyncStorage =
-                require("@react-native-async-storage/async-storage").default;
-        }
-        catch (error) {
-            throw new Error("AsyncStorage is not available. Make sure @react-native-async-storage/async-storage is installed in React Native environment.");
-        }
-    }
-    async getItem(key) {
-        return await this.AsyncStorage.getItem(key);
-    }
-    async setItem(key, value) {
-        try {
-            await this.AsyncStorage.setItem(key, value);
-        }
-        catch (error) {
-            console.error(`Failed to set item for key ${key}:`, error);
-            throw error;
-        }
-    }
-    async removeItem(key) {
-        try {
-            await this.AsyncStorage.removeItem(key);
-        }
-        catch (error) {
-            console.error(`Failed to remove item for key ${key}:`, error);
-            throw error;
-        }
-    }
-    async clear() {
-        try {
-            await this.AsyncStorage.clear();
-        }
-        catch (error) {
-            console.error("Failed to clear AsyncStorage:", error);
-            throw error;
-        }
-    }
-}

package/dist/esm/storage/fileSystem.js

@@ -1,104 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-export class FileSystemStorageAdapter {
-    constructor(dirPath) {
-        // Normalize and resolve the storage base path once
-        this.basePath = path.resolve(dirPath).replace(/[/\\]+$/, "");
-    }
-    validateAndGetFilePath(key) {
-        // Reject dangerous keys
-        if (key === "." || key === "..") {
-            throw new Error("Invalid key: '.' and '..' are not allowed");
-        }
-        // Check for null bytes
-        if (key.includes("\0")) {
-            throw new Error("Invalid key: null bytes are not allowed");
-        }
-        // Check for path traversal attempts before normalization
-        if (key.includes("..")) {
-            throw new Error("Invalid key: directory traversal is not allowed");
-        }
-        // Check for reserved Windows names (case-insensitive)
-        const reservedNames = /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
-        const keyWithoutExt = key.split(".")[0];
-        if (reservedNames.test(keyWithoutExt)) {
-            throw new Error(`Invalid key: '${key}' uses a reserved Windows name`);
-        }
-        // Check for trailing spaces or dots
-        if (key.endsWith(" ") || key.endsWith(".")) {
-            throw new Error("Invalid key: trailing spaces or dots are not allowed");
-        }
-        // Normalize path separators and sanitize key
-        const normalizedKey = key
-            .replace(/[/\\]/g, "_")
-            .replace(/[^a-zA-Z0-9._-]/g, "_");
-        // Resolve the full path and check for directory traversal
-        const resolved = path.resolve(this.basePath, normalizedKey);
-        const relative = path.relative(this.basePath, resolved);
-        // Reject if trying to escape the base directory
-        if (relative.startsWith("..") || relative.includes(path.sep + "..")) {
-            throw new Error("Invalid key: directory traversal is not allowed");
-        }
-        return resolved;
-    }
-    async ensureDirectory() {
-        try {
-            await fs.access(this.basePath);
-        }
-        catch {
-            await fs.mkdir(this.basePath, { recursive: true });
-        }
-    }
-    async getItem(key) {
-        try {
-            const filePath = this.validateAndGetFilePath(key);
-            const data = await fs.readFile(filePath, "utf-8");
-            return data;
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return null;
-            }
-            console.error(`Failed to read file for key ${key}:`, error);
-            return null;
-        }
-    }
-    async setItem(key, value) {
-        try {
-            await this.ensureDirectory();
-            const filePath = this.validateAndGetFilePath(key);
-            await fs.writeFile(filePath, value, "utf-8");
-        }
-        catch (error) {
-            console.error(`Failed to write file for key ${key}:`, error);
-            throw error;
-        }
-    }
-    async removeItem(key) {
-        try {
-            const filePath = this.validateAndGetFilePath(key);
-            await fs.unlink(filePath);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                console.error(`Failed to remove file for key ${key}:`, error);
-            }
-        }
-    }
-    async clear() {
-        try {
-            const entries = await fs.readdir(this.basePath);
-            await Promise.all(entries.map(async (entry) => {
-                const entryPath = path.join(this.basePath, entry);
-                // Use fs.rm with recursive option to handle both files and directories
-                await fs.rm(entryPath, { recursive: true, force: true });
-            }));
-        }
-        catch (error) {
-            console.error("Failed to clear storage directory:", error);
-        }
-    }
-}

package/dist/esm/storage/inMemory.js

@@ -1,20 +0,0 @@
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-export class InMemoryStorageAdapter {
-    constructor() {
-        this.store = new Map();
-    }
-    async getItem(key) {
-        return this.store.get(key) ?? null;
-    }
-    async setItem(key, value) {
-        this.store.set(key, value);
-    }
-    async removeItem(key) {
-        this.store.delete(key);
-    }
-    async clear() {
-        this.store.clear();
-    }
-}

package/dist/esm/storage/index.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/storage/indexedDB.js

@@ -1,97 +0,0 @@
-import { DB_VERSION } from "../repositories/indexedDB/db.js";
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-export class IndexedDBStorageAdapter {
-    constructor(dbName, version = DB_VERSION) {
-        this.db = null;
-        this.dbName = dbName;
-        this.version = version;
-    }
-    async getDB() {
-        if (this.db)
-            return this.db;
-        const globalObject = typeof window === "undefined" ? self : window;
-        if (!(globalObject && "indexedDB" in globalObject)) {
-            throw new Error("IndexedDB is not available in this environment");
-        }
-        return new Promise((resolve, reject) => {
-            const request = globalObject.indexedDB.open(this.dbName, this.version);
-            request.onerror = () => reject(request.error);
-            request.onsuccess = () => {
-                this.db = request.result;
-                resolve(this.db);
-            };
-            request.onupgradeneeded = () => {
-                const db = request.result;
-                if (!db.objectStoreNames.contains("storage")) {
-                    db.createObjectStore("storage");
-                }
-            };
-        });
-    }
-    async getItem(key) {
-        try {
-            const db = await this.getDB();
-            return new Promise((resolve, reject) => {
-                const transaction = db.transaction(["storage"], "readonly");
-                const store = transaction.objectStore("storage");
-                const request = store.get(key);
-                request.onerror = () => reject(request.error);
-                request.onsuccess = () => {
-                    resolve(request.result || null);
-                };
-            });
-        }
-        catch (error) {
-            console.error(`Failed to get item for key ${key}:`, error);
-            return null;
-        }
-    }
-    async setItem(key, value) {
-        try {
-            const db = await this.getDB();
-            return new Promise((resolve, reject) => {
-                const transaction = db.transaction(["storage"], "readwrite");
-                const store = transaction.objectStore("storage");
-                const request = store.put(value, key);
-                request.onerror = () => reject(request.error);
-                request.onsuccess = () => resolve();
-            });
-        }
-        catch (error) {
-            console.error(`Failed to set item for key ${key}:`, error);
-            throw error;
-        }
-    }
-    async removeItem(key) {
-        try {
-            const db = await this.getDB();
-            return new Promise((resolve, reject) => {
-                const transaction = db.transaction(["storage"], "readwrite");
-                const store = transaction.objectStore("storage");
-                const request = store.delete(key);
-                request.onerror = () => reject(request.error);
-                request.onsuccess = () => resolve();
-            });
-        }
-        catch (error) {
-            console.error(`Failed to remove item for key ${key}:`, error);
-        }
-    }
-    async clear() {
-        try {
-            const db = await this.getDB();
-            return new Promise((resolve, reject) => {
-                const transaction = db.transaction(["storage"], "readwrite");
-                const store = transaction.objectStore("storage");
-                const request = store.clear();
-                request.onerror = () => reject(request.error);
-                request.onsuccess = () => resolve();
-            });
-        }
-        catch (error) {
-            console.error("Failed to clear storage:", error);
-        }
-    }
-}

package/dist/esm/storage/localStorage.js

@@ -1,47 +0,0 @@
-/**
- * @deprecated Use repository implementations via `StorageConfig` instead.
- */
-export class LocalStorageAdapter {
-    getSafeLocalStorage() {
-        try {
-            if (typeof window === "undefined" || !window.localStorage) {
-                return null;
-            }
-            // Test access to ensure localStorage is actually available
-            window.localStorage.length;
-            return window.localStorage;
-        }
-        catch {
-            // localStorage may throw in some environments (e.g., private browsing, disabled storage)
-            return null;
-        }
-    }
-    async getItem(key) {
-        const localStorage = this.getSafeLocalStorage();
-        if (!localStorage) {
-            throw new Error("localStorage is not available in this environment");
-        }
-        return localStorage.getItem(key);
-    }
-    async setItem(key, value) {
-        const localStorage = this.getSafeLocalStorage();
-        if (!localStorage) {
-            throw new Error("localStorage is not available in this environment");
-        }
-        localStorage.setItem(key, value);
-    }
-    async removeItem(key) {
-        const localStorage = this.getSafeLocalStorage();
-        if (!localStorage) {
-            throw new Error("localStorage is not available in this environment");
-        }
-        localStorage.removeItem(key);
-    }
-    async clear() {
-        const localStorage = this.getSafeLocalStorage();
-        if (!localStorage) {
-            throw new Error("localStorage is not available in this environment");
-        }
-        localStorage.clear();
-    }
-}

package/dist/esm/tree/signingSession.js

@@ -1,191 +0,0 @@
-import * as musig2 from "../musig2/index.js";
-import { Script } from "@scure/btc-signer/script.js";
-import { SigHash } from "@scure/btc-signer/transaction.js";
-import { hex } from "@scure/base";
-import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
-import { randomPrivateKeyBytes } from "@scure/btc-signer/utils.js";
-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.graph = null;
-        this.scriptRoot = null;
-        this.rootSharedOutputAmount = null;
-    }
-    static random() {
-        const secretKey = randomPrivateKeyBytes();
-        return new TreeSignerSession(secretKey);
-    }
-    async init(tree, scriptRoot, rootInputAmount) {
-        this.graph = tree;
-        this.scriptRoot = scriptRoot;
-        this.rootSharedOutputAmount = rootInputAmount;
-    }
-    async getPublicKey() {
-        return secp256k1.getPublicKey(this.secretKey);
-    }
-    async getNonces() {
-        if (!this.graph)
-            throw ErrMissingVtxoGraph;
-        if (!this.myNonces) {
-            this.myNonces = this.generateNonces();
-        }
-        const publicNonces = new Map();
-        for (const [txid, nonces] of this.myNonces) {
-            publicNonces.set(txid, { pubNonce: nonces.pubNonce });
-        }
-        return publicNonces;
-    }
-    async aggregatedNonces(txid, noncesByPubkey) {
-        if (!this.graph)
-            throw ErrMissingVtxoGraph;
-        if (!this.aggregateNonces) {
-            this.aggregateNonces = new Map();
-        }
-        if (!this.myNonces) {
-            await this.getNonces(); // generate nonces if not generated yet
-        }
-        if (this.aggregateNonces.has(txid)) {
-            return {
-                hasAllNonces: this.aggregateNonces.size === this.myNonces?.size,
-            };
-        }
-        const myNonce = this.myNonces.get(txid);
-        if (!myNonce)
-            throw new Error(`missing nonce for txid ${txid}`);
-        const myPublicKey = await this.getPublicKey();
-        // set my nonce to not rely on server
-        noncesByPubkey.set(hex.encode(myPublicKey.subarray(1)), myNonce);
-        const tx = this.graph.find(txid);
-        if (!tx)
-            throw new Error(`missing tx for txid ${txid}`);
-        const cosigners = getArkPsbtFields(tx.root, 0, CosignerPublicKey).map((c) => hex.encode(c.key.subarray(1)) // xonly pubkey
-        );
-        const pubNonces = [];
-        for (const cosigner of cosigners) {
-            const nonce = noncesByPubkey.get(cosigner);
-            if (!nonce) {
-                throw new Error(`missing nonce for cosigner ${cosigner}`);
-            }
-            pubNonces.push(nonce.pubNonce);
-        }
-        const aggregateNonce = musig2.aggregateNonces(pubNonces);
-        this.aggregateNonces.set(txid, { pubNonce: aggregateNonce });
-        return {
-            hasAllNonces: this.aggregateNonces.size === this.myNonces?.size,
-        };
-    }
-    async sign() {
-        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 = new Map();
-        for (const g of this.graph.iterator()) {
-            const sig = this.signPartial(g);
-            sigs.set(g.txid, sig);
-        }
-        return sigs;
-    }
-    generateNonces() {
-        if (!this.graph)
-            throw ErrMissingVtxoGraph;
-        const myNonces = new Map();
-        const publicKey = secp256k1.getPublicKey(this.secretKey);
-        for (const g of this.graph.iterator()) {
-            const nonces = musig2.generateNonces(publicKey);
-            myNonces.set(g.txid, nonces);
-        }
-        return myNonces;
-    }
-    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.get(g.txid);
-        if (!myNonce)
-            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 = getArkPsbtFields(g.root, 0, CosignerPublicKey).map((c) => c.key);
-        const { finalKey } = musig2.aggregateKeys(cosigners, true, {
-            taprootTweak: this.scriptRoot,
-        });
-        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 = 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,
-            sortKeys: true,
-        });
-    }
-}
-TreeSignerSession.NOT_INITIALIZED = new Error("session not initialized, call init method");
-// Helper function to validate tree signatures
-export async function validateTreeSigs(finalAggregatedKey, sharedOutputAmount, vtxoTree) {
-    // Iterate through each level of the tree
-    for (const g of vtxoTree.iterator()) {
-        // 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, graph, sharedOutputAmount, tx) {
-    // generate P2TR script from musig2 final key
-    const pkScript = Script.encode(["OP_1", finalKey.slice(1)]);
-    // if the input is the root input, return the shared output amount
-    if (tx.id === graph.txid) {
-        return {
-            amount: sharedOutputAmount,
-            script: pkScript,
-        };
-    }
-    // find the parent transaction
-    const parentInput = tx.getInput(0);
-    if (!parentInput.txid)
-        throw new Error("missing parent input txid");
-    const parentTxid = hex.encode(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 = parent.root.getOutput(parentInput.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,
-    };
-}