@arkade-os/sdk 0.3.0-alpha.8 → 0.3.1-alpha.1

package/dist/esm/providers/ark.js

@@ -32,25 +32,36 @@ export class RestArkProvider {
         }
         const fromServer = await response.json();
         return {
-            ...fromServer,
-            vtxoTreeExpiry: BigInt(fromServer.vtxoTreeExpiry ?? 0),
-            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
-            roundInterval: BigInt(fromServer.roundInterval ?? 0),
-            dust: BigInt(fromServer.dust ?? 0),
-            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
-            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
-            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
-            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
             boardingExitDelay: BigInt(fromServer.boardingExitDelay ?? 0),
-            checkpointExitClosure: fromServer.checkpointTapscript ?? "",
-            marketHour: "marketHour" in fromServer && fromServer.marketHour != null
+            checkpointTapscript: fromServer.checkpointTapscript ?? "",
+            deprecatedSigners: fromServer.deprecatedSigners?.map((signer) => ({
+                cutoffDate: BigInt(signer.cutoffDate ?? 0),
+                pubkey: signer.pubkey ?? "",
+            })) ?? [],
+            digest: fromServer.digest ?? "",
+            dust: BigInt(fromServer.dust ?? 0),
+            fees: fromServer.fees,
+            forfeitAddress: fromServer.forfeitAddress ?? "",
+            forfeitPubkey: fromServer.forfeitPubkey ?? "",
+            network: fromServer.network ?? "",
+            scheduledSession: "scheduledSession" in fromServer &&
+                fromServer.scheduledSession != null
                 ? {
-                    nextStartTime: BigInt(fromServer.marketHour.nextStartTime ?? 0),
-                    nextEndTime: BigInt(fromServer.marketHour.nextEndTime ?? 0),
-                    period: BigInt(fromServer.marketHour.period ?? 0),
-                    roundInterval: BigInt(fromServer.marketHour.roundInterval ?? 0),
+                    duration: BigInt(fromServer.scheduledSession.duration ?? 0),
+                    nextStartTime: BigInt(fromServer.scheduledSession.nextStartTime ?? 0),
+                    nextEndTime: BigInt(fromServer.scheduledSession.nextEndTime ?? 0),
+                    period: BigInt(fromServer.scheduledSession.period ?? 0),
                 }
                 : undefined,
+            serviceStatus: fromServer.serviceStatus ?? {},
+            sessionDuration: BigInt(fromServer.sessionDuration ?? 0),
+            signerPubkey: fromServer.signerPubkey ?? "",
+            unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
+            utxoMaxAmount: BigInt(fromServer.utxoMaxAmount ?? -1),
+            utxoMinAmount: BigInt(fromServer.utxoMinAmount ?? 0),
+            version: fromServer.version ?? "",
+            vtxoMaxAmount: BigInt(fromServer.vtxoMaxAmount ?? -1),
+            vtxoMinAmount: BigInt(fromServer.vtxoMinAmount ?? 0),
         };
     }
     async submitTx(signedArkTx, checkpointTxs) {
@@ -61,8 +72,8 @@ export class RestArkProvider {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                signedArkTx: signedArkTx,
-                checkpointTxs: checkpointTxs,
+                signedArkTx,
+                checkpointTxs,
             }),
         });
         if (!response.ok) {
@@ -111,7 +122,7 @@ export class RestArkProvider {
             },
             body: JSON.stringify({
                 intent: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
@@ -132,7 +143,7 @@ export class RestArkProvider {
             },
             body: JSON.stringify({
                 proof: {
-                    signature: intent.signature,
+                    proof: intent.proof,
                     message: intent.message,
                 },
             }),
@@ -305,6 +316,31 @@ export class RestArkProvider {
             }
         }
     }
+    async getPendingTxs(intent) {
+        const url = `${this.serverUrl}/v1/tx/pending`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ intent }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            try {
+                const grpcError = JSON.parse(errorText);
+                // gRPC errors usually have a message and code field
+                throw new Error(`Failed to get pending transactions: ${grpcError.message || grpcError.error || errorText}`);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (_) {
+                // If JSON parse fails, use the raw error text
+                throw new Error(`Failed to get pending transactions: ${errorText}`);
+            }
+        }
+        const data = await response.json();
+        return data.pendingTxs;
+    }
     parseSettlementEvent(data) {
         // Check for BatchStarted event
         if (data.batchStarted) {
@@ -383,6 +419,10 @@ export class RestArkProvider {
                 signature: data.treeSignature.signature,
             };
         }
+        // TODO: Handle TreeNoncesEvent when implemented server-side
+        if (data.treeNonces) {
+            return null;
+        }
         // Skip heartbeat events
         if (data.heartbeat) {
             return null;
@@ -426,17 +466,16 @@ function encodeMusig2Nonces(nonces) {
     for (const [txid, nonce] of nonces) {
         noncesObject[txid] = hex.encode(nonce.pubNonce);
     }
-    return JSON.stringify(noncesObject);
+    return noncesObject;
 }
 function encodeMusig2Signatures(signatures) {
     const sigObject = {};
     for (const [txid, sig] of signatures) {
         sigObject[txid] = hex.encode(sig.encode());
     }
-    return JSON.stringify(sigObject);
+    return sigObject;
 }
-function decodeMusig2Nonces(str) {
-    const noncesObject = JSON.parse(str);
+function decodeMusig2Nonces(noncesObject) {
     return new Map(Object.entries(noncesObject).map(([txid, nonce]) => {
         if (typeof nonce !== "string") {
             throw new Error("invalid nonce");

package/dist/esm/providers/expoArk.js

@@ -1,4 +1,5 @@
 import { RestArkProvider, isFetchTimeoutError, } from './ark.js';
+import { getExpoFetch, sseStreamIterator } from './expoUtils.js';
 /**
  * Expo-compatible Ark provider implementation using expo/fetch for SSE support.
  * This provider works specifically in React Native/Expo environments where
@@ -17,87 +18,23 @@ export class ExpoArkProvider extends RestArkProvider {
         super(serverUrl);
     }
     async *getEventStream(signal, topics) {
-        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
-        let expoFetch = fetch; // Default to standard fetch
-        try {
-            const expoFetchModule = await import("expo/fetch");
-            // expo/fetch returns a compatible fetch function but with different types
-            expoFetch = expoFetchModule.fetch;
-            console.debug("Using expo/fetch for SSE");
-        }
-        catch (error) {
-            // Fall back to standard fetch if expo/fetch is not available
-            console.warn("Using standard fetch instead of expo/fetch. " +
-                "Streaming may not be fully supported in some environments.", error);
-        }
+        const expoFetch = await getExpoFetch();
         const url = `${this.serverUrl}/v1/batch/events`;
         const queryParams = topics.length > 0
             ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
             : "";
         while (!signal?.aborted) {
-            // Create a new AbortController for this specific fetch attempt
-            // to prevent accumulating listeners on the parent signal
-            const fetchController = new AbortController();
-            const cleanup = () => fetchController.abort();
-            signal?.addEventListener("abort", cleanup, { once: true });
             try {
-                const response = await expoFetch(url + queryParams, {
-                    headers: {
-                        Accept: "text/event-stream",
-                    },
-                    signal: fetchController.signal,
-                });
-                if (!response.ok) {
-                    throw new Error(`Unexpected status ${response.status} when fetching event stream`);
-                }
-                if (!response.body) {
-                    throw new Error("Response body is null");
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                while (!signal?.aborted) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
+                yield* sseStreamIterator(url + queryParams, signal, expoFetch, {}, (data) => {
+                    // Handle different response structures
+                    // v8 mesh API might wrap in {result: ...} or send directly
+                    const eventData = data.result || data;
+                    // Skip heartbeat messages
+                    if (eventData.heartbeat !== undefined) {
+                        return null;
                     }
-                    // Append new data to buffer and split by newlines
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    // Process all complete lines
-                    for (let i = 0; i < lines.length - 1; i++) {
-                        const line = lines[i].trim();
-                        if (!line)
-                            continue;
-                        try {
-                            // Parse SSE format: "data: {json}"
-                            if (line.startsWith("data:")) {
-                                const jsonStr = line.substring(5).trim();
-                                if (!jsonStr)
-                                    continue;
-                                const data = JSON.parse(jsonStr);
-                                // Handle different response structures
-                                // v8 mesh API might wrap in {result: ...} or send directly
-                                const eventData = data.result || data;
-                                // Skip heartbeat messages
-                                if (eventData.heartbeat !== undefined) {
-                                    continue;
-                                }
-                                const event = this.parseSettlementEvent(eventData);
-                                if (event) {
-                                    yield event;
-                                }
-                            }
-                        }
-                        catch (err) {
-                            console.error("Failed to parse event:", line);
-                            console.error("Parse error:", err);
-                            throw err;
-                        }
-                    }
-                    // Keep the last partial line in the buffer
-                    buffer = lines[lines.length - 1];
-                }
+                    return this.parseSettlementEvent(eventData);
+                });
             }
             catch (error) {
                 if (error instanceof Error && error.name === "AbortError") {
@@ -112,71 +49,16 @@ export class ExpoArkProvider extends RestArkProvider {
                 console.error("Event stream error:", error);
                 throw error;
             }
-            finally {
-                // Clean up the abort listener
-                signal?.removeEventListener("abort", cleanup);
-            }
         }
     }
     async *getTransactionsStream(signal) {
-        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
-        let expoFetch = fetch; // Default to standard fetch
-        try {
-            const expoFetchModule = await import("expo/fetch");
-            // expo/fetch returns a compatible fetch function but with different types
-            expoFetch = expoFetchModule.fetch;
-            console.debug("Using expo/fetch for transaction stream");
-        }
-        catch (error) {
-            // Fall back to standard fetch if expo/fetch is not available
-            console.warn("Using standard fetch instead of expo/fetch. " +
-                "Streaming may not be fully supported in some environments.", error);
-        }
+        const expoFetch = await getExpoFetch();
         const url = `${this.serverUrl}/v1/txs`;
         while (!signal?.aborted) {
-            // Create a new AbortController for this specific fetch attempt
-            // to prevent accumulating listeners on the parent signal
-            const fetchController = new AbortController();
-            const cleanup = () => fetchController.abort();
-            signal?.addEventListener("abort", cleanup, { once: true });
             try {
-                const response = await expoFetch(url, {
-                    headers: {
-                        Accept: "text/event-stream",
-                    },
-                    signal: fetchController.signal,
+                yield* sseStreamIterator(url, signal, expoFetch, {}, (data) => {
+                    return this.parseTransactionNotification(data.result);
                 });
-                if (!response.ok) {
-                    throw new Error(`Unexpected status ${response.status} when fetching transaction stream`);
-                }
-                if (!response.body) {
-                    throw new Error("Response body is null");
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                while (!signal?.aborted) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
-                    }
-                    // Append new data to buffer and split by newlines
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    // Process all complete lines
-                    for (let i = 0; i < lines.length - 1; i++) {
-                        const line = lines[i].trim();
-                        if (!line)
-                            continue;
-                        const data = JSON.parse(line);
-                        const txNotification = this.parseTransactionNotification(data.result);
-                        if (txNotification) {
-                            yield txNotification;
-                        }
-                    }
-                    // Keep the last partial line in the buffer
-                    buffer = lines[lines.length - 1];
-                }
             }
             catch (error) {
                 if (error instanceof Error && error.name === "AbortError") {
@@ -188,13 +70,9 @@ export class ExpoArkProvider extends RestArkProvider {
                     console.debug("Timeout error ignored");
                     continue;
                 }
-                console.error("Address subscription error:", error);
+                console.error("Transaction stream error:", error);
                 throw error;
             }
-            finally {
-                // Clean up the abort listener
-                signal?.removeEventListener("abort", cleanup);
-            }
         }
     }
 }

package/dist/esm/providers/expoIndexer.js

@@ -1,5 +1,6 @@
 import { RestIndexerProvider } from './indexer.js';
 import { isFetchTimeoutError } from './ark.js';
+import { getExpoFetch, sseStreamIterator } from './expoUtils.js';
 // Helper function to convert Vtxo to VirtualCoin (same as in indexer.ts)
 function convertVtxo(vtxo) {
     return {
@@ -49,95 +50,38 @@ export class ExpoIndexerProvider extends RestIndexerProvider {
         // Detect if we're running in React Native/Expo environment
         const isReactNative = typeof navigator !== "undefined" &&
             navigator.product === "ReactNative";
-        // Dynamic import to avoid bundling expo/fetch in non-Expo environments
-        let expoFetch = fetch; // Default to standard fetch
-        try {
-            const expoFetchModule = await import("expo/fetch");
-            // expo/fetch returns a compatible fetch function but with different types
-            expoFetch = expoFetchModule.fetch;
-            console.debug("Using expo/fetch for indexer subscription");
-        }
-        catch (error) {
+        const expoFetch = await getExpoFetch().catch((error) => {
             // In React Native/Expo, expo/fetch is required for proper streaming support
             if (isReactNative) {
                 throw new Error("expo/fetch is unavailable in React Native environment. " +
                     "Please ensure expo/fetch is installed and properly configured. " +
                     "Streaming support may not work with standard fetch in React Native.");
             }
-            // In non-RN environments, fall back to standard fetch but warn about potential streaming issues
-            console.warn("Using standard fetch instead of expo/fetch. " +
-                "Streaming may not be fully supported in some environments.", error);
-        }
+            throw error;
+        });
         const url = `${this.serverUrl}/v1/indexer/script/subscription/${subscriptionId}`;
         while (!abortSignal.aborted) {
             try {
-                const res = await expoFetch(url, {
-                    headers: {
-                        Accept: "text/event-stream",
-                        "Content-Type": "application/json",
-                    },
-                    signal: abortSignal,
-                });
-                if (!res.ok) {
-                    throw new Error(`Unexpected status ${res.status} when subscribing to address updates`);
-                }
-                // Check if response is the expected content type
-                const contentType = res.headers.get("content-type");
-                if (contentType &&
-                    !contentType.includes("text/event-stream") &&
-                    !contentType.includes("application/json")) {
-                    throw new Error(`Unexpected content-type: ${contentType}. Expected text/event-stream or application/json`);
-                }
-                if (!res.body) {
-                    throw new Error("Response body is null");
-                }
-                const reader = res.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                while (!abortSignal.aborted) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        break;
+                yield* sseStreamIterator(url, abortSignal, expoFetch, { "Content-Type": "application/json" }, (data) => {
+                    // Handle new v8 proto format with heartbeat or event
+                    if (data.heartbeat !== undefined) {
+                        // Skip heartbeat messages
+                        return null;
                     }
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    for (let i = 0; i < lines.length - 1; i++) {
-                        const line = lines[i].trim();
-                        if (!line)
-                            continue;
-                        try {
-                            // Parse SSE format: "data: {json}"
-                            if (line.startsWith("data:")) {
-                                const jsonStr = line.substring(5).trim();
-                                if (!jsonStr)
-                                    continue;
-                                const data = JSON.parse(jsonStr);
-                                // Handle new v8 proto format with heartbeat or event
-                                if (data.heartbeat !== undefined) {
-                                    // Skip heartbeat messages
-                                    continue;
-                                }
-                                // Process event messages
-                                if (data.event) {
-                                    yield {
-                                        txid: data.event.txid,
-                                        scripts: data.event.scripts || [],
-                                        newVtxos: (data.event.newVtxos || []).map(convertVtxo),
-                                        spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
-                                        sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
-                                        tx: data.event.tx,
-                                        checkpointTxs: data.event.checkpointTxs,
-                                    };
-                                }
-                            }
-                        }
-                        catch (parseError) {
-                            console.error("Failed to parse subscription response:", parseError);
-                            throw parseError;
-                        }
+                    // Process event messages
+                    if (data.event) {
+                        return {
+                            txid: data.event.txid,
+                            scripts: data.event.scripts || [],
+                            newVtxos: (data.event.newVtxos || []).map(convertVtxo),
+                            spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
+                            sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                            tx: data.event.tx,
+                            checkpointTxs: data.event.checkpointTxs,
+                        };
                     }
-                    buffer = lines[lines.length - 1];
-                }
+                    return null;
+                });
             }
             catch (error) {
                 if (error instanceof Error && error.name === "AbortError") {

package/dist/esm/providers/expoUtils.js

@@ -0,0 +1,87 @@
+/**
+ * Dynamically imports expo/fetch with fallback to standard fetch.
+ * @returns A fetch function suitable for SSE streaming
+ */
+export async function getExpoFetch(options) {
+    const requireExpo = options?.requireExpo ?? false;
+    try {
+        const expoFetchModule = await import("expo/fetch");
+        console.debug("Using expo/fetch for streaming");
+        return expoFetchModule.fetch;
+    }
+    catch (error) {
+        if (requireExpo) {
+            throw new Error("expo/fetch is unavailable in this environment. " +
+                "Please ensure expo/fetch is installed and properly configured.");
+        }
+        console.warn("Using standard fetch instead of expo/fetch. " +
+            "Streaming may not be fully supported in some environments.", error);
+        return fetch;
+    }
+}
+/**
+ * Generic SSE stream processor using fetch API with ReadableStream.
+ * Handles SSE format parsing, buffer management, and abort signals.
+ *
+ * @param url - The SSE endpoint URL
+ * @param abortSignal - Signal to abort the stream
+ * @param fetchFn - Fetch function to use (defaults to standard fetch)
+ * @param headers - Additional headers to send
+ * @param parseData - Function to parse and yield data from SSE events
+ */
+export async function* sseStreamIterator(url, abortSignal, fetchFn, headers, parseData) {
+    const fetchController = new AbortController();
+    const cleanup = () => fetchController.abort();
+    abortSignal?.addEventListener("abort", cleanup, { once: true });
+    try {
+        const response = await fetchFn(url, {
+            headers: {
+                Accept: "text/event-stream",
+                ...headers,
+            },
+            signal: fetchController.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Unexpected status ${response.status} when fetching SSE stream`);
+        }
+        if (!response.body) {
+            throw new Error("Response body is null");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (!abortSignal?.aborted) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            for (let i = 0; i < lines.length - 1; i++) {
+                const line = lines[i].trim();
+                if (!line)
+                    continue;
+                if (line.startsWith("data:")) {
+                    const jsonStr = line.substring(5).trim();
+                    if (!jsonStr)
+                        continue;
+                    try {
+                        const data = JSON.parse(jsonStr);
+                        const parsed = parseData(data);
+                        if (parsed !== null) {
+                            yield parsed;
+                        }
+                    }
+                    catch (parseError) {
+                        console.error("Failed to parse SSE data:", parseError);
+                        throw parseError;
+                    }
+                }
+            }
+            buffer = lines[lines.length - 1];
+        }
+    }
+    finally {
+        abortSignal?.removeEventListener("abort", cleanup);
+    }
+}

package/dist/esm/script/base.js

@@ -1,7 +1,6 @@
-import { Script, Address, p2tr, taprootListToTree } from "@scure/btc-signer";
+import { Script, Address, p2tr, taprootListToTree, TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer";
 import { TAP_LEAF_VERSION } from "@scure/btc-signer/payment.js";
 import { PSBTOutput } from "@scure/btc-signer/psbt.js";
-import { TAPROOT_UNSPENDABLE_KEY, } from "@scure/btc-signer/utils.js";
 import { hex } from "@scure/base";
 import { ArkAddress } from './address.js';
 import { ConditionCSVMultisigTapscript, CSVMultisigTapscript, } from './tapscript.js';

package/dist/esm/script/tapscript.js

@@ -1,6 +1,5 @@
 import * as bip68 from "bip68";
-import { Script, ScriptNum } from "@scure/btc-signer/script.js";
-import { p2tr_ms } from "@scure/btc-signer/payment.js";
+import { Script, ScriptNum, p2tr_ms } from "@scure/btc-signer";
 import { hex } from "@scure/base";
 const MinimalScriptNum = ScriptNum(undefined, true);
 export var TapscriptType;

package/dist/esm/script/vhtlc.js

@@ -1,4 +1,4 @@
-import { Script } from "@scure/btc-signer/script.js";
+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';

package/dist/esm/tree/signingSession.js

@@ -3,7 +3,7 @@ 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, sha256x2 } from "@scure/btc-signer/utils.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");
@@ -20,15 +20,15 @@ export class TreeSignerSession {
         const secretKey = randomPrivateKeyBytes();
         return new TreeSignerSession(secretKey);
     }
-    init(tree, scriptRoot, rootInputAmount) {
+    async init(tree, scriptRoot, rootInputAmount) {
         this.graph = tree;
         this.scriptRoot = scriptRoot;
         this.rootSharedOutputAmount = rootInputAmount;
     }
-    getPublicKey() {
+    async getPublicKey() {
         return secp256k1.getPublicKey(this.secretKey);
     }
-    getNonces() {
+    async getNonces() {
         if (!this.graph)
             throw ErrMissingVtxoGraph;
         if (!this.myNonces) {
@@ -40,12 +40,12 @@ export class TreeSignerSession {
         }
         return publicNonces;
     }
-    setAggregatedNonces(nonces) {
+    async setAggregatedNonces(nonces) {
         if (this.aggregateNonces)
             throw new Error("nonces already set");
         this.aggregateNonces = nonces;
     }
-    sign() {
+    async sign() {
         if (!this.graph)
             throw ErrMissingVtxoGraph;
         if (!this.aggregateNonces)
@@ -128,9 +128,8 @@ export async function validateTreeSigs(finalAggregatedKey, sharedOutputAmount, v
 function getPrevOutput(finalKey, graph, sharedOutputAmount, tx) {
     // generate P2TR script from musig2 final key
     const pkScript = Script.encode(["OP_1", finalKey.slice(1)]);
-    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) {
+    if (tx.id === graph.txid) {
         return {
             amount: sharedOutputAmount,
             script: pkScript,
@@ -140,7 +139,7 @@ function getPrevOutput(finalKey, graph, sharedOutputAmount, tx) {
     const parentInput = tx.getInput(0);
     if (!parentInput.txid)
         throw new Error("missing parent input txid");
-    const parentTxid = hex.encode(new Uint8Array(parentInput.txid));
+    const parentTxid = hex.encode(parentInput.txid);
     const parent = graph.find(parentTxid);
     if (!parent)
         throw new Error("parent  tx not found");