@atomiqlabs/base 9.1.0 → 10.0.0-dev.2

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export * from "./storage/StorageObject";
 export * from "./swaps/SwapContract";
 export * from "./swaps/SwapData";
 export * from "./swaps/ChainSwapType";
-export * from "./swaps/SwapCommitStatus";
+export * from "./swaps/SwapCommitState";
 export * from "./errors/SignatureVerificationError";
 export * from "./errors/CannotInitializeATAError";
 export * from "./errors/SwapDataVerificationError";

package/dist/index.js

@@ -32,7 +32,7 @@ __exportStar(require("./storage/StorageObject"), exports);
 __exportStar(require("./swaps/SwapContract"), exports);
 __exportStar(require("./swaps/SwapData"), exports);
 __exportStar(require("./swaps/ChainSwapType"), exports);
-__exportStar(require("./swaps/SwapCommitStatus"), exports);
+__exportStar(require("./swaps/SwapCommitState"), exports);
 __exportStar(require("./errors/SignatureVerificationError"), exports);
 __exportStar(require("./errors/CannotInitializeATAError"), exports);
 __exportStar(require("./errors/SwapDataVerificationError"), exports);

package/dist/spv_swap/SpvVaultContract.d.ts

@@ -103,6 +103,14 @@ 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 current vault data
      *
@@ -156,32 +164,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/SwapCommitState.d.ts

@@ -0,0 +1,38 @@
+export declare enum SwapCommitStateType {
+    EXPIRED = 0,
+    NOT_COMMITED = 1,
+    COMMITED = 2,
+    PAID = 3,
+    REFUNDABLE = 4
+}
+export type SwapNotCommitedState = {
+    type: SwapCommitStateType.NOT_COMMITED;
+    getRefundTxId?: () => Promise<string>;
+    getTxBlock?: () => Promise<{
+        blockHeight: number;
+        blockTime: number;
+    }>;
+};
+export type SwapExpiredState = {
+    type: SwapCommitStateType.EXPIRED;
+    getRefundTxId?: () => Promise<string>;
+    getTxBlock?: () => Promise<{
+        blockHeight: number;
+        blockTime: number;
+    }>;
+};
+export type SwapRefundableState = {
+    type: SwapCommitStateType.REFUNDABLE;
+};
+export type SwapCommitedState = {
+    type: SwapCommitStateType.COMMITED;
+};
+export type SwapPaidState = {
+    type: SwapCommitStateType.PAID;
+    getClaimTxId: () => Promise<string>;
+    getTxBlock: () => Promise<{
+        blockHeight: number;
+        blockTime: number;
+    }>;
+};
+export type SwapCommitState = SwapNotCommitedState | SwapExpiredState | SwapRefundableState | SwapCommitedState | SwapPaidState;

package/dist/swaps/SwapCommitState.js

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

package/dist/swaps/SwapContract.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
 import { SwapData } from "./SwapData";
 import { BtcStoredHeader } from "../btcrelay/types/BtcStoredHeader";
-import { SwapCommitStatus } from "./SwapCommitStatus";
 import { ChainSwapType } from "./ChainSwapType";
 import { RelaySynchronizer } from "../btcrelay/synchronizer/RelaySynchronizer";
 import { Buffer } from "buffer";
 import { AbstractSigner, TransactionConfirmationOptions } from "../chains/ChainInterface";
+import { SwapCommitState } from "./SwapCommitState";
 export type IntermediaryReputationType = {
     [key in ChainSwapType]: {
         successVolume: bigint;
@@ -50,12 +50,13 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
     /**
      * Returns the unsigned transactions required for initializing a non-payIn swap (BTC -> SC)
      *
+     * @param sender Transaction sender address, must be either offerer or claimer
      * @param swapData Swap to init
      * @param signature Signature data from the offerer
      * @param skipChecks Whether to skip verification of the signature & checking if the swap is already committed
      * @param feeRate Fee rate to use for the transaction
      */
-    txsInit(swapData: T, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<TX[]>;
+    txsInit(sender: string, swapData: T, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<TX[]>;
     /**
      * Signs & sends transactions required for claiming an HTLC swap
      *
@@ -182,12 +183,12 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
      */
     isCommited(swapData: T): Promise<boolean>;
     /**
-     * Returns the full status of the swap, expiry is handler by the isExpired function so also requires a signer
+     * Returns the full status of the swap, expiry is handled by the isExpired function so also requires a signer/sender
      *
      * @param signer
      * @param swapData
      */
-    getCommitStatus(signer: string, swapData: T): Promise<SwapCommitStatus>;
+    getCommitStatus(signer: string, swapData: T): Promise<SwapCommitState>;
     /**
      * Checks whether a given swap is refundable by us, i.e. it is already expired, we are offerer & swap is committed on-chain
      *
@@ -217,13 +218,14 @@ export interface SwapContract<T extends SwapData = SwapData, TX = any, PreFetchD
     /**
      * Checks whether a signature is a valid initialization signature for a given swap
      *
+     * @param sender Address of the sender of the transaction (must be either offerer or claimer)
      * @param swapData Swap to initialize
      * @param signature Signature data
      * @param feeRate Fee rate used for the authorization
      * @param preFetchedVerificationData Optional pre-fetched data required for signature validation
      * @returns {Buffer | null} The message being signed if valid or null if invalid signature
      */
-    isValidInitAuthorization(swapData: T, signature: SignatureData, feeRate?: string, preFetchedVerificationData?: PreFetchVerification): Promise<Buffer | null>;
+    isValidInitAuthorization(sender: string, swapData: T, signature: SignatureData, feeRate?: string, preFetchedVerificationData?: PreFetchVerification): Promise<Buffer | null>;
     /**
      * Returns the expiry timestamp (UNIX milliseconds) of the authorization
      *
@@ -306,17 +308,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
      *
@@ -336,17 +340,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/package.json

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

package/src/index.ts

@@ -16,7 +16,7 @@ export * from "./storage/StorageObject";
 export * from "./swaps/SwapContract";
 export * from "./swaps/SwapData";
 export * from "./swaps/ChainSwapType";
-export * from "./swaps/SwapCommitStatus";
+export * from "./swaps/SwapCommitState";
 
 export * from "./errors/SignatureVerificationError";
 export * from "./errors/CannotInitializeATAError"

package/src/spv_swap/SpvVaultContract.ts

@@ -127,6 +127,15 @@ 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 current vault data
      *
@@ -183,36 +192,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/SwapCommitState.ts

@@ -0,0 +1,39 @@
+export enum SwapCommitStateType {
+    EXPIRED=0,
+    NOT_COMMITED=1,
+    COMMITED=2,
+    PAID=3,
+    REFUNDABLE=4
+}
+
+export type SwapNotCommitedState = {
+    type: SwapCommitStateType.NOT_COMMITED,
+    getRefundTxId?: () => Promise<string>,
+    getTxBlock?: () => Promise<{blockHeight: number, blockTime: number}>
+};
+
+export type SwapExpiredState = {
+    type: SwapCommitStateType.EXPIRED,
+    getRefundTxId?: () => Promise<string>,
+    getTxBlock?: () => Promise<{blockHeight: number, blockTime: number}>
+};
+
+export type SwapRefundableState = {
+    type: SwapCommitStateType.REFUNDABLE
+};
+
+export type SwapCommitedState = {
+    type: SwapCommitStateType.COMMITED
+};
+
+export type SwapPaidState = {
+    type: SwapCommitStateType.PAID,
+    getClaimTxId: () => Promise<string>,
+    getTxBlock: () => Promise<{blockHeight: number, blockTime: number}>
+};
+
+export type SwapCommitState = SwapNotCommitedState |
+    SwapExpiredState |
+    SwapRefundableState |
+    SwapCommitedState |
+    SwapPaidState;

package/src/swaps/SwapContract.ts

@@ -1,10 +1,10 @@
 import {SwapData} from "./SwapData";
 import {BtcStoredHeader} from "../btcrelay/types/BtcStoredHeader";
-import {SwapCommitStatus} from "./SwapCommitStatus";
 import {ChainSwapType} from "./ChainSwapType";
 import {RelaySynchronizer} from "../btcrelay/synchronizer/RelaySynchronizer";
 import {Buffer} from "buffer";
 import {AbstractSigner, TransactionConfirmationOptions} from "../chains/ChainInterface";
+import {SwapCommitState} from "./SwapCommitState";
 
 export type IntermediaryReputationType = {
     [key in ChainSwapType]: {
@@ -64,12 +64,13 @@ export interface SwapContract<
     /**
      * Returns the unsigned transactions required for initializing a non-payIn swap (BTC -> SC)
      *
+     * @param sender Transaction sender address, must be either offerer or claimer
      * @param swapData Swap to init
      * @param signature Signature data from the offerer
      * @param skipChecks Whether to skip verification of the signature & checking if the swap is already committed
      * @param feeRate Fee rate to use for the transaction
      */
-    txsInit(swapData: T, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<TX[]>;
+    txsInit(sender: string, swapData: T, signature: SignatureData, skipChecks?: boolean, feeRate?: string): Promise<TX[]>;
 
     /**
      * Signs & sends transactions required for claiming an HTLC swap
@@ -229,12 +230,12 @@ export interface SwapContract<
     isCommited(swapData: T): Promise<boolean>;
 
     /**
-     * Returns the full status of the swap, expiry is handler by the isExpired function so also requires a signer
+     * Returns the full status of the swap, expiry is handled by the isExpired function so also requires a signer/sender
      *
      * @param signer
      * @param swapData
      */
-    getCommitStatus(signer: string, swapData: T): Promise<SwapCommitStatus>;
+    getCommitStatus(signer: string, swapData: T): Promise<SwapCommitState>;
 
     /**
      * Checks whether a given swap is refundable by us, i.e. it is already expired, we are offerer & swap is committed on-chain
@@ -269,13 +270,14 @@ export interface SwapContract<
     /**
      * Checks whether a signature is a valid initialization signature for a given swap
      *
+     * @param sender Address of the sender of the transaction (must be either offerer or claimer)
      * @param swapData Swap to initialize
      * @param signature Signature data
      * @param feeRate Fee rate used for the authorization
      * @param preFetchedVerificationData Optional pre-fetched data required for signature validation
      * @returns {Buffer | null} The message being signed if valid or null if invalid signature
      */
-    isValidInitAuthorization(swapData: T, signature: SignatureData, feeRate?: string, preFetchedVerificationData?: PreFetchVerification): Promise<Buffer | null>;
+    isValidInitAuthorization(sender: string, swapData: T, signature: SignatureData, feeRate?: string, preFetchedVerificationData?: PreFetchVerification): Promise<Buffer | null>;
 
     /**
      * Returns the expiry timestamp (UNIX milliseconds) of the authorization
@@ -382,18 +384,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
@@ -416,18 +420,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/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 = {}));

package/src/swaps/SwapCommitStatus.ts

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