@arkade-os/sdk 0.1.4 → 0.2.0

package/dist/esm/providers/ark.js

@@ -1,13 +1,24 @@
-import { TxTree } from '../tree/vtxoTree.js';
 import { hex } from "@scure/base";
 export var SettlementEventType;
 (function (SettlementEventType) {
-    SettlementEventType["Finalization"] = "finalization";
-    SettlementEventType["Finalized"] = "finalized";
-    SettlementEventType["Failed"] = "failed";
-    SettlementEventType["SigningStart"] = "signing_start";
-    SettlementEventType["SigningNoncesGenerated"] = "signing_nonces_generated";
+    SettlementEventType["BatchStarted"] = "batch_started";
+    SettlementEventType["BatchFinalization"] = "batch_finalization";
+    SettlementEventType["BatchFinalized"] = "batch_finalized";
+    SettlementEventType["BatchFailed"] = "batch_failed";
+    SettlementEventType["TreeSigningStarted"] = "tree_signing_started";
+    SettlementEventType["TreeNoncesAggregated"] = "tree_nonces_aggregated";
+    SettlementEventType["TreeTx"] = "tree_tx";
+    SettlementEventType["TreeSignature"] = "tree_signature";
 })(SettlementEventType || (SettlementEventType = {}));
+/**
+ * REST-based Ark provider implementation.
+ * @see https://buf.build/arkade-os/arkd/docs/main:ark.v1#ark.v1.ArkService
+ * @example
+ * ```typescript
+ * const provider = new RestArkProvider('https://ark.example.com');
+ * const info = await provider.getInfo();
+ * ```
+ */
 export class RestArkProvider {
     constructor(serverUrl) {
         this.serverUrl = serverUrl;
@@ -21,48 +32,35 @@ export class RestArkProvider {
         const fromServer = await response.json();
         return {
             ...fromServer,
+            vtxoTreeExpiry: BigInt(fromServer.vtxoTreeExpiry ?? 0),
             unilateralExitDelay: BigInt(fromServer.unilateralExitDelay ?? 0),
-            batchExpiry: BigInt(fromServer.vtxoTreeExpiry ?? 0),
-        };
-    }
-    async getVirtualCoins(address) {
-        const url = `${this.serverUrl}/v1/vtxos/${address}`;
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch VTXOs: ${response.statusText}`);
-        }
-        const data = await response.json();
-        return {
-            spendableVtxos: [...(data.spendableVtxos || [])].map(convertVtxo),
-            spentVtxos: [...(data.spentVtxos || [])].map(convertVtxo),
-        };
-    }
-    async getRound(txid) {
-        const url = `${this.serverUrl}/v1/round/${txid}`;
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch round: ${response.statusText}`);
-        }
-        const data = (await response.json());
-        const round = data.round;
-        return {
-            id: round.id,
-            start: new Date(Number(round.start) * 1000), // Convert from Unix timestamp to Date
-            end: new Date(Number(round.end) * 1000), // Convert from Unix timestamp to Date
-            vtxoTree: this.toTxTree(round.vtxoTree),
-            forfeitTxs: round.forfeitTxs || [],
-            connectors: this.toTxTree(round.connectors),
+            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),
+            marketHour: "marketHour" in fromServer && fromServer.marketHour != 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),
+                }
+                : undefined,
         };
     }
-    async submitVirtualTx(psbtBase64) {
-        const url = `${this.serverUrl}/v1/redeem-tx`;
+    async submitTx(signedArkTx, checkpointTxs) {
+        const url = `${this.serverUrl}/v1/tx/submit`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                redeem_tx: psbtBase64,
+                signedArkTx: signedArkTx,
+                checkpointTxs: checkpointTxs,
             }),
         });
         if (!response.ok) {
@@ -79,140 +77,96 @@ export class RestArkProvider {
             }
         }
         const data = await response.json();
-        // Handle both current and future response formats
-        return data.txid || data.signedRedeemTx;
-    }
-    async subscribeToEvents(callback) {
-        const url = `${this.serverUrl}/v1/events`;
-        let abortController = new AbortController();
-        (async () => {
-            while (!abortController.signal.aborted) {
-                try {
-                    const response = await fetch(url, {
-                        headers: {
-                            Accept: "application/json",
-                        },
-                        signal: abortController.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 (!abortController.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;
-                            try {
-                                const data = JSON.parse(line);
-                                callback(data);
-                            }
-                            catch (err) {
-                                console.error("Failed to parse event:", err);
-                            }
-                        }
-                        // Keep the last partial line in the buffer
-                        buffer = lines[lines.length - 1];
-                    }
-                }
-                catch (error) {
-                    if (!abortController.signal.aborted) {
-                        console.error("Event stream error:", error);
-                    }
-                }
-            }
-        })();
-        // Return unsubscribe function
-        return () => {
-            abortController.abort();
-            // Create a new controller for potential future subscriptions
-            abortController = new AbortController();
+        return {
+            arkTxid: data.arkTxid,
+            finalArkTx: data.finalArkTx,
+            signedCheckpointTxs: data.signedCheckpointTxs,
         };
     }
-    async registerInputsForNextRound(inputs) {
-        const url = `${this.serverUrl}/v1/round/registerInputs`;
-        const vtxoInputs = [];
-        const noteInputs = [];
-        for (const input of inputs) {
-            if (typeof input === "string") {
-                noteInputs.push(input);
-            }
-            else {
-                vtxoInputs.push({
-                    outpoint: {
-                        txid: input.outpoint.txid,
-                        vout: input.outpoint.vout,
-                    },
-                    tapscripts: {
-                        scripts: input.tapscripts,
-                    },
-                });
-            }
+    async finalizeTx(arkTxid, finalCheckpointTxs) {
+        const url = `${this.serverUrl}/v1/tx/finalize`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                arkTxid,
+                finalCheckpointTxs,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to finalize offchain transaction: ${errorText}`);
         }
+    }
+    async registerIntent(intent) {
+        const url = `${this.serverUrl}/v1/batch/registerIntent`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                inputs: vtxoInputs,
-                notes: noteInputs,
+                intent: {
+                    signature: intent.signature,
+                    message: intent.message,
+                },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to register inputs: ${errorText}`);
+            throw new Error(`Failed to register intent: ${errorText}`);
         }
         const data = await response.json();
-        return { requestId: data.requestId };
+        return data.intentId;
     }
-    async registerOutputsForNextRound(requestId, outputs, cosignersPublicKeys, signingAll = false) {
-        const url = `${this.serverUrl}/v1/round/registerOutputs`;
+    async deleteIntent(intent) {
+        const url = `${this.serverUrl}/v1/batch/deleteIntent`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                requestId,
-                outputs: outputs.map((output) => ({
-                    address: output.address,
-                    amount: output.amount.toString(10),
-                })),
-                musig2: {
-                    cosignersPublicKeys,
-                    signingAll,
+                proof: {
+                    signature: intent.signature,
+                    message: intent.message,
                 },
             }),
         });
         if (!response.ok) {
             const errorText = await response.text();
-            throw new Error(`Failed to register outputs: ${errorText}`);
+            throw new Error(`Failed to delete intent: ${errorText}`);
+        }
+    }
+    async confirmRegistration(intentId) {
+        const url = `${this.serverUrl}/v1/batch/ack`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                intentId,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to confirm registration: ${errorText}`);
         }
     }
-    async submitTreeNonces(settlementID, pubkey, nonces) {
-        const url = `${this.serverUrl}/v1/round/tree/submitNonces`;
+    async submitTreeNonces(batchId, pubkey, nonces) {
+        const url = `${this.serverUrl}/v1/batch/tree/submitNonces`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                roundId: settlementID,
+                batchId,
                 pubkey,
-                treeNonces: encodeNoncesMatrix(nonces),
+                treeNonces: encodeMusig2Nonces(nonces),
             }),
         });
         if (!response.ok) {
@@ -220,17 +174,17 @@ export class RestArkProvider {
             throw new Error(`Failed to submit tree nonces: ${errorText}`);
         }
     }
-    async submitTreeSignatures(settlementID, pubkey, signatures) {
-        const url = `${this.serverUrl}/v1/round/tree/submitSignatures`;
+    async submitTreeSignatures(batchId, pubkey, signatures) {
+        const url = `${this.serverUrl}/v1/batch/tree/submitSignatures`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                roundId: settlementID,
+                batchId,
                 pubkey,
-                treeSignatures: encodeSignaturesMatrix(signatures),
+                treeSignatures: encodeMusig2Signatures(signatures),
             }),
         });
         if (!response.ok) {
@@ -238,8 +192,8 @@ export class RestArkProvider {
             throw new Error(`Failed to submit tree signatures: ${errorText}`);
         }
     }
-    async submitSignedForfeitTxs(signedForfeitTxs, signedRoundTx) {
-        const url = `${this.serverUrl}/v1/round/submitForfeitTxs`;
+    async submitSignedForfeitTxs(signedForfeitTxs, signedCommitmentTx) {
+        const url = `${this.serverUrl}/v1/batch/submitForfeitTxs`;
         const response = await fetch(url, {
             method: "POST",
             headers: {
@@ -247,25 +201,21 @@ export class RestArkProvider {
             },
             body: JSON.stringify({
                 signedForfeitTxs: signedForfeitTxs,
-                signedRoundTx: signedRoundTx,
+                signedCommitmentTx: signedCommitmentTx,
             }),
         });
         if (!response.ok) {
             throw new Error(`Failed to submit forfeit transactions: ${response.statusText}`);
         }
     }
-    async ping(requestId) {
-        const url = `${this.serverUrl}/v1/round/ping/${requestId}`;
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Ping failed: ${response.statusText}`);
-        }
-    }
-    async *getEventStream(signal) {
-        const url = `${this.serverUrl}/v1/events`;
+    async *getEventStream(signal, topics) {
+        const url = `${this.serverUrl}/v1/batch/events`;
+        const queryParams = topics.length > 0
+            ? `?${topics.map((topic) => `topics=${encodeURIComponent(topic)}`).join("&")}`
+            : "";
         while (!signal?.aborted) {
             try {
-                const response = await fetch(url, {
+                const response = await fetch(url + queryParams, {
                     headers: {
                         Accept: "application/json",
                     },
@@ -313,22 +263,29 @@ export class RestArkProvider {
                 if (error instanceof Error && error.name === "AbortError") {
                     break;
                 }
+                // ignore timeout errors, they're expected when the server is not sending anything for 5 min
+                // these timeouts are set by builtin fetch function
+                if (isFetchTimeoutError(error)) {
+                    console.debug("Timeout error ignored");
+                    continue;
+                }
                 console.error("Event stream error:", error);
                 throw error;
             }
         }
     }
-    async *subscribeForAddress(address, abortSignal) {
-        const url = `${this.serverUrl}/v1/vtxos/${address}/subscribe`;
-        while (!abortSignal.aborted) {
+    async *getTransactionsStream(signal) {
+        const url = `${this.serverUrl}/v1/txs`;
+        while (!signal?.aborted) {
             try {
                 const response = await fetch(url, {
                     headers: {
                         Accept: "application/json",
                     },
+                    signal,
                 });
                 if (!response.ok) {
-                    throw new Error(`Unexpected status ${response.status} when subscribing to address updates`);
+                    throw new Error(`Unexpected status ${response.status} when fetching transaction stream`);
                 }
                 if (!response.body) {
                     throw new Error("Response body is null");
@@ -336,35 +293,33 @@ export class RestArkProvider {
                 const reader = response.body.getReader();
                 const decoder = new TextDecoder();
                 let buffer = "";
-                while (!abortSignal.aborted) {
+                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;
-                        try {
-                            const data = JSON.parse(line);
-                            if ("result" in data) {
-                                yield {
-                                    newVtxos: (data.result.newVtxos || []).map(convertVtxo),
-                                    spentVtxos: (data.result.spentVtxos || []).map(convertVtxo),
-                                };
-                            }
-                        }
-                        catch (err) {
-                            console.error("Failed to parse address update:", err);
-                            throw err;
+                        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") {
+                    break;
+                }
                 // ignore timeout errors, they're expected when the server is not sending anything for 5 min
                 // these timeouts are set by builtin fetch function
                 if (isFetchTimeoutError(error)) {
@@ -376,178 +331,138 @@ export class RestArkProvider {
             }
         }
     }
-    toConnectorsIndex(connectorsIndex) {
-        return new Map(Object.entries(connectorsIndex).map(([key, value]) => [
-            key,
-            { txid: value.txid, vout: value.vout },
-        ]));
-    }
-    toTxTree(t) {
-        // collect the parent txids to determine later if a node is a leaf
-        const parentTxids = new Set();
-        t.levels.forEach((level) => level.nodes.forEach((node) => {
-            if (node.parentTxid) {
-                parentTxids.add(node.parentTxid);
-            }
-        }));
-        return new TxTree(t.levels.map((level) => level.nodes.map((node) => ({
-            txid: node.txid,
-            tx: node.tx,
-            parentTxid: node.parentTxid,
-            leaf: !parentTxids.has(node.txid),
-        }))));
-    }
     parseSettlementEvent(data) {
-        // Check for Finalization event
-        if (data.roundFinalization) {
+        // Check for BatchStarted event
+        if (data.batchStarted) {
+            return {
+                type: SettlementEventType.BatchStarted,
+                id: data.batchStarted.id,
+                intentIdHashes: data.batchStarted.intentIdHashes,
+                batchExpiry: BigInt(data.batchStarted.batchExpiry),
+            };
+        }
+        // Check for BatchFinalization event
+        if (data.batchFinalization) {
+            return {
+                type: SettlementEventType.BatchFinalization,
+                id: data.batchFinalization.id,
+                commitmentTx: data.batchFinalization.commitmentTx,
+            };
+        }
+        // Check for BatchFinalized event
+        if (data.batchFinalized) {
+            return {
+                type: SettlementEventType.BatchFinalized,
+                id: data.batchFinalized.id,
+                commitmentTxid: data.batchFinalized.commitmentTxid,
+            };
+        }
+        // Check for BatchFailed event
+        if (data.batchFailed) {
             return {
-                type: SettlementEventType.Finalization,
-                id: data.roundFinalization.id,
-                roundTx: data.roundFinalization.roundTx,
-                vtxoTree: this.toTxTree(data.roundFinalization.vtxoTree),
-                connectors: this.toTxTree(data.roundFinalization.connectors),
-                connectorsIndex: this.toConnectorsIndex(data.roundFinalization.connectorsIndex),
-                // divide by 1000 to convert to sat/vbyte
-                minRelayFeeRate: BigInt(data.roundFinalization.minRelayFeeRate) /
-                    BigInt(1000),
+                type: SettlementEventType.BatchFailed,
+                id: data.batchFailed.id,
+                reason: data.batchFailed.reason,
             };
         }
-        // Check for Finalized event
-        if (data.roundFinalized) {
+        // Check for TreeSigningStarted event
+        if (data.treeSigningStarted) {
             return {
-                type: SettlementEventType.Finalized,
-                id: data.roundFinalized.id,
-                roundTxid: data.roundFinalized.roundTxid,
+                type: SettlementEventType.TreeSigningStarted,
+                id: data.treeSigningStarted.id,
+                cosignersPublicKeys: data.treeSigningStarted.cosignersPubkeys,
+                unsignedCommitmentTx: data.treeSigningStarted.unsignedCommitmentTx,
             };
         }
-        // Check for Failed event
-        if (data.roundFailed) {
+        // Check for TreeNoncesAggregated event
+        if (data.treeNoncesAggregated) {
             return {
-                type: SettlementEventType.Failed,
-                id: data.roundFailed.id,
-                reason: data.roundFailed.reason,
+                type: SettlementEventType.TreeNoncesAggregated,
+                id: data.treeNoncesAggregated.id,
+                treeNonces: decodeMusig2Nonces(data.treeNoncesAggregated.treeNonces),
             };
         }
-        // Check for Signing event
-        if (data.roundSigning) {
+        // Check for TreeTx event
+        if (data.treeTx) {
+            const children = Object.fromEntries(Object.entries(data.treeTx.children).map(([outputIndex, txid]) => {
+                return [parseInt(outputIndex), txid];
+            }));
             return {
-                type: SettlementEventType.SigningStart,
-                id: data.roundSigning.id,
-                cosignersPublicKeys: data.roundSigning.cosignersPubkeys,
-                unsignedVtxoTree: this.toTxTree(data.roundSigning.unsignedVtxoTree),
-                unsignedSettlementTx: data.roundSigning.unsignedRoundTx,
+                type: SettlementEventType.TreeTx,
+                id: data.treeTx.id,
+                topic: data.treeTx.topic,
+                batchIndex: data.treeTx.batchIndex,
+                chunk: {
+                    txid: data.treeTx.txid,
+                    tx: data.treeTx.tx,
+                    children,
+                },
             };
         }
-        // Check for SigningNoncesGenerated event
-        if (data.roundSigningNoncesGenerated) {
+        if (data.treeSignature) {
             return {
-                type: SettlementEventType.SigningNoncesGenerated,
-                id: data.roundSigningNoncesGenerated.id,
-                treeNonces: decodeNoncesMatrix(hex.decode(data.roundSigningNoncesGenerated.treeNonces)),
+                type: SettlementEventType.TreeSignature,
+                id: data.treeSignature.id,
+                topic: data.treeSignature.topic,
+                batchIndex: data.treeSignature.batchIndex,
+                txid: data.treeSignature.txid,
+                signature: data.treeSignature.signature,
             };
         }
-        console.warn("Unknown event structure:", data);
+        console.warn("Unknown event type:", data);
         return null;
     }
-}
-function encodeMatrix(matrix) {
-    // Calculate total size needed:
-    // 4 bytes for number of rows
-    // For each row: 4 bytes for length + sum of encoded cell lengths + isNil byte * cell count
-    let totalSize = 4;
-    for (const row of matrix) {
-        totalSize += 4; // row length
-        for (const cell of row) {
-            totalSize += 1;
-            totalSize += cell.length;
+    parseTransactionNotification(data) {
+        if (data.commitmentTx) {
+            return {
+                commitmentTx: {
+                    txid: data.commitmentTx.txid,
+                    tx: data.commitmentTx.tx,
+                    spentVtxos: data.commitmentTx.spentVtxos.map(mapVtxo),
+                    spendableVtxos: data.commitmentTx.spendableVtxos.map(mapVtxo),
+                    checkpointTxs: data.commitmentTx.checkpointTxs,
+                },
+            };
         }
-    }
-    // Create buffer and DataView
-    const buffer = new ArrayBuffer(totalSize);
-    const view = new DataView(buffer);
-    let offset = 0;
-    // Write number of rows
-    view.setUint32(offset, matrix.length, true); // true for little-endian
-    offset += 4;
-    // Write each row
-    for (const row of matrix) {
-        // Write row length
-        view.setUint32(offset, row.length, true);
-        offset += 4;
-        // Write each cell
-        for (const cell of row) {
-            const notNil = cell.length > 0;
-            view.setInt8(offset, notNil ? 1 : 0);
-            offset += 1;
-            if (!notNil) {
-                continue;
-            }
-            new Uint8Array(buffer).set(cell, offset);
-            offset += cell.length;
+        if (data.arkTx) {
+            return {
+                arkTx: {
+                    txid: data.arkTx.txid,
+                    tx: data.arkTx.tx,
+                    spentVtxos: data.arkTx.spentVtxos.map(mapVtxo),
+                    spendableVtxos: data.arkTx.spendableVtxos.map(mapVtxo),
+                    checkpointTxs: data.arkTx.checkpointTxs,
+                },
+            };
         }
+        console.warn("Unknown transaction notification type:", data);
+        return null;
     }
-    return new Uint8Array(buffer);
 }
-function decodeMatrix(matrix, cellLength) {
-    // Create DataView to read the buffer
-    const view = new DataView(matrix.buffer, matrix.byteOffset, matrix.byteLength);
-    let offset = 0;
-    // Read number of rows
-    const numRows = view.getUint32(offset, true); // true for little-endian
-    offset += 4;
-    // Initialize result matrix
-    const result = [];
-    // Read each row
-    for (let i = 0; i < numRows; i++) {
-        // Read row length
-        const rowLength = view.getUint32(offset, true);
-        offset += 4;
-        const row = [];
-        // Read each cell in the row
-        for (let j = 0; j < rowLength; j++) {
-            const notNil = view.getUint8(offset) === 1;
-            offset += 1;
-            if (notNil) {
-                const cell = new Uint8Array(matrix.buffer, matrix.byteOffset + offset, cellLength);
-                row.push(new Uint8Array(cell));
-                offset += cellLength;
-            }
-            else {
-                row.push(new Uint8Array());
-            }
-        }
-        result.push(row);
+function encodeMusig2Nonces(nonces) {
+    const noncesObject = {};
+    for (const [txid, nonce] of nonces) {
+        noncesObject[txid] = hex.encode(nonce.pubNonce);
     }
-    return result;
-}
-function decodeNoncesMatrix(matrix) {
-    const decoded = decodeMatrix(matrix, 66);
-    return decoded.map((row) => row.map((nonce) => ({ pubNonce: nonce })));
+    return JSON.stringify(noncesObject);
 }
-function encodeNoncesMatrix(nonces) {
-    return hex.encode(encodeMatrix(nonces.map((row) => row.map((nonce) => (nonce ? nonce.pubNonce : new Uint8Array())))));
-}
-function encodeSignaturesMatrix(signatures) {
-    return hex.encode(encodeMatrix(signatures.map((row) => row.map((s) => (s ? s.encode() : new Uint8Array())))));
+function encodeMusig2Signatures(signatures) {
+    const sigObject = {};
+    for (const [txid, sig] of signatures) {
+        sigObject[txid] = hex.encode(sig.encode());
+    }
+    return JSON.stringify(sigObject);
 }
-function convertVtxo(vtxo) {
-    return {
-        txid: vtxo.outpoint.txid,
-        vout: vtxo.outpoint.vout,
-        value: Number(vtxo.amount),
-        status: {
-            confirmed: !!vtxo.roundTxid,
-        },
-        virtualStatus: {
-            state: vtxo.isPending ? "pending" : "settled",
-            batchTxID: vtxo.roundTxid,
-            batchExpiry: vtxo.expireAt ? Number(vtxo.expireAt) : undefined,
-        },
-        spentBy: vtxo.spentBy,
-        createdAt: new Date(vtxo.createdAt * 1000),
-    };
+function decodeMusig2Nonces(str) {
+    const noncesObject = JSON.parse(str);
+    return new Map(Object.entries(noncesObject).map(([txid, nonce]) => {
+        if (typeof nonce !== "string") {
+            throw new Error("invalid nonce");
+        }
+        return [txid, { pubNonce: hex.decode(nonce) }];
+    }));
 }
-function isFetchTimeoutError(err) {
+export function isFetchTimeoutError(err) {
     const checkError = (error) => {
         return (error instanceof Error &&
             (error.name === "HeadersTimeoutError" ||
@@ -557,3 +472,23 @@ function isFetchTimeoutError(err) {
     };
     return checkError(err) || checkError(err.cause);
 }
+function mapVtxo(vtxo) {
+    return {
+        outpoint: {
+            txid: vtxo.outpoint.txid,
+            vout: vtxo.outpoint.vout,
+        },
+        amount: vtxo.amount,
+        script: vtxo.script,
+        createdAt: vtxo.createdAt,
+        expiresAt: vtxo.expiresAt,
+        commitmentTxids: vtxo.commitmentTxids,
+        isPreconfirmed: vtxo.isPreconfirmed,
+        isSwept: vtxo.isSwept,
+        isUnrolled: vtxo.isUnrolled,
+        isSpent: vtxo.isSpent,
+        spentBy: vtxo.spentBy,
+        settledBy: vtxo.settledBy,
+        arkTxid: vtxo.arkTxid,
+    };
+}