@atomiqlabs/sdk 8.7.7 → 8.9.0

package/dist/bitcoin/coinselect2/utils.js

@@ -73,6 +73,15 @@ function transactionBytes(inputs, outputs, changeType) {
     }
     return Math.ceil(size);
 }
+function numberOrNaN(v) {
+    if (typeof v !== 'number')
+        return NaN;
+    if (!isFinite(v))
+        return NaN;
+    if (v < 0)
+        return NaN;
+    return v;
+}
 function uintOrNaN(v) {
     if (typeof v !== 'number')
         return NaN;
@@ -91,26 +100,50 @@ function sumOrNaN(range) {
     return range.reduce((a, x) => a + uintOrNaN(x.value), 0);
 }
 function finalize(inputs, outputs, feeRate, changeType, cpfpAddFee = 0) {
-    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);
-    // is it worth a change output?
-    if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
-        outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+    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 });
+        }
     }
     const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
     logger.debug("finalize(): Re-calculated total fee: ", fee);
-    if (!isFinite(fee))
+    if (!isFinite(fee) || fee < 0)
         return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+    let txVSize = exports.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, utxo) {
+    const utxoBytes = exports.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;
+}
 exports.utils = {
     dustThreshold: dustThreshold,
     finalize: finalize,
@@ -119,5 +152,7 @@ exports.utils = {
     sumOrNaN: sumOrNaN,
     sumForgiving: sumForgiving,
     transactionBytes: transactionBytes,
-    uintOrNaN: uintOrNaN
+    uintOrNaN: uintOrNaN,
+    numberOrNaN: numberOrNaN,
+    isDetrimentalInput
 };

package/dist/bitcoin/wallet/BitcoinWallet.d.ts

@@ -1,29 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { CoinselectAddressTypes } from "../coinselect2";
 import { BTC_NETWORK } from "@scure/btc-signer/utils";
 import { Transaction } from "@scure/btc-signer";
-import { IBitcoinWallet } from "./IBitcoinWallet";
-import { Buffer } from "buffer";
+import { BitcoinWalletUtxo, BitcoinWalletUtxoBase, IBitcoinWallet } from "./IBitcoinWallet";
 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;
-};
 /**
  * Identifies the address type of a Bitcoin address
  *
@@ -96,7 +75,7 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
         pubkey: string;
         address: string;
         addressType: CoinselectAddressTypes;
-    }[], psbt: Transaction, feeRate?: number): Promise<{
+    }[], psbt: Transaction, _feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<{
         fee: number;
         psbt?: Transaction;
         inputAddressIndexes?: {
@@ -106,13 +85,13 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
     protected _getSpendableBalance(sendingAccounts: {
         address: string;
         addressType: CoinselectAddressTypes;
-    }[], psbt?: Transaction, feeRate?: number): Promise<{
+    }[], psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxoPool?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint;
         feeRate: number;
         totalFee: number;
     }>;
     abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
-    abstract fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    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>;
@@ -127,4 +106,8 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
         totalFee: number;
     }>;
     static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK;
+    static getSpendableBalance(utxoPool: BitcoinWalletUtxoBase[], feeRate: number, psbt?: Transaction, outputAddressType?: CoinselectAddressTypes): {
+        balance: bigint;
+        totalFee: number;
+    };
 }

package/dist/bitcoin/wallet/BitcoinWallet.js

@@ -5,10 +5,10 @@ const coinselect2_1 = require("../coinselect2");
 const utils_1 = require("@scure/btc-signer/utils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
-const Utils_1 = require("../../utils/Utils");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 const Logger_1 = require("../../utils/Logger");
 const base_1 = require("@atomiqlabs/base");
+const utils_2 = require("../coinselect2/utils");
 /**
  * Identifies the address type of a Bitcoin address
  *
@@ -135,10 +135,11 @@ class BitcoinWallet {
         });
         return this._fundPsbt(sendingAccounts, psbt, feeRate);
     }
-    async _fundPsbt(sendingAccounts, psbt, feeRate) {
-        if (feeRate == null)
-            feeRate = await this.getFeeRate();
-        const utxoPool = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+    async _fundPsbt(sendingAccounts, psbt, _feeRate, utxos, spendFully) {
+        const feeRate = _feeRate ?? await this.getFeeRate();
+        const utxoPool = utxos ?? (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);
         const accountPubkeys = {};
         sendingAccounts.forEach(acc => accountPubkeys[acc.address] = acc.pubkey);
@@ -177,13 +178,23 @@ class BitcoinWallet {
             });
         }
         logger.debug("_fundPsbt(): Coinselect targets: ", targets);
-        let coinselectResult = (0, coinselect2_1.coinSelect)(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
+        let coinselectResult = spendFully
+            ? utils_2.utils.finalize(requiredInputs.concat(utxoPool.filter(utxo => !utils_2.utils.isDetrimentalInput(feeRate, utxo))), targets, feeRate, null)
+            : (0, coinselect2_1.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);
@@ -264,9 +275,18 @@ class BitcoinWallet {
             inputAddressIndexes
         };
     }
-    async _getSpendableBalance(sendingAccounts, psbt, feeRate) {
+    async _getSpendableBalance(sendingAccounts, psbt, feeRate, outputAddressType, utxoPool) {
         feeRate ??= await this.getFeeRate();
-        const utxoPool = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        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
+        };
+    }
+    static bitcoinNetworkToObject(network) {
+        return btcNetworkMapping[network];
+    }
+    static getSpendableBalance(utxoPool, feeRate, psbt, outputAddressType) {
         const requiredInputs = [];
         if (psbt != null)
             for (let i = 0; i < psbt.inputsLength; i++) {
@@ -303,20 +323,13 @@ class BitcoinWallet {
                     script: buffer_1.Buffer.from(output.script)
                 });
             }
-        const target = btc_signer_1.OutScript.encode({
-            type: "wsh",
-            hash: (0, Utils_1.randomBytes)(32)
-        });
-        let coinselectResult = (0, coinselect2_1.maxSendable)(utxoPool, { script: buffer_1.Buffer.from(target), type: "p2wsh" }, feeRate, requiredInputs, additionalOutputs);
+        const target = (0, BitcoinUtils_1.getDummyOutputScript)(outputAddressType ?? "p2wsh");
+        let coinselectResult = (0, coinselect2_1.maxSendable)(utxoPool, { script: buffer_1.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
         };
     }
-    static bitcoinNetworkToObject(network) {
-        return btcNetworkMapping[network];
-    }
 }
 exports.BitcoinWallet = BitcoinWallet;

package/dist/bitcoin/wallet/IBitcoinWallet.d.ts

@@ -1,4 +1,32 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { Transaction } from "@scure/btc-signer";
+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}
  *
@@ -25,8 +53,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
      *
@@ -69,10 +101,16 @@ 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/dist/bitcoin/wallet/SingleAddressBitcoinWallet.d.ts

@@ -6,6 +6,7 @@ import { Transaction } from "@scure/btc-signer";
 import { Buffer } from "buffer";
 import { BitcoinWallet } from "./BitcoinWallet";
 import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
+import { BitcoinWalletUtxo, BitcoinWalletUtxoBase } from "./IBitcoinWallet";
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
@@ -37,7 +38,7 @@ export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    fundPsbt(inputPsbt: Transaction, feeRate?: number): Promise<Transaction>;
+    fundPsbt(inputPsbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
     /**
      * @inheritDoc
      */
@@ -68,11 +69,15 @@ export declare 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;
     }>;
+    /**
+     * @inheritDoc
+     */
+    getUtxoPool(): Promise<BitcoinWalletUtxo[]>;
     /**
      * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance
      *

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -80,8 +80,8 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
     /**
      * @inheritDoc
      */
-    async fundPsbt(inputPsbt, feeRate) {
-        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+    async fundPsbt(inputPsbt, feeRate, utxos, spendFully) {
+        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate, utxos, spendFully);
         if (psbt == null) {
             throw new Error("Not enough balance!");
         }
@@ -133,8 +133,14 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
     /**
      * @inheritDoc
      */
-    getSpendableBalance(psbt, feeRate) {
-        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate);
+    getSpendableBalance(psbt, feeRate, outputAddressType, utxos) {
+        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate, outputAddressType, utxos);
+    }
+    /**
+     * @inheritDoc
+     */
+    async getUtxoPool() {
+        return this._getUtxoPool(this.address, this.addressType);
     }
     /**
      * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance

package/dist/events/UnifiedSwapEventListener.d.ts

@@ -1,6 +1,5 @@
 import { ChainEvent, ChainType } from "@atomiqlabs/base";
 import { ISwap } from "../swaps/ISwap";
-import { EventListener } from "@atomiqlabs/base/src/events/ChainEvents";
 import { SwapType } from "../enums/SwapType";
 import { UnifiedSwapStorage } from "../storage/UnifiedSwapStorage";
 export type SwapEventListener<T extends ChainType, S extends ISwap<T>> = (event: ChainEvent<T["Data"]>, swap: S) => Promise<void>;
@@ -15,8 +14,10 @@ export declare class UnifiedSwapEventListener<T extends ChainType> {
     };
     constructor(unifiedStorage: UnifiedSwapStorage<T>, events: T["Events"]);
     processEvents(events: ChainEvent<T["Data"]>[]): Promise<void>;
-    listener?: EventListener<T["Data"]>;
-    start(): Promise<void>;
+    private noAutomaticPoll?;
+    private listener?;
+    start(noAutomaticPoll?: boolean): Promise<void>;
+    poll(previousState: any): Promise<any>;
     stop(): Promise<void>;
     registerListener<S extends ISwap<T>>(type: SwapType, listener: SwapEventListener<T, S>, reviver: new (val: any) => S): void;
     unregisterListener(type: SwapType): boolean;

package/dist/events/UnifiedSwapEventListener.js

@@ -96,13 +96,14 @@ class UnifiedSwapEventListener {
             }
         }
     }
-    async start() {
+    async start(noAutomaticPoll) {
         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);
@@ -110,6 +111,11 @@ class UnifiedSwapEventListener {
         });
         logger.info("start(): Successfully initiated the unified swap event listener!");
     }
+    poll(previousState) {
+        if (!this.noAutomaticPoll)
+            throw new Error("Only supported when no automatic events polling is configured!");
+        return this.events.poll(previousState);
+    }
     stop() {
         logger.info("stop(): Stopping unified swap event listener");
         if (this.listener != null)

package/dist/http/HttpUtils.d.ts

@@ -13,15 +13,17 @@ export declare function fetchWithTimeout(input: RequestInfo | URL, init: Request
  * @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 declare function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200?: boolean): Promise<T>;
+export declare function httpGet<T>(url: string, timeout?: number, abortSignal?: AbortSignal, allowNon200?: boolean, headers?: Record<string, string>): Promise<T>;
 /**
  * Sends an HTTP POST request through a fetch API, handles non 200 response codes as errors
  * @param url Send request to this URL
  * @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 declare function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal): Promise<T>;
+export declare function httpPost<T>(url: string, body: any, timeout?: number, abortSignal?: AbortSignal, headers?: Record<string, string>): Promise<T>;

package/dist/http/HttpUtils.js

@@ -30,13 +30,15 @@ exports.fetchWithTimeout = fetchWithTimeout;
  * @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
  */
-async function httpGet(url, timeout, abortSignal, allowNon200 = false) {
+async function httpGet(url, timeout, abortSignal, allowNon200 = false, headers = {}) {
     const init = {
         method: "GET",
         timeout,
-        signal: abortSignal
+        signal: abortSignal,
+        headers
     };
     const response = await fetchWithTimeout(url, init);
     if (response.status !== 200) {
@@ -65,14 +67,18 @@ exports.httpGet = httpGet;
  * @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
  */
-async function httpPost(url, body, timeout, abortSignal) {
+async function httpPost(url, body, timeout, abortSignal, headers = {}) {
     const init = {
         method: "POST",
         timeout,
         body: JSON.stringify(body),
-        headers: { 'Content-Type': 'application/json' },
+        headers: {
+            ...headers,
+            'Content-Type': 'application/json'
+        },
         signal: abortSignal
     };
     const response = timeout == null ? await fetch(url, init) : await fetchWithTimeout(url, init);

package/dist/http/paramcoders/client/StreamingFetchPromise.d.ts

@@ -11,6 +11,7 @@ export type RequestBody = {
  * @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 declare function streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean): Promise<RequestSchemaResultPromise<T>>;
+export declare function streamingFetchPromise<T extends RequestSchema>(url: string, body: RequestBody, schema: T, timeout?: number, signal?: AbortSignal, streamRequest?: boolean, _headers?: Record<string, string>): Promise<RequestSchemaResultPromise<T>>;

package/dist/http/paramcoders/client/StreamingFetchPromise.js

@@ -39,14 +39,15 @@ 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
  */
-async function streamingFetchPromise(url, body, schema, timeout, signal, streamRequest) {
+async function streamingFetchPromise(url, body, schema, timeout, signal, streamRequest, _headers = {}) {
     if (streamRequest == null)
         streamRequest = supportsRequestStreams;
     if (timeout != null)
         signal = (0, TimeoutUtils_1.timeoutSignal)(timeout, new Error("Network request timed out"), signal);
-    const headers = {};
+    const headers = { ..._headers };
     const init = {
         method: "POST",
         headers

package/dist/index.d.ts

@@ -78,6 +78,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/dist/index.js

@@ -151,6 +151,7 @@ __exportStar(require("./types/SwapStateInfo"), exports);
 __exportStar(require("./types/AmountData"), exports);
 __exportStar(require("./types/CustomPriceFunction"), exports);
 __exportStar(require("./types/SwapExecutionAction"), exports);
+__exportStar(require("./types/SwapExecutionStep"), exports);
 __exportStar(require("./types/SwapWithSigner"), exports);
 __exportStar(require("./types/Token"), exports);
 __exportStar(require("./types/TokenAmount"), exports);

package/dist/intermediaries/IntermediaryDiscovery.d.ts

@@ -3,6 +3,7 @@ import { Intermediary } from "./Intermediary";
 import { SwapType } from "../enums/SwapType";
 import { SpvVaultContract, SwapContract } from "@atomiqlabs/base";
 import { EventEmitter } from "events";
+import { IntermediaryAPI } from "./apis/IntermediaryAPI";
 /**
  * Swap handler type mapping for intermediary communication
  *
@@ -109,6 +110,10 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      * @private
      */
     private overrideNodeUrls?;
+    /**
+     * @private
+     */
+    private lpApi;
     constructor(swapContracts: {
         [chainIdentifier: string]: {
             [contractVersion: string]: {
@@ -116,7 +121,7 @@ export declare class IntermediaryDiscovery extends EventEmitter {
                 spvVaultContract: SpvVaultContract;
             };
         };
-    }, registryUrl?: string, nodeUrls?: string[], httpRequestTimeout?: number, maxWaitForOthersTimeout?: number);
+    }, lpApi: IntermediaryAPI, registryUrl?: string, nodeUrls?: string[], httpRequestTimeout?: number, maxWaitForOthersTimeout?: number);
     /**
      * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
      *
@@ -193,7 +198,7 @@ export declare 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

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -6,7 +6,6 @@ const SwapType_1 = require("../enums/SwapType");
 const events_1 = require("events");
 const buffer_1 = require("buffer");
 const Utils_1 = require("../utils/Utils");
-const IntermediaryAPI_1 = require("./apis/IntermediaryAPI");
 const Logger_1 = require("../utils/Logger");
 const HttpUtils_1 = require("../http/HttpUtils");
 const RetryUtils_1 = require("../utils/RetryUtils");
@@ -94,7 +93,7 @@ const DEFAULT_CHAIN = "SOLANA";
  * @category LPs
  */
 class IntermediaryDiscovery extends events_1.EventEmitter {
-    constructor(swapContracts, registryUrl = REGISTRY_URL, nodeUrls, httpRequestTimeout, maxWaitForOthersTimeout) {
+    constructor(swapContracts, lpApi, registryUrl = REGISTRY_URL, nodeUrls, httpRequestTimeout, maxWaitForOthersTimeout) {
         super();
         /**
          * A current list of active intermediaries
@@ -105,6 +104,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         this.overrideNodeUrls = nodeUrls;
         this.httpRequestTimeout = httpRequestTimeout;
         this.maxWaitForOthersTimeout = maxWaitForOthersTimeout;
+        this.lpApi = lpApi;
     }
     /**
      * Fetches the URLs of swap intermediaries from registry or from a pre-defined array of node urls
@@ -129,7 +129,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
      * @param abortSignal
      */
     async getNodeInfo(url, abortSignal) {
-        const response = await (0, RetryUtils_1.tryWithRetries)(() => IntermediaryAPI_1.IntermediaryAPI.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal, "debug");
+        const response = await (0, RetryUtils_1.tryWithRetries)(() => this.lpApi.getIntermediaryInfo(url, this.httpRequestTimeout, abortSignal), { maxRetries: 3, delay: 100, exponential: true }, undefined, abortSignal, "debug");
         abortSignal?.throwIfAborted();
         const promises = [];
         const addresses = {};
@@ -365,7 +365,7 @@ class IntermediaryDiscovery extends events_1.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