@atomiqlabs/sdk 8.7.7 → 8.9.0

package/src/bitcoin/coinselect2/utils.ts

@@ -132,6 +132,13 @@ function transactionBytes (
     return Math.ceil(size);
 }
 
+function numberOrNaN(v: number): number {
+    if (typeof v !== 'number') return NaN;
+    if (!isFinite(v)) return NaN;
+    if (v < 0) return NaN;
+    return v;
+}
+
 function uintOrNaN(v: number): number {
   if (typeof v !== 'number') return NaN;
   if (!isFinite(v)) return NaN;
@@ -148,41 +155,73 @@ function sumOrNaN(range: {value: number}[]): number {
   return range.reduce((a, x)  => a + uintOrNaN(x.value), 0);
 }
 
-function finalize(
-    inputs: CoinselectTxInput[],
+function finalize<T extends Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">>(
+    inputs: T[],
     outputs: CoinselectTxOutput[],
     feeRate: number,
-    changeType: CoinselectAddressTypes,
+    changeType: CoinselectAddressTypes | null,
     cpfpAddFee: number = 0
 ): {
-    inputs?: CoinselectTxInput[],
+    inputs?: T[],
     outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
     fee: number
 } {
-  const bytesAccum = transactionBytes(inputs, outputs, changeType);
+  const bytesAccum = transactionBytes(inputs, outputs, changeType ?? undefined);
   logger.debug("finalize(): Transaction bytes: ", bytesAccum);
 
-  const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({type: changeType}))) + cpfpAddFee;
-  logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
-  const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
-  logger.debug("finalize(): Leaves change (changeType="+changeType+") value: ", remainderAfterExtraOutput);
+  if(changeType!=null) {
+      const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({type: changeType}))) + cpfpAddFee;
+      logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
+      const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
+      logger.debug("finalize(): Leaves change (changeType="+changeType+") value: ", remainderAfterExtraOutput);
 
-  // is it worth a change output?
-  if (remainderAfterExtraOutput >= dustThreshold({type: changeType})) {
-    outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType })
+      // is it worth a change output?
+      if (remainderAfterExtraOutput >= dustThreshold({type: changeType})) {
+          outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType })
+      }
   }
 
   const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
   logger.debug("finalize(): Re-calculated total fee: ", fee);
-  if (!isFinite(fee)) return { fee: (feeRate * bytesAccum) + cpfpAddFee }
+  if (!isFinite(fee) || fee<0) return { fee: (feeRate * bytesAccum) + cpfpAddFee }
+
+  let txVSize = utils.transactionBytes(inputs, outputs);
+  let txFee = fee;
+  const cpfpSortedInputs = [...inputs].sort(
+      (a, b) => (b.cpfp?.txEffectiveFeeRate ?? 0) - (a.cpfp?.txEffectiveFeeRate ?? 0)
+  );
+  cpfpSortedInputs.forEach(input => {
+    if(input.cpfp==null) return;
+      const currentEffectiveFeeRate = txFee / txVSize;
+      if(currentEffectiveFeeRate > input.cpfp.txEffectiveFeeRate) {
+        txVSize += input.cpfp.txVsize;
+        txFee += input.cpfp.txVsize * input.cpfp.txEffectiveFeeRate;
+      }
+    }
+  );
 
   return {
     inputs: inputs,
     outputs: outputs,
+    effectiveFeeRate: txFee / txVSize,
     fee: fee
   }
 }
 
+function isDetrimentalInput(
+    feeRate: number,
+    utxo: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">
+) {
+    const utxoBytes = utils.inputBytes(utxo);
+    const utxoFee = feeRate * utxoBytes;
+    let cpfpFee = 0;
+    if(utxo.cpfp!=null && utxo.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = Math.ceil(utxo.cpfp.txVsize*(feeRate - utxo.cpfp.txEffectiveFeeRate));
+
+    // skip detrimental input
+    return utxoFee + cpfpFee > utxo.value;
+}
+
 export const utils = {
   dustThreshold: dustThreshold,
   finalize: finalize,
@@ -191,5 +230,7 @@ export const utils = {
   sumOrNaN: sumOrNaN,
   sumForgiving: sumForgiving,
   transactionBytes: transactionBytes,
-  uintOrNaN: uintOrNaN
+  uintOrNaN: uintOrNaN,
+  numberOrNaN: numberOrNaN,
+  isDetrimentalInput
 };

package/src/bitcoin/wallet/BitcoinWallet.ts

@@ -1,32 +1,14 @@
 import {coinSelect, maxSendable, CoinselectAddressTypes, CoinselectTxInput} from "../coinselect2";
 import {BTC_NETWORK, NETWORK, TEST_NETWORK} from "@scure/btc-signer/utils"
 import {p2wpkh, OutScript, Transaction, p2tr, Address} from "@scure/btc-signer";
-import {IBitcoinWallet} from "./IBitcoinWallet";
+import {BitcoinWalletUtxo, BitcoinWalletUtxoBase, IBitcoinWallet} from "./IBitcoinWallet";
 import {Buffer} from "buffer";
 import {randomBytes} from "../../utils/Utils";
-import {toCoinselectAddressType, toOutputScript} from "../../utils/BitcoinUtils";
+import {getDummyOutputScript, toCoinselectAddressType, toOutputScript} from "../../utils/BitcoinUtils";
 import {TransactionInputUpdate} from "@scure/btc-signer/psbt";
 import {getLogger} from "../../utils/Logger";
 import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
-
-/**
- * UTXO data structure for Bitcoin wallets
- *
- * @category Bitcoin
- */
-export type BitcoinWalletUtxo = {
-    vout: number,
-    txId: string,
-    value: number,
-    type: CoinselectAddressTypes,
-    outputScript: Buffer,
-    address: string,
-    cpfp?: {
-        txVsize: number,
-        txEffectiveFeeRate: number
-    },
-    confirmed: boolean
-};
+import {utils} from "../coinselect2/utils";
 
 /**
  * Identifies the address type of a Bitcoin address
@@ -200,15 +182,18 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             addressType: CoinselectAddressTypes,
         }[],
         psbt: Transaction,
-        feeRate?: number
+        _feeRate?: number,
+        utxos?: BitcoinWalletUtxo[],
+        spendFully?: boolean
     ): Promise<{
         fee: number,
         psbt?: Transaction,
         inputAddressIndexes?: {[address: string]: number[]}
     }> {
-        if(feeRate==null) feeRate = await this.getFeeRate();
+        const feeRate = _feeRate ?? await this.getFeeRate();
+        const utxoPool: BitcoinWalletUtxo[] = utxos ?? (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
 
-        const utxoPool: BitcoinWalletUtxo[] = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        if(spendFully && utxoPool==null) throw new Error("Cannot fully spend when no utxos are passed!");
 
         logger.debug("_fundPsbt(): fee rate: "+feeRate+" utxo pool: ", utxoPool);
 
@@ -247,15 +232,26 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
         }
         logger.debug("_fundPsbt(): Coinselect targets: ", targets);
 
-        let coinselectResult = coinSelect(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
+        let coinselectResult = spendFully
+            ? utils.finalize(requiredInputs.concat(utxoPool.filter(utxo => !utils.isDetrimentalInput(feeRate, utxo))), targets, feeRate, null)
+            : coinSelect(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
         logger.debug("_fundPsbt(): Coinselect result: ", coinselectResult);
 
-        if(coinselectResult.inputs==null || coinselectResult.outputs==null) {
+        if(coinselectResult.inputs==null || coinselectResult.outputs==null || coinselectResult.effectiveFeeRate==null) {
             return {
                 fee: coinselectResult.fee
             };
         }
 
+        if(spendFully && feeRate!=null) {
+            const maximumAllowedFeeRate = (1.5*feeRate) + 10;
+            if(coinselectResult.effectiveFeeRate > maximumAllowedFeeRate)
+                throw new Error(`Effective fee rate too high, feeRate: ${coinselectResult.effectiveFeeRate} sats/vB, maximum: ${maximumAllowedFeeRate} sats/vB!`);
+            const minimumAllowedFeeRate = 0.9*feeRate;
+            if(coinselectResult.effectiveFeeRate < minimumAllowedFeeRate)
+                throw new Error(`Effective fee rate too low, feeRate: ${coinselectResult.effectiveFeeRate} sats/vB, minimum: ${minimumAllowedFeeRate} sats/vB!`);
+        }
+
         // Remove in/outs that are already in the PSBT
         coinselectResult.inputs.splice(0, psbt.inputsLength);
         coinselectResult.outputs.splice(0, psbt.outputsLength);
@@ -346,16 +342,59 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             addressType: CoinselectAddressTypes,
         }[],
         psbt?: Transaction,
-        feeRate?: number
+        feeRate?: number,
+        outputAddressType?: CoinselectAddressTypes,
+        utxoPool?: BitcoinWalletUtxoBase[]
     ): Promise<{
         balance: bigint,
         feeRate: number,
         totalFee: number
     }> {
         feeRate ??= await this.getFeeRate();
+        utxoPool ??= (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+
+        return {
+            ...BitcoinWallet.getSpendableBalance(
+                utxoPool ?? (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat(),
+                feeRate ?? await this.getFeeRate(),
+                psbt,
+                outputAddressType
+            ),
+            feeRate
+        };
+    }
+
+    abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
+    abstract fundPsbt(psbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
+    abstract signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
+
+    abstract getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
+    abstract getFundedPsbtFee(psbt: Transaction, feeRate?: number): Promise<number>;
+
+    abstract getReceiveAddress(): string;
+    abstract getBalance(): Promise<{
+        confirmedBalance: bigint,
+        unconfirmedBalance: bigint
+    }>;
+    abstract getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint,
+        feeRate: number,
+        totalFee: number
+    }>;
 
-        const utxoPool: BitcoinWalletUtxo[] = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK {
+        return btcNetworkMapping[network];
+    }
 
+    static getSpendableBalance(
+        utxoPool: BitcoinWalletUtxoBase[],
+        feeRate: number,
+        psbt?: Transaction,
+        outputAddressType?: CoinselectAddressTypes
+    ): {
+        balance: bigint,
+        totalFee: number
+    } {
         const requiredInputs: CoinselectTxInput[] = [];
         if(psbt!=null) for(let i=0;i<psbt.inputsLength;i++) {
             const input = psbt.getInput(i);
@@ -387,42 +426,15 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             })
         }
 
-        const target = OutScript.encode({
-            type: "wsh",
-            hash: randomBytes(32)
-        });
-
-        let coinselectResult = maxSendable(utxoPool, {script: Buffer.from(target), type: "p2wsh"}, feeRate, requiredInputs, additionalOutputs);
+        const target: Uint8Array = getDummyOutputScript(outputAddressType ?? "p2wsh");
+        let coinselectResult = maxSendable(utxoPool, {script: Buffer.from(target), type: outputAddressType ?? "p2wsh"}, feeRate, requiredInputs, additionalOutputs);
 
         logger.debug("_getSpendableBalance(): Max spendable result: ", coinselectResult);
 
         return {
-            feeRate: feeRate,
             balance: BigInt(Math.floor(coinselectResult.value)),
             totalFee: coinselectResult.fee
         }
     }
 
-    abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
-    abstract fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
-    abstract signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
-
-    abstract getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
-    abstract getFundedPsbtFee(psbt: Transaction, feeRate?: number): Promise<number>;
-
-    abstract getReceiveAddress(): string;
-    abstract getBalance(): Promise<{
-        confirmedBalance: bigint,
-        unconfirmedBalance: bigint
-    }>;
-    abstract getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
-        balance: bigint,
-        feeRate: number,
-        totalFee: number
-    }>;
-
-    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK {
-        return btcNetworkMapping[network];
-    }
-
 }

package/src/bitcoin/wallet/IBitcoinWallet.ts

@@ -1,4 +1,33 @@
-import {Transaction} from "@scure/btc-signer";
+import {Address, Transaction} from "@scure/btc-signer";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
+import {CoinselectAddressTypes} from "../coinselect2";
+
+/**
+ * UTXO data structure for Bitcoin wallets
+ *
+ * @category Bitcoin
+ */
+export type BitcoinWalletUtxo = {
+    vout: number,
+    txId: string,
+    value: number,
+    type: CoinselectAddressTypes,
+    outputScript: Buffer,
+    address: string,
+    cpfp?: {
+        txVsize: number,
+        txEffectiveFeeRate: number
+    },
+    confirmed: boolean
+};
+
+/**
+ * Base UTXO data structure used for maximum spendable balance calculation, doesn't contain all the fields necessary
+ *  for constructing the full transaction.
+ *
+ * @category Bitcoin
+ */
+export type BitcoinWalletUtxoBase = Omit<BitcoinWalletUtxo, "txId" | "vout" | "outputScript" | "address" | "confirmed">;
 
 /**
  * Type guard to check if an object implements {@link IBitcoinWallet}
@@ -39,8 +68,12 @@ export interface IBitcoinWallet {
      *
      * @param psbt PSBT to add the inputs to
      * @param feeRate Optional fee rate in sats/vB to use for the transaction
+     * @param utxos Pre-fetched list of UTXOs to spend from
+     * @param spendFully Instructs the wallet to spend all the passed UTXOs in the transaction without creating any
+     *  change output, if the `feeRate` is passed, it will also enforce that the feeRate in sats/vB for the resulting
+     *  transaction is not more than 50% and 10 sats/vB larger (considering also the CPFP adjustments)
      */
-    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    fundPsbt(psbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
 
     /**
      * Signs inputs in the provided PSBT
@@ -90,10 +123,18 @@ export interface IBitcoinWallet {
      *
      * @param psbt A PSBT to which additional inputs from wallet's UTXO set will be added and fee estimated
      * @param feeRate Optional fee rate in sats/vB to use for the transaction
+     * @param outputAddressType Expected output address type, if known
+     * @param utxos Optional pre-fetched UTXOs
      */
-    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+    getSpendableBalance(psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxos?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint,
         feeRate: number,
         totalFee: number
     }>;
+
+    /**
+     * Returns a list of available UTXOs for the wallet
+     */
+    getUtxoPool?(): Promise<BitcoinWalletUtxo[]>;
+
 }

package/src/bitcoin/wallet/SingleAddressBitcoinWallet.ts

@@ -8,6 +8,7 @@ import {HDKey} from "@scure/bip32";
 import {entropyToMnemonic, generateMnemonic, mnemonicToSeed} from "@scure/bip39";
 import {wordlist} from "@scure/bip39/wordlists/english.js";
 import {sha256} from "@noble/hashes/sha2";
+import {BitcoinWalletUtxo, BitcoinWalletUtxoBase} from "./IBitcoinWallet";
 
 const logger = getLogger("SingleAddressBitcoinWallet: ");
 
@@ -88,8 +89,8 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    async fundPsbt(inputPsbt: Transaction, feeRate?: number): Promise<Transaction> {
-        const {psbt} = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+    async fundPsbt(inputPsbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction> {
+        const {psbt} = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate, utxos, spendFully);
         if(psbt==null) {
             throw new Error("Not enough balance!");
         }
@@ -150,12 +151,19 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+    getSpendableBalance(psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxos?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint,
         feeRate: number,
         totalFee: number
     }> {
-        return this._getSpendableBalance([{address: this.address, addressType: this.addressType}], psbt, feeRate);
+        return this._getSpendableBalance([{address: this.address, addressType: this.addressType}], psbt, feeRate, outputAddressType, utxos);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    async getUtxoPool(): Promise<BitcoinWalletUtxo[]> {
+        return this._getUtxoPool(this.address, this.addressType);
     }
 
     /**

package/src/events/UnifiedSwapEventListener.ts

@@ -136,13 +136,16 @@ export class UnifiedSwapEventListener<
 
     }
 
-    listener?: EventListener<T["Data"]>;
-    async start() {
+    private noAutomaticPoll?: boolean;
+    private listener?: EventListener<T["Data"]>;
+
+    async start(noAutomaticPoll?: boolean) {
         if(this.listener!=null) return;
         logger.info("start(): Starting unified swap event listener");
         await this.storage.init();
         logger.debug("start(): Storage initialized");
-        await this.events.init();
+        await this.events.init(noAutomaticPoll);
+        this.noAutomaticPoll = noAutomaticPoll;
         logger.debug("start(): Events initialized");
         this.events.registerListener(this.listener = async (events) => {
             await this.processEvents(events);
@@ -151,6 +154,11 @@ export class UnifiedSwapEventListener<
         logger.info("start(): Successfully initiated the unified swap event listener!");
     }
 
+    poll(previousState: any): Promise<any> {
+        if(!this.noAutomaticPoll) throw new Error("Only supported when no automatic events polling is configured!");
+        return this.events.poll(previousState);
+    }
+
     stop(): Promise<void> {
         logger.info("stop(): Stopping unified swap event listener");
         if(this.listener!=null) this.events.unregisterListener(this.listener);

package/src/http/HttpUtils.ts

@@ -29,13 +29,15 @@ export function fetchWithTimeout(input: RequestInfo | URL, init: RequestInit & {
  * @param timeout Timeout (in milliseconds) for the request to conclude
  * @param abortSignal
  * @param allowNon200 Whether to allow non-200 status code HTTP responses
+ * @param headers
  * @throws {RequestError} if non 200 response code was returned or body cannot be parsed
  */
-export async function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200: boolean = false): Promise<T> {
+export async function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200: boolean = false, headers: Record<string, string> = {}): Promise<T> {
     const init = {
         method: "GET",
         timeout,
-        signal: abortSignal
+        signal: abortSignal,
+        headers
     };
 
     const response: Response = await fetchWithTimeout(url, init);
@@ -65,14 +67,18 @@ export async function httpGet<T>(url: string, timeout?: number, abortSignal?: Ab
  * @param body A HTTP request body to send to the server
  * @param timeout Timeout (in milliseconds) for the request to conclude
  * @param abortSignal
+ * @param headers
  * @throws {RequestError} if non 200 response code was returned
  */
-export async function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T> {
+export async function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal, headers: Record<string, string> = {}): Promise<T> {
     const init = {
         method: "POST",
         timeout,
         body: JSON.stringify(body),
-        headers: {'Content-Type': 'application/json'},
+        headers: {
+            ...headers,
+            'Content-Type': 'application/json'
+        },
         signal: abortSignal
     };
 

package/src/http/paramcoders/client/StreamingFetchPromise.ts

@@ -46,6 +46,7 @@ logger.info("Environment supports request stream: "+supportsRequestStreams);
  * @param timeout Timeout in millseconds for the request to succeed & all its response properties to resolve
  * @param signal Abort signal
  * @param streamRequest Whether the request should be streamed or not
+ * @param _headers
  * @throws {RequestError} When the response code is not 200
  */
 export async function streamingFetchPromise<T extends RequestSchema>(
@@ -54,12 +55,13 @@ export async function streamingFetchPromise<T extends RequestSchema>(
     schema: T,
     timeout?: number,
     signal?: AbortSignal,
-    streamRequest?: boolean
+    streamRequest?: boolean,
+    _headers: Record<string, string> = {}
 ): Promise<RequestSchemaResultPromise<T>> {
     if(streamRequest==null) streamRequest = supportsRequestStreams;
     if(timeout!=null) signal = timeoutSignal(timeout, new Error("Network request timed out"), signal);
 
-    const headers: Record<string, string> = {};
+    const headers = {..._headers};
     const init: RequestInit = {
         method: "POST",
         headers

package/src/index.ts

@@ -132,6 +132,7 @@ export * from "./types/SwapStateInfo";
 export * from "./types/AmountData";
 export * from "./types/CustomPriceFunction";
 export * from "./types/SwapExecutionAction";
+export * from "./types/SwapExecutionStep";
 export * from "./types/SwapWithSigner";
 export * from "./types/Token";
 export * from "./types/TokenAmount";

package/src/intermediaries/IntermediaryDiscovery.ts

@@ -192,8 +192,14 @@ export class IntermediaryDiscovery extends EventEmitter {
      */
     private overrideNodeUrls?: string[];
 
+    /**
+     * @private
+     */
+    private lpApi: IntermediaryAPI;
+
     constructor(
         swapContracts: {[chainIdentifier: string]: {[contractVersion: string]: {swapContract: SwapContract, spvVaultContract: SpvVaultContract}}},
+        lpApi: IntermediaryAPI,
         registryUrl: string = REGISTRY_URL,
         nodeUrls?: string[],
         httpRequestTimeout?: number,
@@ -205,6 +211,7 @@ export class IntermediaryDiscovery extends EventEmitter {
         this.overrideNodeUrls = nodeUrls;
         this.httpRequestTimeout = httpRequestTimeout;
         this.maxWaitForOthersTimeout = maxWaitForOthersTimeout;
+        this.lpApi = lpApi;
     }
 
     /**
@@ -242,7 +249,7 @@ export class IntermediaryDiscovery extends EventEmitter {
         info: InfoHandlerResponseEnvelope
     }> {
         const response = await tryWithRetries(
-            () => IntermediaryAPI.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal),
+            () => this.lpApi.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal),
             {maxRetries: 3, delay: 100, exponential: true},
             undefined,
             abortSignal,
@@ -489,7 +496,7 @@ export class IntermediaryDiscovery extends EventEmitter {
     /**
      * Returns swap candidates for a specific swap type & token address
      *
-     * @remark Also filters the LPs based on supported swap versions
+     * @remarks Also filters the LPs based on supported swap versions
      *
      * @param chainIdentifier Chain identifier of the smart chain
      * @param swapType Swap protocol type