@atomiqlabs/chain-evm 1.0.0-dev.100

package/dist/evm/swaps/modules/EVMSwapRefund.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSwapRefund = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const EVMSwapModule_1 = require("../EVMSwapModule");
+const EVMFees_1 = require("../../chain/modules/EVMFees");
+const Refund = [
+    { name: "swapHash", type: "bytes32" },
+    { name: "timeout", type: "uint256" }
+];
+class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param handlerGas
+     * @private
+     */
+    async Refund(signer, swapData, witness, feeRate, handlerGas) {
+        const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
+        tx.from = signer;
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData) + (handlerGas ?? 0), feeRate);
+        return tx;
+    }
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @param feeRate
+     * @private
+     */
+    async RefundWithSignature(sender, swapData, timeout, signature, feeRate) {
+        const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
+        tx.from = sender;
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData), feeRate);
+        return tx;
+    }
+    async signSwapRefund(signer, swapData, authorizationTimeout) {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(this.contract.contractAddress, signer, Refund, "Refund", {
+            "swapHash": "0x" + swapData.getEscrowHash(),
+            "timeout": BigInt(authTimeout)
+        });
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+    async isSignatureValid(swapData, timeout, prefix, signature) {
+        if (prefix !== "refund")
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(this.contract.contractAddress, signature, swapData.claimer, Refund, "Refund", {
+            "swapHash": "0x" + swapData.getEscrowHash(),
+            "timeout": BigInt(expiryTimestamp)
+        });
+        if (!valid) {
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        }
+        return null;
+    }
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    async txsRefund(signer, swapData, check, feeRate, witnessData) {
+        const refundHandler = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if (refundHandler == null)
+            throw new Error("Invalid refund handler");
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+        const tx = await this.Refund(signer, swapData, witness, feeRate, refundHandler.getGas(swapData));
+        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
+        return [...initialTxns, tx];
+    }
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.contract.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const tx = await this.RefundWithSignature(signer, swapData, timeout, signature, feeRate);
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [tx];
+    }
+    getRefundGas(swapData) {
+        let totalGas = EVMSwapRefund.GasCosts.BASE;
+        if (swapData.reputation)
+            totalGas += EVMSwapRefund.GasCosts.REPUTATION;
+        if (swapData.isPayIn()) {
+            if (swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        else {
+            totalGas += EVMSwapRefund.GasCosts.LP_VAULT_TRANSFER;
+        }
+        if (swapData.getSecurityDeposit() > 0n) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        if (swapData.getClaimerBounty() > swapData.getSecurityDeposit()) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        return totalGas;
+    }
+    /**
+     * Get the estimated transaction fee of the refund transaction
+     */
+    async getRefundFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(this.getRefundGas(swapData), feeRate);
+    }
+}
+exports.EVMSwapRefund = EVMSwapRefund;
+EVMSwapRefund.GasCosts = {
+    BASE: 35000 + 21000,
+    ERC20_TRANSFER: 40000,
+    NATIVE_TRANSFER: 35500,
+    LP_VAULT_TRANSFER: 10000,
+    REPUTATION: 25000
+};

package/dist/evm/typechain/common.d.ts

@@ -0,0 +1,50 @@
+import type { FunctionFragment, Typed, EventFragment, ContractTransaction, ContractTransactionResponse, DeferredTopicFilter, EventLog, TransactionRequest, LogDescription } from "ethers";
+export interface TypedDeferredTopicFilter<_TCEvent extends TypedContractEvent> extends DeferredTopicFilter {
+}
+export interface TypedContractEvent<InputTuple extends Array<any> = any, OutputTuple extends Array<any> = any, OutputObject = any> {
+    (...args: Partial<InputTuple>): TypedDeferredTopicFilter<TypedContractEvent<InputTuple, OutputTuple, OutputObject>>;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: Partial<InputTuple>): EventFragment;
+}
+type __TypechainAOutputTuple<T> = T extends TypedContractEvent<infer _U, infer W> ? W : never;
+type __TypechainOutputObject<T> = T extends TypedContractEvent<infer _U, infer _W, infer V> ? V : never;
+export interface TypedEventLog<TCEvent extends TypedContractEvent> extends Omit<EventLog, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export interface TypedLogDescription<TCEvent extends TypedContractEvent> extends Omit<LogDescription, "args"> {
+    args: __TypechainAOutputTuple<TCEvent> & __TypechainOutputObject<TCEvent>;
+}
+export type TypedListener<TCEvent extends TypedContractEvent> = (...listenerArg: [
+    ...__TypechainAOutputTuple<TCEvent>,
+    TypedEventLog<TCEvent>,
+    ...undefined[]
+]) => void;
+export type MinEthersFactory<C, ARGS> = {
+    deploy(...a: ARGS[]): Promise<C>;
+};
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export type StateMutability = "nonpayable" | "payable" | "view";
+export type BaseOverrides = Omit<TransactionRequest, "to" | "data">;
+export type NonPayableOverrides = Omit<BaseOverrides, "value" | "blockTag" | "enableCcipRead">;
+export type PayableOverrides = Omit<BaseOverrides, "blockTag" | "enableCcipRead">;
+export type ViewOverrides = Omit<TransactionRequest, "to" | "data">;
+export type Overrides<S extends StateMutability> = S extends "nonpayable" ? NonPayableOverrides : S extends "payable" ? PayableOverrides : ViewOverrides;
+export type PostfixOverrides<A extends Array<any>, S extends StateMutability> = A | [...A, Overrides<S>];
+export type ContractMethodArgs<A extends Array<any>, S extends StateMutability> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}, S>;
+export type DefaultReturnType<R> = R extends Array<any> ? R[0] : R;
+export interface TypedContractMethod<A extends Array<any> = Array<any>, R = any, S extends StateMutability = "payable"> {
+    (...args: ContractMethodArgs<A, S>): S extends "view" ? Promise<DefaultReturnType<R>> : Promise<ContractTransactionResponse>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A, S>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A, S>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A, "view">): Promise<DefaultReturnType<R>>;
+    send(...args: ContractMethodArgs<A, S>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A, S>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A, "view">): Promise<R>;
+}
+export {};

package/dist/evm/typechain/common.js

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

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,29 @@
+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>;
+    private readonly sendTransactionQueue;
+    sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;
+}

package/dist/evm/wallet/EVMPersistentSigner.js

@@ -0,0 +1,230 @@
+"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 promise_queue_ts_1 = require("promise-queue-ts");
+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.sendTransactionQueue = new promise_queue_ts_1.PromiseQueue();
+        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.sending && 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 => {
+                        if (e.code === "NONCE_EXPIRED") {
+                            this.logger.debug("checkPastTransactions(): Tx re-broadcast success, tx already confirmed: ", lastTx.hash);
+                            return;
+                        }
+                        if (e.error?.message === "already known") {
+                            this.logger.debug("checkPastTransactions(): Tx re-broadcast success, tx already known to the RPC: ", lastTx.hash);
+                            return;
+                        }
+                        this.logger.error("checkPastTransactions(): Tx re-broadcast error", e);
+                    });
+                    data.lastBumped = Date.now();
+                    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.serialized, lastTx.hash, signedRawTx, newTx.hash);
+                    }
+                    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 => {
+                    if (e.code === "NONCE_EXPIRED")
+                        return;
+                    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();
+    }
+    sendTransaction(transaction, onBeforePublish) {
+        return this.sendTransactionQueue.enqueue(async () => {
+            if (transaction.nonce != null) {
+                if (transaction.nonce !== this.pendingNonce + 1)
+                    throw new Error("Invalid transaction nonce!");
+            }
+            else {
+                transaction.nonce = this.pendingNonce + 1;
+            }
+            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);
+                }
+            }
+            const pendingTxObject = { txs: [signedTx], lastBumped: Date.now(), sending: true };
+            this.pendingNonce++;
+            this.logger.debug("sendTransaction(): Incrementing pending nonce to: ", this.pendingNonce);
+            this.pendingTxs.set(transaction.nonce, pendingTxObject);
+            this.save();
+            this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
+            try {
+                const result = await this.chainInterface.provider.broadcastTransaction(signedRawTx);
+                pendingTxObject.sending = false;
+                return result;
+            }
+            catch (e) {
+                this.chainInterface.Transactions._knownTxSet.delete(signedTx.hash);
+                this.pendingTxs.delete(transaction.nonce);
+                this.pendingNonce--;
+                this.logger.debug("sendTransaction(): Error when broadcasting transaction, reverting pending nonce to: ", this.pendingNonce);
+                throw e;
+            }
+        });
+    }
+}
+exports.EVMPersistentSigner = EVMPersistentSigner;

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

@@ -0,0 +1,12 @@
+import { AbstractSigner } from "@atomiqlabs/base";
+import { Signer, TransactionRequest, TransactionResponse } from "ethers";
+export declare class EVMSigner implements AbstractSigner {
+    type: "AtomiqAbstractSigner";
+    account: Signer;
+    readonly address: string;
+    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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSigner = void 0;
+const ethers_1 = require("ethers");
+class EVMSigner {
+    constructor(account, address, isManagingNoncesInternally = false) {
+        this.type = "AtomiqAbstractSigner";
+        this.account = account;
+        this.address = address;
+        this.isManagingNoncesInternally = isManagingNoncesInternally;
+    }
+    getAddress() {
+        return (0, ethers_1.getAddress)(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,
+                chainId: transaction.chainId
+            }).serialized);
+        return txResponse;
+    }
+}
+exports.EVMSigner = EVMSigner;

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+export * from "./evm/btcrelay/headers/EVMBtcHeader";
+export * from "./evm/btcrelay/headers/EVMBtcStoredHeader";
+export * from "./evm/btcrelay/EVMBtcRelay";
+export * from "./evm/chain/EVMChainInterface";
+export * from "./evm/chain/EVMModule";
+export * from "./evm/chain/modules/EVMAddresses";
+export * from "./evm/chain/modules/EVMBlocks";
+export * from "./evm/chain/modules/EVMEvents";
+export * from "./evm/chain/modules/EVMFees";
+export * from "./evm/chain/modules/EVMSignatures";
+export * from "./evm/chain/modules/EVMTokens";
+export * from "./evm/chain/modules/EVMTransactions";
+export * from "./evm/contract/modules/EVMContractEvents";
+export * from "./evm/contract/EVMContractBase";
+export * from "./evm/contract/EVMContractModule";
+export * from "./evm/events/EVMChainEventsBrowser";
+export * from "./evm/spv_swap/EVMSpvVaultContract";
+export * from "./evm/spv_swap/EVMSpvWithdrawalData";
+export * from "./evm/spv_swap/EVMSpvVaultData";
+export * from "./evm/swaps/EVMSwapContract";
+export * from "./evm/swaps/EVMSwapData";
+export * from "./evm/swaps/EVMSwapModule";
+export * from "./evm/swaps/modules/EVMLpVault";
+export * from "./evm/swaps/modules/EVMSwapInit";
+export * from "./evm/swaps/modules/EVMSwapClaim";
+export * from "./evm/swaps/modules/EVMSwapRefund";
+export * from "./evm/swaps/handlers/IHandler";
+export * from "./evm/swaps/handlers/refund/TimelockRefundHandler";
+export * from "./evm/swaps/handlers/claim/ClaimHandlers";
+export * from "./evm/swaps/handlers/claim/HashlockClaimHandler";
+export * from "./evm/swaps/handlers/claim/btc/IBitcoinClaimHandler";
+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";
+export * from "./chains/botanix/BotanixInitializer";
+export * from "./chains/botanix/BotanixChainType";
+export * from "./evm/providers/JsonRpcProviderWithRetries";
+export * from "./evm/providers/WebSocketProviderWithRetries";
+export * from "./evm/providers/ReconnectingWebSocketProvider";

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./evm/btcrelay/headers/EVMBtcHeader"), exports);
+__exportStar(require("./evm/btcrelay/headers/EVMBtcStoredHeader"), exports);
+__exportStar(require("./evm/btcrelay/EVMBtcRelay"), exports);
+__exportStar(require("./evm/chain/EVMChainInterface"), exports);
+__exportStar(require("./evm/chain/EVMModule"), exports);
+__exportStar(require("./evm/chain/modules/EVMAddresses"), exports);
+__exportStar(require("./evm/chain/modules/EVMBlocks"), exports);
+__exportStar(require("./evm/chain/modules/EVMEvents"), exports);
+__exportStar(require("./evm/chain/modules/EVMFees"), exports);
+__exportStar(require("./evm/chain/modules/EVMSignatures"), exports);
+__exportStar(require("./evm/chain/modules/EVMTokens"), exports);
+__exportStar(require("./evm/chain/modules/EVMTransactions"), exports);
+__exportStar(require("./evm/contract/modules/EVMContractEvents"), exports);
+__exportStar(require("./evm/contract/EVMContractBase"), exports);
+__exportStar(require("./evm/contract/EVMContractModule"), exports);
+__exportStar(require("./evm/events/EVMChainEventsBrowser"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvVaultContract"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvWithdrawalData"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvVaultData"), exports);
+__exportStar(require("./evm/swaps/EVMSwapContract"), exports);
+__exportStar(require("./evm/swaps/EVMSwapData"), exports);
+__exportStar(require("./evm/swaps/EVMSwapModule"), exports);
+__exportStar(require("./evm/swaps/modules/EVMLpVault"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapInit"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapClaim"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapRefund"), exports);
+__exportStar(require("./evm/swaps/handlers/IHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/refund/TimelockRefundHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/ClaimHandlers"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/HashlockClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/IBitcoinClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler"), exports);
+__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);
+__exportStar(require("./chains/botanix/BotanixInitializer"), exports);
+__exportStar(require("./chains/botanix/BotanixChainType"), exports);
+__exportStar(require("./evm/providers/JsonRpcProviderWithRetries"), exports);
+__exportStar(require("./evm/providers/WebSocketProviderWithRetries"), exports);
+__exportStar(require("./evm/providers/ReconnectingWebSocketProvider"), exports);