@atomiqlabs/base 12.0.4 → 13.0.4

package/dist/chains/ChainData.d.ts

@@ -3,6 +3,11 @@ import { BitcoinRpc } from "../btc/rpc/BitcoinRpc";
 import { BitcoinNetwork } from "../btc/BitcoinNetwork";
 import { IStorageManager } from "../storage/IStorageManager";
 import { StorageObject } from "../storage/StorageObject";
+/**
+ * A type defining tokens available on the selected chain, indexed by ticker
+ *
+ * @category Tokens
+ */
 export type BaseTokenType<T extends string = string> = {
     [ticker in T]: {
         address: string;
@@ -10,6 +15,11 @@ export type BaseTokenType<T extends string = string> = {
         displayDecimals?: number;
     };
 };
+/**
+ * A comprehensive chain data type for a specific chain
+ *
+ * @category Chains
+ */
 export type ChainData<T extends ChainType> = {
     chainId: ChainType["ChainId"];
     chainInterface: T["ChainInterface"];
@@ -21,11 +31,41 @@ export type ChainData<T extends ChainType> = {
     spvVaultDataConstructor: new (data: any) => T["SpvVaultData"];
     spvVaultWithdrawalDataConstructor: new (data: any) => T["SpvVaultWithdrawalData"];
 };
+/**
+ * An initializer function that returns populated {@link ChainData} for a given chain based on the passed
+ *  arguments
+ *
+ * @category Chains
+ */
 export type ChainInitializerFn<O, C extends ChainType> = (options: O, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork, storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>) => ChainData<C>;
+/**
+ * Chain definition containing
+ *
+ * @category Chains
+ */
 export type ChainInitializer<O, C extends ChainType, T extends BaseTokenType> = {
+    /**
+     * Chain identifier string
+     */
     chainId: C["ChainId"];
-    chainType: C;
+    /**
+     * Initializer function returning the {@link ChainData}
+     */
     initializer: ChainInitializerFn<O, C>;
+    /**
+     * Available tokens on the chain
+     */
     tokens: T;
+    /**
+     * Chain type
+     *
+     * NOTE: This is just a type reference, should not be used as value
+     */
+    chainType: C;
+    /**
+     * The type of the options to be passed to the initializer function
+     *
+     * NOTE: This is just a type reference, should not be used as value
+     */
     options: O;
 };

package/dist/chains/ChainInterface.d.ts

@@ -1,16 +1,36 @@
+/**
+ * @category Chain
+ */
 export type TransactionConfirmationOptions = {
     waitForConfirmation?: boolean;
     abortSignal?: AbortSignal;
     feeRate?: string;
 };
+/**
+ * Defines of a signer, contains an address getter and optionally init() & stop() functions
+ *  to initiate internal processes inside the signer (if required and exposed)
+ *
+ * @category Signer
+ */
 export type AbstractSigner = {
     type: "AtomiqAbstractSigner";
     getAddress: () => string;
     init?: () => Promise<void>;
     stop?: () => Promise<void>;
 };
+/**
+ * Type guard for the {@link AbstractSigner} type
+ *
+ * @param val
+ */
 export declare function isAbstractSigner(val: any): val is AbstractSigner;
-export interface ChainInterface<TX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string, NativeSigner = any> {
+/**
+ * An interface representing a smart chain, allowing basic operations on the chain and reading chain data
+ */
+export interface ChainInterface<TX = any, SignedTX = any, Signer extends AbstractSigner = AbstractSigner, ChainId extends string = string, NativeSigner = any> {
+    /**
+     * Chain identifier string
+     */
     readonly chainId: ChainId;
     /**
      * Returns the token balance of a specific address
@@ -74,6 +94,18 @@ export interface ChainInterface<TX = any, Signer extends AbstractSigner = Abstra
      * @param txData Serialized transaction data string
      */
     deserializeTx(txData: string): Promise<TX>;
+    /**
+     * Serializes a given transaction to a string
+     *
+     * @param signedTX Transaction to serialize
+     */
+    serializeSignedTx(signedTX: SignedTX): Promise<string>;
+    /**
+     * Deserializes a transaction from string
+     *
+     * @param txData Serialized transaction data string
+     */
+    deserializeSignedTx(txData: string): Promise<SignedTX>;
     /**
      * Returns the status of the given serialized transaction
      *
@@ -106,6 +138,17 @@ export interface ChainInterface<TX = any, Signer extends AbstractSigner = Abstra
      * @param onBeforePublish Callback called before a tx is broadcast
      */
     sendAndConfirm(signer: Signer, txs: TX[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * Sends already signed transactions and optionally waits for their confirmation
+     *
+     * @param signedTxs Signed transactions to be sent
+     * @param waitForConfirmation Whether to wait for transaction confirmation (if parallel is not specified,
+     *  every transaction's confirmation except the last one is awaited)
+     * @param abortSignal Abort signal
+     * @param parallel Whether to send all transactions in parallel or one by one (always waiting for the previous TX to confirm)
+     * @param onBeforePublish Callback called before a tx is broadcast
+     */
+    sendSignedAndConfirm(signedTxs: SignedTX[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
     /**
      * Callback called when transaction is being replaced (used for EVM, when fee is bumped on an unconfirmed tx)
      *

package/dist/chains/ChainInterface.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAbstractSigner = void 0;
+/**
+ * Type guard for the {@link AbstractSigner} type
+ *
+ * @param val
+ */
 function isAbstractSigner(val) {
     return typeof (val) === "object" && val.type === "AtomiqAbstractSigner" && typeof (val.getAddress) === "function";
 }

package/dist/chains/ChainType.d.ts

@@ -6,11 +6,17 @@ 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, 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>> = {
+/**
+ * A comprehensive unified type struct for a given chain, contains all the type definitions of a given chain
+ *
+ * @category Chains
+ */
+export type ChainType<ChainId extends string = string, PreFetchData = any, PreFetchVerification = any, TXType = any, SignedTXType = 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, SignedTXType, Signer, ChainId, NativeSigner> = ChainInterface<TXType, SignedTXType, Signer, ChainId, NativeSigner>, E extends ChainEvents<T> = ChainEvents<T>, B extends BtcRelay<any, TXType, any, Signer> = BtcRelay<any, TXType, any, Signer>, SpvWithdrawalData extends SpvWithdrawalTransactionData = SpvWithdrawalTransactionData, SpvData extends SpvVaultData<SpvWithdrawalData> = SpvVaultData<SpvWithdrawalData>, SpvContract extends SpvVaultContract<TXType, Signer, ChainId, SpvWithdrawalData, SpvData> = SpvVaultContract<TXType, Signer, ChainId, SpvWithdrawalData, SpvData>> = {
     ChainId: ChainId;
     PreFetchData: PreFetchData;
     PreFetchVerification: PreFetchVerification;
     TX: TXType;
+    SignedTXType: SignedTXType;
     Signer: Signer;
     ChainInterface: I;
     Data: T;

package/dist/errors/CannotInitializeATAError.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Represents a Solana-specific error when an ATA (associated token account) couldn't be initialized
+ *
+ * @category Errors
+ */
 export declare class CannotInitializeATAError extends Error {
     constructor(msg: string);
 }

package/dist/errors/CannotInitializeATAError.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CannotInitializeATAError = void 0;
+/**
+ * Represents a Solana-specific error when an ATA (associated token account) couldn't be initialized
+ *
+ * @category Errors
+ */
 class CannotInitializeATAError extends Error {
     constructor(msg) {
         super(msg);

package/dist/errors/SignatureVerificationError.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Represents a signature verification error
+ *
+ * @category Errors
+ */
 export declare class SignatureVerificationError extends Error {
     constructor(msg: string);
 }

package/dist/errors/SignatureVerificationError.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignatureVerificationError = void 0;
+/**
+ * Represents a signature verification error
+ *
+ * @category Errors
+ */
 class SignatureVerificationError extends Error {
     constructor(msg) {
         super(msg);

package/dist/errors/SwapDataVerificationError.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Represents an error or inconsistency when verifying {@link SwapData}
+ *
+ * @category Errors
+ */
 export declare class SwapDataVerificationError extends Error {
     constructor(msg: string);
 }

package/dist/errors/SwapDataVerificationError.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapDataVerificationError = void 0;
+/**
+ * Represents an error or inconsistency when verifying {@link SwapData}
+ *
+ * @category Errors
+ */
 class SwapDataVerificationError extends Error {
     constructor(msg) {
         super(msg);

package/dist/errors/TransactionRevertedError.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Indicates that the sent transaction has reverted (i.e. was confirmed but the execution failed)
+ *
+ * @category Errors
+ */
 export declare class TransactionRevertedError extends Error {
     constructor(msg: string);
 }

package/dist/errors/TransactionRevertedError.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionRevertedError = void 0;
+/**
+ * Indicates that the sent transaction has reverted (i.e. was confirmed but the execution failed)
+ *
+ * @category Errors
+ */
 class TransactionRevertedError extends Error {
     constructor(msg) {
         super(msg);

package/dist/events/ChainEvents.d.ts

@@ -1,9 +1,47 @@
 import { SwapData } from "../swaps/SwapData";
 import { ChainEvent } from "./types/ChainEvent";
+/**
+ * A type of the on-chain event listener callback
+ *
+ * @category Events
+ */
 export type EventListener<T extends SwapData> = (obj: ChainEvent<T>[]) => Promise<boolean>;
-export interface ChainEvents<T extends SwapData> {
-    init(): Promise<void>;
+/**
+ * An interface defining an on-chain events listener, allowing registering callbacks to receive on-chain events
+ *
+ * @category Events
+ */
+export interface ChainEvents<T extends SwapData, S extends any = any> {
+    /**
+     * Initializes the chains event listener, by default this initiates a websocket events subscription or
+     *  HTTP polling for new events.
+     *
+     * @param noAutomaticPoll When this flag is passed the listener doesn't initiate the websocket events subscription
+     *  or HTTP polling, instead it relies on the implementor calling the {@link ChainEvents.poll} to fetch new events
+     */
+    init(noAutomaticPoll?: boolean): Promise<void>;
+    /**
+     * Registers a new listener to listen for on-chain events
+     *
+     * @param cbk
+     */
     registerListener(cbk: EventListener<T>): void;
+    /**
+     * Unregisters a previously registered events listener, returning `true` if success, `false` if failed
+     *
+     * @param cbk
+     */
     unregisterListener(cbk: EventListener<T>): boolean;
+    /**
+     * Stops the event listener's polling and websocket subscription
+     */
     stop(): Promise<void>;
+    /**
+     * Triggers a single poll on the events instance, usually ran automatically, but should be called manually
+     *  when initiated with `noAutomaticPoll`=`true`
+     *
+     * @param currentState The current state of the chain events
+     * @returns The new state that should be saved, persisted and passed to the subsequent `poll()` call
+     */
+    poll(currentState?: S): Promise<S | null>;
 }

package/dist/events/types/ChainEvent.d.ts

@@ -1,5 +1,13 @@
 import { SwapData } from "../../swaps/SwapData";
+/**
+ * Represents a processed on-chain event
+ *
+ * @category Events
+ */
 export declare class ChainEvent<T extends SwapData> {
+    /**
+     * Event metadata
+     */
     meta?: {
         blockTime: number;
         txId: string;

package/dist/events/types/ChainEvent.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChainEvent = void 0;
+/**
+ * Represents a processed on-chain event
+ *
+ * @category Events
+ */
 class ChainEvent {
 }
 exports.ChainEvent = ChainEvent;

package/dist/events/types/spv_vault/SpvVaultClaimEvent.d.ts

@@ -1,12 +1,41 @@
 import { SpvVaultEvent, SpvVaultEventType } from "./SpvVaultEvent";
+/**
+ * SPV vault (UTXO-controlled vault) Claim event representation, a valid withdrawal from an SPV vault
+ *
+ * @category Events
+ */
 export declare class SpvVaultClaimEvent extends SpvVaultEvent<SpvVaultEventType.CLAIM> {
     readonly eventType = SpvVaultEventType.CLAIM;
+    /**
+     * Which bitcoin transaction authorized this claim (withdrawal) from the vault
+     */
     btcTxId: string;
+    /**
+     * Recipient of the withdrawn funds
+     */
     recipient: string;
+    /**
+     * If funds should transfered to the execution contract (swap+) this specifies the execution hash of the scheduled
+     *  execution
+     */
     executionHash: string;
+    /**
+     * Scaled token amounts that have been claim (withdrawn) from the vault (NOTE: These are scaled by the corresponding vault-defined
+     *  multiplier for the tokens)
+     */
     amounts: bigint[];
+    /**
+     * Address of the party which submitted the claim (withdrawal) transaction on the smart chain side
+     */
     caller: string;
+    /**
+     * If the withdrawal was fronted, this contains an address of the party which fronted it, or 0 address if the
+     *  withdrawal was not fronted
+     */
     frontingAddress: string;
+    /**
+     * The sequence of this claim (withdrawal) - i.e. the total number of deposits done before this one
+     */
     withdrawCount: number;
     constructor(owner: string, vaultId: bigint, btcTxId: string, recipient: string, executionHash: string, amounts: bigint[], caller: string, frontingAddress: string, withdrawCount: number);
 }

package/dist/events/types/spv_vault/SpvVaultClaimEvent.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultClaimEvent = void 0;
 const SpvVaultEvent_1 = require("./SpvVaultEvent");
+/**
+ * SPV vault (UTXO-controlled vault) Claim event representation, a valid withdrawal from an SPV vault
+ *
+ * @category Events
+ */
 class SpvVaultClaimEvent extends SpvVaultEvent_1.SpvVaultEvent {
     constructor(owner, vaultId, btcTxId, recipient, executionHash, amounts, caller, frontingAddress, withdrawCount) {
         super(owner, vaultId);

package/dist/events/types/spv_vault/SpvVaultCloseEvent.d.ts

@@ -1,7 +1,20 @@
 import { SpvVaultEvent, SpvVaultEventType } from "./SpvVaultEvent";
+/**
+ * SPV vault (UTXO-controlled vault) Close event representation, a withdrawal with invalid transaction
+ *  spending the vault UTXO but not correctly comitting the data has been made, this returns the full
+ *  balance of the vault back to its owner.
+ *
+ * @category Events
+ */
 export declare class SpvVaultCloseEvent extends SpvVaultEvent<SpvVaultEventType.CLOSE> {
     readonly eventType = SpvVaultEventType.CLOSE;
+    /**
+     * Bitcoin transaction ID that caused the error and close event to happen
+     */
     btcTxId: string;
+    /**
+     * A representation of the actual error that has happened
+     */
     error: string;
     constructor(owner: string, vaultId: bigint, btcTxId: string, error: string);
 }

package/dist/events/types/spv_vault/SpvVaultCloseEvent.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultCloseEvent = void 0;
 const SpvVaultEvent_1 = require("./SpvVaultEvent");
+/**
+ * SPV vault (UTXO-controlled vault) Close event representation, a withdrawal with invalid transaction
+ *  spending the vault UTXO but not correctly comitting the data has been made, this returns the full
+ *  balance of the vault back to its owner.
+ *
+ * @category Events
+ */
 class SpvVaultCloseEvent extends SpvVaultEvent_1.SpvVaultEvent {
     constructor(owner, vaultId, btcTxId, error) {
         super(owner, vaultId);

package/dist/events/types/spv_vault/SpvVaultDepositEvent.d.ts

@@ -1,7 +1,19 @@
 import { SpvVaultEvent, SpvVaultEventType } from "./SpvVaultEvent";
+/**
+ * SPV vault (UTXO-controlled vault) Deposit event representation, additional funds have been deposited to the SPV vault
+ *
+ * @category Events
+ */
 export declare class SpvVaultDepositEvent extends SpvVaultEvent<SpvVaultEventType.DEPOSIT> {
     readonly eventType = SpvVaultEventType.DEPOSIT;
+    /**
+     * Scaled token amounts that have been deposited to the vault (NOTE: These are scaled by the corresponding vault-defined
+     *  multiplier for the tokens)
+     */
     amounts: bigint[];
+    /**
+     * The sequence of this deposit - i.e. the total number of deposits done before this one
+     */
     depositCount: number;
     constructor(owner: string, vaultId: bigint, amounts: bigint[], depositCount: number);
 }

package/dist/events/types/spv_vault/SpvVaultDepositEvent.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultDepositEvent = void 0;
 const SpvVaultEvent_1 = require("./SpvVaultEvent");
+/**
+ * SPV vault (UTXO-controlled vault) Deposit event representation, additional funds have been deposited to the SPV vault
+ *
+ * @category Events
+ */
 class SpvVaultDepositEvent extends SpvVaultEvent_1.SpvVaultEvent {
     constructor(owner, vaultId, amounts, depositCount) {
         super(owner, vaultId);

package/dist/events/types/spv_vault/SpvVaultEvent.d.ts

@@ -1,5 +1,10 @@
 import { ChainEvent } from "../ChainEvent";
 import { SwapData } from "../../../swaps/SwapData";
+/**
+ * Enum of the various types of SPV vault (UTXO-controlled vault) related events
+ *
+ * @category Events
+ */
 export declare enum SpvVaultEventType {
     OPEN = 0,
     DEPOSIT = 1,
@@ -7,9 +12,20 @@ export declare enum SpvVaultEventType {
     CLOSE = 3,
     FRONT = 4
 }
-export declare class SpvVaultEvent<C extends SpvVaultEventType = SpvVaultEventType> extends ChainEvent<SwapData> {
-    readonly eventType: C;
+/**
+ * Represents an SPV vault (UTXO-controlled vault) on-chain event
+ *
+ * @category Events
+ */
+export declare abstract class SpvVaultEvent<C extends SpvVaultEventType = SpvVaultEventType> extends ChainEvent<SwapData> {
+    abstract readonly eventType: C;
+    /**
+     * Owner of the underlying SPV vault (UTXO-controlled vault)
+     */
     owner: string;
+    /**
+     * ID of the SPV vault (UTXO-controlled vault)
+     */
     vaultId: bigint;
     constructor(owner: string, vaultId: bigint);
 }

package/dist/events/types/spv_vault/SpvVaultEvent.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultEvent = exports.SpvVaultEventType = void 0;
 const ChainEvent_1 = require("../ChainEvent");
+/**
+ * Enum of the various types of SPV vault (UTXO-controlled vault) related events
+ *
+ * @category Events
+ */
 var SpvVaultEventType;
 (function (SpvVaultEventType) {
     SpvVaultEventType[SpvVaultEventType["OPEN"] = 0] = "OPEN";
@@ -10,6 +15,11 @@ var SpvVaultEventType;
     SpvVaultEventType[SpvVaultEventType["CLOSE"] = 3] = "CLOSE";
     SpvVaultEventType[SpvVaultEventType["FRONT"] = 4] = "FRONT";
 })(SpvVaultEventType = exports.SpvVaultEventType || (exports.SpvVaultEventType = {}));
+/**
+ * Represents an SPV vault (UTXO-controlled vault) on-chain event
+ *
+ * @category Events
+ */
 class SpvVaultEvent extends ChainEvent_1.ChainEvent {
     constructor(owner, vaultId) {
         super();

package/dist/events/types/spv_vault/SpvVaultFrontEvent.d.ts

@@ -1,10 +1,32 @@
 import { SpvVaultEvent, SpvVaultEventType } from "./SpvVaultEvent";
+/**
+ * SPV vault (UTXO-controlled vault) Front event representation, an SPV vault withdrawal was fronted
+ *
+ * @category Events
+ */
 export declare class SpvVaultFrontEvent extends SpvVaultEvent<SpvVaultEventType.FRONT> {
     readonly eventType = SpvVaultEventType.FRONT;
+    /**
+     * Withdrawal in this bitcoin transaction is getting fronted
+     */
     btcTxId: string;
+    /**
+     * Original recipient of the fronted withdrawal
+     */
     recipient: string;
+    /**
+     * If funds should transfered to the execution contract (swap+) this specifies the execution hash of the scheduled
+     *  execution
+     */
     executionHash: string;
+    /**
+     * Scaled token amounts that have been fronted by the fronter (NOTE: These are scaled by the corresponding vault-defined
+     *  multiplier for the tokens)
+     */
     amounts: bigint[];
+    /**
+     * Address of the party which fronted the withdrawal
+     */
     frontingAddress: string;
     constructor(owner: string, vaultId: bigint, btcTxId: string, recipient: string, executionHash: string, amounts: bigint[], frontingAddress: string);
 }

package/dist/events/types/spv_vault/SpvVaultFrontEvent.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultFrontEvent = void 0;
 const SpvVaultEvent_1 = require("./SpvVaultEvent");
+/**
+ * SPV vault (UTXO-controlled vault) Front event representation, an SPV vault withdrawal was fronted
+ *
+ * @category Events
+ */
 class SpvVaultFrontEvent extends SpvVaultEvent_1.SpvVaultEvent {
     constructor(owner, vaultId, btcTxId, recipient, executionHash, amounts, frontingAddress) {
         super(owner, vaultId);

package/dist/events/types/spv_vault/SpvVaultOpenEvent.d.ts

@@ -1,7 +1,18 @@
 import { SpvVaultEvent, SpvVaultEventType } from "./SpvVaultEvent";
+/**
+ * SPV vault (UTXO-controlled vault) Open event representation, new SPV vault was opened
+ *
+ * @category Events
+ */
 export declare class SpvVaultOpenEvent extends SpvVaultEvent<SpvVaultEventType.OPEN> {
     readonly eventType = SpvVaultEventType.OPEN;
+    /**
+     * Vault ownership utxo transaction ID
+     */
     btcTxId: string;
+    /**
+     * Vault ownership utxo transaction vout
+     */
     vout: number;
     constructor(owner: string, vaultId: bigint, btcTxId: string, vout: number);
 }

package/dist/events/types/spv_vault/SpvVaultOpenEvent.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpvVaultOpenEvent = void 0;
 const SpvVaultEvent_1 = require("./SpvVaultEvent");
+/**
+ * SPV vault (UTXO-controlled vault) Open event representation, new SPV vault was opened
+ *
+ * @category Events
+ */
 class SpvVaultOpenEvent extends SpvVaultEvent_1.SpvVaultEvent {
     constructor(owner, vaultId, btcTxId, vout) {
         super(owner, vaultId);

package/dist/events/types/swap/ClaimEvent.d.ts

@@ -1,7 +1,15 @@
 import { SwapEvent, SwapEventType } from "./SwapEvent";
 import { SwapData } from "../../../swaps/SwapData";
+/**
+ * Escrow swap Claim event representation, claimer claimed funds from the escrow
+ *
+ * @category Events
+ */
 export declare class ClaimEvent<T extends SwapData> extends SwapEvent<T, SwapEventType.CLAIM> {
     readonly eventType: SwapEventType.CLAIM;
+    /**
+     * The result of the Claim event, usually either a secret pre-image or transaction hash
+     */
     result: string;
     constructor(escrowHash: string, result: string);
 }

package/dist/events/types/swap/ClaimEvent.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaimEvent = void 0;
 const SwapEvent_1 = require("./SwapEvent");
+/**
+ * Escrow swap Claim event representation, claimer claimed funds from the escrow
+ *
+ * @category Events
+ */
 class ClaimEvent extends SwapEvent_1.SwapEvent {
     constructor(escrowHash, result) {
         super(escrowHash);
+        this.eventType = SwapEvent_1.SwapEventType.CLAIM;
         this.result = result;
     }
 }