viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/utils/buildRequest.ts

@@ -1,7 +1,7 @@
-import type { RpcError } from '../errors/index.js'
+import { BaseError } from '../errors/base.js'
+import { HttpRequestError } from '../errors/request.js'
 import {
-  BaseError,
-  HttpRequestError,
+  ChainDisconnectedError,
   InternalRpcError,
   InvalidInputRpcError,
   InvalidParamsRpcError,
@@ -11,19 +11,34 @@ import {
   MethodNotFoundRpcError,
   MethodNotSupportedRpcError,
   ParseRpcError,
+  ProviderDisconnectedError,
+  type ProviderRpcErrorCode,
   ResourceNotFoundRpcError,
   ResourceUnavailableRpcError,
+  type RpcError,
+  type RpcErrorCode,
   SwitchChainError,
   TransactionRejectedRpcError,
+  UnauthorizedProviderError,
   UnknownRpcError,
+  UnsupportedProviderMethodError,
   UserRejectedRequestError,
-} from '../errors/index.js'
-import { withRetry } from './promise/index.js'
+} from '../errors/rpc.js'
+
+import { withRetry } from './promise/withRetry.js'
 
 export const isDeterministicError = (error: Error) => {
-  if ('code' in error) return error.code !== -32603 && error.code !== -32005
+  if ('code' in error)
+    return (
+      error.code !== -1 &&
+      error.code !== -32004 &&
+      error.code !== -32005 &&
+      error.code !== -32042 &&
+      error.code !== -32603
+    )
   if (error instanceof HttpRequestError && error.status)
     return (
+      error.status !== 403 &&
       error.status !== 408 &&
       error.status !== 413 &&
       error.status !== 429 &&
@@ -53,23 +68,68 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
         try {
           return await request(args)
         } catch (err_) {
-          const 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)
-          if (err.code === 4001) throw new UserRejectedRequestError(err)
-          if (err.code === 4902) throw new SwitchChainError(err)
-          if (err_ instanceof BaseError) throw err_
-          throw new UnknownRpcError(err as Error)
+          const err = err_ as unknown as RpcError<
+            RpcErrorCode | ProviderRpcErrorCode
+          >
+          switch (err.code) {
+            // -32700
+            case ParseRpcError.code:
+              throw new ParseRpcError(err)
+            // -32600
+            case InvalidRequestRpcError.code:
+              throw new InvalidRequestRpcError(err)
+            // -32601
+            case MethodNotFoundRpcError.code:
+              throw new MethodNotFoundRpcError(err)
+            // -32602
+            case InvalidParamsRpcError.code:
+              throw new InvalidParamsRpcError(err)
+            // -32603
+            case InternalRpcError.code:
+              throw new InternalRpcError(err)
+            // -32000
+            case InvalidInputRpcError.code:
+              throw new InvalidInputRpcError(err)
+            // -32001
+            case ResourceNotFoundRpcError.code:
+              throw new ResourceNotFoundRpcError(err)
+            // -32002
+            case ResourceUnavailableRpcError.code:
+              throw new ResourceUnavailableRpcError(err)
+            // -32003
+            case TransactionRejectedRpcError.code:
+              throw new TransactionRejectedRpcError(err)
+            // -32004
+            case MethodNotSupportedRpcError.code:
+              throw new MethodNotSupportedRpcError(err)
+            // -32005
+            case LimitExceededRpcError.code:
+              throw new LimitExceededRpcError(err)
+            // -32006
+            case JsonRpcVersionUnsupportedError.code:
+              throw new JsonRpcVersionUnsupportedError(err)
+            // 4001
+            case UserRejectedRequestError.code:
+              throw new UserRejectedRequestError(err)
+            // 4100
+            case UnauthorizedProviderError.code:
+              throw new UnauthorizedProviderError(err)
+            // 4200
+            case UnsupportedProviderMethodError.code:
+              throw new UnsupportedProviderMethodError(err)
+            // 4900
+            case ProviderDisconnectedError.code:
+              throw new ProviderDisconnectedError(err)
+            // 4901
+            case ChainDisconnectedError.code:
+              throw new ChainDisconnectedError(err)
+            // 4902
+            case SwitchChainError.code:
+              throw new SwitchChainError(err)
+            default:
+              if (err_ instanceof BaseError) throw err_
+              throw new UnknownRpcError(err as Error)
+          }
         }
       },
       {

package/src/utils/ccip.ts

@@ -0,0 +1,166 @@
+import type { Abi, Address } from 'abitype'
+
+import { type CallParameters, call } from '../actions/public/call.js'
+import type { Transport } from '../clients/transports/createTransport.js'
+import { type BaseError } from '../errors/base.js'
+import {
+  OffchainLookupError,
+  OffchainLookupResponseMalformedError,
+  OffchainLookupSenderMismatchError,
+} from '../errors/ccip.js'
+import { HttpRequestError } from '../errors/request.js'
+import type { Chain } from '../types/chain.js'
+import type { GetErrorArgs } from '../types/contract.js'
+import type { Hex } from '../types/misc.js'
+
+import type { Client } from '../clients/createClient.js'
+import { decodeErrorResult } from './abi/decodeErrorResult.js'
+import { encodeAbiParameters } from './abi/encodeAbiParameters.js'
+import { isAddressEqual } from './address/isAddressEqual.js'
+import { concat } from './data/concat.js'
+import { isHex } from './data/isHex.js'
+import { stringify } from './stringify.js'
+
+export const offchainLookupSignature = '0x556f1830'
+export const offchainLookupAbiItem = {
+  name: 'OffchainLookup',
+  type: 'error',
+  inputs: [
+    {
+      name: 'sender',
+      type: 'address',
+    },
+    {
+      name: 'urls',
+      type: 'string[]',
+    },
+    {
+      name: 'callData',
+      type: 'bytes',
+    },
+    {
+      name: 'callbackFunction',
+      type: 'bytes4',
+    },
+    {
+      name: 'extraData',
+      type: 'bytes',
+    },
+  ],
+} as const satisfies Abi[number]
+
+export async function offchainLookup<TChain extends Chain | undefined,>(
+  client: Client<Transport, TChain>,
+  {
+    blockNumber,
+    blockTag,
+    data,
+    to,
+  }: Pick<CallParameters, 'blockNumber' | 'blockTag'> & {
+    data: Hex
+    to: Address
+  },
+): Promise<Hex> {
+  const { args } = decodeErrorResult({
+    data,
+    abi: [offchainLookupAbiItem],
+  }) as unknown as GetErrorArgs<
+    [typeof offchainLookupAbiItem],
+    'OffchainLookup'
+  >
+  const [sender, urls, callData, callbackSelector, extraData] = args
+
+  try {
+    if (!isAddressEqual(to, sender))
+      throw new OffchainLookupSenderMismatchError({ sender, to })
+
+    const result = await ccipFetch({ data: callData, sender, urls })
+
+    const { data: data_ } = await call(client, {
+      blockNumber,
+      blockTag,
+      data: concat([
+        callbackSelector,
+        encodeAbiParameters(
+          [{ type: 'bytes' }, { type: 'bytes' }],
+          [result, extraData],
+        ),
+      ]),
+      to,
+    } as CallParameters)
+
+    return data_!
+  } catch (err) {
+    throw new OffchainLookupError({
+      callbackSelector,
+      cause: err as BaseError,
+      data,
+      extraData,
+      sender,
+      urls,
+    })
+  }
+}
+
+export async function ccipFetch({
+  data,
+  sender,
+  urls,
+}: { data: Hex; sender: Address; urls: readonly string[] }) {
+  let error = new Error('An unknown error occurred.')
+
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i]
+    const method =
+      url.includes('{sender}') || url.includes('{data}') ? 'GET' : 'POST'
+    const body = method === 'POST' ? { data, sender } : undefined
+
+    try {
+      const response = await fetch(
+        url.replace('{sender}', sender).replace('{data}', data),
+        {
+          body: JSON.stringify(body),
+          method,
+        },
+      )
+
+      let result
+      if (
+        response.headers.get('Content-Type')?.startsWith('application/json')
+      ) {
+        result = (await response.json()).data
+      } else {
+        result = (await response.text()) as any
+      }
+
+      if (!response.ok) {
+        error = new HttpRequestError({
+          body,
+          details: stringify(result.error) || response.statusText,
+          headers: response.headers,
+          status: response.status,
+          url,
+        })
+        continue
+      }
+
+      if (!isHex(result)) {
+        error = new OffchainLookupResponseMalformedError({
+          result,
+          url,
+        })
+        continue
+      }
+
+      return result
+    } catch (err) {
+      error = new HttpRequestError({
+        body,
+        details: (err as Error).message,
+        url,
+      })
+    }
+  }
+
+  throw error
+}

package/src/utils/chain.ts

@@ -1,11 +1,37 @@
-import { ChainDoesNotSupportContract } from '../errors/index.js'
-import type { Chain, ChainContract, Formatters } from '../types/index.js'
+import {
+  ChainDoesNotSupportContract,
+  ChainMismatchError,
+  ChainNotFoundError,
+} from '../errors/chain.js'
+import type { Chain, ChainContract } from '../types/chain.js'
+import type { Formatters } from '../types/formatter.js'
+
+export type AssertCurrentChainParameters = {
+  chain?: Chain
+  currentChainId: number
+}
+
+export function assertCurrentChain({
+  chain,
+  currentChainId,
+}: AssertCurrentChainParameters): void {
+  if (!chain) throw new ChainNotFoundError()
+  if (currentChainId !== chain.id)
+    throw new ChainMismatchError({ chain, currentChainId })
+}
 
 export function defineChain<
-  TFormatters extends Formatters = Formatters,
-  TChain extends Chain<TFormatters> = Chain<TFormatters>,
->(chain: TChain) {
-  return chain
+  TChain extends Chain,
+  TFormatters extends Formatters,
+>(
+  chain: TChain,
+  config?: Pick<Chain<TFormatters>, 'formatters' | 'serializers'>,
+) {
+  return {
+    ...chain,
+    formatters: config?.formatters,
+    serializers: config?.serializers,
+  }
 }
 
 export function getChainContractAddress({

package/src/utils/data/concat.ts

@@ -1,4 +1,4 @@
-import type { ByteArray, Hex } from '../../types/index.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
 
 export type ConcatReturnType<TValue extends Hex | ByteArray> =
   TValue extends Hex ? Hex : ByteArray

package/src/utils/data/isBytes.ts

@@ -1,4 +1,4 @@
-import type { ByteArray } from '../../types/index.js'
+import type { ByteArray } from '../../types/misc.js'
 
 export function isBytes(value: unknown): value is ByteArray {
   if (!value) return false

package/src/utils/data/isBytesEqual.ts

@@ -0,0 +1,8 @@
+import { type ByteArray, type Hex, isHex, toBytes } from '../../index.js'
+import { equalBytes } from '@noble/curves/abstract/utils'
+
+export function isBytesEqual(a_: ByteArray | Hex, b_: ByteArray | Hex) {
+  const a = isHex(a_) ? toBytes(a_) : a_
+  const b = isHex(b_) ? toBytes(b_) : b_
+  return equalBytes(a, b)
+}

package/src/utils/data/isHex.ts

@@ -1,7 +1,10 @@
-import type { Hex } from '../../types/index.js'
+import type { Hex } from '../../types/misc.js'
 
-export function isHex(value: unknown): value is Hex {
+export function isHex(
+  value: unknown,
+  { strict = true }: { strict?: boolean } = {},
+): value is Hex {
   if (!value) return false
   if (typeof value !== 'string') return false
-  return /^0x[0-9a-fA-F]*$/.test(value)
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x')
 }

package/src/utils/data/pad.ts

@@ -1,5 +1,5 @@
-import { SizeExceedsPaddingSizeError } from '../../errors/index.js'
-import type { ByteArray, Hex } from '../../types/index.js'
+import { SizeExceedsPaddingSizeError } from '../../errors/data.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
 
 type PadOptions = {
   dir?: 'left' | 'right'

package/src/utils/data/size.ts

@@ -1,4 +1,5 @@
-import type { ByteArray, Hex } from '../../types/index.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+
 import { isHex } from './isHex.js'
 
 /**
@@ -8,6 +9,6 @@ import { isHex } from './isHex.js'
  * @returns The size of the value (in bytes).
  */
 export function size(value: Hex | ByteArray) {
-  if (isHex(value)) return Math.ceil((value.length - 2) / 2)
+  if (isHex(value, { strict: false })) return Math.ceil((value.length - 2) / 2)
   return value.length
 }

package/src/utils/data/slice.ts

@@ -1,4 +1,6 @@
-import type { ByteArray, Hex } from '../../types/index.js'
+import { SliceOffsetOutOfBoundsError } from '../../errors/data.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+
 import { isHex } from './isHex.js'
 import { size } from './size.js'
 
@@ -17,19 +19,38 @@ export function slice<TValue extends ByteArray | Hex>(
   value: TValue,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): SliceReturnType<TValue> {
-  if (isHex(value))
-    return sliceHex(value as Hex, start, end) as SliceReturnType<TValue>
-  return sliceBytes(value as ByteArray, start, end) as SliceReturnType<TValue>
+  if (isHex(value, { strict: false }))
+    return sliceHex(value as Hex, start, end, {
+      strict,
+    }) as SliceReturnType<TValue>
+  return sliceBytes(value as ByteArray, start, end, {
+    strict,
+  }) as SliceReturnType<TValue>
 }
 
 function assertStartOffset(value: Hex | ByteArray, start?: number) {
   if (typeof start === 'number' && start > 0 && start > size(value) - 1)
-    throw new Error(
-      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
-        value,
-      )}).`,
-    )
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: 'start',
+      size: size(value),
+    })
+}
+
+function assertEndOffset(value: Hex | ByteArray, start?: number, end?: number) {
+  if (
+    typeof start === 'number' &&
+    typeof end === 'number' &&
+    size(value) !== end - start
+  ) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: 'end',
+      size: size(value),
+    })
+  }
 }
 
 /**
@@ -40,12 +61,15 @@ function assertStartOffset(value: Hex | ByteArray, start?: number) {
  * @param end The end offset (in bytes).
  */
 export function sliceBytes(
-  value: ByteArray,
+  value_: ByteArray,
   start?: number,
   end?: number,
+  { strict }: { strict?: boolean } = {},
 ): ByteArray {
-  assertStartOffset(value, start)
-  return value.slice(start, end)
+  assertStartOffset(value_, start)
+  const value = value_.slice(start, end)
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }
 
 /**
@@ -55,10 +79,16 @@ export function sliceBytes(
  * @param start The start offset (in bytes).
  * @param end The end offset (in bytes).
  */
-export function sliceHex(value_: Hex, start?: number, end?: number): Hex {
+export function sliceHex(
+  value_: Hex,
+  start?: number,
+  end?: number,
+  { strict }: { strict?: boolean } = {},
+): Hex {
   assertStartOffset(value_, start)
-  const value = value_
+  const value = `0x${value_
     .replace('0x', '')
-    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
-  return `0x${value}`
+    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)}` as const
+  if (strict) assertEndOffset(value, start, end)
+  return value
 }

package/src/utils/data/trim.ts

@@ -1,4 +1,4 @@
-import type { ByteArray, Hex } from '../../types/index.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
 
 type TrimOptions = {
   dir?: 'left' | 'right'
@@ -27,7 +27,9 @@ export function trim<TValue extends ByteArray | Hex>(
 
   if (typeof hexOrBytes === 'string') {
     if (data.length === 1 && dir === 'right') data = `${data}0`
-    return `0x${data}` as TrimReturnType<TValue>
+    return `0x${
+      data.length % 2 === 1 ? `0${data}` : data
+    }` as TrimReturnType<TValue>
   }
   return data as TrimReturnType<TValue>
 }