@atomiqlabs/base 7.2.2 → 8.0.0

package/dist/btc/BitcoinNetwork.d.ts

@@ -0,0 +1,4 @@
+export declare enum BitcoinNetwork {
+    MAINNET = 0,
+    TESTNET = 1
+}

package/dist/btc/BitcoinNetwork.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinNetwork = void 0;
+var BitcoinNetwork;
+(function (BitcoinNetwork) {
+    BitcoinNetwork[BitcoinNetwork["MAINNET"] = 0] = "MAINNET";
+    BitcoinNetwork[BitcoinNetwork["TESTNET"] = 1] = "TESTNET";
+})(BitcoinNetwork = exports.BitcoinNetwork || (exports.BitcoinNetwork = {}));

package/dist/btcrelay/BtcRelay.d.ts

@@ -1,14 +1,15 @@
 /// <reference types="node" />
 import { BtcStoredHeader } from "./types/BtcStoredHeader";
 import { BtcBlock } from "./types/BtcBlock";
-import * as BN from "bn.js";
 import { AbstractSigner } from "../swaps/SwapContract";
+import { Buffer } from "buffer";
 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;
     }>;
@@ -54,7 +55,7 @@ export interface BtcRelay<V extends BtcStoredHeader<any>, T, B extends BtcBlock,
     }>;
     getMainFeeRate?(signer: string): Promise<string>;
     getForkFeeRate?(signer: string, forkId: number): Promise<string>;
-    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<BN>;
-    getFeePerBlock(feeRate?: any): Promise<BN>;
+    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
+    getFeePerBlock(feeRate?: any): Promise<bigint>;
     sweepForkData?(signer: Signer, lastSweepTimestamp?: number): Promise<number | null>;
 }

package/dist/btcrelay/rpc/BitcoinRpc.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { BtcBlock } from "../types/BtcBlock";
+import { Buffer } from "buffer";
 export type BtcVout = {
     value: number;
     n: number;

package/dist/btcrelay/synchronizer/RelaySynchronizer.d.ts

@@ -1,7 +1,7 @@
 import { BtcStoredHeader } from "../types/BtcStoredHeader";
 import { BtcBlock } from "../types/BtcBlock";
 export interface RelaySynchronizer<V extends BtcStoredHeader<any>, T, B extends BtcBlock> {
-    syncToLatestTxs(signer: string): Promise<{
+    syncToLatestTxs(signer: string, feeRate?: string): Promise<{
         txs: T[];
         targetCommitedHeader: V;
         computedHeaderMap: {

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Buffer } from "buffer";
 export interface BtcBlock {
     getVersion(): number;
     getPrevBlockhash(): string;

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

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

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

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { BtcHeader } from "./BtcHeader";
+import { Buffer } from "buffer";
 export interface BtcStoredHeader<T extends BtcHeader> {
     getChainWork(): Buffer;
     getHeader(): T;

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Buffer } from "buffer";
 export declare class StatePredictorUtils {
     static readonly DIFF_ADJUSTMENT_PERIOD = 2016;
     static gtBuffer(a: Buffer, b: Buffer): boolean;
@@ -6,4 +7,5 @@ export declare class StatePredictorUtils {
     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,6 +1,8 @@
 "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++) {
@@ -31,7 +33,7 @@ class StatePredictorUtils {
         }
     }
     static nbitsToTarget(nbits) {
-        const target = Buffer.alloc(32, 0);
+        const target = buffer_1.Buffer.alloc(32, 0);
         const nSize = (nbits >> 24) & 0xFF;
         const nWord = [
             ((nbits >> 16) & 0x7F),
@@ -60,14 +62,19 @@ class StatePredictorUtils {
         for (let i = 0; i < 3; i++) {
             num |= target[start + i] << ((2 - i) * 8);
         }
-        const arr = Buffer.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
+        const arr = buffer_1.Buffer.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
         StatePredictorUtils.divInPlace(arr, num);
-        const result = Buffer.alloc(32, 0);
+        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

@@ -0,0 +1,29 @@
+import { ChainType } from "./ChainType";
+import { BtcRelay } from "../btcrelay/BtcRelay";
+import { BitcoinRpc } from "../btcrelay/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"];
+    btcRelay: BtcRelay<any, T["TX"], any, T["Signer"]>;
+    swapContract: T["Contract"];
+    chainEvents: T["Events"];
+    swapDataConstructor: new (data: any) => T["Data"];
+    storagePrefix?: string;
+};
+export type ChainInitializerFn<O, C extends ChainType> = (options: O, bitcoinRelay: 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

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

package/dist/chains/ChainType.d.ts

@@ -0,0 +1,15 @@
+import { SwapData } from "../swaps/SwapData";
+import { ChainEvents } from "../events/ChainEvents";
+import { AbstractSigner, SwapContract } from "../swaps/SwapContract";
+import { BtcRelay } from "../btcrelay/BtcRelay";
+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>, E extends ChainEvents<T> = ChainEvents<T>, B extends BtcRelay<any, TXType, any, Signer> = BtcRelay<any, TXType, any, Signer>> = {
+    ChainId: ChainId;
+    PreFetchData: PreFetchData;
+    PreFetchVerification: PreFetchVerification;
+    TX: TXType;
+    Signer: Signer;
+    Data: T;
+    Contract: C;
+    Events: E;
+    BtcRelay: B;
+};

package/dist/chains/ChainType.js

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

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

@@ -1,7 +1,6 @@
 import { SwapEvent } from "./SwapEvent";
 import { SwapData } from "../../swaps/SwapData";
-import * as BN from "bn.js";
 export declare class ClaimEvent<T extends SwapData> extends SwapEvent<T> {
-    secret: string;
-    constructor(paymentHash: string, sequence: BN, secret: string);
+    result: string;
+    constructor(escrowHash: string, result: string);
 }

package/dist/events/types/ClaimEvent.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClaimEvent = void 0;
 const SwapEvent_1 = require("./SwapEvent");
 class ClaimEvent extends SwapEvent_1.SwapEvent {
-    constructor(paymentHash, sequence, secret) {
-        super(paymentHash, sequence);
-        this.secret = secret;
+    constructor(escrowHash, result) {
+        super(escrowHash);
+        this.result = result;
     }
 }
 exports.ClaimEvent = ClaimEvent;

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

@@ -1,10 +1,8 @@
 import { SwapEvent } from "./SwapEvent";
 import { SwapData } from "../../swaps/SwapData";
-import * as BN from "bn.js";
 import { ChainSwapType } from "../../swaps/ChainSwapType";
 export declare class InitializeEvent<T extends SwapData> extends SwapEvent<T> {
-    txoHash: string;
     swapType: ChainSwapType;
     swapData: () => Promise<T>;
-    constructor(paymentHash: string, sequence: BN, txoHash: string, swapType: ChainSwapType, swapData: () => Promise<T>);
+    constructor(escrowHash: string, swapType: ChainSwapType, swapData: () => Promise<T>);
 }

package/dist/events/types/InitializeEvent.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitializeEvent = void 0;
 const SwapEvent_1 = require("./SwapEvent");
 class InitializeEvent extends SwapEvent_1.SwapEvent {
-    constructor(paymentHash, sequence, txoHash, swapType, swapData) {
-        super(paymentHash, sequence);
-        this.txoHash = txoHash;
+    constructor(escrowHash, swapType, swapData) {
+        super(escrowHash);
         this.swapType = swapType;
         this.swapData = swapData;
     }

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

@@ -1,6 +1,4 @@
 import { SwapEvent } from "./SwapEvent";
 import { SwapData } from "../../swaps/SwapData";
-import * as BN from "bn.js";
 export declare class RefundEvent<T extends SwapData> extends SwapEvent<T> {
-    constructor(paymentHash: string, sequence: BN);
 }

package/dist/events/types/RefundEvent.js

@@ -3,8 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RefundEvent = void 0;
 const SwapEvent_1 = require("./SwapEvent");
 class RefundEvent extends SwapEvent_1.SwapEvent {
-    constructor(paymentHash, sequence) {
-        super(paymentHash, sequence);
-    }
 }
 exports.RefundEvent = RefundEvent;

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

@@ -1,11 +1,9 @@
 import { SwapData } from "../../swaps/SwapData";
-import * as BN from "bn.js";
 export declare class SwapEvent<T extends SwapData> {
     meta?: {
         blockTime: number;
         txId: string;
     };
-    paymentHash: string;
-    sequence: BN;
-    constructor(paymentHash: string, sequence: BN);
+    escrowHash: string;
+    constructor(escrowHash: string);
 }

package/dist/events/types/SwapEvent.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapEvent = void 0;
 class SwapEvent {
-    constructor(paymentHash, sequence) {
-        this.paymentHash = paymentHash;
-        this.sequence = sequence;
+    constructor(escrowHash) {
+        this.escrowHash = escrowHash;
     }
 }
 exports.SwapEvent = SwapEvent;

package/dist/index.d.ts

@@ -20,4 +20,7 @@ export * from "./swaps/SwapCommitStatus";
 export * from "./errors/SignatureVerificationError";
 export * from "./errors/CannotInitializeATAError";
 export * from "./errors/SwapDataVerificationError";
-export * from "./ChainType";
+export * from "./chains/ChainType";
+export * from "./chains/ChainData";
+export * from "./utils/BigIntBufferUtils";
+export * from "./btc/BitcoinNetwork";

package/dist/index.js

@@ -36,29 +36,7 @@ __exportStar(require("./swaps/SwapCommitStatus"), exports);
 __exportStar(require("./errors/SignatureVerificationError"), exports);
 __exportStar(require("./errors/CannotInitializeATAError"), exports);
 __exportStar(require("./errors/SwapDataVerificationError"), exports);
-__exportStar(require("./ChainType"), exports);
-// export {
-//     BitcoinRpc,
-//     RelaySynchronizer,
-//     BtcBlock,
-//     BtcHeader,
-//     BtcStoredHeader,
-//     StatePredictorUtils,
-//     BtcRelay,
-//
-//     ClaimEvent,
-//     InitializeEvent,
-//     RefundEvent,
-//     SwapEvent,
-//     ChainEvents,
-//
-//     Lockable,
-//
-//     StorageObject,
-//
-//     ISwapNonce,
-//     SwapContract,
-//     SwapData,
-//     SwapType,
-//     TokenAddress,
-// }
+__exportStar(require("./chains/ChainType"), exports);
+__exportStar(require("./chains/ChainData"), exports);
+__exportStar(require("./utils/BigIntBufferUtils"), exports);
+__exportStar(require("./btc/BitcoinNetwork"), exports);