ox 0.14.28 → 1.0.0-beta.0

package/src/core/_test/Provider.test.ts

@@ -0,0 +1,914 @@
+import { Provider, RpcRequest, RpcResponse } from 'ox'
+import { describe, expect, test } from 'vp/test'
+import { address } from '../../../test/constants/addresses.js'
+import { anvilMainnet } from '../../../test/prool.js'
+
+describe('Provider.createEmitter', () => {
+  test('default', () => {
+    const emitter = Provider.createEmitter()
+
+    expect(emitter).toMatchInlineSnapshot(`
+    {
+      "addListener": [Function],
+      "emit": [Function],
+      "eventNames": [Function],
+      "listenerCount": [Function],
+      "listeners": [Function],
+      "off": [Function],
+      "on": [Function],
+      "once": [Function],
+      "removeAllListeners": [Function],
+      "removeListener": [Function],
+    }
+  `)
+  })
+})
+
+describe('Provider.from', () => {
+  test('default', async () => {
+    const store = RpcRequest.createStore()
+
+    const provider = Provider.from({
+      async request(args) {
+        return await fetch(anvilMainnet.rpcUrl, {
+          body: JSON.stringify(store.prepare(args as never)),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        })
+          .then((res) => res.json())
+          .then(RpcResponse.parse)
+      },
+    })
+
+    const blockNumber = await provider.request({
+      method: 'eth_blockNumber',
+    })
+
+    expect(blockNumber).toMatchInlineSnapshot(`"0x12f2974"`)
+  })
+
+  test('behavior: pre-parsed', async () => {
+    const store = RpcRequest.createStore()
+
+    const provider = Provider.from({
+      async request(args) {
+        return await fetch(anvilMainnet.rpcUrl, {
+          body: JSON.stringify(store.prepare(args as never)),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        })
+          .then((res) => res.json())
+          .then(RpcResponse.parse)
+      },
+    })
+
+    const blockNumber = await provider.request({ method: 'eth_blockNumber' })
+
+    expect(blockNumber).toMatchInlineSnapshot(`"0x12f2974"`)
+  })
+
+  test('behavior: events', async () => {
+    const emitter = Provider.createEmitter()
+    const store = RpcRequest.createStore()
+
+    const provider = Provider.from({
+      ...emitter,
+      async request(args) {
+        return await fetch(anvilMainnet.rpcUrl, {
+          body: JSON.stringify(store.prepare(args as never)),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        })
+          .then((res) => res.json())
+          .then(RpcResponse.parse)
+      },
+    })
+
+    const calls: any = []
+
+    provider.on('accountsChanged', (accounts) => calls.push(accounts))
+
+    emitter.emit('accountsChanged', [address.vitalik])
+    emitter.emit('accountsChanged', [address.usdcHolder])
+
+    expect(calls).toMatchInlineSnapshot(`
+    [
+      [
+        "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
+      ],
+      [
+        "0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078",
+      ],
+    ]
+  `)
+  })
+
+  test('behavior: methods work without explicit binding', () => {
+    const emitter = Provider.createEmitter()
+
+    const provider = Provider.from({
+      ...emitter,
+      async request(args) {
+        return args
+      },
+    })
+
+    // Test that destructured methods still work correctly
+    const { on, emit, off, once } = provider
+    const calls: any = []
+
+    // Methods should work when called independently
+    on('accountsChanged', (accounts) => calls.push(['on', accounts]))
+    once('chainChanged', (chainId) => calls.push(['once', chainId]))
+
+    emit('accountsChanged', [address.vitalik])
+    emit('accountsChanged', [address.usdcHolder])
+    emit('chainChanged', '0x1')
+    emit('chainChanged', '0x89') // Should not be captured by 'once'
+
+    expect(calls).toMatchInlineSnapshot(`
+    [
+      [
+        "on",
+        [
+          "0xd8da6bf26964af9d7eed9e03e53415d37aa96045",
+        ],
+      ],
+      [
+        "on",
+        [
+          "0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078",
+        ],
+      ],
+      [
+        "once",
+        "0x1",
+      ],
+    ]
+  `)
+
+    // Clean up
+    off('accountsChanged')
+  })
+
+  test('behavior: preserves prototype methods and accessors', async () => {
+    class CustomProvider {
+      _calls: string[] = []
+      get isCustom() {
+        return true
+      }
+      async request(args: any) {
+        this._calls.push(args.method)
+        return '0x1'
+      }
+    }
+
+    const original = new CustomProvider()
+    const provider = Provider.from(original) as Provider.Provider & {
+      isCustom: boolean
+      _calls: string[]
+    }
+
+    expect(provider.isCustom).toBe(true)
+    expect(await provider.request({ method: 'eth_blockNumber' })).toBe('0x1')
+    expect(original._calls).toEqual(['eth_blockNumber'])
+  })
+
+  test('behavior: does not parse JSON-RPC envelope success payloads', async () => {
+    // EIP-1193 `request` resolves with the method result, not a JSON-RPC
+    // envelope. If a provider returns an envelope-shaped object as the
+    // method result, Provider.from should pass it through verbatim.
+    const envelopeShapedResult = {
+      jsonrpc: '2.0',
+      id: 0,
+      result: '0x1',
+    }
+    const provider = Provider.from({
+      async request(_) {
+        return envelopeShapedResult
+      },
+    })
+
+    const result = await provider.request({ method: 'eth_blockNumber' })
+    expect(result).toEqual(envelopeShapedResult)
+  })
+
+  test('behavior: UnauthorizedError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UnauthorizedError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnauthorizedError: The requested method and/or account has not been authorized by the user.]',
+    )
+  })
+
+  test('behavior: UnauthorizedError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UnauthorizedError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnauthorizedError: foo]',
+    )
+  })
+
+  test('behavior: UserRejectedRequestError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UserRejectedRequestError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UserRejectedRequestError: The user rejected the request.]',
+    )
+  })
+
+  test('behavior: UserRejectedRequestError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UserRejectedRequestError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UserRejectedRequestError: foo]',
+    )
+  })
+
+  test('behavior: UnsupportedMethodError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UnsupportedMethodError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedMethodError: The provider does not support the requested method.]',
+    )
+  })
+
+  test('behavior: UnsupportedMethodError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UnsupportedMethodError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedMethodError: foo]',
+    )
+  })
+
+  test('behavior: DisconnectedError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.DisconnectedError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.DisconnectedError: The provider is disconnected from all chains.]',
+    )
+  })
+
+  test('behavior: DisconnectedError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.DisconnectedError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.DisconnectedError: foo]',
+    )
+  })
+
+  test('behavior: ChainDisconnectedError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.ChainDisconnectedError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.ChainDisconnectedError: The provider is not connected to the requested chain.]',
+    )
+  })
+
+  test('behavior: ChainDisconnectedError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.ChainDisconnectedError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.ChainDisconnectedError: foo]',
+    )
+  })
+
+  test('behavior: SwitchChainError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.SwitchChainError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.SwitchChainError: An error occurred when attempting to switch chain.]',
+    )
+  })
+
+  test('behavior: SwitchChainError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.SwitchChainError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.SwitchChainError: foo]',
+    )
+  })
+
+  test('behavior: UnsupportedNonOptionalCapabilityError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UnsupportedNonOptionalCapabilityError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedNonOptionalCapabilityError: This Wallet does not support a capability that was not marked as optional.]',
+    )
+  })
+
+  test('behavior: UnsupportedNonOptionalCapabilityError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UnsupportedNonOptionalCapabilityError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedNonOptionalCapabilityError: foo]',
+    )
+  })
+
+  test('behavior: UnsupportedChainIdError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UnsupportedChainIdError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedChainIdError: This Wallet does not support the requested chain ID.]',
+    )
+  })
+
+  test('behavior: UnsupportedChainIdError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UnsupportedChainIdError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnsupportedChainIdError: foo]',
+    )
+  })
+
+  test('behavior: DuplicateIdError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.DuplicateIdError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.DuplicateIdError: There is already a bundle submitted with this ID.]',
+    )
+  })
+
+  test('behavior: DuplicateIdError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.DuplicateIdError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.DuplicateIdError: foo]',
+    )
+  })
+
+  test('behavior: UnknownBundleIdError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.UnknownBundleIdError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnknownBundleIdError: This bundle id is unknown / has not been submitted.]',
+    )
+  })
+
+  test('behavior: UnknownBundleIdError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.UnknownBundleIdError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.UnknownBundleIdError: foo]',
+    )
+  })
+
+  test('behavior: BundleTooLargeError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.BundleTooLargeError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.BundleTooLargeError: The call bundle is too large for the Wallet to process.]',
+    )
+  })
+
+  test('behavior: BundleTooLargeError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.BundleTooLargeError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.BundleTooLargeError: foo]',
+    )
+  })
+
+  test('behavior: AtomicReadyWalletRejectedUpgradeError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.AtomicReadyWalletRejectedUpgradeError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.AtomicReadyWalletRejectedUpgradeError: The Wallet can support atomicity after an upgrade, but the user rejected the upgrade.]',
+    )
+  })
+
+  test('behavior: AtomicReadyWalletRejectedUpgradeError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.AtomicReadyWalletRejectedUpgradeError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.AtomicReadyWalletRejectedUpgradeError: foo]',
+    )
+  })
+
+  test('behavior: AtomicityNotSupportedError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Provider.AtomicityNotSupportedError()
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.AtomicityNotSupportedError: The wallet does not support atomic execution but the request requires it.]',
+    )
+  })
+
+  test('behavior: AtomicityNotSupportedError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: Provider.AtomicityNotSupportedError.code,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Provider.AtomicityNotSupportedError: foo]',
+    )
+  })
+
+  test('behavior: BaseError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Error('foo')
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[RpcResponse.InternalError: foo]',
+    )
+  })
+
+  test('behavior: InternalError', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new RpcResponse.InternalError({
+          message: 'foo',
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[RpcResponse.InternalError: foo]',
+    )
+  })
+
+  test('behavior: InternalError (cause)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        throw new Error('lol')
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[RpcResponse.InternalError: lol]',
+    )
+  })
+
+  test('behavior: BaseError (raw)', async () => {
+    const provider = Provider.from({
+      async request(_) {
+        return RpcResponse.parse({
+          jsonrpc: '2.0',
+          id: 0,
+          error: {
+            code: 1000,
+            message: 'foo',
+          },
+        })
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_blockNumber',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[RpcResponse.InternalError: foo]',
+    )
+  })
+
+  test('behavior: network rpc error', async () => {
+    const store = RpcRequest.createStore()
+
+    const provider = Provider.from({
+      async request(args) {
+        return await fetch(anvilMainnet.rpcUrl, {
+          body: JSON.stringify(store.prepare(args as never)),
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+        })
+          .then((res) => res.json())
+          .then(RpcResponse.parse)
+      },
+    })
+
+    await expect(() =>
+      provider.request({
+        method: 'eth_sendTransaction',
+        params: [
+          {
+            from: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+            to: '0x0000000000000000000000000000000000000000',
+          },
+        ],
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[RpcResponse.InvalidParamsError: No Signer available]`,
+    )
+  })
+
+  test('error: undefined', () => {
+    expect(() => Provider.from(undefined)).toThrowErrorMatchingInlineSnapshot(
+      '[Provider.IsUndefinedError: `provider` is undefined.]',
+    )
+  })
+})
+
+test('Provider.InvalidMessageFieldError', () => {
+  expect(new Provider.UserRejectedRequestError()).toMatchInlineSnapshot(
+    '[Provider.UserRejectedRequestError: The user rejected the request.]',
+  )
+  expect(
+    new Provider.UserRejectedRequestError({ message: 'foo' }),
+  ).toMatchInlineSnapshot('[Provider.UserRejectedRequestError: foo]')
+  expect(
+    JSON.stringify(new Provider.UserRejectedRequestError()),
+  ).toMatchInlineSnapshot(
+    `"{"name":"Provider.UserRejectedRequestError","code":4001,"details":"The user rejected the request."}"`,
+  )
+})
+
+test('Provider.UnauthorizedError', () => {
+  expect(new Provider.UnauthorizedError()).toMatchInlineSnapshot(
+    '[Provider.UnauthorizedError: The requested method and/or account has not been authorized by the user.]',
+  )
+  expect(
+    new Provider.UnauthorizedError({ message: 'foo' }),
+  ).toMatchInlineSnapshot('[Provider.UnauthorizedError: foo]')
+  expect(
+    JSON.stringify(new Provider.UnauthorizedError()),
+  ).toMatchInlineSnapshot(
+    `"{"name":"Provider.UnauthorizedError","code":4100,"details":"The requested method and/or account has not been authorized by the user."}"`,
+  )
+})
+
+test('Provider.UnsupportedMethodError', () => {
+  expect(new Provider.UnsupportedMethodError()).toMatchInlineSnapshot(
+    '[Provider.UnsupportedMethodError: The provider does not support the requested method.]',
+  )
+  expect(
+    new Provider.UnsupportedMethodError({ message: 'foo' }),
+  ).toMatchInlineSnapshot('[Provider.UnsupportedMethodError: foo]')
+  expect(
+    JSON.stringify(new Provider.UnsupportedMethodError()),
+  ).toMatchInlineSnapshot(
+    `"{"name":"Provider.UnsupportedMethodError","code":4200,"details":"The provider does not support the requested method."}"`,
+  )
+})
+
+test('Provider.DisconnectedError', () => {
+  expect(new Provider.DisconnectedError()).toMatchInlineSnapshot(
+    '[Provider.DisconnectedError: The provider is disconnected from all chains.]',
+  )
+  expect(
+    new Provider.DisconnectedError({ message: 'foo' }),
+  ).toMatchInlineSnapshot('[Provider.DisconnectedError: foo]')
+  expect(
+    JSON.stringify(new Provider.DisconnectedError()),
+  ).toMatchInlineSnapshot(
+    `"{"name":"Provider.DisconnectedError","code":4900,"details":"The provider is disconnected from all chains."}"`,
+  )
+})
+
+test('Provider.ChainDisconnectedError', () => {
+  expect(new Provider.ChainDisconnectedError()).toMatchInlineSnapshot(
+    '[Provider.ChainDisconnectedError: The provider is not connected to the requested chain.]',
+  )
+  expect(
+    new Provider.ChainDisconnectedError({ message: 'foo' }),
+  ).toMatchInlineSnapshot('[Provider.ChainDisconnectedError: foo]')
+  expect(
+    JSON.stringify(new Provider.ChainDisconnectedError()),
+  ).toMatchInlineSnapshot(
+    `"{"name":"Provider.ChainDisconnectedError","code":4901,"details":"The provider is not connected to the requested chain."}"`,
+  )
+})
+
+test('exports', () => {
+  expect(Object.keys(Provider)).toMatchInlineSnapshot(`
+    [
+      "ProviderRpcError",
+      "UserRejectedRequestError",
+      "UnauthorizedError",
+      "UnsupportedMethodError",
+      "DisconnectedError",
+      "ChainDisconnectedError",
+      "SwitchChainError",
+      "UnsupportedNonOptionalCapabilityError",
+      "UnsupportedChainIdError",
+      "DuplicateIdError",
+      "UnknownBundleIdError",
+      "BundleTooLargeError",
+      "AtomicReadyWalletRejectedUpgradeError",
+      "AtomicityNotSupportedError",
+      "createEmitter",
+      "from",
+      "parseError",
+      "IsUndefinedError",
+    ]
+  `)
+})