viem 0.0.1-alpha.2 → 0.0.1-alpha.20

package/src/utils/address/getContractAddress.ts

@@ -0,0 +1,59 @@
+import type { Address, ByteArray, Hex } from '../../types'
+import { concat, isBytes, pad, slice } from '../data'
+import { encodeBytes, encodeRlp } from '../encoding'
+import { keccak256 } from '../hash'
+import { getAddress } from './getAddress'
+
+export type GetCreateAddressOptions = {
+  from: Address
+  nonce: bigint
+}
+
+export type GetCreate2AddressOptions = {
+  bytecode: ByteArray | Hex
+  from: Address
+  salt: ByteArray | Hex
+}
+
+export type GetContractAddressOptions =
+  | ({
+      opcode?: 'CREATE'
+    } & GetCreateAddressOptions)
+  | ({ opcode: 'CREATE2' } & GetCreate2AddressOptions)
+
+export function getContractAddress(opts: GetContractAddressOptions) {
+  if (opts.opcode === 'CREATE2') return getCreate2Address(opts)
+  return getCreateAddress(opts)
+}
+
+export function getCreateAddress(opts: GetCreateAddressOptions) {
+  const from = encodeBytes(getAddress(opts.from))
+
+  let nonce = encodeBytes(opts.nonce)
+  if (nonce[0] === 0) nonce = new Uint8Array([])
+
+  return getAddress(
+    `0x${keccak256(encodeRlp([from, nonce], 'bytes')).slice(26)}` as Address,
+  )
+}
+
+export function getCreate2Address(opts: GetCreate2AddressOptions) {
+  const from = encodeBytes(getAddress(opts.from))
+  const salt = pad(
+    isBytes(opts.salt) ? opts.salt : encodeBytes(opts.salt as Hex),
+    { size: 32 },
+  ) as ByteArray
+  const bytecodeHash = encodeBytes(
+    keccak256(
+      (isBytes(opts.bytecode)
+        ? opts.bytecode
+        : encodeBytes(opts.bytecode as Hex)) as ByteArray,
+    ),
+  )
+  return getAddress(
+    slice(
+      keccak256(concat([encodeBytes('0xff'), from, salt, bytecodeHash])),
+      12,
+    ),
+  )
+}

package/src/utils/address/index.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from 'vitest'
+
+import * as address from './index'
+
+test('exports address', () => {
+  expect(address).toMatchInlineSnapshot(`
+    {
+      "checksumAddress": [Function],
+      "getAddress": [Function],
+      "getContractAddress": [Function],
+      "getCreate2Address": [Function],
+      "getCreateAddress": [Function],
+      "isAddress": [Function],
+      "isAddressEqual": [Function],
+    }
+  `)
+})

package/src/utils/address/index.ts

@@ -0,0 +1,16 @@
+export { checksumAddress, getAddress } from './getAddress'
+
+export type {
+  GetContractAddressOptions,
+  GetCreate2AddressOptions,
+  GetCreateAddressOptions,
+} from './getContractAddress'
+export {
+  getContractAddress,
+  getCreate2Address,
+  getCreateAddress,
+} from './getContractAddress'
+
+export { isAddress } from './isAddress'
+
+export { isAddressEqual } from './isAddressEqual'

package/src/utils/address/isAddress.test.ts

@@ -0,0 +1,10 @@
+import { expect, test } from 'vitest'
+
+import { isAddress } from './isAddress'
+
+test('checks if address is valid', () => {
+  expect(isAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac')).toBeTruthy()
+  expect(isAddress('0xa0cf798816d4b9b9866b5330eea46a18382f251e')).toBeTruthy()
+  expect(isAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az')).toBeFalsy()
+  expect(isAddress('0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678aff')).toBeFalsy()
+})

package/src/utils/address/isAddress.ts

@@ -0,0 +1,10 @@
+import type { Address } from '../../types'
+import { getAddress } from './getAddress'
+
+export function isAddress(address: Address) {
+  try {
+    return Boolean(getAddress(address))
+  } catch {
+    return false
+  }
+}

package/src/utils/address/isAddressEqual.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'vitest'
+
+import { isAddressEqual } from './isAddressEqual'
+
+test('checksums address', () => {
+  expect(
+    isAddressEqual(
+      '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac',
+      '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+    ),
+  ).toBeTruthy()
+  expect(
+    isAddressEqual(
+      '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    ),
+  ).toBeTruthy()
+  expect(
+    isAddressEqual(
+      '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac',
+      '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac',
+    ),
+  ).toBeTruthy()
+  expect(
+    isAddressEqual(
+      '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
+      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251f',
+    ),
+  ).toBeFalsy()
+})
+
+describe('errors', () => {
+  test('invalid address', () => {
+    expect(() =>
+      isAddressEqual(
+        '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az',
+        '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Address \\"0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678az\\" is invalid.
+
+      Version: viem@1.0.2"
+    `)
+    expect(() =>
+      isAddressEqual(
+        '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678aff',
+        '0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678ac',
+      ),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "Address \\"0xa5cc3c03994db5b0d9a5eEdD10Cabab0813678aff\\" is invalid.
+
+      Version: viem@1.0.2"
+    `)
+  })
+})

package/src/utils/address/isAddressEqual.ts

@@ -0,0 +1,6 @@
+import type { Address } from '../../types'
+import { getAddress } from './getAddress'
+
+export function isAddressEqual(a: Address, b: Address) {
+  return getAddress(a) === getAddress(b)
+}

package/src/utils/buildRequest.test.ts

@@ -0,0 +1,365 @@
+import { expect, test } from 'vitest'
+
+import { BaseError, RpcError, TimeoutError } from '../errors'
+import { buildRequest } from './buildRequest'
+
+test('valid request', async () => {
+  expect(
+    await buildRequest((args) => Promise.resolve({ ok: true, ...args }))({
+      foo: 'bar',
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "foo": "bar",
+      "ok": true,
+    }
+  `)
+})
+
+test('BaseError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(new BaseError('foo', { details: 'bar' })),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ViemError: foo
+
+      Details: bar
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ParseRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32700, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ParseRpcError: Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidRpcRequestError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32600, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidRequestRpcError: JSON is not a valid request object.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('MethodNotFoundRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32601, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [MethodNotFoundRpcError: The method does not exist / is not available.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidParamsRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32602, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidParamsRpcError: Invalid parameters were provided to the RPC method.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InternalRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32603, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InternalRpcError: An internal error was received.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidInputRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32000, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidInputRpcError: Missing or invalid parameters.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ResourceNotFoundRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32001, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ResourceNotFoundRpcError: Requested resource not found.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('ResourceUnavailableRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32002, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [ResourceUnavailableRpcError: Requested resource not available.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('TransactionRejectedRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32003, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [TransactionRejectedRpcError: Transaction creation failed.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('MethodNotSupportedRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32004, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [MethodNotSupportedRpcError: Method is not implemented.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('LimitExceededRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32005, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [LimitExceededRpcError: Request exceeds defined limit.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('JsonRpcVersionUnsupportedError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32006, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [JsonRpcVersionUnsupportedError: Version of JSON-RPC protocol is not supported.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('InvalidParamsRpcError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: -32602, message: 'message' },
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [InvalidParamsRpcError: Invalid parameters were provided to the RPC method.
+      Double check you have provided the correct parameters.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('Error', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new RpcError({
+          body: { foo: 'bar' },
+          url: 'https://viem.sh',
+          error: { code: 69, message: 'message' },
+        }),
+      ),
+    )
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [UnknownRpcError: An unknown RPC error occurred.
+
+      Details: message
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('TimeoutError', async () => {
+  try {
+    await buildRequest(() =>
+      Promise.reject(
+        new TimeoutError({
+          body: { foo: 'bar' },
+          url: 'http://localhost:8000',
+        }),
+      ),
+    )()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [TimeoutError: The request took too long to respond.
+
+      URL: http://localhost:8000
+      Request body: {"foo":"bar"}
+
+      Details: The request timed out.
+      Version: viem@1.0.2]
+    `)
+  }
+})
+
+test('Unknown error', async () => {
+  try {
+    await buildRequest(() => Promise.reject(new Error('wagmi')))()
+  } catch (err) {
+    expect(err).toMatchInlineSnapshot(`
+      [UnknownRpcError: An unknown RPC error occurred.
+
+      Details: wagmi
+      Version: viem@1.0.2]
+    `)
+  }
+})

package/src/utils/buildRequest.ts

@@ -0,0 +1,45 @@
+import {
+  BaseError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcError,
+  TransactionRejectedRpcError,
+  UnknownRpcError,
+} from '../errors'
+
+export function buildRequest<TRequest extends (args: any) => Promise<any>>(
+  request: TRequest,
+) {
+  return (async (args: any) => {
+    try {
+      return await request(args)
+    } catch (err_) {
+      let err = err_ as unknown as RpcError
+      if (err.code === -32700) throw new ParseRpcError(err)
+      if (err.code === -32600) throw new InvalidRequestRpcError(err)
+      if (err.code === -32601) throw new MethodNotFoundRpcError(err)
+      if (err.code === -32602) throw new InvalidParamsRpcError(err)
+      if (err.code === -32603) throw new InternalRpcError(err)
+      if (err.code === -32000) throw new InvalidInputRpcError(err)
+      if (err.code === -32001) throw new ResourceNotFoundRpcError(err)
+      if (err.code === -32002) throw new ResourceUnavailableRpcError(err)
+      if (err.code === -32003) throw new TransactionRejectedRpcError(err)
+      if (err.code === -32004) throw new MethodNotSupportedRpcError(err)
+      if (err.code === -32005) throw new LimitExceededRpcError(err)
+      if (err.code === -32006) throw new JsonRpcVersionUnsupportedError(err)
+      // TODO: 4001 - user rejected
+      // TODO: 4902 - switch chain error
+      if (err_ instanceof BaseError) throw err_
+      throw new UnknownRpcError(err as Error)
+    }
+  }) as TRequest
+}

package/src/utils/chain.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'vitest'
+import { celo } from '../chains'
+import { defineChain } from './chain'
+
+describe('defineChain', () => {
+  test('default', () => {
+    expect(
+      defineChain({
+        id: 42220,
+        name: 'Celo',
+        network: 'celo',
+        nativeCurrency: { name: 'Celo', symbol: 'CELO', decimals: 18 },
+        rpcUrls: {
+          public: { http: ['https://rpc.ankr.com/celo'] },
+          default: { http: ['https://rpc.ankr.com/celo'] },
+        },
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "id": 42220,
+        "name": "Celo",
+        "nativeCurrency": {
+          "decimals": 18,
+          "name": "Celo",
+          "symbol": "CELO",
+        },
+        "network": "celo",
+        "rpcUrls": {
+          "default": {
+            "http": [
+              "https://rpc.ankr.com/celo",
+            ],
+          },
+          "public": {
+            "http": [
+              "https://rpc.ankr.com/celo",
+            ],
+          },
+        },
+      }
+    `)
+  })
+})

package/src/utils/chain.ts

@@ -0,0 +1,8 @@
+import { Chain, Formatters } from '../types'
+
+export function defineChain<
+  TFormatters extends Formatters = Formatters,
+  TChain extends Chain<TFormatters> = Chain<TFormatters>,
+>(chain: TChain) {
+  return chain
+}