@arkade-os/sdk 0.1.4 → 0.2.1

package/dist/cjs/tree/txTree.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxTree = void 0;
+const btc_signer_1 = require("@scure/btc-signer");
+const base_1 = require("@scure/base");
+const base_2 = require("@scure/base");
+const utils_1 = require("@scure/btc-signer/utils");
+/**
+ * TxTree is a graph of bitcoin transactions.
+ * It is used to represent batch tree created during settlement session
+ */
+class TxTree {
+    constructor(root, children = new Map()) {
+        this.root = root;
+        this.children = children;
+    }
+    static create(chunks) {
+        if (chunks.length === 0) {
+            throw new Error("empty chunks");
+        }
+        // Create a map to store all chunks by their txid for easy lookup
+        const chunksByTxid = new Map();
+        for (const chunk of chunks) {
+            const decodedChunk = decodeNode(chunk);
+            const txid = base_2.hex.encode((0, utils_1.sha256x2)(decodedChunk.tx.toBytes(true)).reverse());
+            chunksByTxid.set(txid, decodedChunk);
+        }
+        // Find the root chunks (the ones that aren't referenced as a child)
+        const rootTxids = [];
+        for (const [txid] of chunksByTxid) {
+            let isChild = false;
+            for (const [otherTxid, otherChunk] of chunksByTxid) {
+                if (otherTxid === txid) {
+                    // skip self
+                    continue;
+                }
+                // check if the current chunk is a child of the other chunk
+                isChild = hasChild(otherChunk, txid);
+                if (isChild) {
+                    break;
+                }
+            }
+            // if the chunk is not a child of any other chunk, it is a root
+            if (!isChild) {
+                rootTxids.push(txid);
+                continue;
+            }
+        }
+        if (rootTxids.length === 0) {
+            throw new Error("no root chunk found");
+        }
+        if (rootTxids.length > 1) {
+            throw new Error(`multiple root chunks found: ${rootTxids.join(", ")}`);
+        }
+        const graph = buildGraph(rootTxids[0], chunksByTxid);
+        if (!graph) {
+            throw new Error(`chunk not found for root txid: ${rootTxids[0]}`);
+        }
+        // verify that the number of chunks is equal to the number node in the graph
+        if (graph.nbOfNodes() !== chunks.length) {
+            throw new Error(`number of chunks (${chunks.length}) is not equal to the number of nodes in the graph (${graph.nbOfNodes()})`);
+        }
+        return graph;
+    }
+    nbOfNodes() {
+        let count = 1; // count this node
+        for (const child of this.children.values()) {
+            count += child.nbOfNodes();
+        }
+        return count;
+    }
+    validate() {
+        if (!this.root) {
+            throw new Error("unexpected nil root");
+        }
+        const nbOfOutputs = this.root.outputsLength;
+        const nbOfInputs = this.root.inputsLength;
+        if (nbOfInputs !== 1) {
+            throw new Error(`unexpected number of inputs: ${nbOfInputs}, expected 1`);
+        }
+        // the children map can't be bigger than the number of outputs (excluding the P2A)
+        // a graph can be "partial" and specify only some of the outputs as children,
+        // that's why we allow len(g.Children) to be less than nbOfOutputs-1
+        if (this.children.size > nbOfOutputs - 1) {
+            throw new Error(`unexpected number of children: ${this.children.size}, expected maximum ${nbOfOutputs - 1}`);
+        }
+        // validate each child
+        for (const [outputIndex, child] of this.children) {
+            if (outputIndex >= nbOfOutputs) {
+                throw new Error(`output index ${outputIndex} is out of bounds (nb of outputs: ${nbOfOutputs})`);
+            }
+            child.validate();
+            const childInput = child.root.getInput(0);
+            const parentTxid = base_2.hex.encode((0, utils_1.sha256x2)(this.root.toBytes(true)).reverse());
+            // verify the input of the child is the output of the parent
+            if (!childInput.txid ||
+                base_2.hex.encode(childInput.txid) !== parentTxid ||
+                childInput.index !== outputIndex) {
+                throw new Error(`input of child ${outputIndex} is not the output of the parent`);
+            }
+            // verify the sum of the child's outputs is equal to the output of the parent
+            let childOutputsSum = 0n;
+            for (let i = 0; i < child.root.outputsLength; i++) {
+                const output = child.root.getOutput(i);
+                if (output?.amount) {
+                    childOutputsSum += output.amount;
+                }
+            }
+            const parentOutput = this.root.getOutput(outputIndex);
+            if (!parentOutput?.amount) {
+                throw new Error(`parent output ${outputIndex} has no amount`);
+            }
+            if (childOutputsSum !== parentOutput.amount) {
+                throw new Error(`sum of child's outputs is not equal to the output of the parent: ${childOutputsSum} != ${parentOutput.amount}`);
+            }
+        }
+    }
+    leaves() {
+        if (this.children.size === 0) {
+            return [this.root];
+        }
+        const leaves = [];
+        for (const child of this.children.values()) {
+            leaves.push(...child.leaves());
+        }
+        return leaves;
+    }
+    get txid() {
+        return base_2.hex.encode((0, utils_1.sha256x2)(this.root.toBytes(true)).reverse());
+    }
+    find(txid) {
+        if (txid === this.txid) {
+            return this;
+        }
+        for (const child of this.children.values()) {
+            const found = child.find(txid);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    update(txid, fn) {
+        if (txid === this.txid) {
+            fn(this.root);
+            return;
+        }
+        for (const child of this.children.values()) {
+            try {
+                child.update(txid, fn);
+                return;
+            }
+            catch (error) {
+                // Continue searching in other children if not found
+                continue;
+            }
+        }
+        throw new Error(`tx not found: ${txid}`);
+    }
+    *[Symbol.iterator]() {
+        yield this;
+        for (const child of this.children.values()) {
+            yield* child;
+        }
+    }
+}
+exports.TxTree = TxTree;
+// Helper function to check if a chunk has a specific child
+function hasChild(chunk, childTxid) {
+    return Object.values(chunk.children).includes(childTxid);
+}
+// buildGraph recursively builds the TxGraph starting from the given txid
+function buildGraph(rootTxid, chunksByTxid) {
+    const chunk = chunksByTxid.get(rootTxid);
+    if (!chunk) {
+        return null;
+    }
+    const rootTx = chunk.tx;
+    const children = new Map();
+    // Recursively build children graphs
+    for (const [outputIndexStr, childTxid] of Object.entries(chunk.children)) {
+        const outputIndex = parseInt(outputIndexStr);
+        const childGraph = buildGraph(childTxid, chunksByTxid);
+        if (childGraph) {
+            children.set(outputIndex, childGraph);
+        }
+    }
+    return new TxTree(rootTx, children);
+}
+function decodeNode(chunk) {
+    const tx = btc_signer_1.Transaction.fromPSBT(base_1.base64.decode(chunk.tx));
+    return { tx, children: chunk.children };
+}

package/dist/cjs/tree/validation.js

@@ -1,184 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrInvalidNodeTransaction = exports.ErrInvalidRootTransaction = exports.ErrInvalidControlBlock = exports.ErrInternalKey = exports.ErrInvalidTaprootScript = exports.ErrLeafChildren = exports.ErrParentTxidInput = exports.ErrNodeTxidDifferent = exports.ErrNodeParentTxidEmpty = exports.ErrNodeTxidEmpty = exports.ErrNodeTxEmpty = exports.ErrNoLeaves = exports.ErrInvalidAmount = exports.ErrWrongSettlementTxid = exports.ErrNumberOfInputs = exports.ErrInvalidRootLevel = exports.ErrEmptyTree = exports.ErrInvalidSettlementTxOutputs = exports.ErrInvalidSettlementTx = void 0;
-exports.validateConnectorsTree = validateConnectorsTree;
-exports.validateVtxoTree = validateVtxoTree;
+exports.ErrMissingCosignersPublicKeys = exports.ErrWrongCommitmentTxid = exports.ErrInvalidRoundTxOutputs = exports.ErrInvalidTaprootScript = exports.ErrNoLeaves = exports.ErrInvalidAmount = exports.ErrWrongSettlementTxid = exports.ErrNumberOfInputs = exports.ErrEmptyTree = exports.ErrInvalidSettlementTxOutputs = exports.ErrInvalidSettlementTx = void 0;
+exports.validateConnectorsTxGraph = validateConnectorsTxGraph;
+exports.validateVtxoTxGraph = validateVtxoTxGraph;
 const base_1 = require("@scure/base");
 const btc_signer_1 = require("@scure/btc-signer");
 const base_2 = require("@scure/base");
 const utils_1 = require("@scure/btc-signer/utils");
 const musig2_1 = require("../musig2");
-const vtxoTree_1 = require("./vtxoTree");
-exports.ErrInvalidSettlementTx = new vtxoTree_1.TxTreeError("invalid settlement transaction");
-exports.ErrInvalidSettlementTxOutputs = new vtxoTree_1.TxTreeError("invalid settlement transaction outputs");
-exports.ErrEmptyTree = new vtxoTree_1.TxTreeError("empty tree");
-exports.ErrInvalidRootLevel = new vtxoTree_1.TxTreeError("invalid root level");
-exports.ErrNumberOfInputs = new vtxoTree_1.TxTreeError("invalid number of inputs");
-exports.ErrWrongSettlementTxid = new vtxoTree_1.TxTreeError("wrong settlement txid");
-exports.ErrInvalidAmount = new vtxoTree_1.TxTreeError("invalid amount");
-exports.ErrNoLeaves = new vtxoTree_1.TxTreeError("no leaves");
-exports.ErrNodeTxEmpty = new vtxoTree_1.TxTreeError("node transaction empty");
-exports.ErrNodeTxidEmpty = new vtxoTree_1.TxTreeError("node txid empty");
-exports.ErrNodeParentTxidEmpty = new vtxoTree_1.TxTreeError("node parent txid empty");
-exports.ErrNodeTxidDifferent = new vtxoTree_1.TxTreeError("node txid different");
-exports.ErrParentTxidInput = new vtxoTree_1.TxTreeError("parent txid input mismatch");
-exports.ErrLeafChildren = new vtxoTree_1.TxTreeError("leaf node has children");
-exports.ErrInvalidTaprootScript = new vtxoTree_1.TxTreeError("invalid taproot script");
-exports.ErrInternalKey = new vtxoTree_1.TxTreeError("invalid internal key");
-exports.ErrInvalidControlBlock = new vtxoTree_1.TxTreeError("invalid control block");
-exports.ErrInvalidRootTransaction = new vtxoTree_1.TxTreeError("invalid root transaction");
-exports.ErrInvalidNodeTransaction = new vtxoTree_1.TxTreeError("invalid node transaction");
-const SHARED_OUTPUT_INDEX = 0;
-const CONNECTORS_OUTPUT_INDEX = 1;
-function validateConnectorsTree(settlementTxB64, connectorsTree) {
-    connectorsTree.validate();
-    const rootNode = connectorsTree.root();
-    if (!rootNode)
-        throw exports.ErrEmptyTree;
-    const rootTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(rootNode.tx));
-    if (rootTx.inputsLength !== 1)
+const unknownFields_1 = require("../utils/unknownFields");
+const ErrInvalidSettlementTx = (tx) => new Error(`invalid settlement transaction: ${tx}`);
+exports.ErrInvalidSettlementTx = ErrInvalidSettlementTx;
+exports.ErrInvalidSettlementTxOutputs = new Error("invalid settlement transaction outputs");
+exports.ErrEmptyTree = new Error("empty tree");
+exports.ErrNumberOfInputs = new Error("invalid number of inputs");
+exports.ErrWrongSettlementTxid = new Error("wrong settlement txid");
+exports.ErrInvalidAmount = new Error("invalid amount");
+exports.ErrNoLeaves = new Error("no leaves");
+exports.ErrInvalidTaprootScript = new Error("invalid taproot script");
+exports.ErrInvalidRoundTxOutputs = new Error("invalid round transaction outputs");
+exports.ErrWrongCommitmentTxid = new Error("wrong commitment txid");
+exports.ErrMissingCosignersPublicKeys = new Error("missing cosigners public keys");
+const BATCH_OUTPUT_VTXO_INDEX = 0;
+const BATCH_OUTPUT_CONNECTORS_INDEX = 1;
+function validateConnectorsTxGraph(settlementTxB64, connectorsGraph) {
+    connectorsGraph.validate();
+    if (connectorsGraph.root.inputsLength !== 1)
         throw exports.ErrNumberOfInputs;
-    const rootInput = rootTx.getInput(0);
+    const rootInput = connectorsGraph.root.getInput(0);
     const settlementTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(settlementTxB64));
-    if (settlementTx.outputsLength <= CONNECTORS_OUTPUT_INDEX)
+    if (settlementTx.outputsLength <= BATCH_OUTPUT_CONNECTORS_INDEX)
         throw exports.ErrInvalidSettlementTxOutputs;
     const expectedRootTxid = base_1.hex.encode((0, utils_1.sha256x2)(settlementTx.toBytes(true)).reverse());
     if (!rootInput.txid)
         throw exports.ErrWrongSettlementTxid;
     if (base_1.hex.encode(rootInput.txid) !== expectedRootTxid)
         throw exports.ErrWrongSettlementTxid;
-    if (rootInput.index !== CONNECTORS_OUTPUT_INDEX)
+    if (rootInput.index !== BATCH_OUTPUT_CONNECTORS_INDEX)
         throw exports.ErrWrongSettlementTxid;
 }
-function validateVtxoTree(settlementTx, vtxoTree, sweepTapTreeRoot) {
-    vtxoTree.validate();
-    // Parse settlement transaction
-    let settlementTransaction;
-    try {
-        settlementTransaction = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(settlementTx));
-    }
-    catch {
-        throw exports.ErrInvalidSettlementTx;
-    }
-    if (settlementTransaction.outputsLength <= SHARED_OUTPUT_INDEX) {
-        throw exports.ErrInvalidSettlementTxOutputs;
-    }
-    const sharedOutput = settlementTransaction.getOutput(SHARED_OUTPUT_INDEX);
-    if (!sharedOutput?.amount)
-        throw exports.ErrInvalidSettlementTxOutputs;
-    const sharedOutputAmount = sharedOutput.amount;
-    const nbNodes = vtxoTree.numberOfNodes();
-    if (nbNodes === 0) {
+// ValidateVtxoTxGraph checks if the given vtxo graph is valid.
+// The function validates:
+// - the number of nodes
+// - the number of leaves
+// - children coherence with parent.
+// - every control block and taproot output scripts.
+// - input and output amounts.
+function validateVtxoTxGraph(graph, roundTransaction, sweepTapTreeRoot) {
+    if (roundTransaction.outputsLength < BATCH_OUTPUT_VTXO_INDEX + 1) {
+        throw exports.ErrInvalidRoundTxOutputs;
+    }
+    const batchOutputAmount = roundTransaction.getOutput(BATCH_OUTPUT_VTXO_INDEX)?.amount;
+    if (!batchOutputAmount) {
+        throw exports.ErrInvalidRoundTxOutputs;
+    }
+    if (!graph.root) {
         throw exports.ErrEmptyTree;
     }
-    if (vtxoTree.levels[0].length !== 1) {
-        throw exports.ErrInvalidRootLevel;
-    }
-    // Check root input is connected to settlement tx
-    const rootNode = vtxoTree.levels[0][0];
-    let rootTx;
-    try {
-        rootTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(rootNode.tx));
+    const rootInput = graph.root.getInput(0);
+    const commitmentTxid = base_1.hex.encode((0, utils_1.sha256x2)(roundTransaction.toBytes(true)).reverse());
+    if (!rootInput.txid ||
+        base_1.hex.encode(rootInput.txid) !== commitmentTxid ||
+        rootInput.index !== BATCH_OUTPUT_VTXO_INDEX) {
+        throw exports.ErrWrongCommitmentTxid;
     }
-    catch {
-        throw exports.ErrInvalidRootTransaction;
-    }
-    if (rootTx.inputsLength !== 1) {
-        throw exports.ErrNumberOfInputs;
-    }
-    const rootInput = rootTx.getInput(0);
-    if (!rootInput.txid || rootInput.index === undefined)
-        throw exports.ErrWrongSettlementTxid;
-    const settlementTxid = base_1.hex.encode((0, utils_1.sha256x2)(settlementTransaction.toBytes(true)).reverse());
-    if (base_1.hex.encode(rootInput.txid) !== settlementTxid ||
-        rootInput.index !== SHARED_OUTPUT_INDEX) {
-        throw exports.ErrWrongSettlementTxid;
-    }
-    // Check root output amounts
     let sumRootValue = 0n;
-    for (let i = 0; i < rootTx.outputsLength; i++) {
-        const output = rootTx.getOutput(i);
-        if (!output?.amount)
-            continue;
-        sumRootValue += output.amount;
+    for (let i = 0; i < graph.root.outputsLength; i++) {
+        const output = graph.root.getOutput(i);
+        if (output?.amount) {
+            sumRootValue += output.amount;
+        }
     }
-    if (sumRootValue >= sharedOutputAmount) {
+    if (sumRootValue !== batchOutputAmount) {
         throw exports.ErrInvalidAmount;
     }
-    if (vtxoTree.leaves().length === 0) {
+    const leaves = graph.leaves();
+    if (leaves.length === 0) {
         throw exports.ErrNoLeaves;
     }
-    // Validate each node in the tree
-    for (const level of vtxoTree.levels) {
-        for (const node of level) {
-            validateNode(vtxoTree, node, sweepTapTreeRoot);
-        }
-    }
-}
-function validateNode(vtxoTree, node, tapTreeRoot) {
-    if (!node.tx)
-        throw exports.ErrNodeTxEmpty;
-    if (!node.txid)
-        throw exports.ErrNodeTxidEmpty;
-    if (!node.parentTxid)
-        throw exports.ErrNodeParentTxidEmpty;
-    // Parse node transaction
-    let tx;
-    try {
-        tx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(node.tx));
-    }
-    catch {
-        throw exports.ErrInvalidNodeTransaction;
-    }
-    const txid = base_1.hex.encode((0, utils_1.sha256x2)(tx.toBytes(true)).reverse());
-    if (txid !== node.txid) {
-        throw exports.ErrNodeTxidDifferent;
-    }
-    if (tx.inputsLength !== 1) {
-        throw exports.ErrNumberOfInputs;
-    }
-    const input = tx.getInput(0);
-    if (!input.txid)
-        throw exports.ErrParentTxidInput;
-    if (base_1.hex.encode(input.txid) !== node.parentTxid) {
-        throw exports.ErrParentTxidInput;
-    }
-    const children = vtxoTree.children(node.txid);
-    if (node.leaf && children.length >= 1) {
-        throw exports.ErrLeafChildren;
-    }
-    // Validate each child
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-        const child = children[childIndex];
-        const childTx = btc_signer_1.Transaction.fromPSBT(base_2.base64.decode(child.tx));
-        const parentOutput = tx.getOutput(childIndex);
-        if (!parentOutput?.script)
-            throw exports.ErrInvalidTaprootScript;
-        const previousScriptKey = parentOutput.script.slice(2);
-        if (previousScriptKey.length !== 32) {
-            throw exports.ErrInvalidTaprootScript;
-        }
-        // Get cosigner keys from input
-        const cosignerKeys = (0, vtxoTree_1.getCosignerKeys)(childTx);
-        // Aggregate keys
-        const { finalKey } = (0, musig2_1.aggregateKeys)(cosignerKeys, true, {
-            taprootTweak: tapTreeRoot,
-        });
-        if (base_1.hex.encode(finalKey) !== base_1.hex.encode(previousScriptKey.slice(2))) {
-            throw exports.ErrInternalKey;
-        }
-        // Check amounts
-        let sumChildAmount = 0n;
-        for (let i = 0; i < childTx.outputsLength; i++) {
-            const output = childTx.getOutput(i);
-            if (!output?.amount)
-                continue;
-            sumChildAmount += output.amount;
-        }
-        if (!parentOutput.amount)
-            throw exports.ErrInvalidAmount;
-        if (sumChildAmount >= parentOutput.amount) {
-            throw exports.ErrInvalidAmount;
+    // validate the graph structure
+    graph.validate();
+    // iterates over all the nodes of the graph to verify that cosigners public keys are corresponding to the parent output
+    for (const g of graph) {
+        for (const [childIndex, child] of g.children) {
+            const parentOutput = g.root.getOutput(childIndex);
+            if (!parentOutput?.script) {
+                throw new Error(`parent output ${childIndex} not found`);
+            }
+            const previousScriptKey = parentOutput.script.slice(2);
+            if (previousScriptKey.length !== 32) {
+                throw new Error(`parent output ${childIndex} has invalid script`);
+            }
+            const cosigners = (0, unknownFields_1.getArkPsbtFields)(child.root, 0, unknownFields_1.CosignerPublicKey);
+            if (cosigners.length === 0) {
+                throw exports.ErrMissingCosignersPublicKeys;
+            }
+            const cosignerKeys = cosigners.map((c) => c.key);
+            const { finalKey } = (0, musig2_1.aggregateKeys)(cosignerKeys, true, {
+                taprootTweak: sweepTapTreeRoot,
+            });
+            if (!finalKey ||
+                base_1.hex.encode(finalKey.slice(1)) !== base_1.hex.encode(previousScriptKey)) {
+                throw exports.ErrInvalidTaprootScript;
+            }
         }
     }
 }

package/dist/cjs/utils/anchor.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2A = exports.ANCHOR_PKSCRIPT = exports.ANCHOR_VALUE = void 0;
+exports.findP2AOutput = findP2AOutput;
+const base_1 = require("@scure/base");
+exports.ANCHOR_VALUE = 0n;
+exports.ANCHOR_PKSCRIPT = new Uint8Array([0x51, 0x02, 0x4e, 0x73]);
+/**
+ * A zero-value anchor output.
+ */
+exports.P2A = {
+    script: exports.ANCHOR_PKSCRIPT,
+    amount: exports.ANCHOR_VALUE,
+};
+const hexP2Ascript = base_1.hex.encode(exports.P2A.script);
+/**
+ * search for anchor in the given transaction.
+ * @throws {Error} if the anchor is not found or has the wrong amount
+ */
+function findP2AOutput(tx) {
+    for (let i = 0; i < tx.outputsLength; i++) {
+        const output = tx.getOutput(i);
+        if (output.script && base_1.hex.encode(output.script) === hexP2Ascript) {
+            if (output.amount !== exports.P2A.amount) {
+                throw new Error(`P2A output has wrong amount, expected ${exports.P2A.amount} got ${output.amount}`);
+            }
+            return {
+                txid: tx.id,
+                index: i,
+                witnessUtxo: exports.P2A,
+            };
+        }
+    }
+    throw new Error("P2A output not found");
+}

package/dist/cjs/utils/arkTransaction.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOffchainTx = buildOffchainTx;
+const btc_signer_1 = require("@scure/btc-signer");
+const tapscript_1 = require("../script/tapscript");
+const base_1 = require("../script/base");
+const anchor_1 = require("./anchor");
+const base_2 = require("@scure/base");
+const utils_1 = require("@scure/btc-signer/utils");
+const unknownFields_1 = require("./unknownFields");
+/**
+ * Builds an offchain transaction with checkpoint transactions.
+ *
+ * Creates one checkpoint transaction per input and a virtual transaction that
+ * combines all the checkpoints, sending to the specified outputs. This is the
+ * core function for creating Ark transactions.
+ *
+ * @param inputs - Array of virtual transaction inputs
+ * @param outputs - Array of transaction outputs
+ * @param serverUnrollScript - Server unroll script for checkpoint transactions
+ * @returns Object containing the virtual transaction and checkpoint transactions
+ */
+function buildOffchainTx(inputs, outputs, serverUnrollScript) {
+    const checkpoints = inputs.map((input) => buildCheckpointTx(input, serverUnrollScript));
+    const arkTx = buildVirtualTx(checkpoints.map((c) => c.input), outputs);
+    return {
+        arkTx,
+        checkpoints: checkpoints.map((c) => c.tx),
+    };
+}
+function buildVirtualTx(inputs, outputs) {
+    let lockTime = 0n;
+    for (const input of inputs) {
+        const tapscript = (0, tapscript_1.decodeTapscript)((0, base_1.scriptFromTapLeafScript)(input.tapLeafScript));
+        if (tapscript_1.CLTVMultisigTapscript.is(tapscript)) {
+            if (lockTime !== 0n) {
+                // if a locktime is already set, check if the new locktime is in the same unit
+                if (isSeconds(lockTime) !==
+                    isSeconds(tapscript.params.absoluteTimelock)) {
+                    throw new Error("cannot mix seconds and blocks locktime");
+                }
+            }
+            if (tapscript.params.absoluteTimelock > lockTime) {
+                lockTime = tapscript.params.absoluteTimelock;
+            }
+        }
+    }
+    const tx = new btc_signer_1.Transaction({
+        version: 3,
+        allowUnknown: true,
+        allowUnknownOutputs: true,
+        lockTime: Number(lockTime),
+    });
+    for (const [i, input] of inputs.entries()) {
+        tx.addInput({
+            txid: input.txid,
+            index: input.vout,
+            sequence: lockTime ? btc_signer_1.DEFAULT_SEQUENCE - 1 : undefined,
+            witnessUtxo: {
+                script: base_1.VtxoScript.decode(input.tapTree).pkScript,
+                amount: BigInt(input.value),
+            },
+            tapLeafScript: [input.tapLeafScript],
+        });
+        (0, unknownFields_1.setArkPsbtField)(tx, i, unknownFields_1.VtxoTaprootTree, input.tapTree);
+    }
+    for (const output of outputs) {
+        tx.addOutput(output);
+    }
+    // add the anchor output
+    tx.addOutput(anchor_1.P2A);
+    return tx;
+}
+function buildCheckpointTx(vtxo, serverUnrollScript) {
+    // create the checkpoint vtxo script from collaborative closure
+    const collaborativeClosure = (0, tapscript_1.decodeTapscript)(vtxo.checkpointTapLeafScript ??
+        (0, base_1.scriptFromTapLeafScript)(vtxo.tapLeafScript));
+    // create the checkpoint vtxo script combining collaborative closure and server unroll script
+    const checkpointVtxoScript = new base_1.VtxoScript([
+        serverUnrollScript.script,
+        collaborativeClosure.script,
+    ]);
+    // build the checkpoint virtual tx
+    const checkpointTx = buildVirtualTx([vtxo], [
+        {
+            amount: BigInt(vtxo.value),
+            script: checkpointVtxoScript.pkScript,
+        },
+    ]);
+    // get the collaborative leaf proof
+    const collaborativeLeafProof = checkpointVtxoScript.findLeaf(base_2.hex.encode(collaborativeClosure.script));
+    // create the checkpoint input that will be used as input of the virtual tx
+    const checkpointInput = {
+        txid: base_2.hex.encode((0, utils_1.sha256x2)(checkpointTx.toBytes(true)).reverse()),
+        vout: 0,
+        value: vtxo.value,
+        tapLeafScript: collaborativeLeafProof,
+        tapTree: checkpointVtxoScript.encode(),
+    };
+    return {
+        tx: checkpointTx,
+        input: checkpointInput,
+    };
+}
+const nLocktimeMinSeconds = 500000000n;
+function isSeconds(locktime) {
+    return locktime >= nLocktimeMinSeconds;
+}