feat: SwapTreeSerializer support for covenants

lib/consts/Types.ts

@@ -59,3 +59,5 @@ export type SwapTree = {
   claimLeaf: Tapleaf;
   refundLeaf: Tapleaf;
 };
+
+export type LiquidSwapTree = SwapTree & { covenantClaimLeaf?: Tapleaf };

lib/liquid/consts/Types.ts

@@ -1,9 +1,7 @@
 import { BIP32Interface } from 'bip32';
 import { ECPairInterface } from 'ecpair';
 import { Transaction, TxOutput } from 'liquidjs-lib';
-import { RefundDetails, SwapTree, Tapleaf } from '../../consts/Types';
-
-export type LiquidSwapTree = SwapTree & { covenantClaimLeaf?: Tapleaf };
+import { LiquidSwapTree, RefundDetails } from '../../consts/Types';
 
 export type LiquidRefundDetails = Omit<RefundDetails, 'value' | 'swapTree'> &
   TxOutput & {

lib/liquid/swap/ReverseSwapTree.ts

@@ -2,13 +2,12 @@ import ops from '@boltz/bitcoin-ops';
 import { crypto, script } from 'bitcoinjs-lib';
 import { reverseBuffer } from 'liquidjs-lib/src/bufferutils';
 import { getHexBuffer } from '../../Utils';
-import { Tapleaf } from '../../consts/Types';
+import { LiquidSwapTree, Tapleaf } from '../../consts/Types';
 import bitcoinReverseSwapTree from '../../swap/ReverseSwapTree';
 import { leafVersionLiquid } from '../../swap/TaprootUtils';
-import { assignTreeProbabilities, sortTree } from '../TreeSort';
+import { assignTreeProbabilities, sortTree } from '../../swap/TreeSort';
 import { getScriptIntrospectionValues } from '../Utils';
 import liquidOps from '../consts/Ops';
-import { LiquidSwapTree } from '../consts/Types';
 
 enum Feature {
   ClaimCovenant,

lib/liquid/swap/TaprootUtils.ts

@@ -3,10 +3,8 @@ import { Taptree, isTapleaf } from 'bitcoinjs-lib/src/types';
 import { Transaction, TxOutput } from 'liquidjs-lib';
 import {
   HashTree,
-  TaprootLeaf,
   findScriptPath as liquidFindScriptPath,
   tapLeafHash as liquidTapLeafHash,
-  toHashTree as liquidToHashTree,
 } from 'liquidjs-lib/src/bip341';
 import { taggedHash } from 'liquidjs-lib/src/crypto';
 import { Network } from 'liquidjs-lib/src/networks';
@@ -44,24 +42,27 @@ export const hashForWitnessV1 = (
 export const tapLeafHash = (leaf: Tapleaf) =>
   liquidTapLeafHash(convertLeaf(leaf));
 
+export const tapBranchHash = (a: Buffer, b: Buffer) =>
+  taggedHash('TapBranch/elements', Buffer.concat([a, b]));
+
 export const tapTweakHash = (publicKey: Buffer, tweak: Buffer) =>
   taggedHash('TapTweak/elements', Buffer.concat([toXOnly(publicKey), tweak]));
 
-export const toHashTree = (tree: Taptree): HashTree => {
-  const leafs: TaprootLeaf[] = [];
+export function toHashTree(scriptTree: Taptree): HashTree {
+  if (isTapleaf(scriptTree)) {
+    return { hash: tapLeafHash(scriptTree as Tapleaf) };
+  }
 
-  const convertToLeafs = (tree: Taptree) => {
-    if (isTapleaf(tree)) {
-      leafs.push(convertLeaf(tree as Tapleaf));
-    } else {
-      convertToLeafs(tree[0]);
-      convertToLeafs(tree[1]);
-    }
-  };
-  convertToLeafs(tree);
+  const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+  hashes.sort((a, b) => a.hash.compare(b.hash));
+  const [left, right] = hashes;
 
-  return liquidToHashTree(leafs);
-};
+  return {
+    hash: tapBranchHash(left.hash, right.hash),
+    left,
+    right,
+  };
+}
 
 export const tweakMusig = (musig: Musig, tree: Taptree): Buffer =>
   toXOnly(

lib/swap/SwapTreeSerializer.ts

@@ -1,6 +1,6 @@
 import { getHexBuffer, getHexString } from '../Utils';
-import { SwapTree, Tapleaf } from '../consts/Types';
-import { swapLeafsToTree } from './TaprootUtils';
+import { LiquidSwapTree, SwapTree, Tapleaf } from '../consts/Types';
+import { assignTreeProbabilities, sortTree } from './TreeSort';
 
 type SerializedLeaf = {
   version: number;
@@ -12,6 +12,10 @@ type SerializedTree = {
   refundLeaf: SerializedLeaf;
 };
 
+type SerializedLiquidSwapTree = SerializedTree & {
+  covenantClaimLeaf?: SerializedLeaf;
+};
+
 const serializeLeaf = (leaf: Tapleaf): SerializedLeaf => ({
   version: leaf.version,
   output: getHexString(leaf.output),
@@ -22,24 +26,38 @@ const deserializeLeaf = (leaf: SerializedLeaf): Tapleaf => ({
   output: getHexBuffer(leaf.output),
 });
 
-export const serializeSwapTree = (tree: SwapTree): SerializedTree => ({
-  claimLeaf: serializeLeaf(tree.claimLeaf),
-  refundLeaf: serializeLeaf(tree.refundLeaf),
-});
+export const serializeSwapTree = (
+  tree: LiquidSwapTree,
+): SerializedTree | SerializedLiquidSwapTree => {
+  const res: SerializedLiquidSwapTree = {
+    claimLeaf: serializeLeaf(tree.claimLeaf),
+    refundLeaf: serializeLeaf(tree.refundLeaf),
+  };
+
+  if (tree.covenantClaimLeaf !== undefined) {
+    res.covenantClaimLeaf = serializeLeaf(tree.covenantClaimLeaf);
+  }
+
+  return res;
+};
 
 export const deserializeSwapTree = (
-  tree: string | SerializedTree,
-): SwapTree => {
+  tree: string | SerializedTree | LiquidSwapTree,
+): SwapTree | LiquidSwapTree => {
   const parsed = typeof tree === 'string' ? JSON.parse(tree) : tree;
 
-  const res = {
+  const res: Omit<LiquidSwapTree, 'tree'> = {
     claimLeaf: deserializeLeaf(parsed.claimLeaf),
     refundLeaf: deserializeLeaf(parsed.refundLeaf),
+    covenantClaimLeaf:
+      parsed.covenantClaimLeaf !== undefined
+        ? deserializeLeaf(parsed.covenantClaimLeaf)
+        : undefined,
   };
 
   return {
     ...res,
-    tree: swapLeafsToTree(res.claimLeaf, res.refundLeaf),
+    tree: sortTree(assignTreeProbabilities(res)),
   };
 };
 

lib/liquid/TreeSort.ts → lib/swap/TreeSort.ts

@@ -1,5 +1,4 @@
-import { Tapleaf } from '../consts/Types';
-import { LiquidSwapTree } from './consts/Types';
+import { LiquidSwapTree } from '../consts/Types';
 
 type ProbabilityNode<T> = { probability: number; value: T };
 
@@ -29,9 +28,18 @@ const subSortTree = <T>(nodes: ProbabilityNode<T>[]): TreeNode<T> => {
 export const sortTree = <T>(nodes: ProbabilityNode<T>[]): TreeNode<T> =>
   subSortTree(nodes.sort((a, b) => b.probability - a.probability));
 
-export const assignTreeProbabilities = (
-  tree: Omit<LiquidSwapTree, 'tree'>,
-): ProbabilityNode<Tapleaf>[] => {
+export const assignTreeProbabilities = <T>(
+  tree: Omit<
+    Record<keyof Omit<LiquidSwapTree, 'covenantClaimLeaf'>, T | undefined> & {
+      covenantClaimLeaf?: T;
+    },
+    'tree'
+  >,
+): ProbabilityNode<T>[] => {
+  if (tree.claimLeaf === undefined || tree.refundLeaf === undefined) {
+    throw 'invalid tree';
+  }
+
   if (tree.covenantClaimLeaf) {
     return [
       {