@atomiqlabs/base 11.0.0 → 12.0.0

package/dist/chains/ChainInterface.d.ts

@@ -4,9 +4,13 @@ export type TransactionConfirmationOptions = {
     feeRate?: string;
 };
 export type AbstractSigner = {
+    type: "AtomiqAbstractSigner";
     getAddress: () => string;
+    init?: () => Promise<void>;
+    stop?: () => Promise<void>;
 };
-export interface ChainInterface<TX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string> {
+export declare function isAbstractSigner(val: any): val is AbstractSigner;
+export interface ChainInterface<TX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string, NativeSigner = any> {
     readonly chainId: ChainId;
     /**
      * Returns the token balance of a specific address
@@ -23,8 +27,15 @@ export interface ChainInterface<TX = any, Signer extends AbstractSigner = Abstra
      * Checks if a given string is a valid wallet address
      *
      * @param address
+     * @param lenient Whether a lenient parsing should be used (i.e. don't strictly enforce the Starknet address lengths)
      */
-    isValidAddress(address: string): boolean;
+    isValidAddress(address: string, lenient?: boolean): boolean;
+    /**
+     * Normalizes a given address i.e. pads it to the specific size
+     *
+     * @param address
+     */
+    normalizeAddress(address: string): string;
     /**
      * Checks if a given string is a valid token identifier
      *
@@ -75,6 +86,14 @@ export interface ChainInterface<TX = any, Signer extends AbstractSigner = Abstra
      * @param txId Transaction ID
      */
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    /**
+     * Returns the latest known finalized block data (this is a block with 100% certainty of not getting re-org, i.e.
+     *  a block already committed on L1)
+     */
+    getFinalizedBlock(): Promise<{
+        height: number;
+        blockHash: string;
+    }>;
     /**
      * Signs, sends a batch of transaction and optionally waits for their confirmation
      *
@@ -107,4 +126,8 @@ export interface ChainInterface<TX = any, Signer extends AbstractSigner = Abstra
      * Returns randomly generated signer
      */
     randomSigner(): Signer;
+    /**
+     * Wraps a native chain signer object to an atomiq-understandable AbstractSigner
+     */
+    wrapSigner(signer: NativeSigner): Promise<Signer>;
 }

package/dist/chains/ChainInterface.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbstractSigner = void 0;
+function isAbstractSigner(val) {
+    return typeof (val) === "object" && val.type === "AtomiqAbstractSigner" && typeof (val.getAddress) === "function";
+}
+exports.isAbstractSigner = isAbstractSigner;

package/dist/chains/ChainType.d.ts

@@ -6,7 +6,7 @@ import { AbstractSigner, ChainInterface } from "./ChainInterface";
 import { SpvVaultData } from "../spv_swap/SpvVaultData";
 import { SpvVaultContract } from "../spv_swap/SpvVaultContract";
 import { SpvWithdrawalTransactionData } from "../spv_swap/SpvWithdrawalTransactionData";
-export type ChainType<ChainId extends string = string, PreFetchData = any, PreFetchVerification = any, TXType = any, Signer extends AbstractSigner = AbstractSigner, T extends SwapData = SwapData, C extends SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId> = SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId>, I extends ChainInterface<TXType, Signer, ChainId> = ChainInterface<TXType, Signer, ChainId>, E extends ChainEvents<T> = ChainEvents<T>, B extends BtcRelay<any, TXType, any, Signer> = BtcRelay<any, TXType, any, Signer>, SpvData extends SpvVaultData = SpvVaultData, SpvWithdrawalData extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData, SpvContract extends SpvVaultContract<TXType, Signer, ChainId, SpvData, SpvWithdrawalData> = SpvVaultContract<TXType, Signer, ChainId, SpvData, SpvWithdrawalData>> = {
+export type ChainType<ChainId extends string = string, PreFetchData = any, PreFetchVerification = any, TXType = any, Signer extends AbstractSigner = AbstractSigner, NativeSigner = any, T extends SwapData = SwapData, C extends SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId> = SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId>, I extends ChainInterface<TXType, Signer, ChainId, NativeSigner> = ChainInterface<TXType, Signer, ChainId, NativeSigner>, E extends ChainEvents<T> = ChainEvents<T>, B extends BtcRelay<any, TXType, any, Signer> = BtcRelay<any, TXType, any, Signer>, SpvData extends SpvVaultData = SpvVaultData, SpvWithdrawalData extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData, SpvContract extends SpvVaultContract<TXType, Signer, ChainId, SpvData, SpvWithdrawalData> = SpvVaultContract<TXType, Signer, ChainId, SpvData, SpvWithdrawalData>> = {
     ChainId: ChainId;
     PreFetchData: PreFetchData;
     PreFetchVerification: PreFetchVerification;
@@ -20,4 +20,5 @@ export type ChainType<ChainId extends string = string, PreFetchData = any, PreFe
     SpvVaultData: SpvData;
     SpvVaultContract: SpvContract;
     SpvVaultWithdrawalData: SpvWithdrawalData;
+    NativeSigner: NativeSigner;
 };

package/dist/errors/TransactionRevertedError.d.ts

@@ -0,0 +1,3 @@
+export declare class TransactionRevertedError extends Error {
+    constructor(msg: string);
+}

package/dist/errors/TransactionRevertedError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionRevertedError = void 0;
+class TransactionRevertedError extends Error {
+    constructor(msg) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, TransactionRevertedError.prototype);
+    }
+}
+exports.TransactionRevertedError = TransactionRevertedError;

package/dist/index.d.ts

@@ -20,6 +20,7 @@ export * from "./swaps/SwapCommitState";
 export * from "./errors/SignatureVerificationError";
 export * from "./errors/CannotInitializeATAError";
 export * from "./errors/SwapDataVerificationError";
+export * from "./errors/TransactionRevertedError";
 export * from "./chains/ChainType";
 export * from "./chains/ChainData";
 export * from "./utils/BigIntBufferUtils";
@@ -36,3 +37,6 @@ export * from "./events/types/spv_vault/SpvVaultClaimEvent";
 export * from "./events/types/spv_vault/SpvVaultDepositEvent";
 export * from "./events/types/spv_vault/SpvVaultOpenEvent";
 export * from "./events/types/spv_vault/SpvVaultFrontEvent";
+export * from "./messaging/Messenger";
+export * from "./messaging/messages/Message";
+export * from "./messaging/messages/SwapClaimWitnessMessage";

package/dist/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./swaps/SwapCommitState"), exports);
 __exportStar(require("./errors/SignatureVerificationError"), exports);
 __exportStar(require("./errors/CannotInitializeATAError"), exports);
 __exportStar(require("./errors/SwapDataVerificationError"), exports);
+__exportStar(require("./errors/TransactionRevertedError"), exports);
 __exportStar(require("./chains/ChainType"), exports);
 __exportStar(require("./chains/ChainData"), exports);
 __exportStar(require("./utils/BigIntBufferUtils"), exports);
@@ -52,3 +53,6 @@ __exportStar(require("./events/types/spv_vault/SpvVaultClaimEvent"), exports);
 __exportStar(require("./events/types/spv_vault/SpvVaultDepositEvent"), exports);
 __exportStar(require("./events/types/spv_vault/SpvVaultOpenEvent"), exports);
 __exportStar(require("./events/types/spv_vault/SpvVaultFrontEvent"), exports);
+__exportStar(require("./messaging/Messenger"), exports);
+__exportStar(require("./messaging/messages/Message"), exports);
+__exportStar(require("./messaging/messages/SwapClaimWitnessMessage"), exports);

package/dist/messaging/Messenger.d.ts

@@ -0,0 +1,8 @@
+import { Message } from "./messages/Message";
+export interface Messenger {
+    init(): Promise<void>;
+    broadcast(msg: Message): Promise<void>;
+    subscribe(callback: (msg: Message) => void): Promise<void>;
+    unsubscribe(callback: (msg: Message) => void): Promise<boolean>;
+    stop(): Promise<void>;
+}

package/dist/messaging/Messenger.js

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

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

@@ -103,6 +103,26 @@ export interface SpvVaultContract<TX = any, Signer extends AbstractSigner = Abst
      * @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
      *
@@ -110,17 +130,64 @@ export interface SpvVaultContract<TX = any, Signer extends AbstractSigner = Abst
      * @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 as specified by the bitcoin transaction ID
+     * 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 btcTxId
+     * @param withdrawalTxs Object with the withdrawal tx to check + an optional start blockheight
      */
-    getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
+    getWithdrawalStates(withdrawalTxs: {
+        withdrawal: WithdrawalTX;
+        scStartBlockheight?: number;
+    }[]): Promise<{
+        [btcTxId: string]: SpvWithdrawalState;
+    }>;
     /**
      * Parses withdrawal data from the parsed bitcoin transaction
      *
@@ -156,32 +223,36 @@ export interface SpvVaultContract<TX = any, Signer extends AbstractSigner = Abst
      * 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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    getRawFrontFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
 }

package/dist/spv_swap/SpvWithdrawalTransactionData.d.ts

@@ -28,6 +28,7 @@ export declare abstract class SpvWithdrawalTransactionData implements StorageObj
     serialize(): any;
     getRecipient(): string;
     abstract isRecipient(address: string): boolean;
+    abstract getFrontingId(): string;
     getOutputWithoutFees(): bigint[];
     getCallerFee(): bigint[];
     getFrontingFee(): bigint[];

package/dist/swaps/SwapContract.d.ts

@@ -33,6 +33,7 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
     readonly claimWithSecretTimeout: number;
     readonly claimWithTxDataTimeout: number;
     readonly refundTimeout: number;
+    readonly supportsInitWithoutClaimer?: boolean;
     /**
      * Initializes the swap contract
      */
@@ -189,6 +190,17 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
      * @param swapData
      */
     getCommitStatus(signer: string, swapData: T): Promise<SwapCommitState>;
+    /**
+     * Returns the full status of the passed swaps, expiry is handled by the isExpired function so also requires a signer/sender
+     *
+     * @param request
+     */
+    getCommitStatuses(request: {
+        signer: string;
+        swapData: T;
+    }[]): Promise<{
+        [escrowHash: string]: SwapCommitState;
+    }>;
     /**
      * Checks whether a given swap is refundable by us, i.e. it is already expired, we are offerer & swap is committed on-chain
      *
@@ -308,17 +320,19 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
     /**
      * Returns the fee in native token base units to commit (initiate) the swap
      *
+     * @param signer
      * @param swapData Swap to initiate
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getCommitFee(swapData: T, feeRate?: string): Promise<bigint>;
+    getCommitFee(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
     /**
      * Returns raw fee (not including any account deposits we might need) for initiating the swap
      *
+     * @param signer
      * @param swapData Swap to initiate
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRawCommitFee?(swapData: T, feeRate?: string): Promise<bigint>;
+    getRawCommitFee?(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
     /**
      * Returns the fee in native token base units to claim the swap
      *
@@ -338,17 +352,19 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
     /**
      * Returns the fee in native token base units to refund the swap
      *
+     * @param signer
      * @param swapData Swap to refund
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRefundFee(swapData: T, feeRate?: string): Promise<bigint>;
+    getRefundFee(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
     /**
      * Returns raw fee (not including any refunds we might get that would make the getRefundFee negative) for claiming the swap
      *
+     * @param signer
      * @param swapData Swap to claim
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRawRefundFee?(swapData: T, feeRate?: string): Promise<bigint>;
+    getRawRefundFee?(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
     /**
      * Returns the fee rate for committing (initializing) a payIn swap
      *

package/dist/swaps/SwapData.d.ts

@@ -33,4 +33,5 @@ export declare abstract class SwapData implements StorageObject {
     abstract getDepositToken(): string;
     abstract isDepositToken(token: string): boolean;
     abstract equals(other: SwapData): boolean;
+    hasSuccessAction(): boolean;
 }

package/dist/swaps/SwapData.js

@@ -9,6 +9,9 @@ class SwapData {
         }
         throw new Error(`No deserializer found for swap data type: ${data.type}`);
     }
+    hasSuccessAction() {
+        return false;
+    }
 }
 exports.SwapData = SwapData;
 SwapData.deserializers = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/base",
-  "version": "11.0.0",
+  "version": "12.0.0",
   "description": "Base classes and interfaces for atomiq protocol",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/chains/ChainInterface.ts

@@ -5,13 +5,21 @@ export type TransactionConfirmationOptions = {
 };
 
 export type AbstractSigner = {
-    getAddress: () => string
+    type: "AtomiqAbstractSigner",
+    getAddress: () => string,
+    init?: () => Promise<void>,
+    stop?: () => Promise<void>
 };
 
+export function isAbstractSigner(val: any): val is AbstractSigner {
+    return typeof(val)==="object" && val.type==="AtomiqAbstractSigner" && typeof(val.getAddress)==="function";
+}
+
 export interface ChainInterface<
     TX = any,
     Signer extends AbstractSigner = AbstractSigner,
-    ChainId extends string = string
+    ChainId extends string = string,
+    NativeSigner = any
 > {
 
     readonly chainId: ChainId;
@@ -33,8 +41,16 @@ export interface ChainInterface<
      * Checks if a given string is a valid wallet address
      *
      * @param address
+     * @param lenient Whether a lenient parsing should be used (i.e. don't strictly enforce the Starknet address lengths)
+     */
+    isValidAddress(address: string, lenient?: boolean): boolean;
+
+    /**
+     * Normalizes a given address i.e. pads it to the specific size
+     *
+     * @param address
      */
-    isValidAddress(address: string): boolean;
+    normalizeAddress(address: string): string;
 
     /**
      * Checks if a given string is a valid token identifier
@@ -93,6 +109,12 @@ export interface ChainInterface<
      */
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
 
+    /**
+     * Returns the latest known finalized block data (this is a block with 100% certainty of not getting re-org, i.e.
+     *  a block already committed on L1)
+     */
+    getFinalizedBlock(): Promise<{height: number, blockHash: string}>;
+
     /**
      * Signs, sends a batch of transaction and optionally waits for their confirmation
      *
@@ -130,4 +152,9 @@ export interface ChainInterface<
      */
     randomSigner(): Signer;
 
+    /**
+     * Wraps a native chain signer object to an atomiq-understandable AbstractSigner
+     */
+    wrapSigner(signer: NativeSigner): Promise<Signer>;
+
 }

package/src/chains/ChainType.ts

@@ -13,9 +13,10 @@ export type ChainType<
     PreFetchVerification = any,
     TXType = any,
     Signer extends AbstractSigner = AbstractSigner,
+    NativeSigner = any,
     T extends SwapData = SwapData,
     C extends SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId> = SwapContract<T, TXType, PreFetchData, PreFetchVerification, Signer, ChainId>,
-    I extends ChainInterface<TXType, Signer, ChainId> = ChainInterface<TXType, Signer, ChainId>,
+    I extends ChainInterface<TXType, Signer, ChainId, NativeSigner> = ChainInterface<TXType, Signer, ChainId, NativeSigner>,
     E extends ChainEvents<T> = ChainEvents<T>,
     B extends BtcRelay<any, TXType, any, Signer> = BtcRelay<any, TXType, any, Signer>,
     SpvData extends SpvVaultData = SpvVaultData,
@@ -34,5 +35,6 @@ export type ChainType<
     BtcRelay: B,
     SpvVaultData: SpvData,
     SpvVaultContract: SpvContract,
-    SpvVaultWithdrawalData: SpvWithdrawalData
+    SpvVaultWithdrawalData: SpvWithdrawalData,
+    NativeSigner: NativeSigner
 }

package/src/errors/TransactionRevertedError.ts

@@ -0,0 +1,11 @@
+
+export class TransactionRevertedError extends Error {
+
+    constructor(msg: string) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, TransactionRevertedError.prototype);
+    }
+
+}
+

package/src/index.ts

@@ -21,6 +21,7 @@ export * from "./swaps/SwapCommitState";
 export * from "./errors/SignatureVerificationError";
 export * from "./errors/CannotInitializeATAError"
 export * from "./errors/SwapDataVerificationError";
+export * from "./errors/TransactionRevertedError";
 
 export * from "./chains/ChainType";
 export * from "./chains/ChainData";
@@ -44,3 +45,7 @@ export * from "./events/types/spv_vault/SpvVaultClaimEvent";
 export * from "./events/types/spv_vault/SpvVaultDepositEvent";
 export * from "./events/types/spv_vault/SpvVaultOpenEvent";
 export * from "./events/types/spv_vault/SpvVaultFrontEvent";
+
+export * from "./messaging/Messenger";
+export * from "./messaging/messages/Message";
+export * from "./messaging/messages/SwapClaimWitnessMessage";

package/src/messaging/Messenger.ts

@@ -0,0 +1,11 @@
+import {Message} from "./messages/Message";
+
+export interface Messenger {
+
+    init(): Promise<void>;
+    broadcast(msg: Message): Promise<void>;
+    subscribe(callback: (msg: Message) => void): Promise<void>;
+    unsubscribe(callback: (msg: Message) => void): Promise<boolean>;
+    stop(): Promise<void>;
+
+}

package/src/messaging/messages/Message.ts

@@ -0,0 +1,25 @@
+
+export enum MessageType {
+    SWAP_CLAIM_WITNESS = 0,
+
+}
+
+export abstract class Message {
+
+    abstract type: MessageType;
+
+    static deserializers: {[type: number]: (obj: any) => Message} = {};
+
+    serialize(): any {
+        return {
+            type: this.type
+        }
+    }
+
+    static deserialize(message: any): Message {
+        const deserializer = Message.deserializers[message.type];
+        if(deserializer==null) throw new Error("Unknown message type " + message.type);
+        return deserializer(message);
+    }
+
+}

package/src/messaging/messages/SwapClaimWitnessMessage.ts

@@ -0,0 +1,34 @@
+import {SwapData} from "../../swaps/SwapData";
+import {Message, MessageType} from "./Message";
+
+
+export class SwapClaimWitnessMessage<T extends SwapData> extends Message {
+
+    type = MessageType.SWAP_CLAIM_WITNESS;
+    swapData: T;
+    witness: string;
+
+    constructor(swapData: T, witness: string) {
+        super();
+        this.swapData = swapData;
+        this.witness = witness;
+    }
+
+    serialize() {
+        return {
+            ...super.serialize(),
+            swapData: this.swapData.serialize(),
+            witness: this.witness
+        }
+    }
+
+    static deserialize(obj: any) {
+        if(obj==null || typeof(obj.witness)!=="string" || typeof(obj.swapData)!=="object") {
+            throw new Error("Invalid format!");
+        }
+        return new SwapClaimWitnessMessage(SwapData.deserialize(obj.swapData), obj.witness);
+    }
+
+}
+
+Message.deserializers[MessageType.SWAP_CLAIM_WITNESS] = SwapClaimWitnessMessage.deserialize;

package/src/spv_swap/SpvVaultContract.ts

@@ -127,6 +127,22 @@ export interface SpvVaultContract<
      */
     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
      *
@@ -135,6 +151,28 @@ export interface SpvVaultContract<
      */
     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
@@ -142,11 +180,21 @@ export interface SpvVaultContract<
     getAllVaults(owner?: string): Promise<Data[]>;
 
     /**
-     * Returns current state of the withdrawal as specified by the bitcoin transaction ID
+     * 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 btcTxId
+     * @param withdrawalTxs Object with the withdrawal tx to check + an optional start blockheight
      */
-    getWithdrawalState(btcTxId: string): Promise<SpvWithdrawalState>;
+    getWithdrawalStates(withdrawalTxs: {withdrawal: WithdrawalTX, scStartBlockheight?: number}[]): Promise<{[btcTxId: string]: SpvWithdrawalState}>;
 
     /**
      * Parses withdrawal data from the parsed bitcoin transaction
@@ -183,36 +231,40 @@ export interface SpvVaultContract<
      * 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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    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, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
+    getRawFrontFee?(signer: string, vault: Data, withdrawalData: WithdrawalTX, feeRate?: string): Promise<bigint>;
 
 }

package/src/spv_swap/SpvWithdrawalTransactionData.ts

@@ -94,6 +94,8 @@ export abstract class SpvWithdrawalTransactionData implements StorageObject {
 
     abstract isRecipient(address: string): boolean;
 
+    abstract getFrontingId(): string;
+
     getOutputWithoutFees(): bigint[] {
         return this.rawAmounts;
     }

package/src/swaps/SwapContract.ts

@@ -44,6 +44,7 @@ export interface SwapContract<
     readonly claimWithSecretTimeout: number;
     readonly claimWithTxDataTimeout: number;
     readonly refundTimeout: number;
+    readonly supportsInitWithoutClaimer?: boolean;
 
     /**
      * Initializes the swap contract
@@ -237,6 +238,13 @@ export interface SwapContract<
      */
     getCommitStatus(signer: string, swapData: T): Promise<SwapCommitState>;
 
+    /**
+     * Returns the full status of the passed swaps, expiry is handled by the isExpired function so also requires a signer/sender
+     *
+     * @param request
+     */
+    getCommitStatuses(request: {signer: string, swapData: T}[]): Promise<{[escrowHash: string]: SwapCommitState}>;
+
     /**
      * Checks whether a given swap is refundable by us, i.e. it is already expired, we are offerer & swap is committed on-chain
      *
@@ -384,18 +392,20 @@ export interface SwapContract<
     /**
      * Returns the fee in native token base units to commit (initiate) the swap
      *
+     * @param signer
      * @param swapData Swap to initiate
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getCommitFee(swapData: T, feeRate?: string): Promise<bigint>;
+    getCommitFee(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
 
     /**
      * Returns raw fee (not including any account deposits we might need) for initiating the swap
      *
+     * @param signer
      * @param swapData Swap to initiate
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRawCommitFee?(swapData: T, feeRate?: string): Promise<bigint>;
+    getRawCommitFee?(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
 
     /**
      * Returns the fee in native token base units to claim the swap
@@ -418,18 +428,20 @@ export interface SwapContract<
     /**
      * Returns the fee in native token base units to refund the swap
      *
+     * @param signer
      * @param swapData Swap to refund
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRefundFee(swapData: T, feeRate?: string): Promise<bigint>;
+    getRefundFee(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
 
     /**
      * Returns raw fee (not including any refunds we might get that would make the getRefundFee negative) for claiming the swap
      *
+     * @param signer
      * @param swapData Swap to claim
      * @param feeRate Optional fee rate (fetched on-demand if not provided)
      */
-    getRawRefundFee?(swapData: T, feeRate?: string): Promise<bigint>;
+    getRawRefundFee?(signer: string, swapData: T, feeRate?: string): Promise<bigint>;
 
     /**
      * Returns the fee rate for committing (initializing) a payIn swap

package/src/swaps/SwapData.ts

@@ -61,5 +61,9 @@ export abstract class SwapData implements StorageObject {
 
     abstract equals(other: SwapData): boolean;
 
+    hasSuccessAction(): boolean {
+        return false;
+    }
+
 }
 

package/dist/swaps/SwapCommitStatus.d.ts

@@ -1,7 +0,0 @@
-export declare enum SwapCommitStatus {
-    EXPIRED = 0,
-    NOT_COMMITED = 1,
-    COMMITED = 2,
-    PAID = 3,
-    REFUNDABLE = 4
-}

package/dist/swaps/SwapCommitStatus.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapCommitStatus = void 0;
-var SwapCommitStatus;
-(function (SwapCommitStatus) {
-    SwapCommitStatus[SwapCommitStatus["EXPIRED"] = 0] = "EXPIRED";
-    SwapCommitStatus[SwapCommitStatus["NOT_COMMITED"] = 1] = "NOT_COMMITED";
-    SwapCommitStatus[SwapCommitStatus["COMMITED"] = 2] = "COMMITED";
-    SwapCommitStatus[SwapCommitStatus["PAID"] = 3] = "PAID";
-    SwapCommitStatus[SwapCommitStatus["REFUNDABLE"] = 4] = "REFUNDABLE";
-})(SwapCommitStatus = exports.SwapCommitStatus || (exports.SwapCommitStatus = {}));