dequanto 0.2.37 → 0.2.40

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/gen/Generator.ts

@@ -108,6 +108,23 @@ export class Generator {
         return generator.generate();
     }
 
+    static async generateFromJson (artifact: string) {
+        $require.True(await File.existsAsync(artifact), `${artifact} does not exist`);
+        let name = /(?<contractName>[^\\/]+).json$/.exec(artifact)?.groups?.contractName;
+        $require.notEmpty(name, `Contract name not resolved from the path ${artifact}`);
+
+        let generator = new Generator({
+            platform: 'hardhat',
+            name: name,
+            source: {
+                path: artifact
+            },
+            output: './0xc/hardhat/',
+            saveSources: false,
+        });
+        return generator.generate();
+    }
+
     /**
      * @deprecated Was possible to generate the Contract Class based on the meta information header in TS file
      */

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);

package/src/indexer/EventsIndexer.ts

@@ -24,20 +24,20 @@ export class EventsIndexer <TContract extends ContractBase> {
     public storeMeta: IEventsIndexerMetaStore
 
     constructor(public contract: TContract, public options: {
-        // Load events from the contract that was deployed to multiple addresses
+        // Load events from a contract deployed to multiple addresses
         addresses?: TAddress[]
         name?: string
         initialBlockNumber?: number
         store?: IEventsIndexerStore
         storeMeta?: IEventsIndexerMetaStore
         fs?: {
-            /** Is used as a base directory. Later the ContractName and the address(es) hash will be appended */
+            /** Used as the base directory. Later, the contract name and address hash are appended */
             directory?: string
 
-            /** The events will be splitted into multiple files by block range */
+            /** Events are split into multiple files by block range */
             // @default ~1week
             rangeSeconds?: number
-            // @default is taken from Web3Client
+            // @default Taken from Web3Client
             blockTimeAvg?: number
         }
     }) {
@@ -116,9 +116,9 @@ export class EventsIndexer <TContract extends ContractBase> {
     > (
         event: TLogName | TLogName[] | '*',
         options?: {
-            // includes block
+            // Includes block
             fromBlock?: number
-            // includes block
+            // Includes block
             toBlock?: number
             blockRangeLimits?: WClient['blockRangeLimits']
             params?: Partial<TContract['Types']['Events'][TLogName]['outputParams']>
@@ -126,9 +126,9 @@ export class EventsIndexer <TContract extends ContractBase> {
     ): AsyncGenerator<
         TLogsRangeProgress<
             ITxLogItem<GetTypes<TContract>['Events'][TLogName]['outputParams'], string>
-        >       // next result
-        , void  // void returns
-        , void  // next doesn't get any parameter
+        >       // Next result
+        , void  // Returns void
+        , void  // next does not receive any parameters
     > {
         let contract = this.contract;
         let client = contract.client;
@@ -184,10 +184,10 @@ export class EventsIndexer <TContract extends ContractBase> {
         let metas = await this.storeMeta.fetch();
         let lastBlock = (params?.fromBlock ?? 0) - 1;
         if (lastBlock < 0) {
-            // remove all metas
+            // Remove all metadata
             await this.storeMeta.removeMany(metas)
         } else {
-            // adjust the lastBlock and the ranges
+            // Adjust lastBlock and ranges
             metas.forEach(x => {
                 x.lastBlock = Math.min(x.lastBlock, lastBlock);
                 x.ranges = PackedRanges.pickTo(x.ranges, x.lastBlock);
@@ -264,11 +264,11 @@ export class EventsIndexer <TContract extends ContractBase> {
                 params: options?.params,
             });
             infos.cached = cachedStreamedBuffer.length;
-            // Note: we don't emit progress right away to keep the order in progress callback
+            // Note: we do not emit progress right away to preserve order in the progress callback
             // Consider: we have blocks [100-150] in cache
             // Requesting range: [50-200]
             // Later we fetch [50-100) and (150-200]
-            // The cached response will be inserted after block.100 to keep consistent order
+            // The cached response will be inserted after block 100 to keep a consistent order
             // if (arr?.length > 0) {
             //     let lastBlock = arr[arr.length - 1].blockNumber;
             //     await options.onProgress({
@@ -342,12 +342,12 @@ export class EventsIndexer <TContract extends ContractBase> {
                     }
 
                     if (options?.onProgress) {
-                        // completed must be set to true only when the last Range completes
+                        // completed must be set to true only when the last range completes
                         chunk.completed = isCompleted;
                         if (cachedStreamedBuffer.length > 0) {
                             if (chunk.logs.length > 0) {
-                                // Preserve the order of logs in progress callback:
-                                // insert cached.blockNumber < fetched.blockNumber first
+                                // Preserve log order in the progress callback:
+                                // Insert cached.blockNumber < fetched.blockNumber first
                                 let [ first ] = chunk.logs;
                                 let i = 0;
                                 for (; i < cachedStreamedBuffer.length; i++) {
@@ -362,7 +362,7 @@ export class EventsIndexer <TContract extends ContractBase> {
                                 }
                             }
                             if (isCompleted) {
-                                // insert everything left from cache
+                                // Insert everything left from cache
                                 chunk.logs = chunk.logs.concat(cachedStreamedBuffer);
                                 cachedStreamedBuffer = [];
                             }
@@ -380,11 +380,11 @@ export class EventsIndexer <TContract extends ContractBase> {
             }
         }
 
-        // Upsert final, if buffer is empty, we still persist the "toBlock" value and the ranges
+        // Upsert final state. If the buffer is empty, we still persist the "toBlock" value and ranges
         await this.upsert(buffer, events, ranges, fromBlock, toBlock, options);
 
         if (isStreamed && typeof options?.onProgress === 'function' && (cachedStreamedBuffer.length > 0 || ranges.load.length === 0)) {
-            // When streaming, we MUST call onProgress, even if there are no ranges to load.
+            // When streaming, we MUST call onProgress, even if there are no ranges to load
             let lastBlock = cachedStreamedBuffer.length > 0
                 ? cachedStreamedBuffer[cachedStreamedBuffer.length - 1].blockNumber
                 : toBlock;
@@ -453,7 +453,7 @@ export class EventsIndexer <TContract extends ContractBase> {
             let explorer = await BlockchainExplorerFactory.get(this.contract.client.platform);
             let deployment = new ContractCreationResolver(client, explorer);
             let contractInfo = await deployment.getInfo(this.contract.address);
-            return $require.Number(contractInfo.block, `Contract deployment not resolved from the blockchain explorer`);
+            return $require.Number(contractInfo.block, `Contract deployment was not resolved from the blockchain explorer`);
         }
         return 0;
     }

package/src/indexer/PendingTxIndexer.ts

@@ -9,7 +9,7 @@ import { TEth } from '@dequanto/models/TEth';
 
 
 export interface IPendingTxIndexerOptions {
-    /** Name of the indexer */
+    /** Indexer name */
     name?: string
 }
 export type TPendingTxListener = (client: Web3Client, tx: TEth.Tx) => Promise<void>
@@ -33,7 +33,7 @@ export class PendingTxIndexer {
         txCount: 0,
         txNulls: 0,
 
-        // tx not seen in mempool
+        // Transaction not seen in the mempool
         txPrivateCount: 0,
     }
 
@@ -112,7 +112,7 @@ export class PendingTxIndexer {
                 delete this.mempoolHash[hash];
                 continue;
             }
-            //Not seen in memhash;
+            // Not seen in memhash
             this.status.txPrivateCount++;
             this.status.txCount++;
             this.mempoolHash[hash] = 1;

package/src/indexer/handlers/BlocksWalker.ts

@@ -76,7 +76,7 @@ export class BlocksWalker {
         }
 
         if (to != null && from == null) {
-            throw new Error(`FromBlock should be set while ToBlock(${to}) is present`);
+            throw new Error(`fromBlock must be set when toBlock (${to}) is present`);
         }
 
         this.walker.setFrom(
@@ -86,8 +86,8 @@ export class BlocksWalker {
             await this.getBlockNumber(to)
         );
 
-        $require.Number(this.ranges.from, 'From should be a number');
-        $require.Number(this.ranges.to, 'To should be a number');
+        $require.Number(this.ranges.from, 'from must be a number');
+        $require.Number(this.ranges.to, 'to must be a number');
 
         this.walker.process();
         if (this.params.logProgress !== false) {
@@ -97,8 +97,8 @@ export class BlocksWalker {
 
 
     /**
-     *  Can be called each time we get a new block from blockchain,
-     *  the walker will process its current blocks and up until the specified number
+     *  Can be called each time we get a new block from the blockchain,
+     *  the walker will process its current blocks up to the specified number
      *  @param nr Number is not included: [from, end)
      */
     async processUntil (nr: number) {
@@ -180,7 +180,7 @@ export class BlocksWalker {
 
     private async processBlocks (nrs: number[]) {
 
-        // reading block and transactions
+        // Read blocks and transactions
         let start = Date.now();
         let blocks = await this.client.getBlocks(nrs);
 
@@ -245,7 +245,7 @@ class RangeWalker {
         threads: 1,
         batch: 1,
         timeout: 20000,
-        // log every N ms
+        // Log every N ms
         logTimeWindow: 5000,
     };
 
@@ -317,7 +317,7 @@ class RangeWalker {
 
         let { from } = this.range;
         if (from != null && from > nr) {
-            throw new Error(`To (${nr}) should be greater then From (${from})`);
+            throw new Error(`to (${nr}) must be greater than from (${from})`);
         }
         this.range.to = nr;
     }
@@ -327,7 +327,7 @@ class RangeWalker {
             this.range.to = to;
 
             if (this.range.from == null) {
-                // In case we started the walker by listening to incoming mined blocks
+                // If the walker was started by listening to incoming mined blocks
                 this.range.from = to;
             }
         }

package/src/indexer/handlers/TxQueueLoader.ts

@@ -7,7 +7,7 @@ export class TxQueueLoader {
     private opts = {
         threads: 4,
         timeout: 20000,
-        // log every N ms
+        // Log every N ms
         logTimeWindow: 5000,
     };
 

package/src/indexer/storage/FsEventsIndexerStore.ts

@@ -22,21 +22,21 @@ export class FsEventsIndexerStore <T extends ContractBase> implements IEventsInd
 
 
     constructor(public contract: T, public options: {
-        // Load events from the contract that was deployed to multiple addresses
+        // Load events from a contract deployed to multiple addresses
         addresses?: TAddress[]
         name?: string
         initialBlockNumber?: number
         fs?: {
-            /** Base directory, in case the path is calculated from chain, name and addresses */
+            /** Base directory when the path is calculated from chain, name, and addresses */
             directory?: string
 
-            /** Relative final directory path to be used as is for store files */
+            /** Relative final directory path to use as is for store files */
             path?: string
 
-            // the events will be splitted into multiple files by block range
-            // default ~1week
+            // Events are split into multiple files by block range
+            // Default ~1week
             rangeSeconds?: number
-            // default is taken from Web3Client
+            // Default is taken from Web3Client
             blockTimeAvg?: number
 
             // Use a single file. Deprecated, used for migration only
@@ -109,7 +109,7 @@ export class FsEventsIndexerStore <T extends ContractBase> implements IEventsInd
     private map (x): ITxLogItem<any> {
 
         let abi = this.abi[x.event];
-        $require.notNull(abi, `Abi for ${x.event} not found.`)
+        $require.notNull(abi, `ABI for ${x.event} was not found`)
 
         let blockNumber = Math.floor(x.id / 100000);
         let logIndex = x.id % 100000;
@@ -126,7 +126,7 @@ export class FsEventsIndexerStore <T extends ContractBase> implements IEventsInd
     private serialize (x: ITxLogItem<any>) {
         return {
             ...x,
-            // remove redundant data
+            // Remove redundant data
             arguments: void 0,
             blockNumber: void 0,
             logIndex: void 0,
@@ -139,7 +139,7 @@ export class FsEventsIndexerStore <T extends ContractBase> implements IEventsInd
 
 
 namespace EventAbiInputs {
-    // primary to convert BigInt from JSON
+    // Mainly converts BigInt from JSON
 
     export function deserialize (params: Record<string, any>, abi: TAbiItem): Record<string, any> {
         let inputs = alot(abi.inputs).toDictionary(x => x.name, x => x);

package/src/indexer/storage/FsEventsMetaStore.ts

@@ -14,7 +14,7 @@ export class FsEventsMetaStore <T extends ContractBase> implements IEventsIndexe
 
 
     constructor(private contract: T, private options: {
-        // Load events from the contract that was deployed to multiple addresses
+        // Load events from a contract deployed to multiple addresses
         addresses?: TAddress[]
         name?: string
         fs?: {

package/src/indexer/storage/FsEventsStoreUtils.ts

@@ -15,7 +15,7 @@ export namespace FsEventsStoreUtils {
         addresses?: TAddress[]
     }): string {
         if (options?.path) {
-            $require.True(options.path.endsWith('/'), `Path for the events store should end with '/'`);
+            $require.True(options.path.endsWith('/'), `Path for the events store must end with '/'`);
             return options.path;
         }
 

package/src/json/JsonArrayMultiStore.ts

@@ -22,7 +22,7 @@ export class JsonArrayMultiStore<T> {
     constructor (public options: IMultiStoreOptions<T>) {
         $require.Function(this.options.groupKey, `Expect a method to get the group key for an entry`);
         $require.Number(this.options.groupSize, `Expect a size for the group`);
-        $require.True(this.options.path.endsWith('/'), `The ${this.options.path} must end with a slash, as it will be used as a folder`);
+        $require.True(this.options.path.endsWith('/'), `${this.options.path} must end with a slash, as it will be used as a folder`);
     }
 
     async query(filter?: {

package/src/json/JsonStoreFs.ts

@@ -263,7 +263,7 @@ class LocalStorageTransport implements ITransport {
         this.global.localStorage.removeItem(this.path);
     }
     async exists (): Promise<boolean> {
-        // To prevent double load with "getItem", assume the existence of the item, later in readAsync the NULL will be handled.
+        // To prevent duplicate loads with "getItem", assume the item exists; later in readAsync the NULL will be handled
         return true;
     }
     async watch (watcherFn: (path?: string) => any) {

package/src/ns/providers/INsProvider.ts

@@ -4,7 +4,7 @@ import { TPlatform } from '@dequanto/models/TPlatform'
 
 export interface INsProviderOptions {
     /**
-     * Loop over each chain the provider supports.
+     * Loop over each chain the provider supports
      * @default: true
      */
     multichain?: boolean

package/src/rpc/$rpc.ts

@@ -29,7 +29,7 @@ export namespace $rpc {
         };
     }
 
-    // will wait for a receipt
+    // Wait for a receipt
     export async function waitForReceipt (rpc: Rpc, hash: TEth.Hex): Promise<TEth.TxReceipt> {
         let knownTx = false;
         let startedAt = Date.now();
@@ -41,7 +41,7 @@ export namespace $rpc {
                 if (tx == null) {
                     let ms = Date.now() - startedAt;
                     if (ms > MEM_POOL_TIMEOUT) {
-                        return [ new Error(`Transaction [${hash}] not found in mempool after ${MEM_POOL_TIMEOUT}ms`) ];
+                        return [ new Error(`Transaction [${hash}] was not found in the mempool after ${MEM_POOL_TIMEOUT}ms`) ];
                     }
                     return [ null ];
                 }

package/src/rpc/Rpc.ts

@@ -146,7 +146,7 @@ eth_accounts(): Promise<TEth.Address[]> {
 
 /**
  * Presents a structured data message for the user to sign. <metamask>
- * Presents a data message for the user to sign in a structured and readable format and returns the signed response. Introduced By [EIP-712](https://eips.ethereum.org/EIPS/eip-712).
+ * Presents a data message for the user to sign in a structured and readable format and returns the signed response. Introduced by [EIP-712](https://eips.ethereum.org/EIPS/eip-712)
  * @param address - The address of the requested signing account.
  * @param typedData -
  * @returns Signature -
@@ -239,7 +239,7 @@ eth_estimateGas(transaction: DataLike<RpcTypes.GenericTransaction>, block?: Data
  * Returns transaction base fee per gas and effective priority fee per gas for the requested/supported block range.
  * @param blockCount - Requested range of blocks. Clients will return less than the requested range if not all blocks are available.
  * @param newestBlock - Highest block of the requested range.
- * @param rewardPercentiles - A monotonically increasing list of percentile values. For each block in the requested range, the transactions will be sorted in ascending order by effective tip per gas and the coresponding effective tip for the percentile will be determined, accounting for gas consumed.
+ * @param rewardPercentiles - A monotonically increasing list of percentile values. For each block in the requested range, the transactions will be sorted in ascending order by effective tip per gas and the corresponding effective tip for the percentile will be determined, accounting for gas consumed
  * @returns feeHistoryResult - Fee history for the returned block range. This can be a subsection of the requested range if not all blocks are available.
  */
 eth_feeHistory(blockCount: bigint, newestBlock: DataLike<RpcTypes.BlockNumberOrTag>, rewardPercentiles: number[]): Promise<{

package/src/rpc/RpcBase.ts

@@ -45,7 +45,7 @@ export abstract class RpcBase {
         let body = arr.map(req => this._wrapBody(req));
         let resp = await this._transport.request(body);
         if (Array.isArray(resp) === false && arr.length === 1 && 'error' in resp === false && 'result' in resp === true) {
-            // Some RPCs return a single response instead of an array for 1 RpcAction in Batch
+            // Some RPCs return a single response instead of an array for one RpcAction in a batch
             resp = [ resp ];
         }
         if (Array.isArray(resp) === false) {
@@ -53,7 +53,7 @@ export abstract class RpcBase {
                 let error = (resp as any).error;
                 throw new RpcError(error);
             }
-            throw new Error(`RpcBatch: invalid response, array expected: ${ JSON.stringify(resp) }`);
+            throw new Error(`RpcBatch: invalid response, expected an array: ${ JSON.stringify(resp) }`);
         }
         return resp.map((resp, i) => {
             let req = arr[i];

package/src/rpc/RpcContract.ts

@@ -70,7 +70,7 @@ export class RpcContract {
         let requests = await this.getCallRequestsRaw(req);
         try {
             let responseArr = await this.client.batch(requests.map(x => x.methodRequest), options);
-
+            $require.eq(requests.length, responseArr.length, `Invalid response count`);
             return responseArr.map((resp, i) => {
                 let abi = requests[i].methodAbi;
                 if (abi == null) {
@@ -137,12 +137,12 @@ export class RpcContract {
         }
 
         if (data == null) {
-            $require.notNull(abiItem, `Method ${method} not found. Available methods: ${abiArr?.map(x => x.name) }`);
+            $require.notNull(abiItem, `Method ${method} was not found. Available methods: ${abiArr?.map(x => x.name) }`);
             data = $abiUtils.serializeMethodCallData(abiItem, params ?? []);
         }
 
         if (blockNumber instanceof Date) {
-            let client = $require.notNull(options?.client, `Blocknumber is Date: ${blockNumber}, Client is required.`);
+            let client = $require.notNull(options?.client, `Block number is a Date: ${blockNumber}, client is required`);
             let resolver = di.resolve(BlockDateResolver, client);
             blockNumber = await resolver.getBlockNumberFor(blockNumber);
         }
@@ -162,7 +162,7 @@ export class RpcContract {
     // async submit (contract: TRpcContract, req: TRpcContractCallReq) {
     //     let abis = contract.abi;
     //     let abi = abis.find(x => x.name === req.method);
-    //     $require.notNull(abi, `Method ${req.method} not found. Available methods: ${abis.map(x => x.name).join(', ')}`);
+    //     $require.notNull(abi, `Method ${req.method} was not found. Available methods: ${abis.map(x => x.name).join(', ')}`);
 
     //     let sig = $abiUtils.getMethodSignature(abi);
     //     let data = $abiUtils.encode(abi.inputs, req.params);
@@ -178,7 +178,7 @@ export class RpcContract {
     //     let results = Array.isArray(result) === false
     //         ? [ result ]
     //         : (outputs.length === 1
-    //             // decode array as single value
+    //             // Decode array as a single value
     //             ? [ result ]
     //             : result
     //         );
@@ -200,7 +200,7 @@ namespace utils {
         if (outputs.length > 1) {
             let isNamedTuple = outputs.every(x => x.name != null && x.name !== '');
             if (isNamedTuple) {
-                // will return as object
+                // Return as an object
                 abi = [ { type: 'tuple', components: outputs, name: null } ];
                 isDynamic = false;
             }

package/src/rpc/RpcSubscription.ts

@@ -34,7 +34,7 @@ export class RpcSubscription<T> extends SubjectStream<T> implements TTransport.S
 
     static createMapping <T> (subscription: TTransport.Subscription<any>, transport: TTransport.Transport, mapper: (x: any) => any): RpcSubscription<T> {
         let stream = new RpcSubscription<T>(subscription.id, transport, mapper);
-        //@TODO: fix 'any'
+        //@TODO Fix 'any'
         stream.fromStream(subscription as any);
         return stream;
     }

package/src/rpc/transports/compatibility/EIP1193Transport.ts

@@ -21,7 +21,7 @@ export class EIP1193Transport implements TTransport.Transport {
     async request(req: TTransport.Request | TTransport.Request[]): Promise<any> {
 
         if (Array.isArray(req)) {
-            // Hardhat in-memory doesn't support batch requests
+            // Hardhat in-memory does not support batch requests
             return alot(req).mapAsync(async x => {
                 return this.request(x);
             }).toArrayAsync({ threads: 5 });
@@ -39,13 +39,13 @@ export class EIP1193Transport implements TTransport.Transport {
                 result
             };
         }
-        throw new Error(`Invalid transport with no sendAsync, request methods`);
+        throw new Error(`Invalid transport: no sendAsync or request methods`);
     }
 
     async subscribe(req: TTransport.Request): Promise<TTransport.Subscription<any>> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
     unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [number]; }): Promise<RpcSubscription<any>> {
-        throw new Error('Method not implemented.');
+        throw new Error('Method not implemented');
     }
 }