How to override a provider's behavior?

[Amxx]

Suggestion

When working with some "exotic" networks, I find it reassuring the have a copy of all the transactions I've broadcasted to the network (in particular the hashes) so I can later review them if anything unexpected happens.

I'm currently doing it using this piece of code

class ProviderRecorder {
    constructor(provider, path = '/dev/stdout') {
        this.provider = provider;
        this.path     = path;
    }

    destroy()                                   { this.provider.destroy();                                          }
    getBlockNumber()                            { return this.provider.getBlockNumber();                            }
    getNetwork()                                { return this.provider.getNetwork();                                }
    getFeeData()                                { return this.provider.getFeeData();                                }
    getBalance(address, blockTag)               { return this.provider.getBalance(address, blockTag);               }
    getTransactionCount(address, blockTag)      { return this.provider.getTransactionCount(address, blockTag);      }
    getCode(address, blockTag)                  { return this.provider.getCode(address, blockTag);                  }
    getStorage(address, position, blockTag)     { return this.provider.getStorage(address, position, blockTag);     }
    estimateGas(tx)                             { return this.provider.estimateGas(tx);                             }
    call(tx)                                    { return this.provider.call(tx);                                    }
    getBlock(blockHashOrBlockTag, prefetchTxs)  { return this.provider.getBlock(blockHashOrBlockTag, prefetchTxs);  }
    getTransaction(hash)                        { return this.provider.getTransaction(hash);                        }
    getTransactionReceipt(hash)                 { return this.provider.getTransactionReceipt(hash);                 }
    getTransactionResult(hash)                  { return this.provider.getTransactionResult(hash);                  }
    getLogs(filter)                             { return this.provider.getLogs(filter);                             }
    resolveName(ensName)                        { return this.provider.resolveName(ensName);                        }
    lookupAddress(address)                      { return this.provider.lookupAddress(address);                      }
    waitForTransaction(hash, confirms, timeout) { return this.provider.waitForTransaction(hash, confirms, timeout); }
    waitForBlock(blockTag)                      { return this.provider.waitForBlock(blockTag);                      }

    broadcastTransaction(signedTx) {
        const { hash, from, nonce, serialized } = ethers.Transaction.from(signedTx);
        fs.writeFileSync(
            this.path,
            JSON.stringify({ hash, from, nonce, serialized }) + '\n',
            { flag: 'a' },
        );
        return this.provider.broadcastTransaction(signedTx);
    }
}

I believe a better option would be to use a Proxy like this:

const ProviderRecorder = (provider, path = '/dev/stdout') => new Proxy(provider, {
    get(target, p, receiver) {
        switch (p) {
            case 'broadcastTransaction':
                // do the logging here
            default:
                return Reflect.get(...arguments);
        }
    }
});

but that doesn't work because reading private members is failling:

/home/amxx/sandbox/node_modules/ethers/lib.commonjs/providers/abstract-provider.js:545
        if (this.#networkPromise == null) {
                 ^

TypeError: Cannot read private member #networkPromise from an object whose class did not declare it
    at Proxy.getNetwork (/home/amxx/sandbox/node_modules/ethers/lib.commonjs/providers/abstract-provider.js:545:18)
    at main (/home/amxx/sandbox/verkle.js:59:37)
    at Object.<anonymous> (/home/amxx/sandbox/verkle.js:90:1)
    at Module._compile (node:internal/modules/cjs/loader:1376:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1435:10)
    at Module.load (node:internal/modules/cjs/loader:1207:32)
    at Module._load (node:internal/modules/cjs/loader:1023:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:135:12)
    at node:internal/main/run_main_module:28:49

Node.js v20.11.0

---

• Does such a provider already exist in the library?
• Is there a way I could make the Proxy approach work?
• Is there a better solution I'm missing?

[ricmoo]

That is a general issue with Proxies, but can be solved as described on MDN.

You will want your "get trap" to look like this (I've updated it so it only logs values when called, not when the property is accessed; if that is what you want, the logging can be moved outside the function declaration):

const ProviderRecorder = (provider, path = '/dev/stdout') => new Proxy(provider, {
  get(target, prop, receiver) {
    const value = target[prop];
    if (value instanceof Function) {
      return function (...args) {
        // Log things...
        switch (prop) {
            case 'broadcastTransaction':
                // do the logging here
        }

        // Make sure the function targets the correct object that has access to the private members
        return value.apply(this === receiver ? target : this, args);
      };

      return value;
    }
  }
});

Another option, if you are using a JsonRpcProvider, is to use the "debug" event, and track the ids of the sending "eth_sendRawTransaction" requests and pluck out the results from the responses. A little poking a provider.on("debug", console.log) should get you started down that route if you don't like the Proxy method (I like Proxies though ;)).

Another option, if you like sub-classing is to use something like:

class RecorderProvider extends JsonRpcProvider {
  async perform(method, params) {
    const result = await super.perform(method, params);
    if (method === "broadcastTransaction") { console.log({ method, params, result }); }
    return result;
  }
}

Those are the first ideas that come to mind, anyways. If something else pops into my head, I'll add it. :)

(moving this to discussions)