@atomiqlabs/base 10.0.0-dev.2 → 10.0.0-dev.4

package/src/spv_swap/SpvVaultData.ts

@@ -1,70 +1,70 @@
-import {StorageObject} from "../storage/StorageObject";
-import {SpvWithdrawalTransactionData} from "./SpvWithdrawalTransactionData";
-import {SpvVaultClaimEvent} from "../events/types/spv_vault/SpvVaultClaimEvent";
-import {SpvVaultCloseEvent} from "../events/types/spv_vault/SpvVaultCloseEvent";
-import {SpvVaultOpenEvent} from "../events/types/spv_vault/SpvVaultOpenEvent";
-import {SpvVaultDepositEvent} from "../events/types/spv_vault/SpvVaultDepositEvent";
-
-export type SpvVaultTokenBalance = SpvVaultTokenData & {
-    rawAmount: bigint,
-    scaledAmount: bigint
-};
-
-export type SpvVaultTokenData = {
-    token: string,
-    multiplier: bigint
-}
-
-export abstract class SpvVaultData<T extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData> implements StorageObject {
-
-    static deserializers: {
-        [type: string]: new (serialized: any) => any,
-    } = {};
-
-    static deserialize<T extends SpvVaultData>(data: any): T {
-        if (SpvVaultData.deserializers[data.type] != null) {
-            return new SpvVaultData.deserializers[data.type](data) as unknown as T;
-        }
-    }
-
-    abstract serialize(): any;
-
-    abstract getOwner(): string;
-    abstract getVaultId(): bigint;
-    abstract getTokenData(): SpvVaultTokenData[];
-
-    abstract getBalances(): SpvVaultTokenBalance[];
-    abstract getUtxo(): string;
-    abstract getConfirmations(): number;
-    abstract getWithdrawalCount(): number;
-    abstract getDepositCount(): number;
-    abstract isOpened(): boolean;
-
-    abstract updateState(withdrawalTxOrEvent: T | SpvVaultClaimEvent | SpvVaultCloseEvent | SpvVaultOpenEvent | SpvVaultDepositEvent): void;
-
-    calculateStateAfter(priorWithdrawalTxs: T[]): {withdrawalCount: number, balances: SpvVaultTokenBalance[]} {
-        const balances = [...this.getBalances()];
-        let withdrawalCount = this.getWithdrawalCount();
-        let utxo = this.getUtxo();
-        for(let withdrawalTx of priorWithdrawalTxs) {
-            if(withdrawalTx.getSpentVaultUtxo()!==utxo) throw new Error("Invalid transaction, doesn't spend prior vault UTXO!");
-            withdrawalTx.getTotalOutput().forEach((value, i) => {
-                if(balances[i]==null) throw new Error("Tried to withdraw non-existing token!");
-                balances[i].rawAmount -= value;
-                if(balances[i].rawAmount < 0n) throw new Error("Prior transaction withdrew more than available in vault");
-            });
-            utxo = withdrawalTx.getCreatedVaultUtxo();
-            withdrawalCount++;
-        }
-
-        balances.forEach(balance => {
-            balance.scaledAmount = balance.rawAmount * balance.multiplier;
-        });
-
-        return {
-            withdrawalCount,
-            balances
-        }
-    }
-
-}
+import {StorageObject} from "../storage/StorageObject";
+import {SpvWithdrawalTransactionData} from "./SpvWithdrawalTransactionData";
+import {SpvVaultClaimEvent} from "../events/types/spv_vault/SpvVaultClaimEvent";
+import {SpvVaultCloseEvent} from "../events/types/spv_vault/SpvVaultCloseEvent";
+import {SpvVaultOpenEvent} from "../events/types/spv_vault/SpvVaultOpenEvent";
+import {SpvVaultDepositEvent} from "../events/types/spv_vault/SpvVaultDepositEvent";
+
+export type SpvVaultTokenBalance = SpvVaultTokenData & {
+    rawAmount: bigint,
+    scaledAmount: bigint
+};
+
+export type SpvVaultTokenData = {
+    token: string,
+    multiplier: bigint
+}
+
+export abstract class SpvVaultData<T extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData> implements StorageObject {
+
+    static deserializers: {
+        [type: string]: new (serialized: any) => any,
+    } = {};
+
+    static deserialize<T extends SpvVaultData>(data: any): T {
+        if (SpvVaultData.deserializers[data.type] != null) {
+            return new SpvVaultData.deserializers[data.type](data) as unknown as T;
+        }
+    }
+
+    abstract serialize(): any;
+
+    abstract getOwner(): string;
+    abstract getVaultId(): bigint;
+    abstract getTokenData(): SpvVaultTokenData[];
+
+    abstract getBalances(): SpvVaultTokenBalance[];
+    abstract getUtxo(): string;
+    abstract getConfirmations(): number;
+    abstract getWithdrawalCount(): number;
+    abstract getDepositCount(): number;
+    abstract isOpened(): boolean;
+
+    abstract updateState(withdrawalTxOrEvent: T | SpvVaultClaimEvent | SpvVaultCloseEvent | SpvVaultOpenEvent | SpvVaultDepositEvent): void;
+
+    calculateStateAfter(priorWithdrawalTxs: T[]): {withdrawalCount: number, balances: SpvVaultTokenBalance[]} {
+        const balances = [...this.getBalances()];
+        let withdrawalCount = this.getWithdrawalCount();
+        let utxo = this.getUtxo();
+        for(let withdrawalTx of priorWithdrawalTxs) {
+            if(withdrawalTx.getSpentVaultUtxo()!==utxo) throw new Error("Invalid transaction, doesn't spend prior vault UTXO!");
+            withdrawalTx.getTotalOutput().forEach((value, i) => {
+                if(balances[i]==null) throw new Error("Tried to withdraw non-existing token!");
+                balances[i].rawAmount -= value;
+                if(balances[i].rawAmount < 0n) throw new Error("Prior transaction withdrew more than available in vault");
+            });
+            utxo = withdrawalTx.getCreatedVaultUtxo();
+            withdrawalCount++;
+        }
+
+        balances.forEach(balance => {
+            balance.scaledAmount = balance.rawAmount * balance.multiplier;
+        });
+
+        return {
+            withdrawalCount,
+            balances
+        }
+    }
+
+}

package/src/spv_swap/SpvWithdrawalState.ts

@@ -1,40 +1,40 @@
-
-export enum SpvWithdrawalStateType {
-    CLOSED = -1,
-    NOT_FOUND = 0,
-    CLAIMED = 1,
-    FRONTED = 2
-}
-
-export type SpvWithdrawalNotFoundState = {
-    type: SpvWithdrawalStateType.NOT_FOUND
-};
-
-type SpvWithdrawalStateCommon = {
-    txId: string,
-    owner: string,
-    vaultId: bigint,
-};
-
-export type SpvWithdrawalClaimedState = {
-    type: SpvWithdrawalStateType.CLAIMED,
-    recipient: string,
-    claimer: string,
-    fronter: string
-} & SpvWithdrawalStateCommon;
-
-export type SpvWithdrawalFrontedState = {
-    type: SpvWithdrawalStateType.FRONTED,
-    recipient: string,
-    fronter: string
-} & SpvWithdrawalStateCommon;
-
-export type SpvWithdrawalClosedState = {
-    type: SpvWithdrawalStateType.CLOSED,
-    error: string
-} & SpvWithdrawalStateCommon;
-
-export type SpvWithdrawalState = SpvWithdrawalNotFoundState |
-    SpvWithdrawalClaimedState |
-    SpvWithdrawalFrontedState |
-    SpvWithdrawalClosedState;
+
+export enum SpvWithdrawalStateType {
+    CLOSED = -1,
+    NOT_FOUND = 0,
+    CLAIMED = 1,
+    FRONTED = 2
+}
+
+export type SpvWithdrawalNotFoundState = {
+    type: SpvWithdrawalStateType.NOT_FOUND
+};
+
+type SpvWithdrawalStateCommon = {
+    txId: string,
+    owner: string,
+    vaultId: bigint,
+};
+
+export type SpvWithdrawalClaimedState = {
+    type: SpvWithdrawalStateType.CLAIMED,
+    recipient: string,
+    claimer: string,
+    fronter: string
+} & SpvWithdrawalStateCommon;
+
+export type SpvWithdrawalFrontedState = {
+    type: SpvWithdrawalStateType.FRONTED,
+    recipient: string,
+    fronter: string
+} & SpvWithdrawalStateCommon;
+
+export type SpvWithdrawalClosedState = {
+    type: SpvWithdrawalStateType.CLOSED,
+    error: string
+} & SpvWithdrawalStateCommon;
+
+export type SpvWithdrawalState = SpvWithdrawalNotFoundState |
+    SpvWithdrawalClaimedState |
+    SpvWithdrawalFrontedState |
+    SpvWithdrawalClosedState;

package/src/spv_swap/SpvWithdrawalTransactionData.ts

@@ -1,170 +1,170 @@
-import {BtcTx} from "../btc/rpc/BitcoinRpc";
-import {Buffer} from "buffer";
-import {StorageObject} from "../storage/StorageObject";
-
-export type ExecutionData = {
-    executionHash: string,
-    executionExpiry: number
-};
-
-export abstract class SpvWithdrawalTransactionData implements StorageObject {
-
-    static deserializers: {
-        [type: string]: new (serialized: any) => any,
-    } = {};
-
-    static deserialize<T extends SpvWithdrawalTransactionData>(data: any): T {
-        if (SpvWithdrawalTransactionData.deserializers[data.type] != null) {
-            return new SpvWithdrawalTransactionData.deserializers[data.type](data) as unknown as T;
-        }
-    }
-
-    protected abstract fromOpReturnData(data: Buffer): {recipient: string, rawAmounts: bigint[], executionHash: string};
-
-    readonly recipient: string;
-    readonly rawAmounts: bigint[];
-
-    readonly callerFeeRate: bigint;
-    readonly executionFeeRate: bigint;
-    readonly frontingFeeRate: bigint;
-
-    readonly executionHash: string;
-    readonly executionExpiry: number;
-
-    readonly btcTx: BtcTx;
-
-    constructor(btcTx: BtcTx) {
-        if(btcTx.ins.length<2) throw new Error("Need at least 2 inputs");
-        if(btcTx.outs.length<2) throw new Error("Need at least 2 outputs");
-
-        const nSequence0 = BigInt(btcTx.ins[0].sequence);
-        const nSequence1 = BigInt(btcTx.ins[1].sequence);
-
-        if((nSequence0 & 0x80000000n) != 0x80000000n) throw new Error("nSequence0 high bit not set!");
-        if((nSequence1 & 0x80000000n) != 0x80000000n) throw new Error("nSequence0 high bit not set!");
-        const callerFeeRate: bigint = nSequence0 & 0xFFFFFn;
-        const executionFeeRate: bigint = nSequence1 & 0xFFFFFn;
-        const frontingFeeRate: bigint = ((nSequence0 >> 10n) & 0b1111_1111_1100_0000_0000n) | ((nSequence1 >> 20n) & 0b11_1111_1111n);
-
-        const executionExpiry = btcTx.locktime + 1_000_000_000;
-        if(executionExpiry >= Math.pow(2, 32)) throw new Error("Execution expiry overflow");
-
-        const opReturnOutput = btcTx.outs[1];
-        //Parse script
-        const opReturnData = Buffer.from(opReturnOutput.scriptPubKey.hex, "hex");
-        if(opReturnData.length===0) throw new Error("Output 1 empty script");
-        if(opReturnData.at(0)!==0x6a) throw new Error("Output 1 is not OP_RETURN");
-        if(opReturnData.at(1)===0) throw new Error("Output 1 OP_RETURN followed by OP_0");
-        let data: Buffer;
-        if(opReturnData.at(1) === 0x4c) { //OP_PUSHDATA1
-            const dataLength = opReturnData.at(2);
-            data = opReturnData.subarray(3, 3+dataLength);
-            if(data.length !== dataLength) throw new Error("Output 1 OP_RETURN data length mismatch!");
-        } else if(opReturnData.at(1) <= 0x4b) { //OP_PUSH<length>
-            const dataLength = opReturnData.at(1);
-            data = opReturnData.subarray(2, 2+dataLength);
-            if(data.length !== dataLength) throw new Error("Output 1 OP_RETURN data length mismatch!");
-        } else {
-            throw new Error("Output 1 invalid push opcode");
-        }
-
-        //Parse OP_RETURN data
-        const res = this.fromOpReturnData(data);
-
-        this.recipient = res.recipient;
-        this.rawAmounts = res.rawAmounts;
-
-        this.callerFeeRate = callerFeeRate;
-        this.frontingFeeRate = frontingFeeRate;
-        this.executionFeeRate = executionFeeRate;
-
-        this.executionHash = res.executionHash;
-        this.executionExpiry = executionExpiry;
-
-        this.btcTx = btcTx;
-    }
-
-    serialize(): any {
-        return this.btcTx;
-    }
-
-    getRecipient(): string {
-        return this.recipient;
-    }
-
-    abstract isRecipient(address: string): boolean;
-
-    abstract getFrontingId(): string;
-
-    getOutputWithoutFees(): bigint[] {
-        return this.rawAmounts;
-    }
-
-    getCallerFee(): bigint[] {
-        return this.rawAmounts.map(val => val * this.callerFeeRate / 100_000n);
-    }
-
-    getFrontingFee(): bigint[] {
-        return this.rawAmounts.map(val => val * this.frontingFeeRate / 100_000n);
-    }
-
-    getExecutionFee(): bigint[] {
-        return [this.rawAmounts[0] * this.executionFeeRate / 100_000n];
-    }
-
-    getTotalOutput(): bigint[] {
-        const amounts = [...this.getOutputWithoutFees()];
-        const callerFee = this.getCallerFee();
-        if(callerFee!=null) callerFee.forEach((fee, i) => {
-            if(fee==null || fee===0n) return;
-            if(amounts[i]==null) throw new Error("Caller fee token out of bounds");
-            amounts[i] += fee;
-        });
-        const frontingFee = this.getFrontingFee();
-        if(frontingFee!=null) frontingFee.forEach((fee, i) => {
-            if(fee==null || fee===0n) return;
-            if(amounts[i]==null) throw new Error("Fronting fee token out of bounds");
-            amounts[i] += fee;
-        });
-        const executionFee = this.getExecutionFee();
-        if(executionFee!=null) executionFee.forEach((fee, i) => {
-            if(fee==null || fee===0n) return;
-            if(amounts[i]==null) throw new Error("Execution fee token out of bounds");
-            amounts[i] += fee;
-        });
-        amounts.forEach((val, index) => {
-            if(val >= 2n**64n) throw new Error("Token "+index+" amount out of bounds");
-        })
-        return amounts;
-    }
-
-    getExecutionData(): ExecutionData | null {
-        if(this.executionHash==null) return null;
-        return {
-            executionHash: this.executionHash,
-            executionExpiry: this.executionExpiry
-        }
-    }
-
-    getTxId(): string {
-        return this.btcTx.txid;
-    }
-
-    getSpentVaultUtxo(): string {
-        const in0 = this.btcTx.ins[0];
-        return in0.txid+":"+in0.vout;
-    }
-
-    getCreatedVaultUtxo(): string {
-        return this.getTxId()+":0";
-    }
-
-    getNewVaultScript(): Buffer {
-        return Buffer.from(this.btcTx.outs[0].scriptPubKey.hex, "hex");
-    }
-
-    getNewVaultBtcAmount(): number {
-        return this.btcTx.outs[0].value;
-    }
-
+import {BtcTx} from "../btc/rpc/BitcoinRpc";
+import {Buffer} from "buffer";
+import {StorageObject} from "../storage/StorageObject";
+
+export type ExecutionData = {
+    executionHash: string,
+    executionExpiry: number
+};
+
+export abstract class SpvWithdrawalTransactionData implements StorageObject {
+
+    static deserializers: {
+        [type: string]: new (serialized: any) => any,
+    } = {};
+
+    static deserialize<T extends SpvWithdrawalTransactionData>(data: any): T {
+        if (SpvWithdrawalTransactionData.deserializers[data.type] != null) {
+            return new SpvWithdrawalTransactionData.deserializers[data.type](data) as unknown as T;
+        }
+    }
+
+    protected abstract fromOpReturnData(data: Buffer): {recipient: string, rawAmounts: bigint[], executionHash: string};
+
+    readonly recipient: string;
+    readonly rawAmounts: bigint[];
+
+    readonly callerFeeRate: bigint;
+    readonly executionFeeRate: bigint;
+    readonly frontingFeeRate: bigint;
+
+    readonly executionHash: string;
+    readonly executionExpiry: number;
+
+    readonly btcTx: BtcTx;
+
+    constructor(btcTx: BtcTx) {
+        if(btcTx.ins.length<2) throw new Error("Need at least 2 inputs");
+        if(btcTx.outs.length<2) throw new Error("Need at least 2 outputs");
+
+        const nSequence0 = BigInt(btcTx.ins[0].sequence);
+        const nSequence1 = BigInt(btcTx.ins[1].sequence);
+
+        if((nSequence0 & 0x80000000n) != 0x80000000n) throw new Error("nSequence0 high bit not set!");
+        if((nSequence1 & 0x80000000n) != 0x80000000n) throw new Error("nSequence0 high bit not set!");
+        const callerFeeRate: bigint = nSequence0 & 0xFFFFFn;
+        const executionFeeRate: bigint = nSequence1 & 0xFFFFFn;
+        const frontingFeeRate: bigint = ((nSequence0 >> 10n) & 0b1111_1111_1100_0000_0000n) | ((nSequence1 >> 20n) & 0b11_1111_1111n);
+
+        const executionExpiry = btcTx.locktime + 1_000_000_000;
+        if(executionExpiry >= Math.pow(2, 32)) throw new Error("Execution expiry overflow");
+
+        const opReturnOutput = btcTx.outs[1];
+        //Parse script
+        const opReturnData = Buffer.from(opReturnOutput.scriptPubKey.hex, "hex");
+        if(opReturnData.length===0) throw new Error("Output 1 empty script");
+        if(opReturnData.at(0)!==0x6a) throw new Error("Output 1 is not OP_RETURN");
+        if(opReturnData.at(1)===0) throw new Error("Output 1 OP_RETURN followed by OP_0");
+        let data: Buffer;
+        if(opReturnData.at(1) === 0x4c) { //OP_PUSHDATA1
+            const dataLength = opReturnData.at(2);
+            data = opReturnData.subarray(3, 3+dataLength);
+            if(data.length !== dataLength) throw new Error("Output 1 OP_RETURN data length mismatch!");
+        } else if(opReturnData.at(1) <= 0x4b) { //OP_PUSH<length>
+            const dataLength = opReturnData.at(1);
+            data = opReturnData.subarray(2, 2+dataLength);
+            if(data.length !== dataLength) throw new Error("Output 1 OP_RETURN data length mismatch!");
+        } else {
+            throw new Error("Output 1 invalid push opcode");
+        }
+
+        //Parse OP_RETURN data
+        const res = this.fromOpReturnData(data);
+
+        this.recipient = res.recipient;
+        this.rawAmounts = res.rawAmounts;
+
+        this.callerFeeRate = callerFeeRate;
+        this.frontingFeeRate = frontingFeeRate;
+        this.executionFeeRate = executionFeeRate;
+
+        this.executionHash = res.executionHash;
+        this.executionExpiry = executionExpiry;
+
+        this.btcTx = btcTx;
+    }
+
+    serialize(): any {
+        return this.btcTx;
+    }
+
+    getRecipient(): string {
+        return this.recipient;
+    }
+
+    abstract isRecipient(address: string): boolean;
+
+    abstract getFrontingId(): string;
+
+    getOutputWithoutFees(): bigint[] {
+        return this.rawAmounts;
+    }
+
+    getCallerFee(): bigint[] {
+        return this.rawAmounts.map(val => val * this.callerFeeRate / 100_000n);
+    }
+
+    getFrontingFee(): bigint[] {
+        return this.rawAmounts.map(val => val * this.frontingFeeRate / 100_000n);
+    }
+
+    getExecutionFee(): bigint[] {
+        return [this.rawAmounts[0] * this.executionFeeRate / 100_000n];
+    }
+
+    getTotalOutput(): bigint[] {
+        const amounts = [...this.getOutputWithoutFees()];
+        const callerFee = this.getCallerFee();
+        if(callerFee!=null) callerFee.forEach((fee, i) => {
+            if(fee==null || fee===0n) return;
+            if(amounts[i]==null) throw new Error("Caller fee token out of bounds");
+            amounts[i] += fee;
+        });
+        const frontingFee = this.getFrontingFee();
+        if(frontingFee!=null) frontingFee.forEach((fee, i) => {
+            if(fee==null || fee===0n) return;
+            if(amounts[i]==null) throw new Error("Fronting fee token out of bounds");
+            amounts[i] += fee;
+        });
+        const executionFee = this.getExecutionFee();
+        if(executionFee!=null) executionFee.forEach((fee, i) => {
+            if(fee==null || fee===0n) return;
+            if(amounts[i]==null) throw new Error("Execution fee token out of bounds");
+            amounts[i] += fee;
+        });
+        amounts.forEach((val, index) => {
+            if(val >= 2n**64n) throw new Error("Token "+index+" amount out of bounds");
+        })
+        return amounts;
+    }
+
+    getExecutionData(): ExecutionData | null {
+        if(this.executionHash==null) return null;
+        return {
+            executionHash: this.executionHash,
+            executionExpiry: this.executionExpiry
+        }
+    }
+
+    getTxId(): string {
+        return this.btcTx.txid;
+    }
+
+    getSpentVaultUtxo(): string {
+        const in0 = this.btcTx.ins[0];
+        return in0.txid+":"+in0.vout;
+    }
+
+    getCreatedVaultUtxo(): string {
+        return this.getTxId()+":0";
+    }
+
+    getNewVaultScript(): Buffer {
+        return Buffer.from(this.btcTx.outs[0].scriptPubKey.hex, "hex");
+    }
+
+    getNewVaultBtcAmount(): number {
+        return this.btcTx.outs[0].value;
+    }
+
 }

package/src/storage/IStorageManager.ts

@@ -1,17 +1,17 @@
-import {StorageObject} from "./StorageObject";
-
-export interface IStorageManager<T extends StorageObject> {
-
-    data: {
-        [key: string]: T
-    };
-
-    init(): Promise<void>;
-    saveData(hash: string, object: T): Promise<void>;
-    removeData(hash: string): Promise<void>;
-    loadData(type: new(data: any) => T): Promise<T[]>;
-
-    removeDataArr?(keys: string[]): Promise<void>;
-    saveDataArr?(values: {id: string, object: T}[]): Promise<void>;
-
+import {StorageObject} from "./StorageObject";
+
+export interface IStorageManager<T extends StorageObject> {
+
+    data: {
+        [key: string]: T
+    };
+
+    init(): Promise<void>;
+    saveData(hash: string, object: T): Promise<void>;
+    removeData(hash: string): Promise<void>;
+    loadData(type: new(data: any) => T): Promise<T[]>;
+
+    removeDataArr?(keys: string[]): Promise<void>;
+    saveDataArr?(values: {id: string, object: T}[]): Promise<void>;
+
 }

package/src/storage/StorageObject.ts

@@ -1,7 +1,7 @@
-
-
-export interface StorageObject {
-
-    serialize(): any;
-
+
+
+export interface StorageObject {
+
+    serialize(): any;
+
 }

package/src/swaps/ChainSwapType.ts

@@ -1,6 +1,6 @@
-export enum ChainSwapType {
-    HTLC = 0,
-    CHAIN = 1,
-    CHAIN_NONCED = 2,
-    CHAIN_TXID = 3
-}
+export enum ChainSwapType {
+    HTLC = 0,
+    CHAIN = 1,
+    CHAIN_NONCED = 2,
+    CHAIN_TXID = 3
+}