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

package/dist/messaging/messages/Message.d.ts

@@ -0,0 +1,11 @@
+export declare enum MessageType {
+    SWAP_CLAIM_WITNESS = 0
+}
+export declare abstract class Message {
+    abstract type: MessageType;
+    static deserializers: {
+        [type: number]: (obj: any) => Message;
+    };
+    serialize(): any;
+    static deserialize(message: any): Message;
+}

package/dist/messaging/messages/Message.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.MessageType = void 0;
+var MessageType;
+(function (MessageType) {
+    MessageType[MessageType["SWAP_CLAIM_WITNESS"] = 0] = "SWAP_CLAIM_WITNESS";
+})(MessageType = exports.MessageType || (exports.MessageType = {}));
+class Message {
+    serialize() {
+        return {
+            type: this.type
+        };
+    }
+    static deserialize(message) {
+        const deserializer = Message.deserializers[message.type];
+        if (deserializer == null)
+            throw new Error("Unknown message type " + message.type);
+        return deserializer(message);
+    }
+}
+exports.Message = Message;
+Message.deserializers = {};

package/dist/messaging/messages/SwapClaimWitnessMessage.d.ts

@@ -0,0 +1,10 @@
+import { SwapData } from "../../swaps/SwapData";
+import { Message, MessageType } from "./Message";
+export declare class SwapClaimWitnessMessage<T extends SwapData> extends Message {
+    type: MessageType;
+    swapData: T;
+    witness: string;
+    constructor(swapData: T, witness: string);
+    serialize(): any;
+    static deserialize(obj: any): SwapClaimWitnessMessage<SwapData>;
+}

package/dist/messaging/messages/SwapClaimWitnessMessage.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapClaimWitnessMessage = void 0;
+const SwapData_1 = require("../../swaps/SwapData");
+const Message_1 = require("./Message");
+class SwapClaimWitnessMessage extends Message_1.Message {
+    constructor(swapData, witness) {
+        super();
+        this.type = Message_1.MessageType.SWAP_CLAIM_WITNESS;
+        this.swapData = swapData;
+        this.witness = witness;
+    }
+    serialize() {
+        return {
+            ...super.serialize(),
+            swapData: this.swapData.serialize(),
+            witness: this.witness
+        };
+    }
+    static deserialize(obj) {
+        if (obj == null || typeof (obj.witness) !== "string" || typeof (obj.swapData) !== "object") {
+            throw new Error("Invalid format!");
+        }
+        return new SwapClaimWitnessMessage(SwapData_1.SwapData.deserialize(obj.swapData), obj.witness);
+    }
+}
+exports.SwapClaimWitnessMessage = SwapClaimWitnessMessage;
+Message_1.Message.deserializers[Message_1.MessageType.SWAP_CLAIM_WITNESS] = SwapClaimWitnessMessage.deserialize;

package/dist/spv_swap/SpvVaultContract.d.ts

@@ -1,199 +1,258 @@
-/// <reference types="node" />
-import { AbstractSigner, TransactionConfirmationOptions } from "../chains/ChainInterface";
-import { SpvVaultData, SpvVaultTokenData } from "./SpvVaultData";
-import { SpvWithdrawalTransactionData } from "./SpvWithdrawalTransactionData";
-import { BtcStoredHeader } from "../btcrelay/types/BtcStoredHeader";
-import { RelaySynchronizer } from "../btcrelay/synchronizer/RelaySynchronizer";
-import { SpvWithdrawalState } from "./SpvWithdrawalState";
-import { Buffer } from "buffer";
-import { BtcTx } from "../btc/rpc/BitcoinRpc";
-export interface SpvVaultContract<TX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string, Data extends SpvVaultData = SpvVaultData, WithdrawalTX extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData> {
-    readonly chainId: ChainId;
-    /**
-     * Signs & sends transactions for opening a specific spv vault
-     *
-     * @param signer Signer to use for the transaction (must match owner in vault)
-     * @param vault Vault to init
-     * @param txOptions Transaction options
-     */
-    open(signer: Signer, vault: Data, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    /**
-     * Returns the unsigned transactions for opening a specific spv vault
-     *
-     * @param signer Signer to use for the transaction (must match owner in vault)
-     * @param vault Vault to init
-     * @param feeRate Fee rate to use for the transaction
-     */
-    txsOpen(signer: string, vault: Data, feeRate?: string): Promise<TX[]>;
-    /**
-     * Signs & sends transactions for depositing funds to a specific spv vault
-     *
-     * @param signer Signer to use for the transaction (can be any)
-     * @param vault Vault to deposit to
-     * @param rawAmounts Raw amounts to deposit (these are unscaled)
-     * @param txOptions Transaction options
-     */
-    deposit(signer: Signer, vault: Data, rawAmounts: bigint[], txOptions?: TransactionConfirmationOptions): Promise<string>;
-    /**
-     * Returns the unsigned transactions for depositing funds to a specific spv vault
-     *
-     * @param signer Signer to use for the transaction (can be any)
-     * @param vault Vault to deposit to
-     * @param rawAmounts Raw amounts to deposit (these are unscaled)
-     * @param feeRate Fee rate to use for the transaction
-     */
-    txsDeposit(signer: string, vault: Data, rawAmounts: bigint[], feeRate?: string): Promise<TX[]>;
-    /**
-     * Signs & sends transactions for fronting liquidity for a specific withdrawal btc transaction
-     *
-     * @param signer Signer to use for the transaction (payer of the fronted liquidity)
-     * @param vault Vault to deposit to
-     * @param realWithdrawalTx Real withdrawal transaction data
-     * @param withdrawSequence Sequence number of the withdrawal that is being fronted, this used as race condition
-     *  prevention, such that fronting will not happen if the withdrawal tx is already used in claim()
-     * @param txOptions Transaction options
-     */
-    frontLiquidity(signer: Signer, vault: Data, realWithdrawalTx: WithdrawalTX, withdrawSequence: number, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    /**
-     * Returns the unsigned transactions for fronting liquidity for a specific withdrawal btc transaction
-     *
-     * @param signer Signer to use for the transaction (payer of the fronted liquidity)
-     * @param vault Vault to deposit to
-     * @param realWithdrawalTx Real withdrawal transaction data
-     * @param withdrawSequence Sequence number of the withdrawal that is being fronted, this used as race condition
-     *  prevention, such that fronting will not happen if the withdrawal tx is already used in claim()
-     * @param feeRate Fee rate to use for the transaction
-     */
-    txsFrontLiquidity(signer: string, vault: Data, realWithdrawalTx: WithdrawalTX, withdrawSequence: number, feeRate?: string): Promise<TX[]>;
-    /**
-     * Signs & sends transactions for claiming the funds from a specific vault
-     *
-     * @param signer Signer to use for the transaction
-     * @param vault Vault to claim from
-     * @param txs
-     * @param synchronizer Optiona synchronizer to be used if BTC relay contract is not synced up to the required blockheight
-     * @param initAta Whether to initialize a token account if it doesn't exist (applies to e.g. Solana, with token specific ATAs)
-     * @param txOptions Transaction options
-     */
-    claim(signer: Signer, vault: Data, txs: {
-        tx: WithdrawalTX;
-        storedHeader?: BtcStoredHeader<any>;
-    }[], synchronizer?: RelaySynchronizer<any, TX, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
-    /**
-     * Returns the unsigned transactions for claiming the funds from a specific vault
-     *
-     * @param signer Signer to use for the transaction
-     * @param vault Vault to claim from
-     * @param txs
-     * @param synchronizer Optiona synchronizer to be used if BTC relay contract is not synced up to the required blockheight
-     * @param initAta Whether to initialize a token account if it doesn't exist (applies to e.g. Solana, with token specific ATAs)
-     * @param feeRate Fee rate to use for the transaction
-     */
-    txsClaim(signer: string, vault: Data, txs: {
-        tx: WithdrawalTX;
-        storedHeader?: BtcStoredHeader<any>;
-    }[], synchronizer?: RelaySynchronizer<any, TX, any>, initAta?: boolean, feeRate?: string): Promise<TX[]>;
-    /**
-     * Creates vault data for a new vault
-     *
-     * @param owner Vault owner
-     * @param vaultId Vault ID
-     * @param utxo Utxo on which to assign the vault initially
-     * @param confirmations Required number of bitcoin confirmations to be able to withdraw funds from the vault
-     * @param tokenData Data about the tokens in the vault
-     */
-    createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<Data>;
-    /**
-     * Returns the party which currently fronted the withdrawal transaction
-     *
-     * @param owner Owner of the vault
-     * @param vaultId Vault ID
-     * @param withdrawal Withdrawal transaction to check the fronting for
-     */
-    getFronterAddress(owner: string, vaultId: bigint, withdrawal: WithdrawalTX): Promise<string | null>;
-    /**
-     * Returns current vault data
-     *
-     * @param owner Owner of the vault
-     * @param vaultId Vault ID
-     */
-    getVaultData(owner: string, vaultId: bigint): Promise<Data>;
-    /**
-     * Returns all currently opened vaults
-     * NOTE: This will take a long time, since the implementation will have to go through all the prior events
-     */
-    getAllVaults(owner?: string): Promise<Data[]>;
-    /**
-     * Returns current state of the withdrawal as specified by the bitcoin transaction ID
-     *
-     * @param btcTxId
-     */
-    getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
-    /**
-     * Parses withdrawal data from the parsed bitcoin transaction
-     *
-     * @param btcTx
-     */
-    getWithdrawalData(btcTx: BtcTx): Promise<WithdrawalTX>;
-    /**
-     * Checks if given withdrawal tx is valid and correctly parses on-chain, throws error when there is any issue with
-     *  the validation
-     *
-     * @param tx
-     */
-    checkWithdrawalTx(tx: WithdrawalTX): Promise<void>;
-    /**
-     * Serializes the withdrawal params to the OP_RETURN data
-     *
-     * @param recipient Recipient of the withdrawn tokens
-     * @param rawAmounts Raw amount of tokens to withdraw
-     * @param executionHash Optional execution hash of the actions to execute
-     */
-    toOpReturnData(recipient: string, rawAmounts: bigint[], executionHash?: string): Buffer;
-    /**
-     * Parses withdrawal params from OP_RETURN data
-     *
-     * @param data data as specified in the OP_RETURN output of the transaction
-     */
-    fromOpReturnData(data: Buffer): {
-        recipient: string;
-        rawAmounts: bigint[];
-        executionHash: string;
-    };
-    /**
-     * Returns the fee in native token base units to claim the swap
-     *
-     * @param signer Signer claiming the swap
-     * @param vault
-     * @param withdrawalData Withdrawal to claim
-     * @param feeRate Optional fee rate (fetched on-demand if not provided)
-     */
-    getClaimFee(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
-    /**
-     * Returns raw fee (not including any refunds we might get that would make the getClaimFee negative) for claiming the swap
-     *
-     * @param signer Signer claiming the swap
-     * @param vault
-     * @param withdrawalData Withdrawal to claim
-     * @param feeRate Optional fee rate (fetched on-demand if not provided)
-     */
-    getRawClaimFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
-    /**
-     * Returns the fee in native token base units to claim the swap
-     *
-     * @param signer Signer claiming the swap
-     * @param vault
-     * @param withdrawalData Withdrawal to claim
-     * @param feeRate Optional fee rate (fetched on-demand if not provided)
-     */
-    getFrontFee(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
-    /**
-     * Returns raw fee (not including any refunds we might get that would make the getClaimFee negative) for claiming the swap
-     *
-     * @param signer Signer claiming the swap
-     * @param vault
-     * @param withdrawalData Withdrawal to claim
-     * @param feeRate Optional fee rate (fetched on-demand if not provided)
-     */
-    getRawFrontFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
-}
+/// <reference types="node" />
+import { AbstractSigner, TransactionConfirmationOptions } from "../chains/ChainInterface";
+import { SpvVaultData, SpvVaultTokenData } from "./SpvVaultData";
+import { SpvWithdrawalTransactionData } from "./SpvWithdrawalTransactionData";
+import { BtcStoredHeader } from "../btcrelay/types/BtcStoredHeader";
+import { RelaySynchronizer } from "../btcrelay/synchronizer/RelaySynchronizer";
+import { SpvWithdrawalState } from "./SpvWithdrawalState";
+import { Buffer } from "buffer";
+import { BtcTx } from "../btc/rpc/BitcoinRpc";
+export interface SpvVaultContract<TX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string, Data extends SpvVaultData = SpvVaultData, WithdrawalTX extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData> {
+    readonly chainId: ChainId;
+    /**
+     * Signs & sends transactions for opening a specific spv vault
+     *
+     * @param signer Signer to use for the transaction (must match owner in vault)
+     * @param vault Vault to init
+     * @param txOptions Transaction options
+     */
+    open(signer: Signer, vault: Data, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * Returns the unsigned transactions for opening a specific spv vault
+     *
+     * @param signer Signer to use for the transaction (must match owner in vault)
+     * @param vault Vault to init
+     * @param feeRate Fee rate to use for the transaction
+     */
+    txsOpen(signer: string, vault: Data, feeRate?: string): Promise<TX[]>;
+    /**
+     * Signs & sends transactions for depositing funds to a specific spv vault
+     *
+     * @param signer Signer to use for the transaction (can be any)
+     * @param vault Vault to deposit to
+     * @param rawAmounts Raw amounts to deposit (these are unscaled)
+     * @param txOptions Transaction options
+     */
+    deposit(signer: Signer, vault: Data, rawAmounts: bigint[], txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * Returns the unsigned transactions for depositing funds to a specific spv vault
+     *
+     * @param signer Signer to use for the transaction (can be any)
+     * @param vault Vault to deposit to
+     * @param rawAmounts Raw amounts to deposit (these are unscaled)
+     * @param feeRate Fee rate to use for the transaction
+     */
+    txsDeposit(signer: string, vault: Data, rawAmounts: bigint[], feeRate?: string): Promise<TX[]>;
+    /**
+     * Signs & sends transactions for fronting liquidity for a specific withdrawal btc transaction
+     *
+     * @param signer Signer to use for the transaction (payer of the fronted liquidity)
+     * @param vault Vault to deposit to
+     * @param realWithdrawalTx Real withdrawal transaction data
+     * @param withdrawSequence Sequence number of the withdrawal that is being fronted, this used as race condition
+     *  prevention, such that fronting will not happen if the withdrawal tx is already used in claim()
+     * @param txOptions Transaction options
+     */
+    frontLiquidity(signer: Signer, vault: Data, realWithdrawalTx: WithdrawalTX, withdrawSequence: number, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * Returns the unsigned transactions for fronting liquidity for a specific withdrawal btc transaction
+     *
+     * @param signer Signer to use for the transaction (payer of the fronted liquidity)
+     * @param vault Vault to deposit to
+     * @param realWithdrawalTx Real withdrawal transaction data
+     * @param withdrawSequence Sequence number of the withdrawal that is being fronted, this used as race condition
+     *  prevention, such that fronting will not happen if the withdrawal tx is already used in claim()
+     * @param feeRate Fee rate to use for the transaction
+     */
+    txsFrontLiquidity(signer: string, vault: Data, realWithdrawalTx: WithdrawalTX, withdrawSequence: number, feeRate?: string): Promise<TX[]>;
+    /**
+     * Signs & sends transactions for claiming the funds from a specific vault
+     *
+     * @param signer Signer to use for the transaction
+     * @param vault Vault to claim from
+     * @param txs
+     * @param synchronizer Optiona synchronizer to be used if BTC relay contract is not synced up to the required blockheight
+     * @param initAta Whether to initialize a token account if it doesn't exist (applies to e.g. Solana, with token specific ATAs)
+     * @param txOptions Transaction options
+     */
+    claim(signer: Signer, vault: Data, txs: {
+        tx: WithdrawalTX;
+        storedHeader?: BtcStoredHeader<any>;
+    }[], synchronizer?: RelaySynchronizer<any, TX, any>, initAta?: boolean, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * Returns the unsigned transactions for claiming the funds from a specific vault
+     *
+     * @param signer Signer to use for the transaction
+     * @param vault Vault to claim from
+     * @param txs
+     * @param synchronizer Optiona synchronizer to be used if BTC relay contract is not synced up to the required blockheight
+     * @param initAta Whether to initialize a token account if it doesn't exist (applies to e.g. Solana, with token specific ATAs)
+     * @param feeRate Fee rate to use for the transaction
+     */
+    txsClaim(signer: string, vault: Data, txs: {
+        tx: WithdrawalTX;
+        storedHeader?: BtcStoredHeader<any>;
+    }[], synchronizer?: RelaySynchronizer<any, TX, any>, initAta?: boolean, feeRate?: string): Promise<TX[]>;
+    /**
+     * Creates vault data for a new vault
+     *
+     * @param owner Vault owner
+     * @param vaultId Vault ID
+     * @param utxo Utxo on which to assign the vault initially
+     * @param confirmations Required number of bitcoin confirmations to be able to withdraw funds from the vault
+     * @param tokenData Data about the tokens in the vault
+     */
+    createVaultData(owner: string, vaultId: bigint, utxo: string, confirmations: number, tokenData: SpvVaultTokenData[]): Promise<Data>;
+    /**
+     * Returns the party which currently fronted the withdrawal transaction
+     *
+     * @param owner Owner of the vault
+     * @param vaultId Vault ID
+     * @param withdrawal Withdrawal transaction to check the fronting for
+     */
+    getFronterAddress(owner: string, vaultId: bigint, withdrawal: WithdrawalTX): Promise<string | null>;
+    /**
+     * Returns the parties which currently fronted the withdrawal transactions
+     *
+     * @param withdrawals withdrawals to query
+     */
+    getFronterAddresses(withdrawals: {
+        owner: string;
+        vaultId: bigint;
+        withdrawal: WithdrawalTX;
+    }[]): Promise<{
+        [btcTxId: string]: string | null;
+    }>;
+    /**
+     * Returns current vault data
+     *
+     * @param owner Owner of the vault
+     * @param vaultId Vault ID
+     */
+    getVaultData(owner: string, vaultId: bigint): Promise<Data>;
+    /**
+     * Returns current vault data for multiple vaults
+     *
+     * @param vaults Vault data to query
+     */
+    getMultipleVaultData(vaults: {
+        owner: string;
+        vaultId: bigint;
+    }[]): Promise<{
+        [owner: string]: {
+            [vaultId: string]: Data;
+        };
+    }>;
+    /**
+     * Returns the latest utxo of a vault (or null if vault closed or not found)
+     *
+     * @param owner Owner of the vault
+     * @param vaultId Vault ID
+     */
+    getVaultLatestUtxo(owner: string, vaultId: bigint): Promise<string | null>;
+    /**
+     * Returns the latest utxos of for multiple vaults (or null if vault closed or not found)
+     *
+     * @param vaults Vault data to query
+     */
+    getVaultLatestUtxos(vaults: {
+        owner: string;
+        vaultId: bigint;
+    }[]): Promise<{
+        [owner: string]: {
+            [vaultId: string]: string | null;
+        };
+    }>;
+    /**
+     * Returns all currently opened vaults
+     * NOTE: This will take a long time, since the implementation will have to go through all the prior events
+     */
+    getAllVaults(owner?: string): Promise<Data[]>;
+    /**
+     * Returns current state of the withdrawal, optionally
+     *  only check withdrawals from the provided block height
+     *
+     * @param withdrawalTx
+     * @param scStartBlockheight
+     */
+    getWithdrawalState(withdrawalTx: WithdrawalTX, scStartBlockheight?: number): Promise<SpvWithdrawalState>;
+    /**
+     * Returns current state of the withdrawals, optionally
+     *  only check withdrawals from the provided block height
+     *
+     * @param withdrawalTxs Object with the withdrawal tx to check + an optional start blockheight
+     */
+    getWithdrawalStates(withdrawalTxs: {
+        withdrawal: WithdrawalTX;
+        scStartBlockheight?: number;
+    }[]): Promise<{
+        [btcTxId: string]: SpvWithdrawalState;
+    }>;
+    /**
+     * Parses withdrawal data from the parsed bitcoin transaction
+     *
+     * @param btcTx
+     */
+    getWithdrawalData(btcTx: BtcTx): Promise<WithdrawalTX>;
+    /**
+     * Checks if given withdrawal tx is valid and correctly parses on-chain, throws error when there is any issue with
+     *  the validation
+     *
+     * @param tx
+     */
+    checkWithdrawalTx(tx: WithdrawalTX): Promise<void>;
+    /**
+     * Serializes the withdrawal params to the OP_RETURN data
+     *
+     * @param recipient Recipient of the withdrawn tokens
+     * @param rawAmounts Raw amount of tokens to withdraw
+     * @param executionHash Optional execution hash of the actions to execute
+     */
+    toOpReturnData(recipient: string, rawAmounts: bigint[], executionHash?: string): Buffer;
+    /**
+     * Parses withdrawal params from OP_RETURN data
+     *
+     * @param data data as specified in the OP_RETURN output of the transaction
+     */
+    fromOpReturnData(data: Buffer): {
+        recipient: string;
+        rawAmounts: bigint[];
+        executionHash: string;
+    };
+    /**
+     * Returns the fee in native token base units to claim the swap
+     *
+     * @param signer Signer claiming the swap
+     * @param vault
+     * @param withdrawalData Withdrawal to claim
+     * @param feeRate Optional fee rate (fetched on-demand if not provided)
+     */
+    getClaimFee(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    /**
+     * Returns raw fee (not including any refunds we might get that would make the getClaimFee negative) for claiming the swap
+     *
+     * @param signer Signer claiming the swap
+     * @param vault
+     * @param withdrawalData Withdrawal to claim
+     * @param feeRate Optional fee rate (fetched on-demand if not provided)
+     */
+    getRawClaimFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    /**
+     * Returns the fee in native token base units to claim the swap
+     *
+     * @param signer Signer claiming the swap
+     * @param vault
+     * @param withdrawalData Withdrawal to claim
+     * @param feeRate Optional fee rate (fetched on-demand if not provided)
+     */
+    getFrontFee(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    /**
+     * Returns raw fee (not including any refunds we might get that would make the getClaimFee negative) for claiming the swap
+     *
+     * @param signer Signer claiming the swap
+     * @param vault
+     * @param withdrawalData Withdrawal to claim
+     * @param feeRate Optional fee rate (fetched on-demand if not provided)
+     */
+    getRawFrontFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+}

package/dist/spv_swap/SpvVaultContract.js

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

package/dist/spv_swap/SpvVaultData.d.ts

@@ -1,35 +1,35 @@
-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 declare 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;
-    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[];
-    };
-}
+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 declare 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;
+    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[];
+    };
+}