Remove BlockscoutProvider temporarily until custom error issues are fixed.

Author: ricmoo

src.ts/providers/default-provider.ts

@@ -3,7 +3,7 @@ import { assert } from "../utils/index.js";
 
 import { AnkrProvider } from "./provider-ankr.js";
 import { AlchemyProvider } from "./provider-alchemy.js";
-import { BlockscoutProvider } from "./provider-blockscout.js";
+//import { BlockscoutProvider } from "./provider-blockscout.js";
 import { ChainstackProvider } from "./provider-chainstack.js";
 import { CloudflareProvider } from "./provider-cloudflare.js";
 import { EtherscanProvider } from "./provider-etherscan.js";
@@ -121,13 +121,13 @@ export function getDefaultProvider(network?: string | Networkish | WebSocketLike
             providers.push(new AnkrProvider(network, options.ankr));
         } catch (error) { }
     }
-
+/* Temporarily remove until custom error issue is fixed
     if (allowService("blockscout")) {
         try {
             providers.push(new BlockscoutProvider(network, options.blockscout));
         } catch (error) { }
     }
-
+*/
     if (allowService("chainstack")) {
         try {
             providers.push(new ChainstackProvider(network, options.chainstack));

src.ts/providers/provider-blockscout.ts

@@ -20,15 +20,16 @@
  *  @_subsection: api/providers/thirdparty:Blockscout  [providers-blockscout]
  */
 import {
-    defineProperties, FetchRequest, assertArgument
+    assertArgument, defineProperties, FetchRequest, isHexString
 } from "../utils/index.js";
 
 import { Network } from "./network.js";
 import { JsonRpcProvider } from "./provider-jsonrpc.js";
 
-import type { AbstractProvider } from "./abstract-provider.js";
+import type { AbstractProvider, PerformActionRequest } from "./abstract-provider.js";
 import type { CommunityResourcable } from "./community.js";
 import type { Networkish } from "./network.js";
+import type { JsonRpcPayload, JsonRpcError } from "./provider-jsonrpc.js";
 
 
 function getUrl(name: string): string {
@@ -108,6 +109,52 @@ export class BlockscoutProvider extends JsonRpcProvider implements CommunityReso
         return (this.apiKey === null);
     }
 
+    getRpcRequest(req: PerformActionRequest): null | { method: string, args: Array<any> } {
+        // Blockscout enforces the TAG argument for estimateGas
+        const resp = super.getRpcRequest(req);
+        if (resp && resp.method === "eth_estimateGas" && resp.args.length == 1) {
+            resp.args = resp.args.slice();
+            resp.args.push("latest");
+        }
+        return resp;
+    }
+
+    getRpcError(payload: JsonRpcPayload, _error: JsonRpcError): Error {
+        const error = _error ? _error.error: null;
+
+        // Blockscout currently drops the VM result and replaces it with a
+        // human-readable string, so we need to make it machine-readable.
+        if (error && error.code === -32015 && !isHexString(error.data || "", true)) {
+            const panicCodes = <Record<string, string>>{
+                "assert(false)": "01",
+                "arithmetic underflow or overflow": "11",
+                "division or modulo by zero": "12",
+                "out-of-bounds array access; popping on an empty array": "31",
+                "out-of-bounds access of an array or bytesN": "32"
+            };
+
+            let panicCode = "";
+            if (error.message === "VM execution error.") {
+                // eth_call passes this message
+                panicCode = panicCodes[error.data] || "";
+            } else if (panicCodes[error.message || ""]) {
+                panicCode = panicCodes[error.message || ""];
+            }
+
+            if (panicCode) {
+                error.message += ` (reverted: ${ error.data })`;
+                error.data = "0x4e487b7100000000000000000000000000000000000000000000000000000000000000" + panicCode;
+            }
+
+        } else if (error && error.code === -32000) {
+            if (error.message === "wrong transaction nonce") {
+                error.message += " (nonce too low)";
+            }
+        }
+
+        return super.getRpcError(payload, _error);
+    }
+
     /**
      *  Returns a prepared request for connecting to %%network%%
      *  with %%apiKey%%.

src.ts/providers/provider-jsonrpc.ts

@@ -1002,6 +1002,11 @@ export abstract class JsonRpcApiProvider extends AbstractProvider {
                     transaction: ((<any>payload).params[0]),
                     info: { payload, error }
                 });
+            } else if (msg.match(/nonce/i) && msg.match(/too low/i)) {
+                return makeError("nonce has already been used", "NONCE_EXPIRED", {
+                    transaction: ((<any>payload).params[0]),
+                    info: { payload, error }
+                });
             }
         }