@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/bitcoin/wallet/BitcoinWallet.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinWallet = exports.identifyAddressType = void 0;
+const coinselect2_1 = require("../coinselect2");
+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");
+/**
+ * Identifies the address type of a Bitcoin address
+ * @category Bitcoin
+ */
+function identifyAddressType(address, network) {
+    switch ((0, btc_signer_1.Address)(network).decode(address).type) {
+        case "pkh":
+            return "p2pkh";
+        case "wpkh":
+            return "p2wpkh";
+        case "tr":
+            return "p2tr";
+        case "sh":
+            return "p2sh-p2wpkh";
+        case "wsh":
+            return "p2wsh";
+        default:
+            throw new Error("Unknown address type of " + address);
+    }
+}
+exports.identifyAddressType = identifyAddressType;
+const logger = (0, Logger_1.getLogger)("BitcoinWallet: ");
+/**
+ * Abstract base class for Bitcoin wallet implementations
+ * @category Bitcoin
+ */
+class BitcoinWallet {
+    constructor(mempoolApi, network, feeMultiplier = 1.25, feeOverride) {
+        this.rpc = mempoolApi;
+        this.network = network;
+        this.feeMultiplier = feeMultiplier;
+        this.feeOverride = feeOverride;
+    }
+    async getFeeRate() {
+        if (this.feeOverride != null) {
+            return this.feeOverride;
+        }
+        return Math.floor((await this.rpc.getFeeRate()) * this.feeMultiplier);
+    }
+    _sendTransaction(rawHex) {
+        return this.rpc.sendRawTransaction(rawHex);
+    }
+    _getBalance(address) {
+        return this.rpc.getAddressBalances(address);
+    }
+    async _getUtxoPool(sendingAddress, sendingAddressType) {
+        const utxos = await this.rpc.getAddressUTXOs(sendingAddress);
+        let totalSpendable = 0;
+        const outputScript = (0, BitcoinUtils_1.toOutputScript)(this.network, sendingAddress);
+        const utxoPool = [];
+        for (let utxo of utxos) {
+            const value = Number(utxo.value);
+            totalSpendable += value;
+            utxoPool.push({
+                vout: utxo.vout,
+                txId: utxo.txid,
+                value: value,
+                type: sendingAddressType,
+                outputScript: outputScript,
+                address: sendingAddress,
+                cpfp: !utxo.confirmed ? await this.rpc.getCPFPData(utxo.txid).then((result) => {
+                    if (result.effectiveFeePerVsize == null)
+                        return;
+                    return {
+                        txVsize: result.adjustedVsize,
+                        txEffectiveFeeRate: result.effectiveFeePerVsize
+                    };
+                }) : undefined,
+                confirmed: utxo.confirmed
+            });
+        }
+        logger.debug("_getUtxoPool(): Total spendable value: " + totalSpendable + " num utxos: " + utxoPool.length);
+        return utxoPool;
+    }
+    async _getPsbt(sendingAccounts, recipient, amount, feeRate) {
+        const psbt = new btc_signer_1.Transaction({ PSBTVersion: 0 });
+        psbt.addOutput({
+            amount: BigInt(amount),
+            script: (0, BitcoinUtils_1.toOutputScript)(this.network, recipient)
+        });
+        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();
+        logger.debug("_fundPsbt(): fee rate: " + feeRate + " utxo pool: ", utxoPool);
+        const accountPubkeys = {};
+        sendingAccounts.forEach(acc => accountPubkeys[acc.address] = acc.pubkey);
+        const requiredInputs = [];
+        for (let i = 0; i < psbt.inputsLength; i++) {
+            const input = psbt.getInput(i);
+            if (input.index == null || input.txid == null)
+                throw new Error("Inputs need txid & index!");
+            let amount;
+            let script;
+            if (input.witnessUtxo != null) {
+                amount = input.witnessUtxo.amount;
+                script = input.witnessUtxo.script;
+            }
+            else if (input.nonWitnessUtxo != null) {
+                amount = input.nonWitnessUtxo.outputs[input.index].amount;
+                script = input.nonWitnessUtxo.outputs[input.index].script;
+            }
+            else
+                throw new Error("Either witnessUtxo or nonWitnessUtxo has to be defined!");
+            requiredInputs.push({
+                txId: buffer_1.Buffer.from(input.txid).toString('hex'),
+                vout: input.index,
+                value: Number(amount),
+                type: (0, BitcoinUtils_1.toCoinselectAddressType)(script)
+            });
+        }
+        const targets = [];
+        for (let i = 0; i < psbt.outputsLength; i++) {
+            const output = psbt.getOutput(i);
+            if (output.amount == null || output.script == null)
+                throw new Error("Outputs need amount & script defined!");
+            targets.push({
+                value: Number(output.amount),
+                script: buffer_1.Buffer.from(output.script)
+            });
+        }
+        logger.debug("_fundPsbt(): Coinselect targets: ", targets);
+        let coinselectResult = (0, coinselect2_1.coinSelect)(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
+        logger.debug("_fundPsbt(): Coinselect result: ", coinselectResult);
+        if (coinselectResult.inputs == null || coinselectResult.outputs == null) {
+            return {
+                fee: coinselectResult.fee
+            };
+        }
+        // Remove in/outs that are already in the PSBT
+        coinselectResult.inputs.splice(0, psbt.inputsLength);
+        coinselectResult.outputs.splice(0, psbt.outputsLength);
+        const inputAddressIndexes = {};
+        coinselectResult.inputs.forEach((input, index) => {
+            inputAddressIndexes[input.address] ??= [];
+            inputAddressIndexes[input.address].push(index);
+        });
+        const formattedInputs = await Promise.all(coinselectResult.inputs.map(async (input) => {
+            switch (input.type) {
+                case "p2tr":
+                    const parsed = (0, btc_signer_1.p2tr)(buffer_1.Buffer.from(accountPubkeys[input.address], "hex"));
+                    return {
+                        txid: input.txId,
+                        index: input.vout,
+                        witnessUtxo: {
+                            script: input.outputScript,
+                            amount: BigInt(input.value)
+                        },
+                        tapInternalKey: parsed.tapInternalKey,
+                        tapMerkleRoot: parsed.tapMerkleRoot,
+                        tapLeafScript: parsed.tapLeafScript
+                    };
+                case "p2wpkh":
+                    return {
+                        txid: input.txId,
+                        index: input.vout,
+                        witnessUtxo: {
+                            script: input.outputScript,
+                            amount: BigInt(input.value)
+                        },
+                        sighashType: 0x01
+                    };
+                case "p2sh-p2wpkh":
+                    return {
+                        txid: input.txId,
+                        index: input.vout,
+                        witnessUtxo: {
+                            script: input.outputScript,
+                            amount: BigInt(input.value)
+                        },
+                        redeemScript: (0, btc_signer_1.p2wpkh)(buffer_1.Buffer.from(accountPubkeys[input.address], "hex"), this.network).script,
+                        sighashType: 0x01
+                    };
+                case "p2pkh":
+                    const tx = await this.rpc.getTransaction(input.txId);
+                    if (tx == null)
+                        throw new Error("Cannot fetch existing tx " + input.txId);
+                    return {
+                        txid: input.txId,
+                        index: input.vout,
+                        nonWitnessUtxo: tx.raw,
+                        sighashType: 0x01
+                    };
+                default:
+                    throw new Error("Invalid input type: " + input.type);
+            }
+        }));
+        formattedInputs.forEach(input => psbt.addInput(input));
+        coinselectResult.outputs.forEach(output => {
+            if (output.script == null && output.address == null) {
+                //Change output
+                psbt.addOutput({
+                    script: (0, BitcoinUtils_1.toOutputScript)(this.network, sendingAccounts[0].address),
+                    amount: BigInt(Math.floor(output.value))
+                });
+            }
+            else {
+                psbt.addOutput({
+                    script: output.script ?? (0, BitcoinUtils_1.toOutputScript)(this.network, output.address),
+                    amount: BigInt(output.value)
+                });
+            }
+        });
+        return {
+            psbt,
+            fee: coinselectResult.fee,
+            inputAddressIndexes
+        };
+    }
+    async _getSpendableBalance(sendingAccounts, psbt, feeRate) {
+        feeRate ??= await this.getFeeRate();
+        const utxoPool = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        const requiredInputs = [];
+        if (psbt != null)
+            for (let i = 0; i < psbt.inputsLength; i++) {
+                const input = psbt.getInput(i);
+                if (input.index == null || input.txid == null)
+                    throw new Error("Inputs need txid & index!");
+                let amount;
+                let script;
+                if (input.witnessUtxo != null) {
+                    amount = input.witnessUtxo.amount;
+                    script = input.witnessUtxo.script;
+                }
+                else if (input.nonWitnessUtxo != null) {
+                    amount = input.nonWitnessUtxo.outputs[input.index].amount;
+                    script = input.nonWitnessUtxo.outputs[input.index].script;
+                }
+                else
+                    throw new Error("Either witnessUtxo or nonWitnessUtxo has to be defined!");
+                requiredInputs.push({
+                    txId: buffer_1.Buffer.from(input.txid).toString('hex'),
+                    vout: input.index,
+                    value: Number(amount),
+                    type: (0, BitcoinUtils_1.toCoinselectAddressType)(script)
+                });
+            }
+        const additionalOutputs = [];
+        if (psbt != null)
+            for (let i = 0; i < psbt.outputsLength; i++) {
+                const output = psbt.getOutput(i);
+                if (output.amount == null || output.script == null)
+                    throw new Error("Outputs need amount & script!");
+                additionalOutputs.push({
+                    value: Number(output.amount),
+                    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);
+        logger.debug("_getSpendableBalance(): Max spendable result: ", coinselectResult);
+        return {
+            feeRate: feeRate,
+            balance: BigInt(Math.floor(coinselectResult.value)),
+            totalFee: coinselectResult.fee
+        };
+    }
+}
+exports.BitcoinWallet = BitcoinWallet;

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

@@ -0,0 +1,28 @@
+import { Transaction } from "@scure/btc-signer";
+/**
+ * Type guard to check if an object implements IBitcoinWallet
+ * @category Bitcoin
+ */
+export declare function isIBitcoinWallet(val: any): val is IBitcoinWallet;
+/**
+ * Interface for Bitcoin wallet operations
+ * @category Bitcoin
+ */
+export interface IBitcoinWallet {
+    sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
+    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
+    getFeeRate(): Promise<number>;
+    getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
+    getFundedPsbtFee(psbt: Transaction, feeRate?: number): Promise<number>;
+    getReceiveAddress(): string;
+    getBalance(): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint;
+        feeRate: number;
+        totalFee: number;
+    }>;
+}

package/dist/bitcoin/wallet/IBitcoinWallet.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIBitcoinWallet = void 0;
+/**
+ * Type guard to check if an object implements IBitcoinWallet
+ * @category Bitcoin
+ */
+function isIBitcoinWallet(val) {
+    return val !== null &&
+        typeof (val.sendTransaction) === "function" &&
+        typeof (val.fundPsbt) === "function" &&
+        typeof (val.signPsbt) === "function" &&
+        typeof (val.getFeeRate) === "function" &&
+        typeof (val.getTransactionFee) === "function" &&
+        typeof (val.getFundedPsbtFee) === "function" &&
+        typeof (val.getReceiveAddress) === "function" &&
+        typeof (val.getBalance) === "function" &&
+        typeof (val.getSpendableBalance) === "function";
+}
+exports.isIBitcoinWallet = isIBitcoinWallet;

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

@@ -0,0 +1,21 @@
+import { Transaction } from "@scure/btc-signer";
+/**
+ * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and produce unsigned
+ *  PSBTs
+ * @category Bitcoin
+ */
+export type MinimalBitcoinWalletInterface = {
+    address: string;
+    publicKey: string;
+};
+/**
+ * A type with minimum possible required data about a bitcoin wallet to be able to estimate fees and sign PSBTs
+ * @category Bitcoin
+ */
+export type MinimalBitcoinWalletInterfaceWithSigner = MinimalBitcoinWalletInterface & {
+    signPsbt: (psbtToSign: {
+        psbt: Transaction;
+        psbtHex: string;
+        psbtBase64: string;
+    }, signInputs: number[]) => Promise<Transaction | string>;
+};

package/dist/bitcoin/wallet/MinimalBitcoinWalletInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+/**
+ * A type with minimum possible required functionality to be usable with lightning network swaps
+ * @category Bitcoin
+ */
+export type MinimalLightningNetworkWalletInterface = {
+    payInvoice: (bolt11PaymentRequest: string) => Promise<string>;
+};

package/dist/bitcoin/wallet/MinimalLightningNetworkWalletInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,40 @@
+import { CoinselectAddressTypes } from "../coinselect2";
+import { BTC_NETWORK } from "@scure/btc-signer/utils";
+import { Transaction } from "@scure/btc-signer";
+import { BitcoinWallet } from "./BitcoinWallet";
+import { BitcoinRpcWithAddressIndex } from "../BitcoinRpcWithAddressIndex";
+/**
+ * Bitcoin wallet implementation for single-address scenarios
+ * @category Bitcoin
+ */
+export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
+    readonly privKey?: Uint8Array;
+    readonly pubkey: Uint8Array;
+    readonly address: string;
+    readonly addressType: CoinselectAddressTypes;
+    constructor(mempoolApi: BitcoinRpcWithAddressIndex<any>, network: BTC_NETWORK, addressDataOrWIF: string | {
+        address: string;
+        publicKey: string;
+    }, feeMultiplier?: number, feeOverride?: number);
+    protected toBitcoinWalletAccounts(): {
+        pubkey: string;
+        address: string;
+        addressType: CoinselectAddressTypes;
+    }[];
+    sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
+    fundPsbt(inputPsbt: Transaction, feeRate?: number): Promise<Transaction>;
+    signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
+    getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
+    getFundedPsbtFee(basePsbt: Transaction, feeRate?: number): Promise<number>;
+    getReceiveAddress(): string;
+    getBalance(): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint;
+        feeRate: number;
+        totalFee: number;
+    }>;
+    static generateRandomPrivateKey(network?: BTC_NETWORK): string;
+}

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleAddressBitcoinWallet = void 0;
+const utils_1 = require("@scure/btc-signer/utils");
+const btc_signer_1 = require("@scure/btc-signer");
+const buffer_1 = require("buffer");
+const BitcoinWallet_1 = require("./BitcoinWallet");
+/**
+ * Bitcoin wallet implementation for single-address scenarios
+ * @category Bitcoin
+ */
+class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
+    constructor(mempoolApi, network, addressDataOrWIF, feeMultiplier = 1.25, feeOverride) {
+        super(mempoolApi, network, feeMultiplier, feeOverride);
+        if (typeof (addressDataOrWIF) === "string") {
+            try {
+                this.privKey = (0, btc_signer_1.WIF)(network).decode(addressDataOrWIF);
+            }
+            catch (e) {
+                this.privKey = (0, btc_signer_1.WIF)().decode(addressDataOrWIF);
+            }
+            this.pubkey = (0, utils_1.pubECDSA)(this.privKey);
+            const address = (0, btc_signer_1.getAddress)("wpkh", this.privKey, network);
+            if (address == null)
+                throw new Error("Failed to generate p2wpkh address from the provided private key!");
+            this.address = address;
+        }
+        else {
+            this.address = addressDataOrWIF.address;
+            this.pubkey = buffer_1.Buffer.from(addressDataOrWIF.publicKey, "hex");
+        }
+        this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
+    }
+    toBitcoinWalletAccounts() {
+        return [{
+                pubkey: buffer_1.Buffer.from(this.pubkey).toString("hex"), address: this.address, addressType: this.addressType
+            }];
+    }
+    async sendTransaction(address, amount, feeRate) {
+        if (!this.privKey)
+            throw new Error("Not supported.");
+        const { psbt, fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
+        if (psbt == null)
+            throw new Error(`Not enough funds, required for fee: ${fee} sats!`);
+        psbt.sign(this.privKey);
+        psbt.finalize();
+        const txHex = buffer_1.Buffer.from(psbt.extract()).toString("hex");
+        return await super._sendTransaction(txHex);
+    }
+    async fundPsbt(inputPsbt, feeRate) {
+        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+        if (psbt == null) {
+            throw new Error("Not enough balance!");
+        }
+        return psbt;
+    }
+    async signPsbt(psbt, signInputs) {
+        if (!this.privKey)
+            throw new Error("Not supported.");
+        for (let signInput of signInputs) {
+            psbt.signIdx(this.privKey, signInput);
+        }
+        return psbt;
+    }
+    async getTransactionFee(address, amount, feeRate) {
+        const { fee } = await super._getPsbt(this.toBitcoinWalletAccounts(), address, Number(amount), feeRate);
+        return fee;
+    }
+    async getFundedPsbtFee(basePsbt, feeRate) {
+        const { fee } = await super._fundPsbt(this.toBitcoinWalletAccounts(), basePsbt, feeRate);
+        return fee;
+    }
+    getReceiveAddress() {
+        return this.address;
+    }
+    getBalance() {
+        return this._getBalance(this.address);
+    }
+    getSpendableBalance(psbt, feeRate) {
+        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate);
+    }
+    static generateRandomPrivateKey(network) {
+        return (0, btc_signer_1.WIF)(network).encode((0, utils_1.randomPrivateKeyBytes)());
+    }
+}
+exports.SingleAddressBitcoinWallet = SingleAddressBitcoinWallet;

package/dist/enums/FeeType.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum representing types of fees in a swap
+ * @category Pricing and LPs
+ */
+export declare enum FeeType {
+    SWAP = 0,
+    NETWORK_OUTPUT = 1
+}

package/dist/enums/FeeType.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeeType = void 0;
+/**
+ * Enum representing types of fees in a swap
+ * @category Pricing and LPs
+ */
+var FeeType;
+(function (FeeType) {
+    FeeType[FeeType["SWAP"] = 0] = "SWAP";
+    FeeType[FeeType["NETWORK_OUTPUT"] = 1] = "NETWORK_OUTPUT";
+})(FeeType = exports.FeeType || (exports.FeeType = {}));

package/dist/enums/SwapAmountType.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum representing whether the swap amount is exact input or exact output
+ * @category Core
+ */
+export declare enum SwapAmountType {
+    EXACT_IN = 1,
+    EXACT_OUT = 0
+}

package/dist/enums/SwapAmountType.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapAmountType = void 0;
+/**
+ * Enum representing whether the swap amount is exact input or exact output
+ * @category Core
+ */
+var SwapAmountType;
+(function (SwapAmountType) {
+    SwapAmountType[SwapAmountType["EXACT_IN"] = 1] = "EXACT_IN";
+    SwapAmountType[SwapAmountType["EXACT_OUT"] = 0] = "EXACT_OUT";
+})(SwapAmountType = exports.SwapAmountType || (exports.SwapAmountType = {}));

package/dist/enums/SwapDirection.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum representing the direction of a swap (from or to Bitcoin)
+ * @category Core
+ */
+export declare enum SwapDirection {
+    FROM_BTC = 0,
+    TO_BTC = 1
+}

package/dist/enums/SwapDirection.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapDirection = void 0;
+/**
+ * Enum representing the direction of a swap (from or to Bitcoin)
+ * @category Core
+ */
+var SwapDirection;
+(function (SwapDirection) {
+    SwapDirection[SwapDirection["FROM_BTC"] = 0] = "FROM_BTC";
+    SwapDirection[SwapDirection["TO_BTC"] = 1] = "TO_BTC";
+})(SwapDirection = exports.SwapDirection || (exports.SwapDirection = {}));

package/dist/enums/SwapType.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Enum representing different types of swaps
+ * @category Core
+ */
+export declare enum SwapType {
+    FROM_BTC = 0,
+    FROM_BTCLN = 1,
+    TO_BTC = 2,
+    TO_BTCLN = 3,
+    TRUSTED_FROM_BTC = 4,
+    TRUSTED_FROM_BTCLN = 5,
+    SPV_VAULT_FROM_BTC = 6,
+    FROM_BTCLN_AUTO = 7
+}

package/dist/enums/SwapType.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapType = void 0;
+/**
+ * Enum representing different types of swaps
+ * @category Core
+ */
+var SwapType;
+(function (SwapType) {
+    SwapType[SwapType["FROM_BTC"] = 0] = "FROM_BTC";
+    SwapType[SwapType["FROM_BTCLN"] = 1] = "FROM_BTCLN";
+    SwapType[SwapType["TO_BTC"] = 2] = "TO_BTC";
+    SwapType[SwapType["TO_BTCLN"] = 3] = "TO_BTCLN";
+    SwapType[SwapType["TRUSTED_FROM_BTC"] = 4] = "TRUSTED_FROM_BTC";
+    SwapType[SwapType["TRUSTED_FROM_BTCLN"] = 5] = "TRUSTED_FROM_BTCLN";
+    SwapType[SwapType["SPV_VAULT_FROM_BTC"] = 6] = "SPV_VAULT_FROM_BTC";
+    SwapType[SwapType["FROM_BTCLN_AUTO"] = 7] = "FROM_BTCLN_AUTO";
+})(SwapType = exports.SwapType || (exports.SwapType = {}));

package/dist/errors/IntermediaryError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * An error or inconsistency in the intermediary's returned data, this will blacklist the intermediary
+ * @category Errors
+ */
+export declare class IntermediaryError extends Error {
+    recoverable: boolean;
+    originalStack?: string;
+    constructor(msg: string, originalError?: any, recoverable?: boolean);
+}

package/dist/errors/IntermediaryError.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntermediaryError = void 0;
+/**
+ * An error or inconsistency in the intermediary's returned data, this will blacklist the intermediary
+ * @category Errors
+ */
+class IntermediaryError extends Error {
+    constructor(msg, originalError, recoverable = false) {
+        if (originalError != null) {
+            if (originalError.name != null)
+                msg += ": " + originalError.name;
+            if (originalError.message != null)
+                msg += ": " + originalError.message;
+            if (typeof (originalError) === "string")
+                msg += ": " + originalError;
+        }
+        super(msg);
+        if (originalError?.stack != null)
+            this.originalStack = originalError.stack;
+        this.recoverable = recoverable;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, IntermediaryError.prototype);
+    }
+}
+exports.IntermediaryError = IntermediaryError;

package/dist/errors/PaymentAuthError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * An error when the payment authorization returned by the intermediary is invalid
+ * @category Errors
+ */
+export declare class PaymentAuthError extends Error {
+    code?: number;
+    data: any;
+    constructor(msg: string, code?: number, data?: any);
+    getCode(): number | undefined;
+    getData(): any;
+}

package/dist/errors/PaymentAuthError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentAuthError = void 0;
+/**
+ * An error when the payment authorization returned by the intermediary is invalid
+ * @category Errors
+ */
+class PaymentAuthError extends Error {
+    constructor(msg, code, data) {
+        super(msg);
+        this.data = data;
+        this.code = code;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, PaymentAuthError.prototype);
+    }
+    getCode() {
+        return this.code;
+    }
+    getData() {
+        return this.data;
+    }
+}
+exports.PaymentAuthError = PaymentAuthError;