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

package/dist/btcrelay/BtcRelay.d.ts

@@ -1,61 +1,61 @@
-/// <reference types="node" />
-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;
-    }>;
-    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>;
-}
+/// <reference types="node" />
+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;
+    }>;
+    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/dist/btcrelay/BtcRelay.js

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

package/dist/btcrelay/synchronizer/RelaySynchronizer.d.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[];
-        targetCommitedHeader: V;
-        latestBlockHeader: B;
-        computedHeaderMap: {
-            [blockheight: number]: V;
-        };
-        blockHeaderMap: {
-            [blockheight: number]: B;
-        };
-        btcRelayTipCommitedHeader: V;
-        btcRelayTipBlockHeader: B;
-        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[];
+        targetCommitedHeader: V;
+        latestBlockHeader: B;
+        computedHeaderMap: {
+            [blockheight: number]: V;
+        };
+        blockHeaderMap: {
+            [blockheight: number]: B;
+        };
+        btcRelayTipCommitedHeader: V;
+        btcRelayTipBlockHeader: B;
+        startForkId?: number;
+    }>;
+}

package/dist/btcrelay/synchronizer/RelaySynchronizer.js

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

package/dist/btcrelay/types/BtcBlock.d.ts

@@ -1,13 +1,13 @@
-/// <reference types="node" />
-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;
-}
+/// <reference types="node" />
+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/dist/btcrelay/types/BtcBlock.js

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

package/dist/btcrelay/types/BtcHeader.d.ts

@@ -1,10 +1,10 @@
-/// <reference types="node" />
-import { Buffer } from "buffer";
-export interface BtcHeader {
-    getVersion(): number;
-    getReversedPrevBlockhash(): Buffer;
-    getMerkleRoot(): Buffer;
-    getTimestamp(): number;
-    getNbits(): number;
-    getNonce(): number;
-}
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export interface BtcHeader {
+    getVersion(): number;
+    getReversedPrevBlockhash(): Buffer;
+    getMerkleRoot(): Buffer;
+    getTimestamp(): number;
+    getNbits(): number;
+    getNonce(): number;
+}

package/dist/btcrelay/types/BtcHeader.js

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

package/dist/btcrelay/types/BtcStoredHeader.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="node" />
-import { BtcHeader } from "./BtcHeader";
-import { Buffer } from "buffer";
-export interface BtcStoredHeader<T extends BtcHeader> {
-    getChainWork(): Buffer;
-    getHeader(): T;
-    getLastDiffAdjustment(): number;
-    getBlockheight(): number;
-    getPrevBlockTimestamps(): number[];
-    computeNext(header: T): BtcStoredHeader<T>;
-}
+/// <reference types="node" />
+import { BtcHeader } from "./BtcHeader";
+import { Buffer } from "buffer";
+export interface BtcStoredHeader<T extends BtcHeader> {
+    getChainWork(): Buffer;
+    getHeader(): T;
+    getLastDiffAdjustment(): number;
+    getBlockheight(): number;
+    getPrevBlockTimestamps(): number[];
+    computeNext(header: T): BtcStoredHeader<T>;
+}

package/dist/btcrelay/types/BtcStoredHeader.js

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

package/dist/btcrelay/utils/StatePredictorUtils.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="node" />
-import { Buffer } from "buffer";
-export declare class StatePredictorUtils {
-    static readonly DIFF_ADJUSTMENT_PERIOD = 2016;
-    static gtBuffer(a: Buffer, b: Buffer): boolean;
-    static divInPlace(arr: Buffer, divisor: number): void;
-    static addInPlace(arr: number[], add: number[]): void;
-    static nbitsToTarget(nbits: number): Buffer;
-    static getDifficulty(nbits: number): Buffer;
-    static getChainwork(nbits: number): Buffer;
-}
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export declare class StatePredictorUtils {
+    static readonly DIFF_ADJUSTMENT_PERIOD = 2016;
+    static gtBuffer(a: Buffer, b: Buffer): boolean;
+    static divInPlace(arr: Buffer, divisor: number): void;
+    static addInPlace(arr: number[], add: number[]): void;
+    static nbitsToTarget(nbits: number): Buffer;
+    static getDifficulty(nbits: number): Buffer;
+    static getChainwork(nbits: number): Buffer;
+}

package/dist/btcrelay/utils/StatePredictorUtils.js

@@ -1,80 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatePredictorUtils = void 0;
-const buffer_1 = require("buffer");
-const BigIntBufferUtils_1 = require("../../utils/BigIntBufferUtils");
-class StatePredictorUtils {
-    static gtBuffer(a, b) {
-        for (let i = 0; i < a.length; i++) {
-            if (a[i] > b[i])
-                return true;
-            if (a[i] < b[i])
-                return false;
-        }
-        return false;
-    }
-    static divInPlace(arr, divisor) {
-        let remainder = 0;
-        for (let i = 0; i < 32; i++) {
-            const val = arr[i] + remainder;
-            const result = Math.floor(val / divisor);
-            remainder = (val % divisor) * 256;
-            arr[i] = result;
-        }
-    }
-    static addInPlace(arr, add) {
-        let remainder = 0;
-        for (let i = 0; i < 32; i++) {
-            const pos = 31 - i;
-            const val = arr[pos] + add[pos] + remainder;
-            const byte = val & 0xFF;
-            remainder = val >> 8;
-            arr[pos] = byte;
-        }
-    }
-    static nbitsToTarget(nbits) {
-        const target = buffer_1.Buffer.alloc(32, 0);
-        const nSize = (nbits >> 24) & 0xFF;
-        const nWord = [
-            ((nbits >> 16) & 0x7F),
-            ((nbits >> 8) & 0xFF),
-            ((nbits) & 0xFF)
-        ];
-        const start = 32 - nSize;
-        for (let i = 0; i < 3; i++) {
-            if (start + i < 32) {
-                target[start + i] = nWord[i];
-            }
-        }
-        return target;
-    }
-    static getDifficulty(nbits) {
-        const target = StatePredictorUtils.nbitsToTarget(nbits);
-        let start = 0;
-        for (let i = 0; i < 32; i++) {
-            if (target[i] > 0) {
-                start = i;
-                break;
-            }
-        }
-        const shift = 32 - start - 3;
-        let num = 0;
-        for (let i = 0; i < 3; i++) {
-            num |= target[start + i] << ((2 - i) * 8);
-        }
-        const arr = buffer_1.Buffer.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
-        StatePredictorUtils.divInPlace(arr, num);
-        const result = buffer_1.Buffer.alloc(32, 0);
-        for (let i = 0; i < 32 - shift; i++) {
-            result[i + shift] = arr[i];
-        }
-        return result;
-    }
-    static getChainwork(nbits) {
-        const target = StatePredictorUtils.nbitsToTarget(nbits);
-        const targetBN = BigIntBufferUtils_1.BigIntBufferUtils.fromBuffer(target);
-        return BigIntBufferUtils_1.BigIntBufferUtils.toBuffer(((~targetBN & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn) / (targetBN + 1n)) + 1n, "be", 32);
-    }
-}
-exports.StatePredictorUtils = StatePredictorUtils;
-StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD = 2016;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatePredictorUtils = void 0;
+const buffer_1 = require("buffer");
+const BigIntBufferUtils_1 = require("../../utils/BigIntBufferUtils");
+class StatePredictorUtils {
+    static gtBuffer(a, b) {
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] > b[i])
+                return true;
+            if (a[i] < b[i])
+                return false;
+        }
+        return false;
+    }
+    static divInPlace(arr, divisor) {
+        let remainder = 0;
+        for (let i = 0; i < 32; i++) {
+            const val = arr[i] + remainder;
+            const result = Math.floor(val / divisor);
+            remainder = (val % divisor) * 256;
+            arr[i] = result;
+        }
+    }
+    static addInPlace(arr, add) {
+        let remainder = 0;
+        for (let i = 0; i < 32; i++) {
+            const pos = 31 - i;
+            const val = arr[pos] + add[pos] + remainder;
+            const byte = val & 0xFF;
+            remainder = val >> 8;
+            arr[pos] = byte;
+        }
+    }
+    static nbitsToTarget(nbits) {
+        const target = buffer_1.Buffer.alloc(32, 0);
+        const nSize = (nbits >> 24) & 0xFF;
+        const nWord = [
+            ((nbits >> 16) & 0x7F),
+            ((nbits >> 8) & 0xFF),
+            ((nbits) & 0xFF)
+        ];
+        const start = 32 - nSize;
+        for (let i = 0; i < 3; i++) {
+            if (start + i < 32) {
+                target[start + i] = nWord[i];
+            }
+        }
+        return target;
+    }
+    static getDifficulty(nbits) {
+        const target = StatePredictorUtils.nbitsToTarget(nbits);
+        let start = 0;
+        for (let i = 0; i < 32; i++) {
+            if (target[i] > 0) {
+                start = i;
+                break;
+            }
+        }
+        const shift = 32 - start - 3;
+        let num = 0;
+        for (let i = 0; i < 3; i++) {
+            num |= target[start + i] << ((2 - i) * 8);
+        }
+        const arr = buffer_1.Buffer.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
+        StatePredictorUtils.divInPlace(arr, num);
+        const result = buffer_1.Buffer.alloc(32, 0);
+        for (let i = 0; i < 32 - shift; i++) {
+            result[i + shift] = arr[i];
+        }
+        return result;
+    }
+    static getChainwork(nbits) {
+        const target = StatePredictorUtils.nbitsToTarget(nbits);
+        const targetBN = BigIntBufferUtils_1.BigIntBufferUtils.fromBuffer(target);
+        return BigIntBufferUtils_1.BigIntBufferUtils.toBuffer(((~targetBN & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn) / (targetBN + 1n)) + 1n, "be", 32);
+    }
+}
+exports.StatePredictorUtils = StatePredictorUtils;
+StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD = 2016;

package/dist/chains/ChainData.d.ts

@@ -1,31 +1,31 @@
-import { ChainType } from "./ChainType";
-import { BitcoinRpc } from "../btc/rpc/BitcoinRpc";
-import { BitcoinNetwork } from "../btc/BitcoinNetwork";
-import { IStorageManager } from "../storage/IStorageManager";
-import { StorageObject } from "../storage/StorageObject";
-export type BaseTokenType<T extends string = string> = {
-    [ticker in T]: {
-        address: string;
-        decimals: number;
-        displayDecimals?: number;
-    };
-};
-export type ChainData<T extends ChainType> = {
-    chainId: ChainType["ChainId"];
-    chainInterface: T["ChainInterface"];
-    btcRelay: T["BtcRelay"];
-    chainEvents: T["Events"];
-    swapContract: T["Contract"];
-    swapDataConstructor: new (data: any) => T["Data"];
-    spvVaultContract: T["SpvVaultContract"];
-    spvVaultDataConstructor: new (data: any) => T["SpvVaultData"];
-    spvVaultWithdrawalDataConstructor: new (data: any) => T["SpvVaultWithdrawalData"];
-};
-export type ChainInitializerFn<O, C extends ChainType> = (options: O, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork, storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>) => ChainData<C>;
-export type ChainInitializer<O, C extends ChainType, T extends BaseTokenType> = {
-    chainId: C["ChainId"];
-    chainType: C;
-    initializer: ChainInitializerFn<O, C>;
-    tokens: T;
-    options: O;
-};
+import { ChainType } from "./ChainType";
+import { BitcoinRpc } from "../btc/rpc/BitcoinRpc";
+import { BitcoinNetwork } from "../btc/BitcoinNetwork";
+import { IStorageManager } from "../storage/IStorageManager";
+import { StorageObject } from "../storage/StorageObject";
+export type BaseTokenType<T extends string = string> = {
+    [ticker in T]: {
+        address: string;
+        decimals: number;
+        displayDecimals?: number;
+    };
+};
+export type ChainData<T extends ChainType> = {
+    chainId: ChainType["ChainId"];
+    chainInterface: T["ChainInterface"];
+    btcRelay: T["BtcRelay"];
+    chainEvents: T["Events"];
+    swapContract: T["Contract"];
+    swapDataConstructor: new (data: any) => T["Data"];
+    spvVaultContract: T["SpvVaultContract"];
+    spvVaultDataConstructor: new (data: any) => T["SpvVaultData"];
+    spvVaultWithdrawalDataConstructor: new (data: any) => T["SpvVaultWithdrawalData"];
+};
+export type ChainInitializerFn<O, C extends ChainType> = (options: O, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork, storageCtor: <T extends StorageObject>(name: string) => IStorageManager<T>) => ChainData<C>;
+export type ChainInitializer<O, C extends ChainType, T extends BaseTokenType> = {
+    chainId: C["ChainId"];
+    chainType: C;
+    initializer: ChainInitializerFn<O, C>;
+    tokens: T;
+    options: O;
+};

package/dist/chains/ChainData.js

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