@atomiqlabs/chain-evm 1.0.0-dev.65 → 1.0.0-dev.67

package/dist/evm/chain/modules/EVMFees.d.ts

@@ -20,7 +20,7 @@ export declare class EVMFees {
      */
     private _getFeeRate;
     /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
      *
      * @private
      */

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

@@ -25,7 +25,7 @@ class EVMFees {
         return baseFee;
     }
     /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
      *
      * @private
      */

package/dist/evm/chain/modules/EVMTransactions.d.ts

@@ -16,11 +16,14 @@ export type EVMTxTrace = {
 };
 export declare class EVMTransactions extends EVMModule<any> {
     private readonly latestConfirmedNonces;
-    private cbkBeforeTxSigned;
+    private readonly latestPendingNonces;
+    private readonly latestSignedNonces;
+    readonly _cbksBeforeTxReplace: ((oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>)[];
+    private readonly cbksBeforeTxSigned;
     private cbkSendTransaction;
+    readonly _knownTxSet: Set<string>;
     /**
-     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
-     *  the transaction at regular interval
+     * Waits for transaction confirmation using HTTP polling
      *
      * @param tx EVM transaction to wait for confirmation for
      * @param abortSignal signal to abort waiting for tx confirmation
@@ -76,7 +79,7 @@ export declare class EVMTransactions extends EVMModule<any> {
      */
     getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted">;
     /**
-     * Gets the status of the starknet transaction with a specific txId
+     * Gets the status of the EVM transaction with a specific txId
      *
      * @param txId
      */
@@ -85,5 +88,7 @@ export declare class EVMTransactions extends EVMModule<any> {
     offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean;
     onSendTransaction(callback: (tx: string) => Promise<string>): void;
     offSendTransaction(callback: (tx: string) => Promise<string>): boolean;
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
     traceTransaction(txId: string): Promise<EVMTxTrace>;
 }

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

@@ -9,29 +9,40 @@ class EVMTransactions extends EVMModule_1.EVMModule {
     constructor() {
         super(...arguments);
         this.latestConfirmedNonces = {};
+        this.latestPendingNonces = {};
+        this.latestSignedNonces = {};
+        this._cbksBeforeTxReplace = [];
+        this.cbksBeforeTxSigned = [];
+        this._knownTxSet = new Set();
     }
     /**
-     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
-     *  the transaction at regular interval
+     * Waits for transaction confirmation using HTTP polling
      *
      * @param tx EVM transaction to wait for confirmation for
      * @param abortSignal signal to abort waiting for tx confirmation
      * @private
      */
     async confirmTransaction(tx, abortSignal) {
+        const checkTxns = new Set([tx.hash]);
+        const txReplaceListener = (oldTx, oldTxId, newTx, newTxId) => {
+            if (checkTxns.has(oldTxId))
+                checkTxns.add(newTxId);
+            return Promise.resolve();
+        };
+        this.onBeforeTxReplace(txReplaceListener);
         let state = "pending";
         while (state === "pending" || state === "not_found") {
             await (0, Utils_1.timeoutPromise)(3000, abortSignal);
-            state = await this.getTxIdStatus(tx.hash);
-            //Don't re-send transactions
-            // if(state==="not_found") await this.sendSignedTransaction(tx).catch(e => {
-            //     if(e.baseError?.code === 59) return; //Transaction already in the mempool
-            //     this.logger.error("confirmTransaction(): Error on transaction re-send: ", e);
-            // });
+            for (let txId of checkTxns) {
+                state = await this.getTxIdStatus(txId);
+                if (state === "reverted" || state === "success")
+                    break;
+            }
         }
+        this.offBeforeTxReplace(txReplaceListener);
         const nextAccountNonce = tx.nonce + 1;
-        const currentNonce = this.latestConfirmedNonces[tx.from];
-        if (currentNonce == null || nextAccountNonce > currentNonce) {
+        const currentConfirmedNonce = this.latestConfirmedNonces[tx.from];
+        if (currentConfirmedNonce == null || nextAccountNonce > currentConfirmedNonce) {
             this.latestConfirmedNonces[tx.from] = nextAccountNonce;
         }
         if (state === "reverted")
@@ -45,26 +56,33 @@ class EVMTransactions extends EVMModule_1.EVMModule {
      * @private
      */
     async prepareTransactions(signer, txs) {
-        let nonce = (await signer.getNonce()) ?? await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
-        const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
-        if (latestConfirmedNonce != null && latestConfirmedNonce > nonce) {
-            this.logger.debug("prepareTransactions(): Using nonce from local cache!");
-            nonce = latestConfirmedNonce;
-        }
-        for (let i = 0; i < txs.length; i++) {
-            const tx = txs[i];
+        for (let tx of txs) {
             tx.chainId = this.root.evmChainId;
             tx.from = signer.getAddress();
-            if (tx.nonce != null)
-                nonce = tx.nonce; //Take the nonce from last tx
-            if (nonce == null)
-                nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
-            if (tx.nonce == null)
-                tx.nonce = nonce;
-            this.logger.debug("sendAndConfirm(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.nonce);
-            nonce++;
-            if (this.cbkBeforeTxSigned != null)
-                await this.cbkBeforeTxSigned(tx);
+        }
+        if (!signer.isManagingNoncesInternally) {
+            let nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
+            const latestKnownNonce = this.latestPendingNonces[signer.getAddress()];
+            if (latestKnownNonce != null && latestKnownNonce > nonce) {
+                this.logger.debug("prepareTransactions(): Using nonce from local cache!");
+                nonce = latestKnownNonce;
+            }
+            for (let i = 0; i < txs.length; i++) {
+                const tx = txs[i];
+                if (tx.nonce != null)
+                    nonce = tx.nonce; //Take the nonce from last tx
+                if (nonce == null)
+                    nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
+                if (tx.nonce == null)
+                    tx.nonce = nonce;
+                this.logger.debug("sendAndConfirm(): transaction prepared (" + (i + 1) + "/" + txs.length + "), nonce: " + tx.nonce);
+                nonce++;
+            }
+        }
+        for (let tx of txs) {
+            for (let callback of this.cbksBeforeTxSigned) {
+                await callback(tx);
+            }
         }
     }
     /**
@@ -106,12 +124,17 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         await this.prepareTransactions(signer, txs);
         const signedTxs = [];
         //Don't separate the signing process from the sending when using browser-based wallet
-        if (!signer.isBrowserWallet)
+        if (signer.signTransaction != null)
             for (let i = 0; i < txs.length; i++) {
                 const tx = txs[i];
-                const signedTx = ethers_1.Transaction.from(await signer.account.signTransaction(tx));
+                const signedTx = ethers_1.Transaction.from(await signer.signTransaction(tx));
                 signedTxs.push(signedTx);
                 this.logger.debug("sendAndConfirm(): transaction signed (" + (i + 1) + "/" + txs.length + "): " + signedTx);
+                const nextAccountNonce = signedTx.nonce + 1;
+                const currentSignedNonce = this.latestSignedNonces[signedTx.from];
+                if (currentSignedNonce == null || nextAccountNonce > currentSignedNonce) {
+                    this.latestSignedNonces[signedTx.from] = nextAccountNonce;
+                }
             }
         this.logger.debug("sendAndConfirm(): sending transactions, count: " + txs.length +
             " waitForConfirmation: " + waitForConfirmation + " parallel: " + parallel);
@@ -120,14 +143,19 @@ class EVMTransactions extends EVMModule_1.EVMModule {
             let promises = [];
             for (let i = 0; i < txs.length; i++) {
                 let tx;
-                if (signer.isBrowserWallet) {
-                    tx = await signer.account.sendTransaction(txs[i]);
+                if (signer.signTransaction == null) {
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
                 }
                 else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);
                     tx = signedTx;
                 }
+                const nextAccountNonce = tx.nonce + 1;
+                const currentPendingNonce = this.latestPendingNonces[tx.from];
+                if (currentPendingNonce == null || nextAccountNonce > currentPendingNonce) {
+                    this.latestPendingNonces[tx.from] = nextAccountNonce;
+                }
                 if (waitForConfirmation)
                     promises.push(this.confirmTransaction(tx, abortSignal));
                 txIds.push(tx.hash);
@@ -143,14 +171,19 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         else {
             for (let i = 0; i < txs.length; i++) {
                 let tx;
-                if (signer.isBrowserWallet) {
-                    tx = await signer.account.sendTransaction(txs[i]);
+                if (signer.signTransaction == null) {
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
                 }
                 else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);
                     tx = signedTx;
                 }
+                const nextAccountNonce = tx.nonce + 1;
+                const currentPendingNonce = this.latestPendingNonces[tx.from];
+                if (currentPendingNonce == null || nextAccountNonce > currentPendingNonce) {
+                    this.latestPendingNonces[tx.from] = nextAccountNonce;
+                }
                 const confirmPromise = this.confirmTransaction(tx, abortSignal);
                 this.logger.debug("sendAndConfirm(): transaction sent (" + (i + 1) + "/" + txs.length + "): " + tx.hash);
                 //Don't await the last promise when !waitForConfirmation
@@ -189,14 +222,14 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         return await this.getTxIdStatus(parsedTx.hash);
     }
     /**
-     * Gets the status of the starknet transaction with a specific txId
+     * Gets the status of the EVM transaction with a specific txId
      *
      * @param txId
      */
     async getTxIdStatus(txId) {
         const txResponse = await this.provider.getTransaction(txId);
         if (txResponse == null)
-            return "not_found";
+            return this._knownTxSet.has(txId) ? "pending" : "not_found";
         if (txResponse.blockHash == null)
             return "pending";
         const [safeBlockNumber, txReceipt] = await Promise.all([
@@ -210,10 +243,13 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         return "success";
     }
     onBeforeTxSigned(callback) {
-        this.cbkBeforeTxSigned = callback;
+        this.cbksBeforeTxSigned.push(callback);
     }
     offBeforeTxSigned(callback) {
-        this.cbkBeforeTxSigned = null;
+        const index = this.cbksBeforeTxSigned.indexOf(callback);
+        if (index === -1)
+            return false;
+        this.cbksBeforeTxSigned.splice(index, 1);
         return true;
     }
     onSendTransaction(callback) {
@@ -223,6 +259,16 @@ class EVMTransactions extends EVMModule_1.EVMModule {
         this.cbkSendTransaction = null;
         return true;
     }
+    onBeforeTxReplace(callback) {
+        this._cbksBeforeTxReplace.push(callback);
+    }
+    offBeforeTxReplace(callback) {
+        const index = this._cbksBeforeTxReplace.indexOf(callback);
+        if (index === -1)
+            return false;
+        this._cbksBeforeTxReplace.splice(index, 1);
+        return true;
+    }
     traceTransaction(txId) {
         return this.provider.send("debug_traceTransaction", [
             txId,

package/dist/evm/wallet/EVMBrowserSigner.d.ts

@@ -0,0 +1,5 @@
+import { Signer } from "ethers";
+import { EVMSigner } from "./EVMSigner";
+export declare class EVMBrowserSigner extends EVMSigner {
+    constructor(account: Signer, address: string);
+}

package/dist/evm/wallet/EVMBrowserSigner.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMBrowserSigner = void 0;
+const EVMSigner_1 = require("./EVMSigner");
+class EVMBrowserSigner extends EVMSigner_1.EVMSigner {
+    constructor(account, address) {
+        super(account, address, false);
+        this.signTransaction = null;
+    }
+}
+exports.EVMBrowserSigner = EVMBrowserSigner;

package/dist/evm/wallet/EVMPersistentSigner.d.ts

@@ -0,0 +1,28 @@
+import { Signer, TransactionRequest, TransactionResponse } from "ethers";
+import { EVMBlockTag } from "../chain/modules/EVMBlocks";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMSigner } from "./EVMSigner";
+export declare class EVMPersistentSigner extends EVMSigner {
+    readonly safeBlockTag: EVMBlockTag;
+    private pendingTxs;
+    private confirmedNonce;
+    private pendingNonce;
+    private feeBumper;
+    private stopped;
+    private readonly directory;
+    private readonly waitBeforeBump;
+    private readonly minFeeIncreaseAbsolute;
+    private readonly minFeeIncreasePpm;
+    private readonly chainInterface;
+    private readonly logger;
+    constructor(account: Signer, address: string, chainInterface: EVMChainInterface, directory: string, minFeeIncreaseAbsolute?: bigint, minFeeIncreasePpm?: bigint, waitBeforeBumpMillis?: number);
+    private load;
+    private priorSavePromise;
+    private saveCount;
+    private save;
+    private checkPastTransactions;
+    private startFeeBumper;
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;
+}

package/dist/evm/wallet/EVMPersistentSigner.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMPersistentSigner = void 0;
+const fs = require("fs/promises");
+const ethers_1 = require("ethers");
+const Utils_1 = require("../../utils/Utils");
+const EVMFees_1 = require("../chain/modules/EVMFees");
+const EVMSigner_1 = require("./EVMSigner");
+const WAIT_BEFORE_BUMP = 15 * 1000;
+const MIN_FEE_INCREASE_ABSOLUTE = 1n * 1000000000n; //1GWei
+const MIN_FEE_INCREASE_PPM = 100000n; // +10%
+class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
+    constructor(account, address, chainInterface, directory, minFeeIncreaseAbsolute, minFeeIncreasePpm, waitBeforeBumpMillis) {
+        super(account, address, true);
+        this.pendingTxs = new Map();
+        this.stopped = false;
+        this.saveCount = 0;
+        this.signTransaction = null;
+        this.chainInterface = chainInterface;
+        this.directory = directory;
+        this.minFeeIncreaseAbsolute = minFeeIncreaseAbsolute ?? MIN_FEE_INCREASE_ABSOLUTE;
+        this.minFeeIncreasePpm = minFeeIncreasePpm ?? MIN_FEE_INCREASE_PPM;
+        this.waitBeforeBump = waitBeforeBumpMillis ?? WAIT_BEFORE_BUMP;
+        this.safeBlockTag = chainInterface.config.safeBlockTag;
+        this.logger = (0, Utils_1.getLogger)("EVMPersistentSigner(" + address + "): ");
+    }
+    async load() {
+        const fileExists = await fs.access(this.directory + "/txs.json", fs.constants.F_OK).then(() => true).catch(() => false);
+        if (!fileExists)
+            return;
+        const res = await fs.readFile(this.directory + "/txs.json");
+        if (res != null) {
+            const pendingTxs = JSON.parse(res.toString());
+            for (let nonceStr in pendingTxs) {
+                const nonceData = pendingTxs[nonceStr];
+                const nonce = parseInt(nonceStr);
+                if (this.confirmedNonce >= nonce)
+                    continue; //Already confirmed
+                if (this.pendingNonce < nonce) {
+                    this.pendingNonce = nonce;
+                }
+                const parsedPendingTxns = nonceData.txs.map(ethers_1.Transaction.from);
+                this.pendingTxs.set(nonce, {
+                    txs: parsedPendingTxns,
+                    lastBumped: nonceData.lastBumped
+                });
+                for (let tx of parsedPendingTxns) {
+                    this.chainInterface.Transactions._knownTxSet.add(tx.hash);
+                }
+            }
+        }
+    }
+    async save() {
+        const pendingTxs = {};
+        for (let [nonce, data] of this.pendingTxs) {
+            pendingTxs[nonce.toString(10)] = {
+                lastBumped: data.lastBumped,
+                txs: data.txs.map(tx => tx.serialized)
+            };
+        }
+        const requiredSaveCount = ++this.saveCount;
+        if (this.priorSavePromise != null) {
+            await this.priorSavePromise;
+        }
+        if (requiredSaveCount === this.saveCount) {
+            this.priorSavePromise = fs.writeFile(this.directory + "/txs.json", JSON.stringify(pendingTxs));
+            await this.priorSavePromise;
+        }
+    }
+    async checkPastTransactions() {
+        let _gasPrice = null;
+        let _safeBlockTxCount = null;
+        for (let [nonce, data] of this.pendingTxs) {
+            if (data.lastBumped < Date.now() - this.waitBeforeBump) {
+                _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+                this.confirmedNonce = _safeBlockTxCount;
+                if (_safeBlockTxCount > nonce) {
+                    this.pendingTxs.delete(nonce);
+                    data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
+                    this.logger.info("checkPastTransactions(): Tx confirmed, required fee bumps: ", data.txs.length);
+                    this.save();
+                    continue;
+                }
+                const lastTx = data.txs[data.txs.length - 1];
+                if (_gasPrice == null) {
+                    const feeRate = await this.chainInterface.Fees.getFeeRate();
+                    const [baseFee, priorityFee] = feeRate.split(",");
+                    _gasPrice = {
+                        baseFee: BigInt(baseFee),
+                        priorityFee: BigInt(priorityFee)
+                    };
+                }
+                let priorityFee = lastTx.maxPriorityFeePerGas;
+                let baseFee = lastTx.maxFeePerGas - lastTx.maxPriorityFeePerGas;
+                baseFee = (0, Utils_1.bigIntMax)(_gasPrice.baseFee, this.minFeeIncreaseAbsolute + (baseFee * (1000000n + this.minFeeIncreasePpm) / 1000000n));
+                priorityFee = (0, Utils_1.bigIntMax)(_gasPrice.priorityFee, this.minFeeIncreaseAbsolute + (priorityFee * (1000000n + this.minFeeIncreasePpm) / 1000000n));
+                if (baseFee > (this.minFeeIncreaseAbsolute + (_gasPrice.baseFee * (1000000n + this.minFeeIncreasePpm) / 1000000n)) &&
+                    priorityFee > (this.minFeeIncreaseAbsolute + (_gasPrice.priorityFee * (1000000n + this.minFeeIncreasePpm) / 1000000n))) {
+                    //Too big of an increase over the current fee rate, don't fee bump
+                    this.logger.debug("checkPastTransactions(): Tx yet unconfirmed but not increasing fee for ", lastTx.hash);
+                    await this.chainInterface.provider.broadcastTransaction(lastTx.serialized).catch(e => this.logger.error("checkPastTransactions(): Tx re-broadcast error", e));
+                    continue;
+                }
+                let newTx = lastTx.clone();
+                EVMFees_1.EVMFees.applyFeeRate(newTx, null, baseFee.toString(10) + "," + priorityFee.toString(10));
+                this.logger.info("checkPastTransactions(): Bump fee for tx: ", lastTx.hash);
+                newTx.signature = null;
+                const signedRawTx = await this.account.signTransaction(newTx);
+                //Double check pending txns still has nonce after async signTransaction was called
+                if (!this.pendingTxs.has(nonce))
+                    continue;
+                newTx = ethers_1.Transaction.from(signedRawTx);
+                for (let callback of this.chainInterface.Transactions._cbksBeforeTxReplace) {
+                    try {
+                        await callback(lastTx.hash, lastTx.serialized, newTx.hash, signedRawTx);
+                    }
+                    catch (e) {
+                        this.logger.error("checkPastTransactions(): beforeTxReplace callback error: ", e);
+                    }
+                }
+                data.txs.push(newTx);
+                data.lastBumped = Date.now();
+                this.save();
+                this.chainInterface.Transactions._knownTxSet.add(newTx.hash);
+                //TODO: Better error handling when sending tx
+                await this.chainInterface.provider.broadcastTransaction(signedRawTx).catch(e => this.logger.error("checkPastTransactions(): Fee-bumped tx broadcast error", e));
+            }
+        }
+    }
+    startFeeBumper() {
+        let func;
+        func = async () => {
+            try {
+                await this.checkPastTransactions();
+            }
+            catch (e) {
+                this.logger.error("startFeeBumper(): Error when check past transactions: ", e);
+            }
+            if (this.stopped)
+                return;
+            this.feeBumper = setTimeout(func, 1000);
+        };
+        func();
+    }
+    async init() {
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+        const txCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+        this.confirmedNonce = txCount - 1;
+        this.pendingNonce = txCount - 1;
+        await this.load();
+        this.startFeeBumper();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.feeBumper != null) {
+            clearTimeout(this.feeBumper);
+            this.feeBumper = null;
+        }
+        return Promise.resolve();
+    }
+    async sendTransaction(transaction, onBeforePublish) {
+        if (transaction.nonce != null) {
+            if (transaction.nonce !== this.pendingNonce + 1)
+                throw new Error("Invalid transaction nonce!");
+            this.pendingNonce++;
+        }
+        else {
+            this.pendingNonce++;
+            transaction.nonce = this.pendingNonce;
+        }
+        const tx = {};
+        for (let key in transaction) {
+            if (transaction[key] instanceof Promise) {
+                tx[key] = await transaction[key];
+            }
+            else {
+                tx[key] = transaction[key];
+            }
+        }
+        const signedRawTx = await this.account.signTransaction(tx);
+        const signedTx = ethers_1.Transaction.from(signedRawTx);
+        if (onBeforePublish != null) {
+            try {
+                await onBeforePublish(signedTx.hash, signedRawTx);
+            }
+            catch (e) {
+                this.logger.error("sendTransaction(): Error when calling onBeforePublish function: ", e);
+            }
+        }
+        this.pendingTxs.set(transaction.nonce, { txs: [signedTx], lastBumped: Date.now() });
+        this.save();
+        this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
+        return await this.chainInterface.provider.broadcastTransaction(signedRawTx);
+    }
+}
+exports.EVMPersistentSigner = EVMPersistentSigner;

package/dist/evm/wallet/EVMSigner.d.ts

@@ -1,10 +1,11 @@
 import { AbstractSigner } from "@atomiqlabs/base";
-import { Signer } from "ethers";
+import { Signer, TransactionRequest, TransactionResponse } from "ethers";
 export declare class EVMSigner implements AbstractSigner {
     account: Signer;
     readonly address: string;
-    readonly isBrowserWallet: boolean;
-    constructor(account: Signer, address: string, isBrowserWallet?: boolean);
-    getNonce(): Promise<number>;
+    readonly isManagingNoncesInternally: boolean;
+    constructor(account: Signer, address: string, isManagingNoncesInternally?: boolean);
     getAddress(): string;
+    signTransaction?(transaction: TransactionRequest): Promise<string>;
+    sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;
 }

package/dist/evm/wallet/EVMSigner.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMSigner = void 0;
+const ethers_1 = require("ethers");
 class EVMSigner {
-    constructor(account, address, isBrowserWallet = false) {
+    constructor(account, address, isManagingNoncesInternally = false) {
         this.account = account;
         this.address = address;
-        this.isBrowserWallet = isBrowserWallet;
-    }
-    getNonce() {
-        return Promise.resolve(null);
+        this.isManagingNoncesInternally = isManagingNoncesInternally;
     }
     getAddress() {
         return this.address;
     }
+    async signTransaction(transaction) {
+        return this.account.signTransaction(transaction);
+    }
+    async sendTransaction(transaction, onBeforePublish) {
+        const txResponse = await this.account.sendTransaction(transaction);
+        if (onBeforePublish != null)
+            await onBeforePublish(txResponse.hash, ethers_1.Transaction.from(txResponse).serialized);
+        return txResponse;
+    }
 }
 exports.EVMSigner = EVMSigner;

package/dist/index.d.ts

@@ -33,6 +33,7 @@ export * from "./evm/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler";
 export * from "./evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler";
 export * from "./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler";
 export * from "./evm/wallet/EVMSigner";
+export * from "./evm/wallet/EVMBrowserSigner";
 export * from "./chains/citrea/CitreaInitializer";
 export * from "./chains/citrea/CitreaChainType";
 export * from "./chains/citrea/CitreaFees";

package/dist/index.js

@@ -49,6 +49,7 @@ __exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler"),
 __exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler"), exports);
 __exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler"), exports);
 __exportStar(require("./evm/wallet/EVMSigner"), exports);
+__exportStar(require("./evm/wallet/EVMBrowserSigner"), exports);
 __exportStar(require("./chains/citrea/CitreaInitializer"), exports);
 __exportStar(require("./chains/citrea/CitreaChainType"), exports);
 __exportStar(require("./chains/citrea/CitreaFees"), exports);

package/dist/utils/Utils.d.ts

@@ -13,3 +13,4 @@ export declare function tryWithRetries<T>(func: () => Promise<T>, retryPolicy?:
     exponential?: boolean;
 }, errorAllowed?: (e: any) => boolean, abortSignal?: AbortSignal): Promise<T>;
 export declare function uint32ReverseEndianness(value: number): number;
+export declare function bigIntMax(a: bigint, b: bigint): bigint;

package/dist/utils/Utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uint32ReverseEndianness = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
+exports.bigIntMax = exports.uint32ReverseEndianness = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
 function timeoutPromise(timeoutMillis, abortSignal) {
     return new Promise((resolve, reject) => {
         const timeout = setTimeout(resolve, timeoutMillis);
@@ -69,3 +69,7 @@ function uint32ReverseEndianness(value) {
         ((valueBN >> 24n) & 0xffn));
 }
 exports.uint32ReverseEndianness = uint32ReverseEndianness;
+function bigIntMax(a, b) {
+    return a > b ? a : b;
+}
+exports.bigIntMax = bigIntMax;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.65",
+  "version": "1.0.0-dev.67",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/evm/chain/modules/EVMFees.ts

@@ -50,7 +50,7 @@ export class EVMFees {
     }
 
     /**
-     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
      *
      * @private
      */

package/src/evm/chain/modules/EVMTransactions.ts

@@ -1,5 +1,5 @@
 import {EVMModule} from "../EVMModule";
-import {Transaction, TransactionRequest} from "ethers";
+import {Transaction, TransactionRequest, TransactionResponse} from "ethers";
 import {timeoutPromise} from "../../../utils/Utils";
 import {EVMSigner} from "../../wallet/EVMSigner";
 
@@ -23,32 +23,45 @@ const MAX_UNCONFIRMED_TXNS = 10;
 export class EVMTransactions extends EVMModule<any> {
 
     private readonly latestConfirmedNonces: {[address: string]: number} = {};
+    private readonly latestPendingNonces: {[address: string]: number} = {};
+    private readonly latestSignedNonces: {[address: string]: number} = {};
 
-    private cbkBeforeTxSigned: (tx: TransactionRequest) => Promise<void>;
+    readonly _cbksBeforeTxReplace: ((oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>)[] = [];
+    private readonly cbksBeforeTxSigned: ((tx: TransactionRequest) => Promise<void>)[] = [];
     private cbkSendTransaction: (tx: string) => Promise<string>;
 
+    readonly _knownTxSet: Set<string> = new Set();
+
     /**
-     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
-     *  the transaction at regular interval
+     * Waits for transaction confirmation using HTTP polling
      *
      * @param tx EVM transaction to wait for confirmation for
      * @param abortSignal signal to abort waiting for tx confirmation
      * @private
      */
-    private async confirmTransaction(tx: {nonce: number, from: string, hash: string}, abortSignal?: AbortSignal) {
+    private async confirmTransaction(tx: TransactionResponse | Transaction, abortSignal?: AbortSignal) {
+        const checkTxns: Set<string> = new Set([tx.hash]);
+
+        const txReplaceListener = (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => {
+            if(checkTxns.has(oldTxId)) checkTxns.add(newTxId);
+            return Promise.resolve();
+        };
+        this.onBeforeTxReplace(txReplaceListener);
+
         let state = "pending";
         while(state==="pending" || state==="not_found") {
             await timeoutPromise(3000, abortSignal);
-            state = await this.getTxIdStatus(tx.hash);
-            //Don't re-send transactions
-            // if(state==="not_found") await this.sendSignedTransaction(tx).catch(e => {
-            //     if(e.baseError?.code === 59) return; //Transaction already in the mempool
-            //     this.logger.error("confirmTransaction(): Error on transaction re-send: ", e);
-            // });
+            for(let txId of checkTxns) {
+                state = await this.getTxIdStatus(txId);
+                if(state==="reverted" || state==="success") break;
+            }
         }
+
+        this.offBeforeTxReplace(txReplaceListener);
+
         const nextAccountNonce = tx.nonce + 1;
-        const currentNonce = this.latestConfirmedNonces[tx.from];
-        if(currentNonce==null || nextAccountNonce > currentNonce) {
+        const currentConfirmedNonce = this.latestConfirmedNonces[tx.from];
+        if(currentConfirmedNonce==null || nextAccountNonce > currentConfirmedNonce) {
             this.latestConfirmedNonces[tx.from] = nextAccountNonce;
         }
         if(state==="reverted") throw new Error("Transaction reverted!");
@@ -62,26 +75,35 @@ export class EVMTransactions extends EVMModule<any> {
      * @private
      */
     private async prepareTransactions(signer: EVMSigner, txs: TransactionRequest[]): Promise<void> {
-        let nonce: number = (await signer.getNonce()) ?? await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
-        const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
-        if(latestConfirmedNonce!=null && latestConfirmedNonce > nonce) {
-            this.logger.debug("prepareTransactions(): Using nonce from local cache!");
-            nonce = latestConfirmedNonce;
-        }
-
-        for(let i=0;i<txs.length;i++) {
-            const tx = txs[i];
+        for(let tx of txs) {
             tx.chainId = this.root.evmChainId;
             tx.from = signer.getAddress();
-            if(tx.nonce!=null) nonce = tx.nonce; //Take the nonce from last tx
-            if(nonce==null) nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
-            if(tx.nonce==null) tx.nonce = nonce;
+        }
 
-            this.logger.debug("sendAndConfirm(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.nonce);
+        if(!signer.isManagingNoncesInternally) {
+            let nonce: number = await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
+            const latestKnownNonce = this.latestPendingNonces[signer.getAddress()];
+            if(latestKnownNonce!=null && latestKnownNonce > nonce) {
+                this.logger.debug("prepareTransactions(): Using nonce from local cache!");
+                nonce = latestKnownNonce;
+            }
 
-            nonce++;
+            for(let i=0;i<txs.length;i++) {
+                const tx = txs[i];
+                if(tx.nonce!=null) nonce = tx.nonce; //Take the nonce from last tx
+                if(nonce==null) nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
+                if(tx.nonce==null) tx.nonce = nonce;
+
+                this.logger.debug("sendAndConfirm(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.nonce);
+
+                nonce++;
+            }
+        }
 
-            if(this.cbkBeforeTxSigned!=null) await this.cbkBeforeTxSigned(tx);
+        for(let tx of txs) {
+            for(let callback of this.cbksBeforeTxSigned) {
+                await callback(tx);
+            }
         }
     }
 
@@ -130,11 +152,17 @@ export class EVMTransactions extends EVMModule<any> {
         const signedTxs: Transaction[] = [];
 
         //Don't separate the signing process from the sending when using browser-based wallet
-        if(!signer.isBrowserWallet) for(let i=0;i<txs.length;i++) {
+        if(signer.signTransaction!=null) for(let i=0;i<txs.length;i++) {
             const tx = txs[i];
-            const signedTx = Transaction.from(await signer.account.signTransaction(tx));
+            const signedTx = Transaction.from(await signer.signTransaction(tx));
             signedTxs.push(signedTx);
             this.logger.debug("sendAndConfirm(): transaction signed ("+(i+1)+"/"+txs.length+"): "+signedTx);
+
+            const nextAccountNonce = signedTx.nonce + 1;
+            const currentSignedNonce = this.latestSignedNonces[signedTx.from];
+            if(currentSignedNonce==null || nextAccountNonce > currentSignedNonce) {
+                this.latestSignedNonces[signedTx.from] = nextAccountNonce;
+            }
         }
 
         this.logger.debug("sendAndConfirm(): sending transactions, count: "+txs.length+
@@ -144,14 +172,21 @@ export class EVMTransactions extends EVMModule<any> {
         if(parallel) {
             let promises: Promise<void>[] = [];
             for(let i=0;i<txs.length;i++) {
-                let tx: {nonce: number, from: string, hash: string};
-                if(signer.isBrowserWallet) {
-                    tx = await signer.account.sendTransaction(txs[i]);
+                let tx: TransactionResponse | Transaction;
+                if(signer.signTransaction==null) {
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
                 } else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);
                     tx = signedTx;
                 }
+
+                const nextAccountNonce = tx.nonce + 1;
+                const currentPendingNonce = this.latestPendingNonces[tx.from];
+                if(currentPendingNonce==null || nextAccountNonce > currentPendingNonce) {
+                    this.latestPendingNonces[tx.from] = nextAccountNonce;
+                }
+
                 if(waitForConfirmation) promises.push(this.confirmTransaction(tx, abortSignal));
                 txIds.push(tx.hash);
                 this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+signedTxs.length+"): "+tx.hash);
@@ -163,14 +198,21 @@ export class EVMTransactions extends EVMModule<any> {
             if(promises.length>0) await Promise.all(promises);
         } else {
             for(let i=0;i<txs.length;i++) {
-                let tx: {nonce: number, from: string, hash: string};
-                if(signer.isBrowserWallet) {
-                    tx = await signer.account.sendTransaction(txs[i]);
+                let tx: TransactionResponse | Transaction;
+                if(signer.signTransaction==null) {
+                    tx = await signer.sendTransaction(txs[i], onBeforePublish);
                 } else {
                     const signedTx = signedTxs[i];
                     await this.sendSignedTransaction(signedTx, onBeforePublish);
                     tx = signedTx;
                 }
+
+                const nextAccountNonce = tx.nonce + 1;
+                const currentPendingNonce = this.latestPendingNonces[tx.from];
+                if(currentPendingNonce==null || nextAccountNonce > currentPendingNonce) {
+                    this.latestPendingNonces[tx.from] = nextAccountNonce;
+                }
+
                 const confirmPromise = this.confirmTransaction(tx, abortSignal);
                 this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+txs.length+"): "+tx.hash);
                 //Don't await the last promise when !waitForConfirmation
@@ -214,13 +256,13 @@ export class EVMTransactions extends EVMModule<any> {
     }
 
     /**
-     * Gets the status of the starknet transaction with a specific txId
+     * Gets the status of the EVM transaction with a specific txId
      *
      * @param txId
      */
     public async getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
         const txResponse = await this.provider.getTransaction(txId);
-        if(txResponse==null) return "not_found";
+        if(txResponse==null) return this._knownTxSet.has(txId) ? "pending" : "not_found";
         if(txResponse.blockHash==null) return "pending";
 
         const [safeBlockNumber, txReceipt] = await Promise.all([
@@ -234,11 +276,13 @@ export class EVMTransactions extends EVMModule<any> {
     }
 
     public onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void {
-        this.cbkBeforeTxSigned = callback;
+        this.cbksBeforeTxSigned.push(callback);
     }
 
     public offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean {
-        this.cbkBeforeTxSigned = null;
+        const index = this.cbksBeforeTxSigned.indexOf(callback);
+        if(index===-1) return false;
+        this.cbksBeforeTxSigned.splice(index, 1);
         return true;
     }
 
@@ -251,6 +295,17 @@ export class EVMTransactions extends EVMModule<any> {
         return true;
     }
 
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void {
+        this._cbksBeforeTxReplace.push(callback);
+    }
+
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean {
+        const index = this._cbksBeforeTxReplace.indexOf(callback);
+        if(index===-1) return false;
+        this._cbksBeforeTxReplace.splice(index, 1);
+        return true;
+    }
+
     public traceTransaction(txId: string): Promise<EVMTxTrace> {
         return this.provider.send("debug_traceTransaction", [
             txId,

package/src/evm/wallet/EVMBrowserSigner.ts

@@ -0,0 +1,12 @@
+import {Signer} from "ethers";
+import {EVMSigner} from "./EVMSigner";
+
+
+export class EVMBrowserSigner extends EVMSigner {
+
+    constructor(account: Signer, address: string) {
+        super(account, address, false);
+        this.signTransaction = null;
+    }
+
+}

package/src/evm/wallet/EVMPersistentSigner.ts

@@ -0,0 +1,276 @@
+import * as fs from "fs/promises";
+import {
+    Signer,
+    Transaction,
+    TransactionRequest,
+    TransactionResponse
+} from "ethers";
+import {bigIntMax, getLogger, LoggerType} from "../../utils/Utils";
+import {EVMBlockTag} from "../chain/modules/EVMBlocks";
+import {EVMChainInterface} from "../chain/EVMChainInterface";
+import {EVMFees} from "../chain/modules/EVMFees";
+import {EVMSigner} from "./EVMSigner";
+
+const WAIT_BEFORE_BUMP = 15*1000;
+const MIN_FEE_INCREASE_ABSOLUTE = 1n*1_000_000_000n; //1GWei
+const MIN_FEE_INCREASE_PPM = 100_000n; // +10%
+
+export class EVMPersistentSigner extends EVMSigner {
+
+    readonly safeBlockTag: EVMBlockTag;
+
+    private pendingTxs: Map<number, {
+        txs: Transaction[],
+        lastBumped: number
+    }> = new Map();
+
+    private confirmedNonce: number;
+    private pendingNonce: number;
+
+    private feeBumper: any;
+    private stopped: boolean = false;
+
+    private readonly directory: string;
+
+    private readonly waitBeforeBump: number;
+    private readonly minFeeIncreaseAbsolute: bigint;
+    private readonly minFeeIncreasePpm: bigint;
+
+    private readonly chainInterface: EVMChainInterface;
+
+    private readonly logger: LoggerType;
+
+    constructor(
+        account: Signer,
+        address: string,
+        chainInterface: EVMChainInterface,
+        directory: string,
+        minFeeIncreaseAbsolute?: bigint,
+        minFeeIncreasePpm?: bigint,
+        waitBeforeBumpMillis?: number
+    ) {
+        super(account, address, true);
+        this.signTransaction = null;
+        this.chainInterface = chainInterface;
+        this.directory = directory;
+        this.minFeeIncreaseAbsolute = minFeeIncreaseAbsolute ?? MIN_FEE_INCREASE_ABSOLUTE;
+        this.minFeeIncreasePpm = minFeeIncreasePpm ?? MIN_FEE_INCREASE_PPM;
+        this.waitBeforeBump = waitBeforeBumpMillis ?? WAIT_BEFORE_BUMP;
+        this.safeBlockTag = chainInterface.config.safeBlockTag;
+        this.logger = getLogger("EVMPersistentSigner("+address+"): ");
+    }
+
+    private async load() {
+        const fileExists = await fs.access(this.directory+"/txs.json", fs.constants.F_OK).then(() => true).catch(() => false);
+        if(!fileExists) return;
+        const res = await fs.readFile(this.directory+"/txs.json");
+        if(res!=null) {
+            const pendingTxs: {
+                [nonce: string]: {
+                    txs: string[],
+                    lastBumped: number
+                }
+            } = JSON.parse((res as Buffer).toString());
+
+            for(let nonceStr in pendingTxs) {
+                const nonceData = pendingTxs[nonceStr];
+
+                const nonce = parseInt(nonceStr);
+                if(this.confirmedNonce>=nonce) continue; //Already confirmed
+
+                if(this.pendingNonce<nonce) {
+                    this.pendingNonce = nonce;
+                }
+                const parsedPendingTxns = nonceData.txs.map(Transaction.from);
+                this.pendingTxs.set(nonce, {
+                    txs: parsedPendingTxns,
+                    lastBumped: nonceData.lastBumped
+                })
+                for(let tx of parsedPendingTxns) {
+                    this.chainInterface.Transactions._knownTxSet.add(tx.hash);
+                }
+            }
+        }
+    }
+
+    private priorSavePromise: Promise<void>;
+    private saveCount: number = 0;
+
+    private async save() {
+        const pendingTxs: {
+            [nonce: string]: {
+                txs: string[],
+                lastBumped: number
+            }
+        } = {};
+        for(let [nonce, data] of this.pendingTxs) {
+            pendingTxs[nonce.toString(10)] = {
+                lastBumped: data.lastBumped,
+                txs: data.txs.map(tx => tx.serialized)
+            };
+        }
+        const requiredSaveCount = ++this.saveCount;
+        if(this.priorSavePromise!=null) {
+            await this.priorSavePromise;
+        }
+        if(requiredSaveCount===this.saveCount) {
+            this.priorSavePromise = fs.writeFile(this.directory+"/txs.json", JSON.stringify(pendingTxs));
+            await this.priorSavePromise;
+        }
+    }
+
+    private async checkPastTransactions() {
+        let _gasPrice: {
+            baseFee: bigint,
+            priorityFee: bigint
+        } = null;
+        let _safeBlockTxCount: number = null;
+
+        for(let [nonce, data] of this.pendingTxs) {
+            if(data.lastBumped<Date.now()-this.waitBeforeBump) {
+                _safeBlockTxCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+                this.confirmedNonce = _safeBlockTxCount;
+                if(_safeBlockTxCount > nonce) {
+                    this.pendingTxs.delete(nonce);
+                    data.txs.forEach(tx => this.chainInterface.Transactions._knownTxSet.delete(tx.hash));
+                    this.logger.info("checkPastTransactions(): Tx confirmed, required fee bumps: ", data.txs.length);
+                    this.save();
+                    continue;
+                }
+
+                const lastTx = data.txs[data.txs.length-1];
+                if(_gasPrice==null) {
+                    const feeRate = await this.chainInterface.Fees.getFeeRate();
+                    const [baseFee, priorityFee] = feeRate.split(",");
+                    _gasPrice = {
+                        baseFee: BigInt(baseFee),
+                        priorityFee: BigInt(priorityFee)
+                    };
+                }
+
+                let priorityFee = lastTx.maxPriorityFeePerGas;
+                let baseFee = lastTx.maxFeePerGas - lastTx.maxPriorityFeePerGas;
+
+                baseFee = bigIntMax(_gasPrice.baseFee, this.minFeeIncreaseAbsolute + (baseFee * (1_000_000n + this.minFeeIncreasePpm) / 1_000_000n));
+                priorityFee = bigIntMax(_gasPrice.priorityFee, this.minFeeIncreaseAbsolute + (priorityFee * (1_000_000n + this.minFeeIncreasePpm) / 1_000_000n));
+
+                if(
+                    baseFee > (this.minFeeIncreaseAbsolute + (_gasPrice.baseFee * (1_000_000n + this.minFeeIncreasePpm) / 1_000_000n)) &&
+                    priorityFee > (this.minFeeIncreaseAbsolute + (_gasPrice.priorityFee * (1_000_000n + this.minFeeIncreasePpm) / 1_000_000n))
+                ) {
+                    //Too big of an increase over the current fee rate, don't fee bump
+                    this.logger.debug("checkPastTransactions(): Tx yet unconfirmed but not increasing fee for ", lastTx.hash);
+                    await this.chainInterface.provider.broadcastTransaction(lastTx.serialized).catch(e => this.logger.error("checkPastTransactions(): Tx re-broadcast error", e));
+                    continue;
+                }
+
+                let newTx = lastTx.clone();
+                EVMFees.applyFeeRate(newTx, null, baseFee.toString(10)+","+priorityFee.toString(10));
+                this.logger.info("checkPastTransactions(): Bump fee for tx: ", lastTx.hash);
+
+                newTx.signature = null;
+                const signedRawTx = await this.account.signTransaction(newTx);
+
+                //Double check pending txns still has nonce after async signTransaction was called
+                if(!this.pendingTxs.has(nonce)) continue;
+
+                newTx = Transaction.from(signedRawTx);
+
+                for(let callback of this.chainInterface.Transactions._cbksBeforeTxReplace) {
+                    try {
+                        await callback(lastTx.hash, lastTx.serialized, newTx.hash, signedRawTx)
+                    } catch (e) {
+                        this.logger.error("checkPastTransactions(): beforeTxReplace callback error: ", e);
+                    }
+                }
+
+                data.txs.push(newTx);
+                data.lastBumped = Date.now();
+                this.save();
+
+                this.chainInterface.Transactions._knownTxSet.add(newTx.hash);
+
+                //TODO: Better error handling when sending tx
+                await this.chainInterface.provider.broadcastTransaction(signedRawTx).catch(e => this.logger.error("checkPastTransactions(): Fee-bumped tx broadcast error", e));
+            }
+        }
+    }
+
+    private startFeeBumper() {
+        let func: () => Promise<void>;
+        func = async () => {
+            try {
+                await this.checkPastTransactions();
+            } catch (e) {
+                this.logger.error("startFeeBumper(): Error when check past transactions: ", e);
+            }
+
+            if(this.stopped) return;
+
+            this.feeBumper = setTimeout(func, 1000);
+        };
+        func();
+    }
+
+    async init(): Promise<void> {
+        try {
+            await fs.mkdir(this.directory)
+        } catch (e) {}
+
+        const txCount = await this.chainInterface.provider.getTransactionCount(this.address, this.safeBlockTag);
+        this.confirmedNonce = txCount-1;
+        this.pendingNonce = txCount-1;
+
+        await this.load();
+
+        this.startFeeBumper();
+    }
+
+    stop(): Promise<void> {
+        this.stopped = true;
+        if(this.feeBumper!=null) {
+            clearTimeout(this.feeBumper);
+            this.feeBumper = null;
+        }
+        return Promise.resolve();
+    }
+
+    async sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse> {
+        if(transaction.nonce!=null) {
+            if(transaction.nonce !== this.pendingNonce + 1)
+                throw new Error("Invalid transaction nonce!");
+            this.pendingNonce++;
+        } else {
+            this.pendingNonce++;
+            transaction.nonce = this.pendingNonce;
+        }
+
+        const tx: TransactionRequest = {};
+        for(let key in transaction) {
+            if(transaction[key] instanceof Promise) {
+                tx[key] = await transaction[key];
+            } else {
+                tx[key] = transaction[key];
+            }
+        }
+
+        const signedRawTx = await this.account.signTransaction(tx);
+        const signedTx = Transaction.from(signedRawTx);
+
+        if(onBeforePublish!=null) {
+            try {
+                await onBeforePublish(signedTx.hash, signedRawTx);
+            } catch (e) {
+                this.logger.error("sendTransaction(): Error when calling onBeforePublish function: ", e);
+            }
+        }
+
+        this.pendingTxs.set(transaction.nonce, {txs: [signedTx], lastBumped: Date.now()});
+        this.save();
+
+        this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
+
+        return await this.chainInterface.provider.broadcastTransaction(signedRawTx);
+    }
+
+}

package/src/evm/wallet/EVMSigner.ts

@@ -1,25 +1,31 @@
 import {AbstractSigner} from "@atomiqlabs/base";
-import {Signer} from "ethers";
+import {Signer, Transaction, TransactionRequest, TransactionResponse} from "ethers";
 
 
 export class EVMSigner implements AbstractSigner {
 
     account: Signer;
     public readonly address: string;
-    public readonly isBrowserWallet: boolean;
+    public readonly isManagingNoncesInternally: boolean;
 
-    constructor(account: Signer, address: string, isBrowserWallet: boolean = false) {
+    constructor(account: Signer, address: string, isManagingNoncesInternally: boolean = false) {
         this.account = account;
         this.address = address;
-        this.isBrowserWallet = isBrowserWallet;
-    }
-
-    getNonce(): Promise<number> {
-        return Promise.resolve(null);
+        this.isManagingNoncesInternally = isManagingNoncesInternally;
     }
 
     getAddress(): string {
         return this.address;
     }
 
+    async signTransaction?(transaction: TransactionRequest): Promise<string> {
+        return this.account.signTransaction(transaction);
+    }
+
+    async sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse> {
+        const txResponse = await this.account.sendTransaction(transaction);
+        if(onBeforePublish!=null) await onBeforePublish(txResponse.hash, Transaction.from(txResponse).serialized);
+        return txResponse;
+    }
+
 }

package/src/index.ts

@@ -39,6 +39,7 @@ export * from "./evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler";
 export * from "./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler";
 
 export * from "./evm/wallet/EVMSigner";
+export * from "./evm/wallet/EVMBrowserSigner";
 
 export * from "./chains/citrea/CitreaInitializer";
 export * from "./chains/citrea/CitreaChainType";

package/src/utils/Utils.ts

@@ -79,3 +79,7 @@ export function uint32ReverseEndianness(value: number): number {
         ((valueBN >> 8n) & 0xFF00n) |
         ((valueBN >> 24n) & 0xFFn));
 }
+
+export function bigIntMax(a: bigint, b: bigint) {
+    return a>b ? a : b;
+}