@atomiqlabs/chain-evm 2.0.7 → 2.0.8

package/dist/evm/btcrelay/EVMBtcRelay.d.ts

@@ -54,7 +54,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
     private getBlock;
     private getBlockHeight;
     /**
-     * Returns data about current main chain tip stored in the btc relay
+     * @inheritDoc
      */
     getTipData(): Promise<{
         commitHash: string;
@@ -63,11 +63,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         blockheight: number;
     } | null>;
     /**
-     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
-     *  btc relay contract is not synced up to the desired blockheight
-     *
-     * @param blockData
-     * @param requiredBlockheight
+     * @inheritDoc
      */
     retrieveLogAndBlockheight(blockData: {
         blockhash: string;
@@ -76,28 +72,20 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         height: number;
     } | null>;
     /**
-     * Retrieves blockheader data by blockheader's commit hash,
-     *
-     * @param commitmentHashStr
-     * @param blockData
+     * @inheritDoc
      */
     retrieveLogByCommitHash(commitmentHashStr: string, blockData: {
         blockhash: string;
     }): Promise<EVMBtcStoredHeader | null>;
     /**
-     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     * @inheritDoc
      */
     retrieveLatestKnownBlockLog(): Promise<{
         resultStoredHeader: EVMBtcStoredHeader;
         resultBitcoinHeader: B;
     } | null>;
     /**
-     * Saves blockheaders as a bitcoin main chain to the btc relay
-     *
-     * @param signer
-     * @param mainHeaders
-     * @param storedHeader
-     * @param feeRate
+     * @inheritDoc
      */
     saveMainHeaders(signer: string, mainHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, feeRate?: string): Promise<{
         forkId: number;
@@ -106,13 +94,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         computedCommitedHeaders: EVMBtcStoredHeader[];
     }>;
     /**
-     * Creates a new long fork and submits the headers to it
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveNewForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -121,14 +103,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         computedCommitedHeaders: EVMBtcStoredHeader[];
     }>;
     /**
-     * Continues submitting blockheaders to a given fork
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param forkId
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, forkId: number, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -137,13 +112,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         computedCommitedHeaders: EVMBtcStoredHeader[];
     }>;
     /**
-     * Submits short fork with given blockheaders
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     saveShortForkHeaders(signer: string, forkHeaders: BtcBlock[], storedHeader: EVMBtcStoredHeader, tipWork: Buffer, feeRate?: string): Promise<{
         forkId: number;
@@ -152,26 +121,24 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
         computedCommitedHeaders: EVMBtcStoredHeader[];
     }>;
     /**
-     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
-     *
-     * @param requiredBlockheight
-     * @param feeRate
+     * @inheritDoc
      */
     estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
     /**
-     * Returns fee required (in native token) to synchronize a single block to btc relay
-     *
-     * @param feeRate
+     * @inheritDoc
      */
     getFeePerBlock(feeRate?: string): Promise<bigint>;
     /**
-     * Gets fee rate required for submitting blockheaders to the main chain
+     * @inheritDoc
      */
     getMainFeeRate(signer: string | null): Promise<string>;
     /**
-     * Gets fee rate required for submitting blockheaders to the specific fork
+     * @inheritDoc
      */
     getForkFeeRate(signer: string, forkId: number): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     saveInitialHeader(signer: string, header: B, epochStart: number, pastBlocksTimestamps: number[], feeRate?: string): Promise<EVMTx>;
     /**
      * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on

package/dist/evm/btcrelay/EVMBtcRelay.js

@@ -175,7 +175,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return Number(await this.contract.getBlockheight());
     }
     /**
-     * Returns data about current main chain tip stored in the btc relay
+     * @inheritDoc
      */
     async getTipData() {
         const commitHash = await this.contract.getTipCommitHash();
@@ -193,11 +193,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         };
     }
     /**
-     * Retrieves blockheader with a specific blockhash, returns null if requiredBlockheight is provided and
-     *  btc relay contract is not synced up to the desired blockheight
-     *
-     * @param blockData
-     * @param requiredBlockheight
+     * @inheritDoc
      */
     async retrieveLogAndBlockheight(blockData, requiredBlockheight) {
         //TODO: we can fetch the blockheight and events in parallel
@@ -218,10 +214,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return { header: storedBlockHeader, height: blockHeight };
     }
     /**
-     * Retrieves blockheader data by blockheader's commit hash,
-     *
-     * @param commitmentHashStr
-     * @param blockData
+     * @inheritDoc
      */
     async retrieveLogByCommitHash(commitmentHashStr, blockData) {
         const result = await this.getBlock(commitmentHashStr, Buffer.from(blockData.blockhash, "hex"));
@@ -237,7 +230,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return storedBlockHeader;
     }
     /**
-     * Retrieves latest known stored blockheader & blockheader from bitcoin RPC that is in the main chain
+     * @inheritDoc
      */
     async retrieveLatestKnownBlockLog() {
         const data = await this.Events.findInContractEvents(["StoreHeader", "StoreForkHeader"], null, async (event) => {
@@ -268,12 +261,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return data;
     }
     /**
-     * Saves blockheaders as a bitcoin main chain to the btc relay
-     *
-     * @param signer
-     * @param mainHeaders
-     * @param storedHeader
-     * @param feeRate
+     * @inheritDoc
      */
     async saveMainHeaders(signer, mainHeaders, storedHeader, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
@@ -281,13 +269,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return this._saveHeaders(signer, mainHeaders, storedHeader, 0, feeRate, 0);
     }
     /**
-     * Creates a new long fork and submits the headers to it
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveNewForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
         let forkId = Math.floor(Math.random() * 0xFFFFFFFFFFFF);
@@ -302,14 +284,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return result;
     }
     /**
-     * Continues submitting blockheaders to a given fork
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param forkId
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveForkHeaders(signer, forkHeaders, storedHeader, forkId, tipWork, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
@@ -323,13 +298,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return result;
     }
     /**
-     * Submits short fork with given blockheaders
-     *
-     * @param signer
-     * @param forkHeaders
-     * @param storedHeader
-     * @param tipWork
-     * @param feeRate
+     * @inheritDoc
      */
     async saveShortForkHeaders(signer, forkHeaders, storedHeader, tipWork, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
@@ -343,10 +312,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return result;
     }
     /**
-     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
-     *
-     * @param requiredBlockheight
-     * @param feeRate
+     * @inheritDoc
      */
     async estimateSynchronizeFee(requiredBlockheight, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
@@ -364,26 +330,27 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return synchronizationFee;
     }
     /**
-     * Returns fee required (in native token) to synchronize a single block to btc relay
-     *
-     * @param feeRate
+     * @inheritDoc
      */
     async getFeePerBlock(feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
         return EVMFees_1.EVMFees.getGasFee(EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER, feeRate);
     }
     /**
-     * Gets fee rate required for submitting blockheaders to the main chain
+     * @inheritDoc
      */
     getMainFeeRate(signer) {
         return this.Chain.Fees.getFeeRate();
     }
     /**
-     * Gets fee rate required for submitting blockheaders to the specific fork
+     * @inheritDoc
      */
     getForkFeeRate(signer, forkId) {
         return this.Chain.Fees.getFeeRate();
     }
+    /**
+     * @inheritDoc
+     */
     saveInitialHeader(signer, header, epochStart, pastBlocksTimestamps, feeRate) {
         throw new Error("Not supported, EVM contract is initialized with constructor!");
     }

package/dist/evm/chain/EVMChainInterface.d.ts

@@ -53,30 +53,99 @@ export declare class EVMChainInterface<ChainId extends string = string> implemen
     Blocks: EVMBlocks;
     protected logger: LoggerType;
     constructor(chainId: ChainId, evmChainId: number, provider: JsonRpcApiProvider, config: EVMConfiguration, retryPolicy?: EVMRetryPolicy, evmFeeEstimator?: EVMFees);
+    /**
+     * @inheritDoc
+     */
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     getNativeCurrencyAddress(): string;
+    /**
+     * @inheritDoc
+     */
     isValidToken(tokenIdentifier: string): boolean;
+    /**
+     * @inheritDoc
+     */
     isValidAddress(address: string): boolean;
+    /**
+     * @inheritDoc
+     */
     normalizeAddress(address: string): string;
+    /**
+     * @inheritDoc
+     */
     offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
+    /**
+     * @inheritDoc
+     */
     onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+    /**
+     * @inheritDoc
+     */
     onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void;
+    /**
+     * @inheritDoc
+     */
     offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean;
+    /**
+     * @inheritDoc
+     */
     randomAddress(): string;
+    /**
+     * @inheritDoc
+     */
     randomSigner(): EVMSigner;
+    /**
+     * @inheritDoc
+     */
     sendAndConfirm(signer: EVMSigner, txs: TransactionRequest[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>, useAccessLists?: boolean): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
     sendSignedAndConfirm(signedTxs: Transaction[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * @inheritDoc
+     */
     serializeTx(tx: TransactionRequest): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deserializeTx(txData: string): Promise<TransactionRequest>;
+    /**
+     * @inheritDoc
+     */
     serializeSignedTx(tx: Transaction): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     deserializeSignedTx(txData: string): Promise<Transaction>;
+    /**
+     * @inheritDoc
+     */
     getTxIdStatus(txId: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    /**
+     * @inheritDoc
+     */
     getTxStatus(tx: string): Promise<"not_found" | "pending" | "success" | "reverted">;
+    /**
+     * @inheritDoc
+     */
     getFinalizedBlock(): Promise<{
         height: number;
         blockHash: string;
     }>;
+    /**
+     * @inheritDoc
+     */
     txsTransfer(signer: string, token: string, amount: bigint, dstAddress: string, feeRate?: string): Promise<TransactionRequest[]>;
+    /**
+     * @inheritDoc
+     */
     transfer(signer: EVMSigner, token: string, amount: bigint, dstAddress: string, txOptions?: TransactionConfirmationOptions): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     wrapSigner(signer: Signer): Promise<EVMSigner>;
 }

package/dist/evm/chain/EVMChainInterface.js

@@ -36,67 +36,127 @@ class EVMChainInterface {
         this.Events = new EVMEvents_1.EVMEvents(this);
         this.Blocks = new EVMBlocks_1.EVMBlocks(this);
     }
+    /**
+     * @inheritDoc
+     */
     async getBalance(signer, tokenAddress) {
         //TODO: For native token we should discount the cost of transactions
         return await this.Tokens.getTokenBalance(signer, tokenAddress);
     }
+    /**
+     * @inheritDoc
+     */
     getNativeCurrencyAddress() {
         return this.Tokens.getNativeCurrencyAddress();
     }
+    /**
+     * @inheritDoc
+     */
     isValidToken(tokenIdentifier) {
         return this.Tokens.isValidToken(tokenIdentifier);
     }
+    /**
+     * @inheritDoc
+     */
     isValidAddress(address) {
         return EVMAddresses_1.EVMAddresses.isValidAddress(address);
     }
+    /**
+     * @inheritDoc
+     */
     normalizeAddress(address) {
         return (0, ethers_1.getAddress)(address);
     }
     ///////////////////////////////////
     //// Callbacks & handlers
+    /**
+     * @inheritDoc
+     */
     offBeforeTxReplace(callback) {
         return true;
     }
+    /**
+     * @inheritDoc
+     */
     onBeforeTxReplace(callback) { }
+    /**
+     * @inheritDoc
+     */
     onBeforeTxSigned(callback) {
         this.Transactions.onBeforeTxSigned(callback);
     }
+    /**
+     * @inheritDoc
+     */
     offBeforeTxSigned(callback) {
         return this.Transactions.offBeforeTxSigned(callback);
     }
+    /**
+     * @inheritDoc
+     */
     randomAddress() {
         return EVMAddresses_1.EVMAddresses.randomAddress();
     }
+    /**
+     * @inheritDoc
+     */
     randomSigner() {
         const wallet = ethers_1.Wallet.createRandom();
         return new EVMSigner_1.EVMSigner(wallet, wallet.address);
     }
     ////////////////////////////////////////////
     //// Transactions
+    /**
+     * @inheritDoc
+     */
     sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish, useAccessLists) {
         return this.Transactions.sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish, useAccessLists);
     }
+    /**
+     * @inheritDoc
+     */
     sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
         return this.Transactions.sendSignedAndConfirm(signedTxs, waitForConfirmation, abortSignal, parallel, onBeforePublish);
     }
+    /**
+     * @inheritDoc
+     */
     serializeTx(tx) {
         return this.Transactions.serializeUnsignedTx(tx);
     }
+    /**
+     * @inheritDoc
+     */
     deserializeTx(txData) {
         return Promise.resolve(this.Transactions.deserializeUnsignedTx(txData));
     }
+    /**
+     * @inheritDoc
+     */
     serializeSignedTx(tx) {
         return Promise.resolve(this.Transactions.serializeSignedTx(tx));
     }
+    /**
+     * @inheritDoc
+     */
     deserializeSignedTx(txData) {
         return Promise.resolve(this.Transactions.deserializeSignedTx(txData));
     }
+    /**
+     * @inheritDoc
+     */
     getTxIdStatus(txId) {
         return this.Transactions.getTxIdStatus(txId);
     }
+    /**
+     * @inheritDoc
+     */
     getTxStatus(tx) {
         return this.Transactions.getTxStatus(tx);
     }
+    /**
+     * @inheritDoc
+     */
     async getFinalizedBlock() {
         const block = await this.Blocks.getBlock(this.config.finalizedBlockTag);
         return {
@@ -104,14 +164,23 @@ class EVMChainInterface {
             blockHash: block.hash
         };
     }
+    /**
+     * @inheritDoc
+     */
     async txsTransfer(signer, token, amount, dstAddress, feeRate) {
         return [await this.Tokens.Transfer(signer, token, amount, dstAddress, feeRate)];
     }
+    /**
+     * @inheritDoc
+     */
     async transfer(signer, token, amount, dstAddress, txOptions) {
         const tx = await this.Tokens.Transfer(signer.getAddress(), token, amount, dstAddress, txOptions?.feeRate);
         const [txId] = await this.Transactions.sendAndConfirm(signer, [tx], txOptions?.waitForConfirmation, txOptions?.abortSignal, false);
         return txId;
     }
+    /**
+     * @inheritDoc
+     */
     async wrapSigner(signer) {
         const address = await signer.getAddress();
         if (signer instanceof ethers_1.JsonRpcSigner || signer.provider instanceof ethers_1.BrowserProvider) {

package/dist/evm/chain/modules/EVMTransactions.js

@@ -211,7 +211,12 @@ class EVMTransactions extends EVMModule_1.EVMModule {
             for (let i = 0; i < txs.length; i++) {
                 let tx;
                 if (signer.signTransaction == null) {
-                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish)
+                        .catch(e => {
+                        if (e?.message?.includes("User rejected"))
+                            e.message = "User refused to sign the transaction";
+                        throw e;
+                    });
                 }
                 else {
                     const signedTx = signedTxs[i];
@@ -241,7 +246,12 @@ class EVMTransactions extends EVMModule_1.EVMModule {
             for (let i = 0; i < txs.length; i++) {
                 let tx;
                 if (signer.signTransaction == null) {
-                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish)
+                        .catch(e => {
+                        if (e?.message?.includes("User rejected"))
+                            e.message = "User refused to sign the transaction";
+                        throw e;
+                    });
                 }
                 else {
                     const signedTx = signedTxs[i];

package/dist/evm/events/EVMChainEventsBrowser.d.ts

@@ -79,6 +79,9 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, E
         blockHash: string;
         logIndex: number;
     }, lastBlockNumber?: number): Promise<EVMEventListenerState>;
+    /**
+     * @inheritDoc
+     */
     poll(lastState?: EVMEventListenerState[]): Promise<EVMEventListenerState[]>;
     /**
      * Sets up event handlers listening for swap events over websocket
@@ -96,9 +99,21 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, E
     protected addOrRemoveBlockListener(): Promise<void>;
     protected startFinalityCheckTimer(): Promise<void>;
     protected setupWebsocket(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     init(noAutomaticPoll?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     stop(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     registerListener(cbk: EventListener<EVMSwapData>): void;
+    /**
+     * @inheritDoc
+     */
     unregisterListener(cbk: EventListener<EVMSwapData>): boolean;
 }
 export {};

package/dist/evm/events/EVMChainEventsBrowser.js

@@ -291,6 +291,9 @@ class EVMChainEventsBrowser {
         }
         return { lastEvent, lastBlockNumber };
     }
+    /**
+     * @inheritDoc
+     */
     async poll(lastState) {
         lastState ?? (lastState = []);
         const currentBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag, false);
@@ -431,6 +434,9 @@ class EVMChainEventsBrowser {
             this.handleWsEvent(event);
         });
     }
+    /**
+     * @inheritDoc
+     */
     async init(noAutomaticPoll) {
         if (noAutomaticPoll)
             return Promise.resolve();
@@ -443,6 +449,9 @@ class EVMChainEventsBrowser {
         this.stopped = false;
         return Promise.resolve();
     }
+    /**
+     * @inheritDoc
+     */
     async stop() {
         this.stopped = true;
         if (this.timeout != null)
@@ -455,9 +464,15 @@ class EVMChainEventsBrowser {
             clearTimeout(this.finalityCheckTimer);
         }
     }
+    /**
+     * @inheritDoc
+     */
     registerListener(cbk) {
         this.listeners.push(cbk);
     }
+    /**
+     * @inheritDoc
+     */
     unregisterListener(cbk) {
         const index = this.listeners.indexOf(cbk);
         if (index >= 0) {