@atomiqlabs/lp-lib 15.0.13 → 15.0.14

package/src/swaps/escrow/tobtcln_abstract/ToBtcLnSwapAbs.ts

@@ -1,81 +1,81 @@
-import {SwapData} from "@atomiqlabs/base";
-import {SwapHandlerType} from "../../../index";
-import {deserializeBN} from "../../../utils/Utils";
-import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
-
-export enum ToBtcLnSwapState {
-    REFUNDED = -3,
-    CANCELED = -2,
-    NON_PAYABLE = -1,
-    SAVED = 0,
-    COMMITED = 1,
-    PAID = 2,
-    CLAIMED = 3
-}
-
-export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
-
-    lnPaymentHash: string;
-    readonly pr: string;
-    payInitiated: boolean;
-
-    secret: string;
-
-    constructor(
-        chainIdentifier: string,
-        lnPaymentHash: string,
-        pr: string,
-        amountMtokens: bigint,
-        swapFee: bigint,
-        swapFeeInToken: bigint,
-        quotedNetworkFee: bigint,
-        quotedNetworkFeeInToken: bigint,
-    );
-    constructor(obj: any);
-
-    constructor(chainIdOrObj: string | any, lnPaymentHash?: string, pr?: string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint, quotedNetworkFee?: bigint, quotedNetworkFeeInToken?: bigint) {
-        if(typeof(chainIdOrObj)==="string") {
-            super(chainIdOrObj, (amount + 999n) / 1000n, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
-            this.state = ToBtcLnSwapState.SAVED;
-            this.lnPaymentHash = lnPaymentHash;
-            this.pr = pr;
-        } else {
-            super(chainIdOrObj);
-            this.pr = chainIdOrObj.pr;
-            this.secret = chainIdOrObj.secret;
-            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
-            this.payInitiated = chainIdOrObj.payInitiated;
-
-            //Compatibility with older versions
-            this.quotedNetworkFee ??= deserializeBN(chainIdOrObj.maxFee);
-            this.realNetworkFee ??= deserializeBN(chainIdOrObj.realRoutingFee);
-        }
-        this.type = SwapHandlerType.TO_BTCLN;
-    }
-
-    getIdentifierHash(): string {
-        return this.lnPaymentHash;
-    }
-
-    serialize(): any {
-        const partialSerialized = super.serialize();
-        partialSerialized.pr = this.pr;
-        partialSerialized.lnPaymentHash = this.lnPaymentHash;
-        partialSerialized.secret = this.secret;
-        partialSerialized.payInitiated = this.payInitiated;
-        return partialSerialized;
-    }
-
-    isInitiated(): boolean {
-        return this.state!==ToBtcLnSwapState.SAVED;
-    }
-
-    isFailed(): boolean {
-        return this.state===ToBtcLnSwapState.NON_PAYABLE || this.state===ToBtcLnSwapState.CANCELED || this.state===ToBtcLnSwapState.REFUNDED;
-    }
-
-    isSuccess(): boolean {
-        return this.state===ToBtcLnSwapState.CLAIMED;
-    }
-
+import {SwapData} from "@atomiqlabs/base";
+import {SwapHandlerType} from "../../../index";
+import {deserializeBN} from "../../../utils/Utils";
+import {ToBtcBaseSwap} from "../ToBtcBaseSwap";
+
+export enum ToBtcLnSwapState {
+    REFUNDED = -3,
+    CANCELED = -2,
+    NON_PAYABLE = -1,
+    SAVED = 0,
+    COMMITED = 1,
+    PAID = 2,
+    CLAIMED = 3
+}
+
+export class ToBtcLnSwapAbs<T extends SwapData = SwapData> extends ToBtcBaseSwap<T, ToBtcLnSwapState> {
+
+    lnPaymentHash: string;
+    readonly pr: string;
+    payInitiated: boolean;
+
+    secret: string;
+
+    constructor(
+        chainIdentifier: string,
+        lnPaymentHash: string,
+        pr: string,
+        amountMtokens: bigint,
+        swapFee: bigint,
+        swapFeeInToken: bigint,
+        quotedNetworkFee: bigint,
+        quotedNetworkFeeInToken: bigint,
+    );
+    constructor(obj: any);
+
+    constructor(chainIdOrObj: string | any, lnPaymentHash?: string, pr?: string, amount?: bigint, swapFee?: bigint, swapFeeInToken?: bigint, quotedNetworkFee?: bigint, quotedNetworkFeeInToken?: bigint) {
+        if(typeof(chainIdOrObj)==="string") {
+            super(chainIdOrObj, (amount + 999n) / 1000n, swapFee, swapFeeInToken, quotedNetworkFee, quotedNetworkFeeInToken);
+            this.state = ToBtcLnSwapState.SAVED;
+            this.lnPaymentHash = lnPaymentHash;
+            this.pr = pr;
+        } else {
+            super(chainIdOrObj);
+            this.pr = chainIdOrObj.pr;
+            this.secret = chainIdOrObj.secret;
+            this.lnPaymentHash = chainIdOrObj.lnPaymentHash;
+            this.payInitiated = chainIdOrObj.payInitiated;
+
+            //Compatibility with older versions
+            this.quotedNetworkFee ??= deserializeBN(chainIdOrObj.maxFee);
+            this.realNetworkFee ??= deserializeBN(chainIdOrObj.realRoutingFee);
+        }
+        this.type = SwapHandlerType.TO_BTCLN;
+    }
+
+    getIdentifierHash(): string {
+        return this.lnPaymentHash;
+    }
+
+    serialize(): any {
+        const partialSerialized = super.serialize();
+        partialSerialized.pr = this.pr;
+        partialSerialized.lnPaymentHash = this.lnPaymentHash;
+        partialSerialized.secret = this.secret;
+        partialSerialized.payInitiated = this.payInitiated;
+        return partialSerialized;
+    }
+
+    isInitiated(): boolean {
+        return this.state!==ToBtcLnSwapState.SAVED;
+    }
+
+    isFailed(): boolean {
+        return this.state===ToBtcLnSwapState.NON_PAYABLE || this.state===ToBtcLnSwapState.CANCELED || this.state===ToBtcLnSwapState.REFUNDED;
+    }
+
+    isSuccess(): boolean {
+        return this.state===ToBtcLnSwapState.CLAIMED;
+    }
+
 }

package/src/swaps/spv_vault_swap/SpvVault.ts

@@ -1,178 +1,178 @@
-import {
-    Lockable,
-    SpvVaultClaimEvent,
-    SpvVaultCloseEvent,
-    SpvVaultData,
-    SpvVaultDepositEvent,
-    SpvVaultOpenEvent,
-    SpvVaultTokenBalance,
-    SpvWithdrawalTransactionData,
-    StorageObject
-} from "@atomiqlabs/base";
-
-export enum SpvVaultState {
-    CLOSED = -1,
-    BTC_INITIATED = 0,
-    BTC_CONFIRMED = 1,
-    OPENED = 2
-}
-
-export class SpvVault<
-    D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData & {sending?: boolean},
-    T extends SpvVaultData = SpvVaultData
-> extends Lockable implements StorageObject {
-
-    readonly chainId: string;
-
-    readonly initialUtxo: string;
-    readonly btcAddress: string;
-
-    readonly pendingWithdrawals: D[];
-    readonly replacedWithdrawals: Map<number, D[]>;
-    data: T;
-
-    state: SpvVaultState;
-
-    balances: SpvVaultTokenBalance[];
-
-    scOpenTx: {txId: string, rawTx: string};
-
-    constructor(chainId: string, vault: T, btcAddress: string);
-    constructor(obj: any);
-    constructor(chainIdOrObj: string | any, vault?: T, btcAddress?: string) {
-        super();
-        if(typeof(chainIdOrObj)==="string") {
-            this.state = SpvVaultState.BTC_INITIATED;
-            this.chainId = chainIdOrObj;
-            this.data = vault;
-            this.initialUtxo = vault.getUtxo();
-            this.btcAddress = btcAddress;
-            this.pendingWithdrawals = [];
-            this.replacedWithdrawals = new Map();
-        } else {
-            this.state = chainIdOrObj.state;
-            this.chainId = chainIdOrObj.chainId;
-            this.data = SpvVaultData.deserialize<T>(chainIdOrObj.data);
-            this.initialUtxo = chainIdOrObj.initialUtxo;
-            this.btcAddress = chainIdOrObj.btcAddress;
-            this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map(SpvWithdrawalTransactionData.deserialize<D>);
-            this.scOpenTx = chainIdOrObj.scOpenTx;
-            this.replacedWithdrawals = new Map();
-            if(chainIdOrObj.replacedWithdrawals!=null) {
-                chainIdOrObj.replacedWithdrawals.forEach((val: [number, any[]]) => {
-                    this.replacedWithdrawals.set(val[0], val[1].map(SpvWithdrawalTransactionData.deserialize<D>));
-                });
-            }
-        }
-        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
-    }
-
-    update(event: SpvVaultOpenEvent | SpvVaultDepositEvent | SpvVaultCloseEvent | SpvVaultClaimEvent): void {
-        if(event instanceof SpvVaultClaimEvent || event instanceof SpvVaultCloseEvent) {
-            const processedWithdrawalIndex = this.pendingWithdrawals.findIndex(val => val.btcTx.txid === event.btcTxId);
-            if(processedWithdrawalIndex!==-1) this.pendingWithdrawals.splice(0, processedWithdrawalIndex + 1);
-            if(event instanceof SpvVaultClaimEvent) {
-                for(let key of this.replacedWithdrawals.keys()) {
-                    if(key<=event.withdrawCount) this.replacedWithdrawals.delete(key);
-                }
-            }
-            if(event instanceof SpvVaultCloseEvent) {
-                this.replacedWithdrawals.clear();
-            }
-        }
-        this.data.updateState(event);
-        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
-    }
-
-    addWithdrawal(withdrawalData: D): void {
-        //Make sure this is a valid state transition before adding the tx to pending withdrawals
-        this.balances = this.data.calculateStateAfter([...this.pendingWithdrawals, withdrawalData]).balances;
-        this.pendingWithdrawals.push(withdrawalData);
-    }
-
-    removeWithdrawal(withdrawalData: D): boolean {
-        const index = this.pendingWithdrawals.indexOf(withdrawalData);
-        if(index===-1) return false;
-        this.pendingWithdrawals.splice(index, 1);
-        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
-        return true;
-    }
-
-    doubleSpendPendingWithdrawal(withdrawalData: D): boolean {
-        const index = this.pendingWithdrawals.indexOf(withdrawalData);
-        if(index===-1) return false;
-        this.pendingWithdrawals.splice(index, 1);
-        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
-
-        const withdrawalIndex = this.data.getWithdrawalCount()+index+1;
-        let arr = this.replacedWithdrawals.get(withdrawalIndex);
-        if(arr==null) this.replacedWithdrawals.set(withdrawalIndex, arr = []);
-        arr.push(withdrawalData);
-        return true;
-    }
-
-    toRawAmounts(amounts: bigint[]): bigint[] {
-        return amounts.map((amt, index) => {
-            const tokenData = this.data.getTokenData()[index];
-            if(tokenData==null) throw new Error("Amount index out of bounds!");
-            return amt / tokenData.multiplier;
-        });
-    }
-
-    fromRawAmounts(rawAmounts: bigint[]): bigint[] {
-        return rawAmounts.map((amt, index) => {
-            const tokenData = this.data.getTokenData()[index];
-            if(tokenData==null) throw new Error("Amount index out of bounds!");
-            return amt * tokenData.multiplier;
-        });
-    }
-
-    /**
-     * Returns the vault balance after processing all currently confirmed (at least 1 btc confirmation) withdrawals
-     */
-    getConfirmedBalance(): SpvVaultTokenBalance[] {
-        return this.data.calculateStateAfter(this.pendingWithdrawals.filter(val => val.btcTx.confirmations>=1)).balances;
-    }
-
-    serialize(): any {
-        const replacedWithdrawals: [number, any[]][] = [];
-        this.replacedWithdrawals.forEach((value, key) => {
-            replacedWithdrawals.push([key, value.map(val => val.serialize())])
-        });
-
-        return {
-            state: this.state,
-            chainId: this.chainId,
-            data: this.data.serialize(),
-            initialUtxo: this.initialUtxo,
-            btcAddress: this.btcAddress,
-            pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
-            replacedWithdrawals,
-            scOpenTx: this.scOpenTx
-        }
-    }
-
-    getIdentifier(): string {
-        return this.chainId+"_"+this.data.getOwner()+"_"+this.data.getVaultId().toString(10);
-    }
-
-    /**
-     * Returns the latest vault utxo
-     */
-    getLatestUtxo(): string {
-        if(this.pendingWithdrawals.length===0) {
-            return this.data.getUtxo();
-        }
-        const latestWithdrawal = this.pendingWithdrawals[this.pendingWithdrawals.length - 1];
-        if(latestWithdrawal.btcTx.confirmations>=1) return latestWithdrawal.btcTx.txid+":0";
-        return null;
-    }
-
-    /**
-     * Returns whether the vault is ready for the next swap
-     */
-    isReady(): boolean {
-        return this.data.isOpened() && this.getLatestUtxo()!=null;
-    }
-
-}
+import {
+    Lockable,
+    SpvVaultClaimEvent,
+    SpvVaultCloseEvent,
+    SpvVaultData,
+    SpvVaultDepositEvent,
+    SpvVaultOpenEvent,
+    SpvVaultTokenBalance,
+    SpvWithdrawalTransactionData,
+    StorageObject
+} from "@atomiqlabs/base";
+
+export enum SpvVaultState {
+    CLOSED = -1,
+    BTC_INITIATED = 0,
+    BTC_CONFIRMED = 1,
+    OPENED = 2
+}
+
+export class SpvVault<
+    D extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData & {sending?: boolean},
+    T extends SpvVaultData = SpvVaultData
+> extends Lockable implements StorageObject {
+
+    readonly chainId: string;
+
+    readonly initialUtxo: string;
+    readonly btcAddress: string;
+
+    readonly pendingWithdrawals: D[];
+    readonly replacedWithdrawals: Map<number, D[]>;
+    data: T;
+
+    state: SpvVaultState;
+
+    balances: SpvVaultTokenBalance[];
+
+    scOpenTx: {txId: string, rawTx: string};
+
+    constructor(chainId: string, vault: T, btcAddress: string);
+    constructor(obj: any);
+    constructor(chainIdOrObj: string | any, vault?: T, btcAddress?: string) {
+        super();
+        if(typeof(chainIdOrObj)==="string") {
+            this.state = SpvVaultState.BTC_INITIATED;
+            this.chainId = chainIdOrObj;
+            this.data = vault;
+            this.initialUtxo = vault.getUtxo();
+            this.btcAddress = btcAddress;
+            this.pendingWithdrawals = [];
+            this.replacedWithdrawals = new Map();
+        } else {
+            this.state = chainIdOrObj.state;
+            this.chainId = chainIdOrObj.chainId;
+            this.data = SpvVaultData.deserialize<T>(chainIdOrObj.data);
+            this.initialUtxo = chainIdOrObj.initialUtxo;
+            this.btcAddress = chainIdOrObj.btcAddress;
+            this.pendingWithdrawals = chainIdOrObj.pendingWithdrawals.map(SpvWithdrawalTransactionData.deserialize<D>);
+            this.scOpenTx = chainIdOrObj.scOpenTx;
+            this.replacedWithdrawals = new Map();
+            if(chainIdOrObj.replacedWithdrawals!=null) {
+                chainIdOrObj.replacedWithdrawals.forEach((val: [number, any[]]) => {
+                    this.replacedWithdrawals.set(val[0], val[1].map(SpvWithdrawalTransactionData.deserialize<D>));
+                });
+            }
+        }
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+    }
+
+    update(event: SpvVaultOpenEvent | SpvVaultDepositEvent | SpvVaultCloseEvent | SpvVaultClaimEvent): void {
+        if(event instanceof SpvVaultClaimEvent || event instanceof SpvVaultCloseEvent) {
+            const processedWithdrawalIndex = this.pendingWithdrawals.findIndex(val => val.btcTx.txid === event.btcTxId);
+            if(processedWithdrawalIndex!==-1) this.pendingWithdrawals.splice(0, processedWithdrawalIndex + 1);
+            if(event instanceof SpvVaultClaimEvent) {
+                for(let key of this.replacedWithdrawals.keys()) {
+                    if(key<=event.withdrawCount) this.replacedWithdrawals.delete(key);
+                }
+            }
+            if(event instanceof SpvVaultCloseEvent) {
+                this.replacedWithdrawals.clear();
+            }
+        }
+        this.data.updateState(event);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+    }
+
+    addWithdrawal(withdrawalData: D): void {
+        //Make sure this is a valid state transition before adding the tx to pending withdrawals
+        this.balances = this.data.calculateStateAfter([...this.pendingWithdrawals, withdrawalData]).balances;
+        this.pendingWithdrawals.push(withdrawalData);
+    }
+
+    removeWithdrawal(withdrawalData: D): boolean {
+        const index = this.pendingWithdrawals.indexOf(withdrawalData);
+        if(index===-1) return false;
+        this.pendingWithdrawals.splice(index, 1);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+        return true;
+    }
+
+    doubleSpendPendingWithdrawal(withdrawalData: D): boolean {
+        const index = this.pendingWithdrawals.indexOf(withdrawalData);
+        if(index===-1) return false;
+        this.pendingWithdrawals.splice(index, 1);
+        this.balances = this.data.calculateStateAfter(this.pendingWithdrawals).balances;
+
+        const withdrawalIndex = this.data.getWithdrawalCount()+index+1;
+        let arr = this.replacedWithdrawals.get(withdrawalIndex);
+        if(arr==null) this.replacedWithdrawals.set(withdrawalIndex, arr = []);
+        arr.push(withdrawalData);
+        return true;
+    }
+
+    toRawAmounts(amounts: bigint[]): bigint[] {
+        return amounts.map((amt, index) => {
+            const tokenData = this.data.getTokenData()[index];
+            if(tokenData==null) throw new Error("Amount index out of bounds!");
+            return amt / tokenData.multiplier;
+        });
+    }
+
+    fromRawAmounts(rawAmounts: bigint[]): bigint[] {
+        return rawAmounts.map((amt, index) => {
+            const tokenData = this.data.getTokenData()[index];
+            if(tokenData==null) throw new Error("Amount index out of bounds!");
+            return amt * tokenData.multiplier;
+        });
+    }
+
+    /**
+     * Returns the vault balance after processing all currently confirmed (at least 1 btc confirmation) withdrawals
+     */
+    getConfirmedBalance(): SpvVaultTokenBalance[] {
+        return this.data.calculateStateAfter(this.pendingWithdrawals.filter(val => val.btcTx.confirmations>=1)).balances;
+    }
+
+    serialize(): any {
+        const replacedWithdrawals: [number, any[]][] = [];
+        this.replacedWithdrawals.forEach((value, key) => {
+            replacedWithdrawals.push([key, value.map(val => val.serialize())])
+        });
+
+        return {
+            state: this.state,
+            chainId: this.chainId,
+            data: this.data.serialize(),
+            initialUtxo: this.initialUtxo,
+            btcAddress: this.btcAddress,
+            pendingWithdrawals: this.pendingWithdrawals.map(val => val.serialize()),
+            replacedWithdrawals,
+            scOpenTx: this.scOpenTx
+        }
+    }
+
+    getIdentifier(): string {
+        return this.chainId+"_"+this.data.getOwner()+"_"+this.data.getVaultId().toString(10);
+    }
+
+    /**
+     * Returns the latest vault utxo
+     */
+    getLatestUtxo(): string {
+        if(this.pendingWithdrawals.length===0) {
+            return this.data.getUtxo();
+        }
+        const latestWithdrawal = this.pendingWithdrawals[this.pendingWithdrawals.length - 1];
+        if(latestWithdrawal.btcTx.confirmations>=1) return latestWithdrawal.btcTx.txid+":0";
+        return null;
+    }
+
+    /**
+     * Returns whether the vault is ready for the next swap
+     */
+    isReady(): boolean {
+        return this.data.isOpened() && this.getLatestUtxo()!=null;
+    }
+
+}