feat: provider proxy

static/scripts/rewards/render-transaction/read-claim-data-from-url.ts

@@ -9,7 +9,8 @@ import { verifyCurrentNetwork } from "../web3/verify-current-network";
 import { claimRewardsPagination } from "./claim-rewards-pagination";
 import { renderTransaction } from "./render-transaction";
 import { setClaimMessage } from "./set-claim-message";
-import { useRpcHandler } from "../web3/use-rpc-handler";
+import { useHandler } from "../web3/use-rpc-handler";
+import { createProviderProxy } from "../web3/onchain-call-handler";
 
 declare const SUPABASE_URL: string;
 declare const SUPABASE_ANON_KEY: string;
@@ -32,9 +33,22 @@ export async function readClaimDataFromUrl(app: AppState) {
   app.claimTxs = await getClaimedTxs(app);
 
   try {
-    app.provider = await useRpcHandler(app);
+    // create a handler instance
+    const handler = await useHandler(app.networkId as number);
+    // get the fastest provider
+    const provider = await handler.getFastestRpcProvider();
+    // needs to be assigned to create our proxy
+    app.provider = provider;
+    // create the proxy
+    app.provider = createProviderProxy(app, handler);
   } catch (e) {
-    toaster.create("error", `e`);
+    if (e instanceof Error) {
+      toaster.create("error", e.message);
+    } else {
+      if (typeof e === "string") {
+        toaster.create("error", e);
+      }
+    }
   }
 
   try {

static/scripts/rewards/web3/onchain-call-handler.ts

@@ -0,0 +1,63 @@
+import { ethers } from "ethers";
+import { AppState } from "../app-state";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { toaster } from "../toaster";
+
+/**
+ * Creates a proxy for the provider so that we can retry any failed provider call
+ * across the app.
+ *
+ * Should a call fail it will retry the call starting with the fastest provider
+ * until it has tried all providers.
+ *
+ * It will do this three times before throwing an error. It is more likely
+ * it'll succeed on the first loop but we'll try three times to be sure.
+ */
+
+export function createProviderProxy(app: AppState, handler: RPCHandler): JsonRpcProvider {
+  return new Proxy(app.provider, {
+    get: function (target: JsonRpcProvider, prop: keyof JsonRpcProvider) {
+      if (typeof target[prop] === "function") {
+        return async function (...args: unknown[]) {
+          // first attempt at the call, if it fails we don't care about the error
+          try {
+            return await (target[prop] as (...args: unknown[]) => Promise<unknown>)(...args);
+          } catch {
+            //
+          }
+
+          const latencies: Record<string, number> = await handler.getLatencies();
+          const sortedLatencies = Object.entries(latencies).sort((a, b) => a[1] - b[1]);
+
+          let loops = 3;
+
+          let lastError: Error | unknown | null = null;
+
+          while (loops > 0) {
+            for (const [rpc] of sortedLatencies) {
+              console.log(`[PROXY] Connected to: ${rpc}`);
+              try {
+                // we do not want to change the app.provider as it is the proxy itself
+                const newProvider = new ethers.providers.JsonRpcProvider(rpc.split("__")[1]);
+                return await (newProvider[prop] as (...args: unknown[]) => Promise<unknown>)(...args);
+              } catch (e) {
+                console.error("[PROXY] Provider Error -> retrying with new provider");
+                lastError = e;
+              }
+            }
+            loops--;
+          }
+
+          toaster.create("error", "Operation failed to complete, see more in the console");
+
+          if (lastError instanceof Error) {
+            console.error(lastError);
+          } else {
+            console.error("Unknown error", lastError);
+          }
+        };
+      }
+      return target[prop];
+    },
+  });
+}