dequanto 0.2.38 → 0.2.41

package/src/contracts/deploy/proxy/ProxyDeployment.ts

@@ -76,7 +76,7 @@ interface IBeaconDeploymentCtx extends IDeploymentCtx {
     }
 }
 
-// Supports OpenZeppelin proxy deployments
+// Supports OpenZeppelin proxy deployments.
 
 export class ProxyDeployment {
 
@@ -96,7 +96,7 @@ export class ProxyDeployment {
     async ensureProxy(ctx: IProxyDeploymentCtx) {
         $require.notEmpty(ctx.proxyId, `ProxyId for the contract is required`);
         $require.Address(ctx.implementation?.address, `Implementation address is required`);
-        //@TODO add support of UUPS proxy
+        //@TODO Add support for UUPS proxies.
         return this.ensureTransparentProxy(ctx);
     }
 
@@ -109,7 +109,7 @@ export class ProxyDeployment {
     }
 
 
-    // Supports OpenZeppelin TransparentProxy of v ^4.0 and ^5.0
+    // Supports OpenZeppelin TransparentProxy v4.x and v5.x.
     protected async ensureTransparentProxy(ctx: IProxyDeploymentCtx) {
         let {
             proxyId,
@@ -143,9 +143,9 @@ export class ProxyDeployment {
 
         let proxyOpts = <Parameters<Deployments['ensure']>[1]>{
             id: proxyId,
-            // will not compare the contract updates, once deployed. As proxies normally not updated
+            // Do not compare contract updates after deployment, as proxies are normally not updated.
             latest: false,
-            // will be used for verification
+            // Used for verification.
             proxyFor: implAddress,
             arguments: [
                 // address _logic, address initialOwner, bytes memory _data
@@ -155,7 +155,7 @@ export class ProxyDeployment {
 
         let proxyAbi = new Proxy().abi;
         let v = proxyAbi.some(x => x.name === 'upgradeToAndCall') || !proxyAbi.some(x => x.type === 'error') ? 'V4' : 'V5';
-        /** OpenZeppelin V5 hides admin/upgrade public methods and introduces "error" types*/
+        /** OpenZeppelin V5 hides admin/upgrade public methods and introduces "error" types. */
 
         let hasProxy = await deployments.has(Proxy, proxyOpts);
         let shouldUpdate = ctx.upgradeImplementation ?? true;
@@ -176,12 +176,12 @@ export class ProxyDeployment {
             }
 
             if ($address.eq(log.params.newAdmin, deployer.address)) {
-                // Openzeppelin < 5 was not deploying AdminContract automatically
+                // OpenZeppelin < 5 does not deploy AdminContract automatically.
                 let { contract } = await deployments.ensure(ProxyAdmin, {
                     id: contractProxyAdminId
                 });
                 contractProxyAdmin = contract;
-                // make sure we upgrade
+                // Make sure we upgrade.
 
                 l`Will change the EOA admin to ProxyAdmin contract`;
                 let receipt = await Interfaces.call(
@@ -192,7 +192,7 @@ export class ProxyDeployment {
                 );
 
             } else {
-                // Openzeppelin TransparentUpgradeableProxy V5 creates additionally the ProxyAdmin contract on Proxy deployment
+                // OpenZeppelin TransparentUpgradeableProxy V5 also creates the ProxyAdmin contract on proxy deployment.
                 contractProxyAdmin = new ProxyAdmin(log.params.newAdmin, client);
                 await this.store.saveDeployment(contractProxyAdmin, {
                     id: contractProxyAdminId,
@@ -201,7 +201,7 @@ export class ProxyDeployment {
             }
         } else {
             contractProxyAdmin = await deployments.get(ProxyAdmin, { id: contractProxyAdminId });
-            $require.notNull(contractProxyAdmin, `Proxy was deployed previously, but the ProxyAdmin ${contractProxyAdminId} not found`);
+            $require.notNull(contractProxyAdmin, `Proxy was deployed previously, but ProxyAdmin ${contractProxyAdminId} was not found`);
         }
 
         if (hasProxy) {
@@ -214,7 +214,7 @@ export class ProxyDeployment {
                     if ($hex.isEmpty(migrationData) === false) {
                         let version = await Interfaces.TransparentProxy[v].contractProxy.version(contractProxy);
                         if (migrationV <= version) {
-                            // Clear migration call; This upgrade is raw implementation upgrade
+                            // Clear the migration call; this upgrade is a raw implementation upgrade.
                             migrationData = null;
                         }
                     }
@@ -229,12 +229,12 @@ export class ProxyDeployment {
                     );
                     await this.saveStorageLayout(proxyId, ctx);
                 } else {
-                    $logger.log(`Skip upgrade ProxyAdmin(${contractProxyAdmin.address}) to ${implAddress} (${v}) from ${address}`);
+                    $logger.log(`Skipping ProxyAdmin(${contractProxyAdmin.address}) upgrade to ${implAddress} (${v}) from ${address}`);
                 }
             }
         }
         if (hasProxy === false && contractProxyReceipt != null) {
-            // new proxy deployment, save the storage layout
+            // New proxy deployment: save the storage layout.
             await this.saveStorageLayout(proxyId, ctx);
         }
         return {
@@ -245,7 +245,7 @@ export class ProxyDeployment {
     }
 
     private async getOpenzeppelinUpgradable(opts?: { proxy?: boolean, beacon?: boolean }) {
-        // We can't compile OpenZeppelin's contracts directly from node_modules folder, so create the wrappers
+        // We cannot compile OpenZeppelin's contracts directly from the node_modules folder, so create wrappers.
         const baseSource = `./node_modules/@openzeppelin/contracts/proxy`;
         const baseOutput = `./contracts/oz`;
         const deps = {
@@ -261,7 +261,7 @@ export class ProxyDeployment {
                 template: `
                     import \"${deps.TransparentUpgradeableProxy}\";
                 `,
-                //install: `TransparentUpgradeableProxy,ProxyAdmin`,
+                // install: `TransparentUpgradeableProxy,ProxyAdmin`,
                 contracts: [`TransparentUpgradeableProxy`, `ProxyAdmin`]
             },
             Beacon: {
@@ -271,7 +271,7 @@ export class ProxyDeployment {
                     import \"${deps.UpgradeableBeacon}\";
                     import \"${deps.BeaconProxy}\";
                 `,
-                //install: `UpgradeableBeacon,BeaconProxy`,
+                // install: `UpgradeableBeacon,BeaconProxy`,
                 contracts: [`UpgradeableBeacon`, `BeaconProxy`],
             }
         };
@@ -384,14 +384,14 @@ export class ProxyDeployment {
             }
         } else {
             if (contractBeaconReceipt?.status) {
-                // new beacon deployment, save the storage layout
+                // New beacon deployment: save the storage layout.
                 await this.saveStorageLayout(beaconId, ctx);
             }
         }
 
         let beaconProxyOpts = {
             id: beaconProxyId,
-            // Pass the target implementation address for verification
+            // Pass the target implementation address for verification.
             proxyFor: implAddress,
             arguments: [
                 // address implementation
@@ -414,7 +414,7 @@ export class ProxyDeployment {
     }
 
     private async saveStorageLayout(proxyId: string, ctx: IDeploymentCtx) {
-        $require.notNull(ctx.ImplementationContract, `Implementation Contract Class is required to compare the storage layout`);
+        $require.notNull(ctx.ImplementationContract, `Implementation contract class is required to compare the storage layout`);
         let newSlots = new ctx.ImplementationContract().storage?.$storage?.slots ?? [];
         await this.store.saveStorageLayoutInfo({
             id: proxyId,
@@ -424,10 +424,10 @@ export class ProxyDeployment {
 
     private async requireCompatibleStorageLayout(proxyId: string, ctx: IDeploymentCtx) {
         if (ctx.options?.skipStorageLayoutCheck !== true) {
-            $require.notNull(ctx.ImplementationContract, `Implementation Contract Class is required to compare the storage layout`);
+            $require.notNull(ctx.ImplementationContract, `Implementation contract class is required to compare the storage layout`);
 
             let newStorageLayout = new ctx.ImplementationContract().storage?.$storage?.slots;
-            $require.notNull(newStorageLayout, `No storage layout was generated for ${ctx.ImplementationContract.name}. `);
+            $require.notNull(newStorageLayout, `No storage layout was generated for ${ctx.ImplementationContract.name}.`);
 
             let currentStorageLayout = await this.store.getStorageLayoutInfo(proxyId);
             if (currentStorageLayout != null) {
@@ -442,7 +442,7 @@ export class ProxyDeployment {
 
     private getOzVersionByBeacon(Beacon: Constructor<IBeacon>): 5 | 4 {
         let $constructor = new Beacon().abi?.find(x => x.type === 'constructor');
-        $require.notNull($constructor, `Invalid Beacon contract: constructor not found`);
+        $require.notNull($constructor, `Invalid Beacon contract: constructor was not found`);
 
         if ($constructor.inputs.length === 1) {
             // constructor(address implementation_)

package/src/contracts/deploy/storage/DeploymentsStorage.ts

@@ -22,11 +22,12 @@ import { $path } from '@dequanto/utils/$path';
 export interface IDeployment {
     id: string
     name: string
-    // TS/JS file
+    immutablesKey?: string
+    // TS/JS file.
     main: string
     address: TAddress
 
-    // If the Contract was deployed with Proxy - the Address is the address of the proxy
+    // If the contract was deployed with a proxy, the address is the proxy address.
     implementation?: TAddress
 
     proxyFor?: TAddress
@@ -53,9 +54,9 @@ export class  DeploymentsStorage {
 
     constructor (public client: Web3Client, public deployer: IAccount, public opts: {
         directory?: string
-        // Will be part of the deployments filename
+        // Part of the deployments filename.
         name?: string
-        // TPlatform of a forked network
+        // TPlatform of a forked network.
         fork?: string
     }) {
 
@@ -103,7 +104,7 @@ export class  DeploymentsStorage {
             if (deploymentsByAddress.length > 1) {
                 let asProxy = deploymentsByAddress.filter(x => x.proxyFor != null);
                 if (asProxy.length > 0) {
-                    $require.eq(asProxy.length, 1, 'Expects only 1 deployment per Address.');
+                    $require.eq(asProxy.length, 1, 'Expected only one deployment per address.');
                     return asProxy[0];
                 }
             }
@@ -111,12 +112,12 @@ export class  DeploymentsStorage {
             if (deploymentsByAddress.length === 0) {
                 let asImplementations = deployments.filter(x => $address.eq(x.implementation, byAddress));
                 if (asImplementations.length > 0) {
-                    $require.eq(asImplementations.length, 1, 'Expects only 1 deployment per Address.');
+                    $require.eq(asImplementations.length, 1, 'Expected only one deployment per address.');
                     return asImplementations[0];
                 }
             }
 
-            throw new Error(`Deployment not found for Address: ${byAddress}`);
+            throw new Error(`Deployment was not found for address: ${byAddress}`);
         }
 
         let id = typeof mix === 'string' ? mix : mix.name;
@@ -158,6 +159,7 @@ export class  DeploymentsStorage {
     async saveDeployment (contract: ContractBase, info: {
         id: string
         name: string
+        immutablesKey?: string
         bytecodeHash?: TEth.Hex
     }, receipt?: TEth.TxReceipt) {
         $contract.store.register(contract as any);
@@ -168,6 +170,7 @@ export class  DeploymentsStorage {
         let deployment = <IDeployment> {
             id: info.id,
             name: info.name,
+            immutablesKey: info.immutablesKey,
             main: $path.getRelativePath(contract.$meta?.class ?? contract.$meta?.artifact ?? contract.$meta.source),
             bytecodeHash: info.bytecodeHash,
             address: contract.address,
@@ -177,7 +180,7 @@ export class  DeploymentsStorage {
             deployer: this.deployer.address,
             timestamp: $date.toUnixTimestamp(new Date()),
 
-            // If current deployment is the implementation, set the field to null, for later reconfiguration, otherwise keep the field uninitialized
+            // If the current deployment is the implementation, set the field to null for later reconfiguration. Otherwise, keep the field uninitialized.
             implementation: currentDeployment?.implementation ? null : void 0,
         };
 
@@ -255,11 +258,11 @@ export class  DeploymentsStorage {
             let upstreamDeployments: IDeployment[];
             let shouldCopy = true;
             if (await File.existsAsync(path)) {
-                // forked deployments path already exists, check if stale
+                // The forked deployments path already exists; check whether it is stale.
                 let blockNumber = await this.client.getBlockNumber();
                 if (upstreamDeploymentExists) {
                     upstreamDeployments = await File.readAsync<IDeployment[]>(upstreamDeploymentsPath);
-                    // 1. Check if the original(upstream) network has more recent deployments
+                    // 1. Check whether the original (upstream) network has more recent deployments.
                     let hasNewDeployments = upstreamDeployments.some(x => x.block > blockNumber);
                     shouldCopy = hasNewDeployments;
                 } else {
@@ -275,11 +278,11 @@ export class  DeploymentsStorage {
                         shouldCopy = true;
                     }
                     if (shouldCopy === false) {
-                        // 3. Just-in-case, check if there are deployments with higher block number, as the current HEAD
+                        // 3. Just in case, check whether any deployments have a higher block number than the current HEAD.
                         let hasNewDeployments = deployments.some(x => x.block > blockNumber);
                         shouldCopy = hasNewDeployments;
                         if (shouldCopy === false) {
-                            // 4. Check if the latest deployments transaction exists in current forked network
+                            // 4. Check whether the latest deployment transaction exists in the current forked network.
                             let latestDeployment = alot(deployments).maxItem(x => x.block);
                             if (latestDeployment != null) {
                                 try {
@@ -292,7 +295,7 @@ export class  DeploymentsStorage {
                         }
                     }
                     if (shouldCopy === false && upstreamDeployments?.length > 0) {
-                        // 5. Just-in-case, if there are upstream deployments with lower block number, as the current HEAD, but not in the current forked network
+                        // 5. Just in case, check for upstream deployments with a lower block number than the current HEAD that are missing from the current forked network.
                         let deploymentIds = alot(deployments).toDictionary(x => x.id);
                         let hasNewDeployments = upstreamDeployments
                             .filter(x => x.block <= blockNumber)
@@ -303,14 +306,14 @@ export class  DeploymentsStorage {
                 }
             }
             if (shouldCopy) {
-                // current forked deployments are stale, copy the upstream deployments or clean
+                // Current forked deployments are stale; copy the upstream deployments or clear them.
                 if (upstreamDeploymentExists) {
                     await File.copyToAsync(upstreamDeploymentsPath, path, {
                         silent: true
                     });
                     File.clearCache();
                 } else {
-                    // clear
+                    // Clear.
                     await File.writeAsync(path, []);
                 }
             }
@@ -340,7 +343,7 @@ export class  DeploymentsStorage {
         ]);
         let deployments = await store.getAll();
         if (deployments.length === 0) {
-            // Nothing to remove: No deployments
+            // Nothing to remove: no deployments.
             return;
         }
         if (block0 == null) {
@@ -349,9 +352,9 @@ export class  DeploymentsStorage {
 
         let stale = deployments.filter(x => {
             return x.timestamp == null
-                // was deployed earlier as current genesis block
+                // Was deployed earlier than the current genesis block.
                 || x.timestamp < block0.timestamp
-                // was deployed in the later block as current block
+                // Was deployed in a later block than the current block.
                 || x.block > blockNumberHead;
         });
         if (stale.length > 0) {

package/src/contracts/utils/AbiDeserializer.ts

@@ -10,7 +10,7 @@ export namespace AbiDeserializer {
 
     export function process(result: any, types: TAbiOutput[]) {
         if (types == null || types.length === 0) {
-            // return as-is
+            // Return as is.
             return result;
         }
         let type: 'array' | 'object' | AbiNativeType = $abiParser.getReturnTypeFromTypes(types);
@@ -48,7 +48,7 @@ export namespace AbiDeserializer {
         }
         if (type.type === 'tuple[]') {
             if (Array.isArray(val) === false) {
-                throw new Error(`${type.name} tuple[] expects array to deserialize. Got ${val}`);
+                throw new Error(`${type.name} tuple[] expects an array to deserialize. Got ${val}`);
             }
             return val.map(item => {
                 return process(item, type.components);
@@ -61,7 +61,7 @@ export namespace AbiDeserializer {
         value = normalizeArray(value);
 
         if (Array.isArray(value) === false) {
-            throw new Error(`Array expected of types: ${types.map(x => x.type)}; Got ${value}`);
+            throw new Error(`Expected an array of types: ${types.map(x => x.type)}; got ${value}`);
         }
 
         let out = [];
@@ -87,7 +87,7 @@ export namespace AbiDeserializer {
         return out;
     }
 
-    // { 0: a, 1: b, 2: c } to array
+    // Convert { 0: a, 1: b, 2: c } to an array.
     function normalizeArray(val) {
         if (Array.isArray(val)) {
             return val;

package/src/contracts/utils/ContractBaseUtils.ts

@@ -11,13 +11,13 @@ export namespace ContractBaseUtils {
     export function $getAbiItem(abi: TAbiItem[], type: 'event' | 'function' | 'string', name: string, argsCount?: number) {
         let arr = abi.filter(x => x.type === type && x.name === name);
         if (arr.length === 0) {
-            throw new Error(`TAbiItem ${name} not found`);
+            throw new Error(`TAbiItem ${name} was not found`);
         }
         if (arr.length === 1) {
             return arr[0];
         }
         if (argsCount == null) {
-            throw new Error(`Found multiple TAbiItems for ${name}. Args count not specified to pick one`);
+            throw new Error(`Found multiple TAbiItems for ${name}. Argument count was not specified to pick one`);
         }
         return arr.find(x => (x.inputs?.length ?? 0) === argsCount);
     }
@@ -98,7 +98,7 @@ export namespace ContractBaseUtils {
         let tx = await writer.writeAsync(account, abi, params);
         let { error, result } = await $promise.caught(tx.onSigned);
 
-        // get TransactionHash
+        // Get the transaction hash.
         let hash = result != null ? $contract.keccak256(result) : null;
         return { error, signed: result, hash };
     }

package/src/erc4337/models/UserOperation.ts

@@ -9,8 +9,8 @@ export const UserOperationDefaults = <UserOperation> {
     initCode: '0x',
     callData: '0x',
     callGasLimit: 0n,
-    verificationGasLimit: 150000n, // default verification gas. will add create2 cost (3200+200*length) if initCode exists
-    preVerificationGas: 21000n, // should also cover calldata cost.
+    verificationGasLimit: 150000n, // Default verification gas, will add the create2 cost (3200+200*length) if initCode exists
+    preVerificationGas: 21000n, // Should also cover calldata cost
     maxFeePerGas: 0n,
     maxPriorityFeePerGas: 0n,
     paymasterAndData: '0x',

package/src/evm/OpcodesWalker.ts

@@ -93,7 +93,7 @@ export class OpcodesWalker {
                 // Is Conditional
                 this.evm.stack.pop();
 
-                // Visit falsy leaf (as if the jump not occured)
+                // Visit the falsy leaf as if the jump did not occur
                 let evm = this.evm.clone();
                 let walker = new OpcodesWalker(evm, this.opcodes);
                 let { opcodes } = walker.goToExit(this.current);

package/src/explorer/BlockchainExplorer.ts

@@ -377,7 +377,7 @@ export class BlockchainExplorer implements IBlockchainExplorer {
                     files
                 };
             } catch (error) {
-                throw new Error(`Source code (${url}) can't be parsed: ${error.message}`);
+                throw new Error(`Source code (${url}) cannot be parsed: ${error.message}`);
             }
         }
         function parseJson(str: string) {

package/src/explorer/BlockchainExplorerFactory.ts

@@ -12,7 +12,7 @@ import { $require } from '@dequanto/utils/$require';
 
 
 /**
- * @obsolete Use BlockchainExplorer class instead.
+ * @obsolete Use BlockchainExplorer class instead
  */
 export namespace BlockchainExplorerFactory {
 

package/src/explorer/BlockchainExplorerStorage.ts

@@ -50,16 +50,16 @@ export class BlockchainExplorerStorage implements IBlockchainExplorer {
         }
     }
     submitContractProxyVerification(contractData: { address: TAddress; expectedImplementation?: TAddress }): Promise<string> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     checkContractProxyVerificationSubmission(submission: { guid: any; }): Promise<string> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     submitContractVerification(contractData: { address: `0x${string}`; sourceCode: any; contractName: any; compilerVersion: any; optimizer?: { enabled?: boolean; runs: number; }; arguments?: `0x${string}`; }): Promise<string> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     checkContractVerificationSubmission(submission: { guid: any; }): Promise<string> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     registerAbi(abis: { name: any; address: any; abi: any; }[]) {
         abis.forEach(x => {
@@ -73,10 +73,10 @@ export class BlockchainExplorerStorage implements IBlockchainExplorer {
     }
 
     getContractMeta(q: string): Promise<IContractDetails> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getContractCreation(address: string): Promise<{ creator: TEth.Address; txHash: TEth.Hex; }> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     async getContractAbi(address: TAddress, opts?: { implementation?: TAddress; }): Promise<{ abi: string; implementation: TAddress; }> {
         let $address = opts?.implementation ?? address;
@@ -103,22 +103,22 @@ export class BlockchainExplorerStorage implements IBlockchainExplorer {
         }
     }
     getTransactions(address: string, params?: { fromBlockNumber?: number; page?: number; size?: number; }): Promise<TEth.Tx[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getTransactionsAll(address: string): Promise<TEth.Tx[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getInternalTransactions(address: string, params?: { fromBlockNumber?: number; page?: number; size?: number; }): Promise<TEth.Tx[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getInternalTransactionsAll(address: string): Promise<TEth.Tx[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getErc20Transfers(address: string, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getErc20TransfersAll(address: string, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
 
 }

package/src/explorer/Evmscan.ts

@@ -3,6 +3,6 @@ import { BlockchainExplorer } from './BlockchainExplorer';
 
 
 /**
- * @obsolete Use BlockchainExplorer class instead.
+ * @obsolete Use BlockchainExplorer class instead
  */
 export const Evmscan = BlockchainExplorer;

package/src/explorer/verifiers/FsHtmlVerifier.ts

@@ -176,25 +176,25 @@ export class FsHtmlVerifier implements IVerifier {
         return `verified`;
     }
     getTransactions(address: `0x${string}`, params?: { fromBlockNumber?: number; page?: number; size?: number; }): Promise<TEth.DataLike<TEth.Tx>[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getTransactionsAll(address: `0x${string}`): Promise<TEth.DataLike<TEth.Tx>[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getInternalTransactions(address: `0x${string}`, params?: { fromBlockNumber?: number; page?: number; size?: number; }): Promise<TEth.DataLike<TEth.Tx>[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getInternalTransactionsAll(address: `0x${string}`): Promise<TEth.DataLike<TEth.Tx>[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getErc20Transfers(address: `0x${string}`, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     getErc20TransfersAll(address: `0x${string}`, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     registerAbi(abis: { name: any; address: any; abi: any; }[]) {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
 
     private extractHostKey (config: TExplorer) {

package/src/flashbots/FlashbotWeb3Client.ts

@@ -18,7 +18,7 @@ export class FlashbotWeb3Client extends Web3Client {
     constructor (opts) {
         super(opts);
 
-        throw new Error('Not Implemented. Use generic Web3Clients and submit transactions via FlashbotsProvider ');
+        throw new Error('Not implemented. Use generic Web3Clients and submit transactions via FlashbotsProvider');
     }
 
 }

package/src/hardhat/HardhatProvider.ts

@@ -51,7 +51,7 @@ export class HardhatProvider {
             if (network == 'localhost') {
                 opts.endpoints = [
                     { url: 'http://127.0.0.1:8545' },
-                    // Use `manual`, will be used for subscriptions only, otherwise BatchRequests will fail, as not implemented yet
+                    // Use `manual` for subscriptions only, otherwise BatchRequests will fail, as they are not implemented yet
                     // https://github.com/NomicFoundation/hardhat/issues/1324
                     { url: 'ws://127.0.0.1:8545' },
                 ];
@@ -72,7 +72,7 @@ export class HardhatProvider {
             let platformClient = await Web3ClientFactory.get(platform);
             url = await platformClient.getNodeURL({ ws: false });
 
-            // Hardhat looks like supports only HTTPs? nodes to fork from
+            // Hardhat seems to support only HTTPS nodes as fork sources
             $require.True(/^(http)/.test(url), `Requires the HTTP path of a node to fork: ${url}`);
 
             // Removed: use default Hardhat's behavior
@@ -301,7 +301,7 @@ export class HardhatProvider {
 
         dir = $path.normalize(dir);
         if (await Directory.existsAsync(dir) === false) {
-            throw new Error(`Directory "${dir}" does not exist.`);
+            throw new Error(`Directory "${dir}" does not exist`);
         }
         const paths = {
             sources: dir,
@@ -420,7 +420,7 @@ export class HardhatProvider {
 
     private async createTmpFile(solidityCode: string, options: Parameters<HardhatProvider['deploySol']>[1] = {}) {
 
-        // Ensure the code includes the necessary pragmas and license header.
+        // Ensure the code includes the necessary pragmas and license header
         if (solidityCode.includes('pragma solidity') === false) {
             solidityCode = `pragma solidity ^0.8.0;\n${solidityCode}`;
         }
@@ -507,7 +507,7 @@ export class HardhatProvider {
             if (rgx_CONTRACT_NAME.test(content) === false) {
                 return null;
             }
-            throw new Error(`No JSONs found in ${outputDir} for ${solContractPath}`);
+            throw new Error(`No JSON files were found in ${outputDir} for ${solContractPath}`);
         }
 
         if (options.contractName != null) {
@@ -525,12 +525,12 @@ export class HardhatProvider {
             }
         }
         if (filename == null) {
-            throw new Error(`Filename not extracted from ${solContractPath}`);
+            throw new Error(`Filename was not extracted from ${solContractPath}`);
         }
         let files = await Directory.readFilesAsync(outputDir);
         let jsons = files.filter(x => /(?<!dbg)\.json$/.test(x.uri.file));
         if (jsons.length === 0) {
-            throw new Error(`No JSONs output found in "${outputDir}/"`);
+            throw new Error(`No JSON output was found in "${outputDir}/"`);
         }
         if (jsons.length === 1) {
             // Only one JSON artifact found, assume it's the main contract

package/src/indexer/BlocksTxIndexer.ts

@@ -8,16 +8,16 @@ import { TEth } from '@dequanto/models/TEth';
 
 
 export interface IBlocksTxIndexerOptions {
-    /** Name of the indexer */
+    /** Indexer name */
     name?: string
 
-    /** Save indexer progress (visited blocks) to a file */
+    /** Saves indexer progress (visited blocks) to a file */
     persistence?: boolean
 
-    /** Load transactions from the block and provide them to the visitor method */
+    /** Loads transactions from the block and provides them to the visitor method */
     loadTransactions?: boolean
 
-    /** Load receipts from the block and provide them to the visitor method */
+    /** Loads receipts from the block and provides them to the visitor method */
     loadReceipts?: boolean
 
     client?: Web3Client
@@ -86,12 +86,12 @@ export class BlocksTxIndexer {
                         return;
                     }
                     if (blockHeader.transactions?.length === 0) {
-                        // hardhat emits empty blocks
+                        // Hardhat emits empty blocks
                         return;
                     }
                     this.walker.processUntil(blockHeader.number + 1);
                 });
-                // Reload the blocknumber, to ensure we didn't missed the block between walker starting and subscription
+                // Reload the block number to ensure we did not miss the block between walker startup and subscription
                 let newTo = await this.client.getBlockNumber();
                 this.walker.processUntil(newTo + 1);
                 console.log('BlockTxIndexer: subscribed', newTo);