refactor: lazy load @vulpemventures/secp256k1-zkp

eslint.config.mjs

@@ -53,6 +53,7 @@ export default [
                                 "@ledgerhq/hw-app-eth",
                                 "@ledgerhq/hw-transport",
                                 "@ledgerhq/hw-transport-webhid",
+                                "@vulpemventures/secp256k1-zkp",
                             ],
                         },
                     ],

src/lazy/bolt12.ts

@@ -1,3 +1,3 @@
 import Loader from "./Loader";
 
-export default new Loader("bolt12", async () => await import("boltz-bolt12"));
+export default new Loader("BOLT12", async () => await import("boltz-bolt12"));

src/lazy/secp.ts

@@ -0,0 +1,15 @@
+import { init } from "boltz-core/dist/lib/liquid";
+import { confidential } from "liquidjs-lib";
+
+import Loader from "./Loader";
+
+export default new Loader("Secp256k1ZKP", async () => {
+    const zkp = (await import("@vulpemventures/secp256k1-zkp")).default;
+    const secp = await zkp();
+
+    init(secp);
+    return {
+        secpZkp: secp,
+        confidential: new confidential.Confidential(secp),
+    };
+});

src/utils/claim.ts

@@ -26,7 +26,6 @@ import {
     getNetwork,
     getOutputAmount,
     getTransaction,
-    setup,
 } from "./compat";
 import { parseBlindingKey, parsePrivateKey } from "./helper";
 import { decodeInvoice } from "./invoice";
@@ -38,7 +37,7 @@ import {
 } from "./swapCreator";
 import { createMusig, hashForWitnessV1, tweakMusig } from "./taproot/musig";
 
-const createAdjustedClaim = <
+const createAdjustedClaim = async <
     T extends
         | (ClaimDetails & { blindingPrivateKey?: Buffer })
         | LiquidClaimDetails,
@@ -50,10 +49,11 @@ const createAdjustedClaim = <
     blindingKey?: Buffer,
 ) => {
     const asset = getRelevantAssetForSwap(swap);
-    const inputSum = claimDetails.reduce(
-        (total: number, input: T) => total + getOutputAmount(asset, input),
-        0,
-    );
+
+    let inputSum = 0;
+    for (const details of claimDetails) {
+        inputSum += await getOutputAmount(asset, details);
+    }
     const feeBudget = Math.floor(inputSum - swap.receiveAmount);
 
     const constructClaimTransaction = getConstructClaimTransaction(asset);
@@ -72,7 +72,6 @@ const claimReverseSwap = async (
     lockupTx: TransactionInterface,
     cooperative: boolean = true,
 ): Promise<TransactionInterface | undefined> => {
-    await setup();
     log.info(`Claiming Taproot swap cooperatively: ${cooperative}`);
     const asset = getRelevantAssetForSwap(swap);
 
@@ -84,7 +83,7 @@ const claimReverseSwap = async (
 
     const decodedAddress = decodeAddress(asset, swap.claimAddress);
     const boltzPublicKey = Buffer.from(swap.refundPublicKey, "hex");
-    const musig = createMusig(privateKey, boltzPublicKey);
+    const musig = await createMusig(privateKey, boltzPublicKey);
     const tree = SwapTreeSerializer.deserializeSwapTree(swap.swapTree);
     const tweakedKey = tweakMusig(asset, musig, tree.tree);
     const swapOutput = detectSwap(tweakedKey, lockupTx);
@@ -101,7 +100,7 @@ const claimReverseSwap = async (
             internalKey: musig.getAggregatedPublicKey(),
         },
     ] as (ClaimDetails & { blindingPrivateKey: Buffer })[];
-    const claimTx = createAdjustedClaim(
+    const claimTx = await createAdjustedClaim(
         swap,
         details,
         decodedAddress.script,
@@ -149,7 +148,10 @@ const claimChainSwap = async (
         "hex",
     );
     const claimPrivateKey = parsePrivateKey(swap.claimPrivateKey);
-    const ourClaimMusig = createMusig(claimPrivateKey, boltzRefundPublicKey);
+    const ourClaimMusig = await createMusig(
+        claimPrivateKey,
+        boltzRefundPublicKey,
+    );
     const claimTree = SwapTreeSerializer.deserializeSwapTree(
         swap.claimDetails.swapTree,
     );
@@ -175,7 +177,7 @@ const claimChainSwap = async (
         },
     ] as (ClaimDetails & { blindingPrivateKey: Buffer })[];
     const decodedAddress = decodeAddress(swap.assetReceive, swap.claimAddress);
-    const claimTx = createAdjustedClaim(
+    const claimTx = await createAdjustedClaim(
         swap,
         details,
         decodedAddress.script,
@@ -205,7 +207,7 @@ const claimChainSwap = async (
                 serverClaimDetails.publicKey,
                 "hex",
             );
-            const theirClaimMusig = createMusig(
+            const theirClaimMusig = await createMusig(
                 parsePrivateKey(swap.refundPrivateKey),
                 boltzClaimPublicKey,
             );
@@ -299,8 +301,6 @@ export const claim = async <T extends ReverseSwap | ChainSwap>(
     swapStatusTransaction: { hex: string },
     cooperative: boolean = true,
 ): Promise<T | undefined> => {
-    await setup();
-
     const asset = getRelevantAssetForSwap(swap);
     if (asset === RBTC) {
         return undefined;
@@ -341,8 +341,7 @@ export const createSubmarineSignature = async (swap: SubmarineSwap) => {
         return;
     }
 
-    await setup();
-    log.info(`creating cooperative claim signature for`, swap.id);
+    log.info("Creating cooperative claim signature for", swap.id);
 
     const claimDetails = await getSubmarineClaimDetails(swap.id);
     if (
@@ -353,7 +352,7 @@ export const createSubmarineSignature = async (swap: SubmarineSwap) => {
     }
 
     const boltzPublicKey = Buffer.from(swap.claimPublicKey, "hex");
-    const musig = createMusig(
+    const musig = await createMusig(
         parsePrivateKey(swap.refundPrivateKey),
         boltzPublicKey,
     );

src/utils/compat.ts

@@ -1,4 +1,3 @@
-import zkp, { Secp256k1ZKP } from "@vulpemventures/secp256k1-zkp";
 import { Network, Transaction, address, networks } from "bitcoinjs-lib";
 import {
     ClaimDetails,
@@ -11,7 +10,6 @@ import {
 import {
     LiquidClaimDetails,
     LiquidRefundDetails,
-    init,
     constructClaimTransaction as lcCT,
     constructRefundTransaction as lcRT,
 } from "boltz-core/dist/lib/liquid";
@@ -27,6 +25,7 @@ import { Network as LiquidNetwork } from "liquidjs-lib/src/networks";
 
 import { config } from "../config";
 import { BTC, LBTC, LN } from "../consts/Assets";
+import secp from "../lazy/secp";
 import { isInvoice, isLnurl } from "./invoice";
 
 type LiquidTransactionOutputWithKey = LiquidTransactionOutput & {
@@ -35,21 +34,8 @@ type LiquidTransactionOutputWithKey = LiquidTransactionOutput & {
 
 type DecodedAddress = { script: Buffer; blindingKey?: Buffer };
 
-export let secp: Secp256k1ZKP;
-let confi: confidential.Confidential;
-
 const possibleUserInputTypes = [LN, LBTC, BTC];
 
-const setup = async () => {
-    if (confi !== undefined) {
-        return;
-    }
-
-    secp = await zkp();
-    init(secp);
-    confi = new confidential.Confidential(secp);
-};
-
 const getAddress = (asset: string): typeof address | typeof LiquidAddress => {
     if (asset === LBTC) {
         return LiquidAddress;
@@ -219,18 +205,19 @@ const getConstructRefundTransaction = (
         );
 };
 
-const getOutputAmount = (
+const getOutputAmount = async (
     asset: string,
     output: TransactionOutput | LiquidTransactionOutputWithKey,
-): number => {
+): Promise<number> => {
     if (asset !== LBTC) {
         return (output as TransactionOutput).value;
     }
 
     output = output as LiquidTransactionOutputWithKey;
 
     if (output.rangeProof?.length !== 0) {
-        const unblinded = confi.unblindOutputWithKey(
+        const { confidential } = await secp.get();
+        const unblinded = confidential.unblindOutputWithKey(
             output,
             output.blindingPrivateKey,
         );
@@ -241,7 +228,6 @@ const getOutputAmount = (
 };
 
 export {
-    setup,
     getAddress,
     getNetwork,
     decodeAddress,

src/utils/refund.ts

@@ -24,7 +24,6 @@ import {
     getConstructRefundTransaction,
     getNetwork,
     getTransaction,
-    setup,
 } from "./compat";
 import { formatError } from "./errors";
 import { parseBlindingKey, parsePrivateKey } from "./helper";
@@ -60,7 +59,7 @@ const refundTaproot = async <T extends TransactionInterface>(
 
     const swapTree = SwapTreeSerializer.deserializeSwapTree(lockupTree);
     const boltzPublicKey = Buffer.from(theirPublicKey, "hex");
-    const musig = createMusig(privateKey, boltzPublicKey);
+    const musig = await createMusig(privateKey, boltzPublicKey);
     const tweakedKey = tweakMusig(swap.assetSend, musig, swapTree.tree);
 
     const swapOutput = detectSwap(tweakedKey, lockupTx);
@@ -193,9 +192,7 @@ export const refund = async <T extends SubmarineSwap | ChainSwap>(
     transactionToRefund: { hex: string; timeoutBlockHeight: number },
     cooperative: boolean = true,
 ): Promise<T> => {
-    log.info(`refunding swap ${swap.id}: `, swap);
-
-    await setup();
+    log.info(`Refunding swap ${swap.id}: `, swap);
 
     const output = decodeAddress(swap.assetSend, refundAddress);
 

src/utils/taproot/musig.ts

@@ -12,15 +12,20 @@ import { Transaction as LiquidTransaction } from "liquidjs-lib";
 import { Network as LiquidNetwork } from "liquidjs-lib/src/networks";
 
 import { LBTC } from "../../consts/Assets";
+import secp from "../../lazy/secp";
 import { TransactionInterface } from "../boltzClient";
-import { secp } from "../compat";
 
-export const createMusig = (ourKeys: ECPairInterface, theirPublicKey: Buffer) =>
-    new Musig(secp, ourKeys, randomBytes(32), [
+export const createMusig = async (
+    ourKeys: ECPairInterface,
+    theirPublicKey: Buffer,
+) => {
+    const { secpZkp } = await secp.get();
+    return new Musig(secpZkp, ourKeys, randomBytes(32), [
         // The key of Boltz always comes first
         theirPublicKey,
         ourKeys.publicKey,
     ]);
+};
 
 export const tweakMusig = (asset: string, musig: Musig, tree: Taptree) =>
     (asset === LBTC ? LiquidTaprootUtils : TaprootUtils).tweakMusig(

src/utils/validation.ts

@@ -16,7 +16,7 @@ import log from "loglevel";
 import { LBTC, RBTC } from "../consts/Assets";
 import { Denomination, Side, SwapType } from "../consts/Enums";
 import { ChainSwapDetails } from "./boltzClient";
-import { decodeAddress, setup } from "./compat";
+import { decodeAddress } from "./compat";
 import { formatAmountDenomination } from "./denomination";
 import { ECPair, ecc } from "./ecpair";
 import { decodeInvoice, isInvoice, isLnurl } from "./invoice";
@@ -48,10 +48,9 @@ const validateAddress = async (
     blindingKey: string | undefined,
     buffer: BufferConstructor,
 ) => {
-    await setup();
     const tweakedKey = tweakMusig(
         chain,
-        createMusig(ourKeys, theirPublicKey),
+        await createMusig(ourKeys, theirPublicKey),
         tree.tree,
     );
 

tests/utils/validation.spec.ts

@@ -3,7 +3,7 @@ import log from "loglevel";
 
 import { BTC, LBTC, LN } from "../../src/consts/Assets";
 import { SwapType } from "../../src/consts/Enums";
-import { decodeAddress, setup } from "../../src/utils/compat";
+import { decodeAddress } from "../../src/utils/compat";
 import { validateInvoice, validateResponse } from "../../src/utils/validation";
 
 describe("validate responses", () => {
@@ -14,9 +14,8 @@ describe("validate responses", () => {
         })) as unknown as () => Contract;
     };
 
-    beforeAll(async () => {
+    beforeAll(() => {
         log.disableAll();
-        await setup();
     });
 
     describe("normal swap", () => {