@atomiqlabs/chain-evm 1.0.0-dev.74 → 1.0.0-dev.76

package/dist/evm/btcrelay/EVMBtcRelay.js

@@ -9,6 +9,7 @@ const EVMBtcStoredHeader_1 = require("./headers/EVMBtcStoredHeader");
 const EVMFees_1 = require("../chain/modules/EVMFees");
 const BtcRelayAbi_1 = require("./BtcRelayAbi");
 const ethers_1 = require("ethers");
+const promise_cache_ts_1 = require("promise-cache-ts");
 function serializeBlockHeader(e) {
     return new EVMBtcHeader_1.EVMBtcHeader({
         version: e.getVersion(),
@@ -54,8 +55,8 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         this.maxHeadersPerTx = 100;
         this.maxForkHeadersPerTx = 50;
         this.maxShortForkHeadersPerTx = 100;
-        this.commitHashCache = new Map;
-        this.blockHashCache = new Map;
+        this.commitHashCache = new promise_cache_ts_1.PromiseLruCache(1000);
+        this.blockHashCache = new promise_cache_ts_1.PromiseLruCache(1000);
         this.bitcoinRpc = bitcoinRpc;
     }
     /**
@@ -153,28 +154,24 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
         return null;
     }
     getBlock(commitHash, blockHash) {
-        if (commitHash != null && this.commitHashCache.has(commitHash)) {
-            logger.debug("getBlock(): Returning block from commit hash cache: ", commitHash);
-            return Promise.resolve([this.commitHashCache.get(commitHash), commitHash]);
-        }
         const blockHashString = blockHash == null ? null : "0x" + Buffer.from([...blockHash]).reverse().toString("hex");
-        if (blockHashString != null && this.blockHashCache.has(blockHashString)) {
-            logger.debug("getBlock(): Returning block from block hash cache: ", blockHashString);
-            const storedBlockheader = this.blockHashCache.get(blockHashString);
-            return Promise.resolve([storedBlockheader, storedBlockheader.getCommitHash()]);
-        }
-        return this.Events.findInContractEvents(["StoreHeader", "StoreForkHeader"], [
+        const generator = () => this.Events.findInContractEvents(["StoreHeader", "StoreForkHeader"], [
             commitHash,
             blockHashString
         ], async (event) => {
             const txTrace = await this.Chain.Transactions.traceTransaction(event.transactionHash);
             const storedBlockheader = await this.findStoredBlockheaderInTraces(txTrace, event.args.commitHash);
-            if (storedBlockheader != null) {
-                this.commitHashCache.set(event.args.commitHash, storedBlockheader);
-                this.blockHashCache.set(event.args.blockHash, storedBlockheader);
-                return [storedBlockheader, event.args.commitHash];
-            }
+            if (storedBlockheader == null)
+                return null;
+            this.commitHashCache.set(event.args.commitHash, Promise.resolve([storedBlockheader, event.args.commitHash]));
+            this.blockHashCache.set(event.args.blockHash, Promise.resolve([storedBlockheader, event.args.commitHash]));
+            return [storedBlockheader, event.args.commitHash];
         });
+        if (commitHash != null)
+            return this.commitHashCache.getOrComputeAsync(commitHash, generator);
+        if (blockHashString != null)
+            return this.blockHashCache.getOrComputeAsync(blockHashString, generator);
+        return null;
     }
     async getBlockHeight() {
         return Number(await this.contract.getBlockheight());

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -12,6 +12,7 @@ const EVMAddresses_1 = require("../chain/modules/EVMAddresses");
 const EVMSpvVaultData_1 = require("./EVMSpvVaultData");
 const EVMSpvWithdrawalData_1 = require("./EVMSpvWithdrawalData");
 const EVMFees_1 = require("../chain/modules/EVMFees");
+const promise_cache_ts_1 = require("promise-cache-ts");
 function decodeUtxo(utxo) {
     const [txId, vout] = utxo.split(":");
     return {
@@ -34,7 +35,7 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         super(chainInterface, contractAddress, SpvVaultContractAbi_1.SpvVaultContractAbi, contractDeploymentHeight);
         this.claimTimeout = 180;
         this.logger = (0, Utils_1.getLogger)("EVMSpvVaultContract: ");
-        this.vaultParamsCache = new Map();
+        this.vaultParamsCache = new promise_cache_ts_1.PromiseLruCache(5000);
         this.btcRelay = btcRelay;
         this.bitcoinRpc = bitcoinRpc;
     }
@@ -126,8 +127,7 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
     }
     async getVaultData(owner, vaultId) {
         const vaultState = await this.contract.getVault(owner, vaultId);
-        let vaultParams = this.vaultParamsCache.get(vaultState.spvVaultParametersCommitment);
-        if (vaultParams == null) {
+        const vaultParams = await this.vaultParamsCache.getOrComputeAsync(vaultState.spvVaultParametersCommitment, async () => {
             const blockheight = Number(vaultState.openBlockheight);
             const events = await this.Events.getContractBlockEvents(["Opened"], [
                 "0x" + owner.substring(2).padStart(64, "0"),
@@ -136,9 +136,8 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             const foundEvent = events.find(event => (0, EVMSpvVaultData_1.getVaultParamsCommitment)(event.args.params) === vaultState.spvVaultParametersCommitment);
             if (foundEvent == null)
                 throw new Error("Valid open event not found!");
-            vaultParams = foundEvent.args.params;
-            this.vaultParamsCache.set(vaultState.spvVaultParametersCommitment, vaultParams);
-        }
+            return foundEvent.args.params;
+        });
         if (vaultParams.btcRelayContract.toLowerCase() !== this.btcRelay.contractAddress.toLowerCase())
             return null;
         return new EVMSpvVaultData_1.EVMSpvVaultData(owner, vaultId, vaultState, vaultParams);

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

@@ -24,5 +24,6 @@ export declare class EVMPersistentSigner extends EVMSigner {
     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

@@ -6,6 +6,7 @@ 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%
@@ -15,6 +16,7 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         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;
@@ -71,7 +73,7 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         let _gasPrice = null;
         let _safeBlockTxCount = null;
         for (let [nonce, data] of this.pendingTxs) {
-            if (data.lastBumped < Date.now() - this.waitBeforeBump) {
+            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) {
@@ -169,39 +171,52 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         }
         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];
+    sendTransaction(transaction, onBeforePublish) {
+        return this.sendTransactionQueue.enqueue(async () => {
+            if (transaction.nonce != null) {
+                if (transaction.nonce !== this.pendingNonce + 1)
+                    throw new Error("Invalid transaction nonce!");
+                this.pendingNonce++;
             }
             else {
-                tx[key] = transaction[key];
+                this.pendingNonce++;
+                transaction.nonce = this.pendingNonce;
             }
-        }
-        const signedRawTx = await this.account.signTransaction(tx);
-        const signedTx = ethers_1.Transaction.from(signedRawTx);
-        if (onBeforePublish != null) {
+            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.pendingTxs.set(transaction.nonce, pendingTxObject);
+            this.save();
+            this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
             try {
-                await onBeforePublish(signedTx.hash, signedRawTx);
+                const result = await this.chainInterface.provider.broadcastTransaction(signedRawTx);
+                pendingTxObject.sending = false;
+                return result;
             }
             catch (e) {
-                this.logger.error("sendTransaction(): Error when calling onBeforePublish function: ", e);
+                this.chainInterface.Transactions._knownTxSet.delete(signedTx.hash);
+                this.pendingTxs.delete(transaction.nonce);
+                this.pendingNonce--;
+                throw 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.74",
+  "version": "1.0.0-dev.76",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -26,7 +26,9 @@
     "@atomiqlabs/base": "^10.0.0-dev.10",
     "@noble/hashes": "^1.8.0",
     "@scure/btc-signer": "1.6.0",
-    "buffer": "6.0.3"
+    "buffer": "6.0.3",
+    "promise-cache-ts": "0.0.4",
+    "promise-queue-ts": "1.0.0"
   },
   "peerDependencies": {
     "ethers": "^6.15.0"

package/src/evm/btcrelay/EVMBtcRelay.ts

@@ -10,6 +10,7 @@ import {EVMFees} from "../chain/modules/EVMFees";
 import {EVMChainInterface} from "../chain/EVMChainInterface";
 import {BtcRelayAbi} from "./BtcRelayAbi";
 import {AbiCoder, hexlify} from "ethers";
+import {PromiseLruCache} from "promise-cache-ts";
 
 function serializeBlockHeader(e: BtcBlock): EVMBtcHeader {
     return new EVMBtcHeader({
@@ -191,22 +192,13 @@ export class EVMBtcRelay<B extends BtcBlock>
         return null;
     }
 
-    private commitHashCache: Map<string, EVMBtcStoredHeader> = new Map<string, EVMBtcStoredHeader>;
-    private blockHashCache: Map<string, EVMBtcStoredHeader> = new Map<string, EVMBtcStoredHeader>;
+    private commitHashCache: PromiseLruCache<string, [EVMBtcStoredHeader, string]> = new PromiseLruCache<string, [EVMBtcStoredHeader, string]>(1000);
+    private blockHashCache: PromiseLruCache<string, [EVMBtcStoredHeader, string]> = new PromiseLruCache<string, [EVMBtcStoredHeader, string]>(1000);
 
     private getBlock(commitHash?: string, blockHash?: Buffer): Promise<[EVMBtcStoredHeader, string] | null> {
-        if(commitHash!=null && this.commitHashCache.has(commitHash)) {
-            logger.debug("getBlock(): Returning block from commit hash cache: ", commitHash);
-            return Promise.resolve([this.commitHashCache.get(commitHash), commitHash]);
-        }
         const blockHashString = blockHash==null ? null : "0x"+Buffer.from([...blockHash]).reverse().toString("hex");
-        if(blockHashString!=null && this.blockHashCache.has(blockHashString)) {
-            logger.debug("getBlock(): Returning block from block hash cache: ", blockHashString);
-            const storedBlockheader = this.blockHashCache.get(blockHashString);
-            return Promise.resolve([storedBlockheader, storedBlockheader.getCommitHash()]);
-        }
 
-        return this.Events.findInContractEvents(
+        const generator = () => this.Events.findInContractEvents<[EVMBtcStoredHeader, string], "StoreHeader" | "StoreForkHeader">(
             ["StoreHeader", "StoreForkHeader"],
             [
                 commitHash,
@@ -215,13 +207,18 @@ export class EVMBtcRelay<B extends BtcBlock>
             async (event) => {
                 const txTrace = await this.Chain.Transactions.traceTransaction(event.transactionHash);
                 const storedBlockheader = await this.findStoredBlockheaderInTraces(txTrace, event.args.commitHash);
-                if(storedBlockheader!=null) {
-                    this.commitHashCache.set(event.args.commitHash, storedBlockheader);
-                    this.blockHashCache.set(event.args.blockHash, storedBlockheader);
-                    return [storedBlockheader, event.args.commitHash];
-                }
+                if(storedBlockheader==null) return null;
+
+                this.commitHashCache.set(event.args.commitHash, Promise.resolve([storedBlockheader, event.args.commitHash]));
+                this.blockHashCache.set(event.args.blockHash, Promise.resolve([storedBlockheader, event.args.commitHash]));
+                return [storedBlockheader, event.args.commitHash];
             }
         );
+
+        if(commitHash!=null) return this.commitHashCache.getOrComputeAsync(commitHash, generator);
+        if(blockHashString!=null) return this.blockHashCache.getOrComputeAsync(blockHashString, generator);
+
+        return null;
     }
 
     private async getBlockHeight(): Promise<number> {

package/src/evm/spv_swap/EVMSpvVaultContract.ts

@@ -26,6 +26,7 @@ import {EVMSpvWithdrawalData} from "./EVMSpvWithdrawalData";
 import {EVMFees} from "../chain/modules/EVMFees";
 import {EVMBtcStoredHeader} from "../btcrelay/headers/EVMBtcStoredHeader";
 import {TypedEventLog} from "../typechain/common";
+import {PromiseLruCache} from "promise-cache-ts";
 
 function decodeUtxo(utxo: string): {txHash: string, vout: bigint} {
     const [txId, vout] = utxo.split(":");
@@ -209,13 +210,12 @@ export class EVMSpvVaultContract<ChainId extends string>
         return frontingAddress;
     }
 
-    private vaultParamsCache: Map<string, SpvVaultParametersStructOutput> = new Map();
+    private vaultParamsCache: PromiseLruCache<string, SpvVaultParametersStructOutput> = new PromiseLruCache<string, SpvVaultParametersStructOutput>(5000);
 
     async getVaultData(owner: string, vaultId: bigint): Promise<EVMSpvVaultData> {
         const vaultState = await this.contract.getVault(owner, vaultId);
 
-        let vaultParams = this.vaultParamsCache.get(vaultState.spvVaultParametersCommitment);
-        if(vaultParams==null) {
+        const vaultParams = await this.vaultParamsCache.getOrComputeAsync(vaultState.spvVaultParametersCommitment, async () => {
             const blockheight = Number(vaultState.openBlockheight);
             const events = await this.Events.getContractBlockEvents(
                 ["Opened"],
@@ -231,9 +231,8 @@ export class EVMSpvVaultContract<ChainId extends string>
             );
             if(foundEvent==null) throw new Error("Valid open event not found!");
 
-            vaultParams = foundEvent.args.params;
-            this.vaultParamsCache.set(vaultState.spvVaultParametersCommitment, vaultParams);
-        }
+            return foundEvent.args.params;
+        });
 
         if(vaultParams.btcRelayContract.toLowerCase()!==this.btcRelay.contractAddress.toLowerCase()) return null;
 

package/src/evm/wallet/EVMPersistentSigner.ts

@@ -10,6 +10,7 @@ import {EVMBlockTag} from "../chain/modules/EVMBlocks";
 import {EVMChainInterface} from "../chain/EVMChainInterface";
 import {EVMFees} from "../chain/modules/EVMFees";
 import {EVMSigner} from "./EVMSigner";
+import {PromiseQueue} from "promise-queue-ts";
 
 const WAIT_BEFORE_BUMP = 15*1000;
 const MIN_FEE_INCREASE_ABSOLUTE = 1n*1_000_000_000n; //1GWei
@@ -21,7 +22,8 @@ export class EVMPersistentSigner extends EVMSigner {
 
     private pendingTxs: Map<number, {
         txs: Transaction[],
-        lastBumped: number
+        lastBumped: number,
+        sending?: boolean //Not saved
     }> = new Map();
 
     private confirmedNonce: number;
@@ -127,7 +129,7 @@ export class EVMPersistentSigner extends EVMSigner {
         let _safeBlockTxCount: number = null;
 
         for(let [nonce, data] of this.pendingTxs) {
-            if(data.lastBumped<Date.now()-this.waitBeforeBump) {
+            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) {
@@ -241,42 +243,56 @@ export class EVMPersistentSigner extends EVMSigner {
         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;
-        }
+    private readonly sendTransactionQueue: PromiseQueue = new PromiseQueue();
 
-        const tx: TransactionRequest = {};
-        for(let key in transaction) {
-            if(transaction[key] instanceof Promise) {
-                tx[key] = await transaction[key];
+    sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse> {
+        return this.sendTransactionQueue.enqueue(async () => {
+            if(transaction.nonce!=null) {
+                if(transaction.nonce !== this.pendingNonce + 1)
+                    throw new Error("Invalid transaction nonce!");
+                this.pendingNonce++;
             } else {
-                tx[key] = transaction[key];
+                this.pendingNonce++;
+                transaction.nonce = this.pendingNonce;
             }
-        }
 
-        const signedRawTx = await this.account.signTransaction(tx);
-        const signedTx = Transaction.from(signedRawTx);
+            const tx: TransactionRequest = {};
+            for(let key in transaction) {
+                if(transaction[key] instanceof Promise) {
+                    tx[key] = await transaction[key];
+                } else {
+                    tx[key] = transaction[key];
+                }
+            }
 
-        if(onBeforePublish!=null) {
-            try {
-                await onBeforePublish(signedTx.hash, signedRawTx);
-            } catch (e) {
-                this.logger.error("sendTransaction(): Error when calling onBeforePublish function: ", e);
+            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();
+            const pendingTxObject = {txs: [signedTx], lastBumped: Date.now(), sending: true};
+            this.pendingTxs.set(transaction.nonce, pendingTxObject);
+            this.save();
 
-        this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
+            this.chainInterface.Transactions._knownTxSet.add(signedTx.hash);
 
-        return await this.chainInterface.provider.broadcastTransaction(signedRawTx);
+            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--;
+                throw e;
+            }
+        });
     }
 
 }