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

package/src/btcrelay/types/BtcStoredHeader.ts

@@ -1,13 +1,13 @@
-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>;
-
+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/src/btcrelay/utils/StatePredictorUtils.ts

@@ -1,108 +1,108 @@
-import {Buffer} from "buffer";
-import {BigIntBufferUtils} from "../../utils/BigIntBufferUtils";
-
-export class StatePredictorUtils {
-
-    static readonly DIFF_ADJUSTMENT_PERIOD = 2016;
-
-    static gtBuffer(a: Buffer, b: Buffer): boolean {
-        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: Buffer, divisor: number): void {
-
-        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: number[], add: number[]): void {
-
-        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: number): Buffer {
-
-        const target = 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: number): Buffer {
-
-        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.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
-
-        StatePredictorUtils.divInPlace(arr, num);
-
-        const result = Buffer.alloc(32, 0);
-
-        for(let i=0;i<32-shift;i++) {
-            result[i+shift] = arr[i];
-        }
-
-        return result;
-
-    }
-
-    static getChainwork(nbits: number): Buffer {
-        const target = StatePredictorUtils.nbitsToTarget(nbits);
-        const targetBN = BigIntBufferUtils.fromBuffer(target);
-        return BigIntBufferUtils.toBuffer(
-            ((~targetBN & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn) / (targetBN + 1n)) + 1n, "be", 32
-        );
-    }
-}
+import {Buffer} from "buffer";
+import {BigIntBufferUtils} from "../../utils/BigIntBufferUtils";
+
+export class StatePredictorUtils {
+
+    static readonly DIFF_ADJUSTMENT_PERIOD = 2016;
+
+    static gtBuffer(a: Buffer, b: Buffer): boolean {
+        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: Buffer, divisor: number): void {
+
+        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: number[], add: number[]): void {
+
+        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: number): Buffer {
+
+        const target = 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: number): Buffer {
+
+        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.from("00000000FFFF0000000000000000000000000000000000000000000000000000", "hex");
+
+        StatePredictorUtils.divInPlace(arr, num);
+
+        const result = Buffer.alloc(32, 0);
+
+        for(let i=0;i<32-shift;i++) {
+            result[i+shift] = arr[i];
+        }
+
+        return result;
+
+    }
+
+    static getChainwork(nbits: number): Buffer {
+        const target = StatePredictorUtils.nbitsToTarget(nbits);
+        const targetBN = BigIntBufferUtils.fromBuffer(target);
+        return BigIntBufferUtils.toBuffer(
+            ((~targetBN & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn) / (targetBN + 1n)) + 1n, "be", 32
+        );
+    }
+}

package/src/chains/ChainData.ts

@@ -1,40 +1,40 @@
-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/src/chains/ChainInterface.ts

@@ -1,133 +1,160 @@
-export type TransactionConfirmationOptions = {
-    waitForConfirmation?: boolean,
-    abortSignal?: AbortSignal,
-    feeRate?: string
-};
-
-export type AbstractSigner = {
-    getAddress: () => string
-};
-
-export interface ChainInterface<
-    TX = any,
-    Signer extends AbstractSigner = AbstractSigner,
-    ChainId extends string = string
-> {
-
-    readonly chainId: ChainId;
-
-    /**
-     * Returns the token balance of a specific address
-     *
-     * @param signer Address to check the balance of
-     * @param token Token
-     */
-    getBalance(signer: string, token: string): Promise<bigint>;
-
-    /**
-     * Returns the token address of the native currency of the chain
-     */
-    getNativeCurrencyAddress(): string;
-
-    /**
-     * Checks if a given string is a valid wallet address
-     *
-     * @param address
-     */
-    isValidAddress(address: string): boolean;
-
-    /**
-     * Checks if a given string is a valid token identifier
-     *
-     * @param tokenIdentifier
-     */
-    isValidToken(tokenIdentifier: string): boolean;
-
-    /**
-     * Transfers the specific token to a given recipient
-     *
-     * @param signer Signer/owner of the tokens
-     * @param token Token to transfer
-     * @param amount Amount of token to transfer
-     * @param dstAddress Destination address of the transfer
-     * @param txOptions Transaction options
-     */
-    transfer(signer: Signer, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
-
-    /**
-     * Returns transactions for transferring a specific token to a given recipient
-     *
-     * @param signer Signer/owner of the tokens
-     * @param token Token to transfer
-     * @param amount Amount of token to transfer
-     * @param dstAddress Destination address of the transfer
-     * @param feeRate Optional fee rate to use for the transaction (fetched on-demand if not provided)
-     */
-    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TX[]>;
-
-    /**
-     * Serializes a given transaction to a string
-     *
-     * @param tx Transaction to serialize
-     */
-    serializeTx(tx: TX): Promise<string>;
-
-    /**
-     * Deserializes a transaction from string
-     *
-     * @param txData Serialized transaction data string
-     */
-    deserializeTx(txData: string): Promise<TX>;
-
-    /**
-     * Returns the status of the given serialized transaction
-     *
-     * @param tx Serialized transaction
-     */
-    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-
-    /**
-     * Returns the status of the given transactionId (use getTxStatus whenever possible, it's more reliable)
-     *
-     * @param txId Transaction ID
-     */
-    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
-
-    /**
-     * Signs, sends a batch of transaction and optionally waits for their confirmation
-     *
-     * @param signer Signer to use for signing transactions
-     * @param txs Transactions to send
-     * @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
-     */
-    sendAndConfirm(signer: Signer, txs: TX[], 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)
-     *
-     * @param callback
-     */
-    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
-
-    /**
-     * Remove tx replace callback
-     *
-     * @param callback
-     */
-    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
-
-    /**
-     * Returns a random valid wallet address
-     */
-    randomAddress(): string;
-
-    /**
-     * Returns randomly generated signer
-     */
-    randomSigner(): Signer;
-
+export type TransactionConfirmationOptions = {
+    waitForConfirmation?: boolean,
+    abortSignal?: AbortSignal,
+    feeRate?: string
+};
+
+export type AbstractSigner = {
+    type: "AtomiqAbstractSigner",
+    getAddress: () => string,
+    init?: () => Promise<void>,
+    stop?: () => Promise<void>
+};
+
+export function isAbstractSigner(val: any): val is AbstractSigner {
+    return typeof(val)==="object" && val.type==="AtomiqAbstractSigner" && typeof(val.getAddress)==="function";
+}
+
+export interface ChainInterface<
+    TX = any,
+    Signer extends AbstractSigner = AbstractSigner,
+    ChainId extends string = string,
+    NativeSigner = any
+> {
+
+    readonly chainId: ChainId;
+
+    /**
+     * Returns the token balance of a specific address
+     *
+     * @param signer Address to check the balance of
+     * @param token Token
+     */
+    getBalance(signer: string, token: string): Promise<bigint>;
+
+    /**
+     * Returns the token address of the native currency of the chain
+     */
+    getNativeCurrencyAddress(): string;
+
+    /**
+     * Checks if a given string is a valid wallet address
+     *
+     * @param address
+     * @param lenient Whether a lenient parsing should be used (i.e. don't strictly enforce the Starknet address lengths)
+     */
+    isValidAddress(address: string, lenient?: boolean): boolean;
+
+    /**
+     * Normalizes a given address i.e. pads it to the specific size
+     *
+     * @param address
+     */
+    normalizeAddress(address: string): string;
+
+    /**
+     * Checks if a given string is a valid token identifier
+     *
+     * @param tokenIdentifier
+     */
+    isValidToken(tokenIdentifier: string): boolean;
+
+    /**
+     * Transfers the specific token to a given recipient
+     *
+     * @param signer Signer/owner of the tokens
+     * @param token Token to transfer
+     * @param amount Amount of token to transfer
+     * @param dstAddress Destination address of the transfer
+     * @param txOptions Transaction options
+     */
+    transfer(signer: Signer, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
+
+    /**
+     * Returns transactions for transferring a specific token to a given recipient
+     *
+     * @param signer Signer/owner of the tokens
+     * @param token Token to transfer
+     * @param amount Amount of token to transfer
+     * @param dstAddress Destination address of the transfer
+     * @param feeRate Optional fee rate to use for the transaction (fetched on-demand if not provided)
+     */
+    txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TX[]>;
+
+    /**
+     * Serializes a given transaction to a string
+     *
+     * @param tx Transaction to serialize
+     */
+    serializeTx(tx: TX): Promise<string>;
+
+    /**
+     * Deserializes a transaction from string
+     *
+     * @param txData Serialized transaction data string
+     */
+    deserializeTx(txData: string): Promise<TX>;
+
+    /**
+     * Returns the status of the given serialized transaction
+     *
+     * @param tx Serialized transaction
+     */
+    getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+
+    /**
+     * Returns the status of the given transactionId (use getTxStatus whenever possible, it's more reliable)
+     *
+     * @param txId Transaction ID
+     */
+    getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+
+    /**
+     * Returns the latest known finalized block data (this is a block with 100% certainty of not getting re-org, i.e.
+     *  a block already committed on L1)
+     */
+    getFinalizedBlock(): Promise<{height: number, blockHash: string}>;
+
+    /**
+     * Signs, sends a batch of transaction and optionally waits for their confirmation
+     *
+     * @param signer Signer to use for signing transactions
+     * @param txs Transactions to send
+     * @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
+     */
+    sendAndConfirm(signer: Signer, txs: TX[], 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)
+     *
+     * @param callback
+     */
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+
+    /**
+     * Remove tx replace callback
+     *
+     * @param callback
+     */
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
+
+    /**
+     * Returns a random valid wallet address
+     */
+    randomAddress(): string;
+
+    /**
+     * Returns randomly generated signer
+     */
+    randomSigner(): Signer;
+
+    /**
+     * Wraps a native chain signer object to an atomiq-understandable AbstractSigner
+     */
+    wrapSigner(signer: NativeSigner): Promise<Signer>;
+
 }