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

package/dist/swaps/SwapContract.js

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

package/dist/swaps/SwapData.d.ts

@@ -1,36 +1,37 @@
-import { ChainSwapType } from "./ChainSwapType";
-import { StorageObject } from "../storage/StorageObject";
-export declare abstract class SwapData implements StorageObject {
-    static deserializers: {
-        [type: string]: new (serialized: any) => any;
-    };
-    static deserialize<T extends SwapData>(data: any): T;
-    abstract getOfferer(): string;
-    abstract setOfferer(newOfferer: string): void;
-    abstract isOfferer(address: string): boolean;
-    abstract getClaimer(): string;
-    abstract setClaimer(newClaimer: string): void;
-    abstract isClaimer(address: string): boolean;
-    abstract serialize(): any;
-    abstract getType(): ChainSwapType;
-    abstract getAmount(): bigint;
-    abstract getToken(): string;
-    abstract isToken(token: string): boolean;
-    abstract getExpiry(): bigint;
-    abstract isPayOut(): boolean;
-    abstract isPayIn(): boolean;
-    abstract getClaimHash(): string;
-    abstract getEscrowHash(): string;
-    abstract getSequence?(): bigint;
-    abstract getExtraData(): string;
-    abstract getConfirmationsHint(): number;
-    abstract getNonceHint(): bigint;
-    abstract getTxoHashHint(): string;
-    abstract setExtraData(extraData: string): void;
-    abstract getSecurityDeposit(): bigint;
-    abstract getClaimerBounty(): bigint;
-    abstract getTotalDeposit(): bigint;
-    abstract getDepositToken(): string;
-    abstract isDepositToken(token: string): boolean;
-    abstract equals(other: SwapData): boolean;
-}
+import { ChainSwapType } from "./ChainSwapType";
+import { StorageObject } from "../storage/StorageObject";
+export declare abstract class SwapData implements StorageObject {
+    static deserializers: {
+        [type: string]: new (serialized: any) => any;
+    };
+    static deserialize<T extends SwapData>(data: any): T;
+    abstract getOfferer(): string;
+    abstract setOfferer(newOfferer: string): void;
+    abstract isOfferer(address: string): boolean;
+    abstract getClaimer(): string;
+    abstract setClaimer(newClaimer: string): void;
+    abstract isClaimer(address: string): boolean;
+    abstract serialize(): any;
+    abstract getType(): ChainSwapType;
+    abstract getAmount(): bigint;
+    abstract getToken(): string;
+    abstract isToken(token: string): boolean;
+    abstract getExpiry(): bigint;
+    abstract isPayOut(): boolean;
+    abstract isPayIn(): boolean;
+    abstract getClaimHash(): string;
+    abstract getEscrowHash(): string;
+    abstract getSequence?(): bigint;
+    abstract getExtraData(): string;
+    abstract getConfirmationsHint(): number;
+    abstract getNonceHint(): bigint;
+    abstract getTxoHashHint(): string;
+    abstract setExtraData(extraData: string): void;
+    abstract getSecurityDeposit(): bigint;
+    abstract getClaimerBounty(): bigint;
+    abstract getTotalDeposit(): bigint;
+    abstract getDepositToken(): string;
+    abstract isDepositToken(token: string): boolean;
+    abstract equals(other: SwapData): boolean;
+    hasSuccessAction(): boolean;
+}

package/dist/swaps/SwapData.js

@@ -1,14 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapData = void 0;
-class SwapData {
-    static deserialize(data) {
-        const deserializer = SwapData.deserializers[data.type];
-        if (deserializer != null) {
-            return new deserializer(data);
-        }
-        throw new Error(`No deserializer found for swap data type: ${data.type}`);
-    }
-}
-exports.SwapData = SwapData;
-SwapData.deserializers = {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapData = void 0;
+class SwapData {
+    static deserialize(data) {
+        const deserializer = SwapData.deserializers[data.type];
+        if (deserializer != null) {
+            return new deserializer(data);
+        }
+        throw new Error(`No deserializer found for swap data type: ${data.type}`);
+    }
+    hasSuccessAction() {
+        return false;
+    }
+}
+exports.SwapData = SwapData;
+SwapData.deserializers = {};

package/dist/utils/BigIntBufferUtils.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
-import { Buffer } from "buffer";
-export declare const BigIntBufferUtils: {
-    toBuffer: (value: bigint, endianness?: "be" | "le", length?: number) => Buffer;
-    fromBuffer: (value: Buffer, endianness?: "be" | "le") => bigint;
-};
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export declare const BigIntBufferUtils: {
+    toBuffer: (value: bigint, endianness?: "be" | "le", length?: number) => Buffer;
+    fromBuffer: (value: Buffer, endianness?: "be" | "le") => bigint;
+};

package/dist/utils/BigIntBufferUtils.js

@@ -1,31 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigIntBufferUtils = void 0;
-const buffer_1 = require("buffer");
-exports.BigIntBufferUtils = {
-    toBuffer: (value, endianness = "be", length) => {
-        let values = Array(length);
-        for (let i = 0; i < length; i++) {
-            values[i] = Number(value & 0xffn);
-            value >>= 8n;
-        }
-        const buff = buffer_1.Buffer.from(values);
-        if (endianness === "be")
-            buff.reverse();
-        return buff;
-    },
-    fromBuffer: (value, endianness = "be") => {
-        if (endianness === "le") {
-            const dst = buffer_1.Buffer.alloc(value.length);
-            value.copy(dst);
-            dst.reverse();
-            value = dst;
-        }
-        let accumulator = 0n;
-        for (let byte of value) {
-            accumulator <<= 8n;
-            accumulator |= BigInt(byte);
-        }
-        return accumulator;
-    }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntBufferUtils = void 0;
+const buffer_1 = require("buffer");
+exports.BigIntBufferUtils = {
+    toBuffer: (value, endianness = "be", length) => {
+        let values = Array(length);
+        for (let i = 0; i < length; i++) {
+            values[i] = Number(value & 0xffn);
+            value >>= 8n;
+        }
+        const buff = buffer_1.Buffer.from(values);
+        if (endianness === "be")
+            buff.reverse();
+        return buff;
+    },
+    fromBuffer: (value, endianness = "be") => {
+        if (endianness === "le") {
+            const dst = buffer_1.Buffer.alloc(value.length);
+            value.copy(dst);
+            dst.reverse();
+            value = dst;
+        }
+        let accumulator = 0n;
+        for (let byte of value) {
+            accumulator <<= 8n;
+            accumulator |= BigInt(byte);
+        }
+        return accumulator;
+    }
+};

package/package.json

@@ -1,31 +1,31 @@
-{
-  "name": "@atomiqlabs/base",
-  "version": "10.0.0-dev.2",
-  "description": "Base classes and interfaces for atomiq protocol",
-  "main": "./dist/index.js",
-  "types:": "./dist/index.d.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "files": [
-    "/dist",
-    "/src"
-  ],
-  "keywords": [
-    "Solana",
-    "Bitcoin",
-    "Cross-chain",
-    "Cryptocurrency",
-    "Bridge",
-    "Trustless"
-  ],
-  "author": "adambor",
-  "license": "ISC",
-  "dependencies": {
-    "buffer": "6.0.3"
-  },
-  "devDependencies": {
-    "@types/node": "18.15.11",
-    "typescript": "4.9.5"
-  }
-}
+{
+  "name": "@atomiqlabs/base",
+  "version": "10.0.0-dev.21",
+  "description": "Base classes and interfaces for atomiq protocol",
+  "main": "./dist/index.js",
+  "types:": "./dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "/dist",
+    "/src"
+  ],
+  "keywords": [
+    "Solana",
+    "Bitcoin",
+    "Cross-chain",
+    "Cryptocurrency",
+    "Bridge",
+    "Trustless"
+  ],
+  "author": "adambor",
+  "license": "ISC",
+  "dependencies": {
+    "buffer": "6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "18.15.11",
+    "typescript": "4.9.5"
+  }
+}

package/src/btc/BitcoinNetwork.ts

@@ -1,7 +1,7 @@
-
-export enum BitcoinNetwork {
-    MAINNET=0,
-    TESTNET=1,
-    TESTNET4=2,
-    REGTEST=3
+
+export enum BitcoinNetwork {
+    MAINNET=0,
+    TESTNET=1,
+    TESTNET4=2,
+    REGTEST=3
 }

package/src/btc/rpc/BitcoinRpc.ts

@@ -1,78 +1,78 @@
-import {BtcBlock} from "../../btcrelay/types/BtcBlock";
-import {Buffer} from "buffer";
-
-
-export type BtcVout = {
-    value: number,
-    n: number,
-    scriptPubKey: {
-        asm?: string,
-        hex: string
-    }
-};
-
-export type BtcVin = {
-    txid: string,
-    vout: number,
-    scriptSig: {
-        asm?: string,
-        hex: string
-    },
-    sequence: number,
-    txinwitness: string[]
-};
-
-export type BtcTx = {
-    blockhash: string,
-    confirmations: number,
-    vsize: number,
-    txid: string,
-    hex: string,
-    raw: string,
-    locktime: number,
-    version: number,
-
-    outs: BtcVout[],
-    ins: BtcVin[]
-};
-
-export type BtcBlockWithTxs = {
-    height: number,
-    hash: string,
-    tx: BtcTx[]
-};
-
-export type BtcSyncInfo = {
-    ibd: boolean,
-    headers: number,
-    blocks: number,
-    verificationProgress: number
-}
-
-export interface BitcoinRpc<T extends BtcBlock> {
-
-    isInMainChain(blockhash: string): Promise<boolean>;
-    getBlockHeader(blockhash: string): Promise<T>;
-    getMerkleProof(txId: string, blockhash: string): Promise<{
-        reversedTxId: Buffer,
-        pos: number,
-        merkle: Buffer[],
-        blockheight: number
-    }>;
-    getTransaction(txId: string): Promise<BtcTx>;
-    getBlockhash(height: number): Promise<string>;
-    getBlockWithTransactions(blockhash: string): Promise<BtcBlockWithTxs>;
-
-    sendRawTransaction(rawTx: string): Promise<string>;
-    sendRawPackage(rawTx: string[]): Promise<string[]>;
-
-    getTipHeight(): Promise<number>;
-
-    getSyncInfo(): Promise<BtcSyncInfo>;
-
-    parseTransaction(rawTx: string): Promise<BtcTx>;
-    isSpent(utxo: string, confirmed?: boolean): Promise<boolean>;
-
-    getEffectiveFeeRate(btcTx: BtcTx): Promise<{vsize: number, fee: number, feeRate: number}>;
-
+import {BtcBlock} from "../../btcrelay/types/BtcBlock";
+import {Buffer} from "buffer";
+
+
+export type BtcVout = {
+    value: number,
+    n: number,
+    scriptPubKey: {
+        asm?: string,
+        hex: string
+    }
+};
+
+export type BtcVin = {
+    txid: string,
+    vout: number,
+    scriptSig: {
+        asm?: string,
+        hex: string
+    },
+    sequence: number,
+    txinwitness: string[]
+};
+
+export type BtcTx = {
+    blockhash: string,
+    confirmations: number,
+    vsize: number,
+    txid: string,
+    hex: string,
+    raw: string,
+    locktime: number,
+    version: number,
+
+    outs: BtcVout[],
+    ins: BtcVin[]
+};
+
+export type BtcBlockWithTxs = {
+    height: number,
+    hash: string,
+    tx: BtcTx[]
+};
+
+export type BtcSyncInfo = {
+    ibd: boolean,
+    headers: number,
+    blocks: number,
+    verificationProgress: number
+}
+
+export interface BitcoinRpc<T extends BtcBlock> {
+
+    isInMainChain(blockhash: string): Promise<boolean>;
+    getBlockHeader(blockhash: string): Promise<T>;
+    getMerkleProof(txId: string, blockhash: string): Promise<{
+        reversedTxId: Buffer,
+        pos: number,
+        merkle: Buffer[],
+        blockheight: number
+    }>;
+    getTransaction(txId: string): Promise<BtcTx>;
+    getBlockhash(height: number): Promise<string>;
+    getBlockWithTransactions(blockhash: string): Promise<BtcBlockWithTxs>;
+
+    sendRawTransaction(rawTx: string): Promise<string>;
+    sendRawPackage(rawTx: string[]): Promise<string[]>;
+
+    getTipHeight(): Promise<number>;
+
+    getSyncInfo(): Promise<BtcSyncInfo>;
+
+    parseTransaction(rawTx: string): Promise<BtcTx>;
+    isSpent(utxo: string, confirmed?: boolean): Promise<boolean>;
+
+    getEffectiveFeeRate(btcTx: BtcTx): Promise<{vsize: number, fee: number, feeRate: number}>;
+
 }

package/src/btcrelay/BtcRelay.ts

@@ -1,71 +1,71 @@
-import {BtcStoredHeader} from "./types/BtcStoredHeader";
-import {BtcBlock} from "./types/BtcBlock";
-import {Buffer} from "buffer";
-import {AbstractSigner} from "../chains/ChainInterface";
-
-export interface BtcRelay<
-    V extends BtcStoredHeader<any>,
-    T,
-    B extends BtcBlock,
-    Signer extends AbstractSigner = AbstractSigner
-> {
-
-    maxHeadersPerTx: number;
-    maxForkHeadersPerTx: number;
-    maxShortForkHeadersPerTx?: number;
-
-    getTipData(): Promise<{
-        blockheight: number,
-        blockhash: string,
-        commitHash: string,
-        chainWork: Buffer
-    }>;
-
-    retrieveLogAndBlockheight(blockData: {blockhash: string, height: number}, requiredBlockheight?: number): Promise<{
-        header: V,
-        height: number
-    }>;
-    retrieveLogByCommitHash(commitHash: string, blockData: {blockhash: string, height: number}): Promise<V>;
-
-    retrieveLatestKnownBlockLog(): Promise<{
-        resultStoredHeader: V,
-        resultBitcoinHeader: B
-    }>;
-    //retrieveOnchainTip(): Promise<B>;
-
-    saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<T>;
-    saveMainHeaders(signer: string, mainHeaders: B[], storedHeader: V, feeRate?: string): Promise<{
-        forkId: number,
-        lastStoredHeader: V,
-        tx: T,
-        computedCommitedHeaders: V[]
-    }>;
-    saveNewForkHeaders(signer: string, forkHeaders: B[], storedHeader: V, tipWork: Buffer, feeRate?: string): Promise<{
-        forkId: number,
-        lastStoredHeader: V,
-        tx: T,
-        computedCommitedHeaders: V[]
-    }>;
-    saveForkHeaders(signer: string, forkHeaders: B[], storedHeader: V, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
-        forkId: number,
-        lastStoredHeader: V,
-        tx: T,
-        computedCommitedHeaders: V[]
-    }>;
-    saveShortForkHeaders?(signer: string, forkHeaders: B[], storedHeader: V, tipWork: Buffer, feeRate?: string): Promise<{
-        forkId: number,
-        lastStoredHeader: V,
-        tx: T,
-        computedCommitedHeaders: V[]
-    }>;
-
-    getMainFeeRate?(signer: string): Promise<string>;
-    getForkFeeRate?(signer: string, forkId: number): Promise<string>;
-
-    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
-
-    getFeePerBlock(feeRate?: any): Promise<bigint>;
-
-    sweepForkData?(signer: Signer, lastSweepTimestamp?: number): Promise<number | null>;
-
+import {BtcStoredHeader} from "./types/BtcStoredHeader";
+import {BtcBlock} from "./types/BtcBlock";
+import {Buffer} from "buffer";
+import {AbstractSigner} from "../chains/ChainInterface";
+
+export interface BtcRelay<
+    V extends BtcStoredHeader<any>,
+    T,
+    B extends BtcBlock,
+    Signer extends AbstractSigner = AbstractSigner
+> {
+
+    maxHeadersPerTx: number;
+    maxForkHeadersPerTx: number;
+    maxShortForkHeadersPerTx?: number;
+
+    getTipData(): Promise<{
+        blockheight: number,
+        blockhash: string,
+        commitHash: string,
+        chainWork: Buffer
+    }>;
+
+    retrieveLogAndBlockheight(blockData: {blockhash: string, height: number}, requiredBlockheight?: number): Promise<{
+        header: V,
+        height: number
+    }>;
+    retrieveLogByCommitHash(commitHash: string, blockData: {blockhash: string, height: number}): Promise<V>;
+
+    retrieveLatestKnownBlockLog(): Promise<{
+        resultStoredHeader: V,
+        resultBitcoinHeader: B
+    }>;
+    //retrieveOnchainTip(): Promise<B>;
+
+    saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<T>;
+    saveMainHeaders(signer: string, mainHeaders: B[], storedHeader: V, feeRate?: string): Promise<{
+        forkId: number,
+        lastStoredHeader: V,
+        tx: T,
+        computedCommitedHeaders: V[]
+    }>;
+    saveNewForkHeaders(signer: string, forkHeaders: B[], storedHeader: V, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number,
+        lastStoredHeader: V,
+        tx: T,
+        computedCommitedHeaders: V[]
+    }>;
+    saveForkHeaders(signer: string, forkHeaders: B[], storedHeader: V, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number,
+        lastStoredHeader: V,
+        tx: T,
+        computedCommitedHeaders: V[]
+    }>;
+    saveShortForkHeaders?(signer: string, forkHeaders: B[], storedHeader: V, tipWork: Buffer, feeRate?: string): Promise<{
+        forkId: number,
+        lastStoredHeader: V,
+        tx: T,
+        computedCommitedHeaders: V[]
+    }>;
+
+    getMainFeeRate?(signer: string): Promise<string>;
+    getForkFeeRate?(signer: string, forkId: number): Promise<string>;
+
+    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
+
+    getFeePerBlock(feeRate?: any): Promise<bigint>;
+
+    sweepForkData?(signer: Signer, lastSweepTimestamp?: number): Promise<number | null>;
+
 }

package/src/btcrelay/synchronizer/RelaySynchronizer.ts

@@ -1,18 +1,18 @@
-import {BtcStoredHeader} from "../types/BtcStoredHeader";
-import {BtcBlock} from "../types/BtcBlock";
-
-
-export interface RelaySynchronizer<V extends BtcStoredHeader<any>, T, B extends BtcBlock> {
-
-    syncToLatestTxs(signer: string, feeRate?: string): Promise<{
-        txs: T[], //Transactions required to synchronize the btc relay
-        targetCommitedHeader: V, //Latest committed header after synchronization
-        latestBlockHeader: B, //Latest block header after synchronization
-        computedHeaderMap: {[blockheight: number]: V}, //Mapping of synchronized committed headers
-        blockHeaderMap: {[blockheight: number]: B}, //Mapping of synchronized block headers
-        btcRelayTipCommitedHeader: V, //Tip committed header of the btc relay before synchronization
-        btcRelayTipBlockHeader: B, //Tip block header of the btc relay before synchronization
-        startForkId?: number
-    }>;
-
+import {BtcStoredHeader} from "../types/BtcStoredHeader";
+import {BtcBlock} from "../types/BtcBlock";
+
+
+export interface RelaySynchronizer<V extends BtcStoredHeader<any>, T, B extends BtcBlock> {
+
+    syncToLatestTxs(signer: string, feeRate?: string): Promise<{
+        txs: T[], //Transactions required to synchronize the btc relay
+        targetCommitedHeader: V, //Latest committed header after synchronization
+        latestBlockHeader: B, //Latest block header after synchronization
+        computedHeaderMap: {[blockheight: number]: V}, //Mapping of synchronized committed headers
+        blockHeaderMap: {[blockheight: number]: B}, //Mapping of synchronized block headers
+        btcRelayTipCommitedHeader: V, //Tip committed header of the btc relay before synchronization
+        btcRelayTipBlockHeader: B, //Tip block header of the btc relay before synchronization
+        startForkId?: number
+    }>;
+
 }

package/src/btcrelay/types/BtcBlock.ts

@@ -1,15 +1,15 @@
-import {Buffer} from "buffer";
-
-export interface BtcBlock {
-
-    getVersion(): number;
-    getPrevBlockhash(): string;
-    getMerkleRoot(): string;
-    getTimestamp(): number;
-    getNbits(): number;
-    getNonce(): number;
-    getHash(): string;
-    getHeight(): number;
-    getChainWork(): Buffer;
-
-}
+import {Buffer} from "buffer";
+
+export interface BtcBlock {
+
+    getVersion(): number;
+    getPrevBlockhash(): string;
+    getMerkleRoot(): string;
+    getTimestamp(): number;
+    getNbits(): number;
+    getNonce(): number;
+    getHash(): string;
+    getHeight(): number;
+    getChainWork(): Buffer;
+
+}

package/src/btcrelay/types/BtcHeader.ts

@@ -1,12 +1,12 @@
-import {Buffer} from "buffer";
-
-export interface BtcHeader {
-
-    getVersion(): number,
-    getReversedPrevBlockhash(): Buffer,
-    getMerkleRoot(): Buffer,
-    getTimestamp(): number,
-    getNbits(): number,
-    getNonce(): number
-
+import {Buffer} from "buffer";
+
+export interface BtcHeader {
+
+    getVersion(): number,
+    getReversedPrevBlockhash(): Buffer,
+    getMerkleRoot(): Buffer,
+    getTimestamp(): number,
+    getNbits(): number,
+    getNonce(): number
+
 }