This format attempts to simplify and provide a consistent implementation between ethers and alloy.

The errors provided by the providers in this library are both imperfect and do not report errors
exactly as their APIs expected. The alloy transport API doesn't look completely finalized, as partial
failures to batch calls seemingly must fail the entire batch if it wants to report a transport error for one
of the RPC calls. To fix this issue, this library places it's own errors inside of an RPC call then retrieves them later.

As for ethers, at the time of writing this library, ethers was already deprecated. It is technically possible to correctly
write a provider that does errors in the way as expected. Though, since this library was already using a shared format for alloy,
the decision was made to just use a shared result format too.

This extra format is optional, but, it will likely be easier to detect connection issues to WalletConnect by using this format than
attempting to extract the RPC result and then extract failure information about the connection. Either way, a failure of connection
will report as an errored result, which is probably all that is needed for handling these issues.

```rust
let prov = client.create_alloy_provider();
let block = prov.get_block_number().await.as_wallet_connect_result();

if let Err(e) = block {
    match e {
        SharedProviderError::Transport(transport_err, full_provider_err) => todo!(),
        SharedProviderError::ProviderFailure(full_provider_err) => todo!(),
        SharedProviderError::RpcFailure(rpc_err, full_provider_err) => todo!(),
    }
}
```