viem 0.3.12 → 0.3.14

package/package.json

@@ -12,7 +12,7 @@
     "isomorphic-ws": "5.0.0",
     "ws": "8.12.0"
   },
-  "version": "0.3.12",
+  "version": "0.3.14",
   "files": [
     "dist",
     "!dist/**/*.tsbuildinfo",

package/src/actions/public/call.ts

@@ -1,7 +1,7 @@
 import type { PublicClient, Transport } from '../../clients/index.js'
 import { aggregate3Signature, multicall3Abi } from '../../constants/index.js'
-import type { BaseError } from '../../errors/index.js'
 import {
+  BaseError,
   ChainDoesNotSupportContract,
   ClientChainNotConfiguredError,
   RawContractError,
@@ -30,6 +30,7 @@ import {
   getCallError,
   getChainContractAddress,
   numberToHex,
+  offchainLookupSignature,
   parseAccount,
 } from '../../utils/index.js'
 import { createBatchScheduler } from '../../utils/promise/createBatchScheduler.js'
@@ -159,6 +160,11 @@ export async function call<TChain extends Chain | undefined>(
     if (response === '0x') return { data: undefined }
     return { data: response }
   } catch (err) {
+    const data = getRevertErrorData(err)
+    if (data?.slice(0, 10) === offchainLookupSignature && to) {
+      const { offchainLookup } = await import('../../utils/ccip.js')
+      return { data: await offchainLookup(client, { data, to }) }
+    }
     throw getCallError(err as BaseError, {
       ...args,
       account,
@@ -272,3 +278,8 @@ async function scheduleMulticall<TChain extends Chain | undefined>(
   if (returnData === '0x') return { data: undefined }
   return { data: returnData }
 }
+
+export function getRevertErrorData(err: unknown) {
+  if (!(err instanceof BaseError)) return undefined
+  return (err.walk() as { data?: Hex })?.data
+}

package/src/actions/public/simulateContract.ts

@@ -7,6 +7,7 @@ import type {
   ContractFunctionConfig,
   ContractFunctionResult,
   GetValue,
+  Hex,
 } from '../../types/index.js'
 import {
   decodeFunctionResult,
@@ -29,6 +30,8 @@ export type SimulateContractParameters<
   TChainOverride extends Chain | undefined = undefined,
 > = {
   chain?: TChainOverride
+  /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
+  dataSuffix?: Hex
 } & ContractFunctionConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> &
   Omit<
     CallParameters<TChainOverride extends Chain ? TChainOverride : TChain>,
@@ -99,6 +102,7 @@ export async function simulateContract<
     abi,
     address,
     args,
+    dataSuffix,
     functionName,
     ...callRequest
   }: SimulateContractParameters<TAbi, TFunctionName, TChain, TChainOverride>,
@@ -116,7 +120,7 @@ export async function simulateContract<
   try {
     const { data } = await call(client, {
       batch: false,
-      data: calldata,
+      data: `${calldata}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
       to: address,
       ...callRequest,
     } as unknown as CallParameters<TChain>)

package/src/actions/test/dropTransaction.ts

@@ -36,7 +36,7 @@ export async function dropTransaction<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { hash }: DropTransactionParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_dropTransaction`,
     params: [hash],
   })

package/src/actions/test/impersonateAccount.ts

@@ -36,7 +36,7 @@ export async function impersonateAccount<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address }: ImpersonateAccountParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_impersonateAccount`,
     params: [address],
   })

package/src/actions/test/mine.ts

@@ -37,7 +37,7 @@ export async function mine<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { blocks, interval }: MineParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_mine`,
     params: [numberToHex(blocks), numberToHex(interval || 0)],
   })

package/src/actions/test/removeBlockTimestampInterval.ts

@@ -27,7 +27,7 @@ import type {
 export async function removeBlockTimestampInterval<
   TChain extends Chain | undefined,
 >(client: TestClient<TestClientMode, Transport, TChain>) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_removeBlockTimestampInterval`,
   })
 }

package/src/actions/test/reset.ts

@@ -36,7 +36,7 @@ export async function reset<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { blockNumber, jsonRpcUrl }: ResetParameters = {},
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_reset`,
     params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }],
   })

package/src/actions/test/revert.ts

@@ -34,7 +34,7 @@ export async function revert<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { id }: RevertParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: 'evm_revert',
     params: [id],
   })

package/src/actions/test/setAutomine.ts

@@ -28,7 +28,7 @@ export async function setAutomine<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   enabled: boolean,
 ) {
-  return await client.request({
+  await client.request({
     method: 'evm_setAutomine',
     params: [enabled],
   })

package/src/actions/test/setBalance.ts

@@ -40,7 +40,7 @@ export async function setBalance<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address, value }: SetBalanceParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setBalance`,
     params: [address, numberToHex(value)],
   })

package/src/actions/test/setBlockGasLimit.ts

@@ -35,7 +35,7 @@ export async function setBlockGasLimit<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { gasLimit }: SetBlockGasLimitParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: 'evm_setBlockGasLimit',
     params: [numberToHex(gasLimit)],
   })

package/src/actions/test/setBlockTimestampInterval.ts

@@ -36,7 +36,7 @@ export async function setBlockTimestampInterval<
   client: TestClient<TestClientMode, Transport, TChain>,
   { interval }: SetBlockTimestampIntervalParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setBlockTimestampInterval`,
     params: [interval],
   })

package/src/actions/test/setCode.ts

@@ -39,7 +39,7 @@ export async function setCode<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address, bytecode }: SetCodeParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setCode`,
     params: [address, bytecode],
   })

package/src/actions/test/setCoinbase.ts

@@ -36,7 +36,7 @@ export async function setCoinbase<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address }: SetCoinbaseParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setCoinbase`,
     params: [address],
   })

package/src/actions/test/setIntervalMining.ts

@@ -34,7 +34,7 @@ export async function setIntervalMining<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { interval }: SetIntervalMiningParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: 'evm_setIntervalMining',
     params: [interval],
   })

package/src/actions/test/setLoggingEnabled.ts

@@ -28,7 +28,7 @@ export async function setLoggingEnabled<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   enabled: boolean,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setLoggingEnabled`,
     params: [enabled],
   })

package/src/actions/test/setMinGasPrice.ts

@@ -39,7 +39,7 @@ export async function setMinGasPrice<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { gasPrice }: SetMinGasPriceParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setMinGasPrice`,
     params: [numberToHex(gasPrice)],
   })

package/src/actions/test/setNextBlockBaseFeePerGas.ts

@@ -39,7 +39,7 @@ export async function setNextBlockBaseFeePerGas<
   client: TestClient<TestClientMode, Transport, TChain>,
   { baseFeePerGas }: SetNextBlockBaseFeePerGasParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setNextBlockBaseFeePerGas`,
     params: [numberToHex(baseFeePerGas)],
   })

package/src/actions/test/setNextBlockTimestamp.ts

@@ -35,7 +35,7 @@ export async function setNextBlockTimestamp<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { timestamp }: SetNextBlockTimestampParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: 'evm_setNextBlockTimestamp',
     params: [numberToHex(timestamp)],
   })

package/src/actions/test/setNonce.ts

@@ -40,7 +40,7 @@ export async function setNonce<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address, nonce }: SetNonceParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setNonce`,
     params: [address, numberToHex(nonce)],
   })

package/src/actions/test/setRpcUrl.ts

@@ -29,7 +29,7 @@ export async function setRpcUrl<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   jsonRpcUrl: string,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setRpcUrl`,
     params: [jsonRpcUrl],
   })

package/src/actions/test/setStorageAt.ts

@@ -43,7 +43,7 @@ export async function setStorageAt<TChain extends Chain | undefined>(
   client: TestClient<TestClientMode, Transport, TChain>,
   { address, index, value }: SetStorageAtParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_setStorageAt`,
     params: [
       address,

package/src/actions/test/stopImpersonatingAccount.ts

@@ -38,7 +38,7 @@ export async function stopImpersonatingAccount<
   client: TestClient<TestClientMode, Transport, TChain>,
   { address }: StopImpersonatingAccountParameters,
 ) {
-  return await client.request({
+  await client.request({
     method: `${client.mode}_stopImpersonatingAccount`,
     params: [address],
   })

package/src/actions/wallet/writeContract.ts

@@ -7,6 +7,7 @@ import type {
   ContractFunctionConfig,
   GetChain,
   GetValue,
+  Hex,
 } from '../../types/index.js'
 import { encodeFunctionData } from '../../utils/index.js'
 import type { EncodeFunctionDataParameters } from '../../utils/index.js'
@@ -28,7 +29,10 @@ export type WriteContractParameters<
     'chain' | 'to' | 'data' | 'value'
   > &
   GetChain<TChain, TChainOverride> &
-  GetValue<TAbi, TFunctionName, SendTransactionParameters<TChain>['value']>
+  GetValue<TAbi, TFunctionName, SendTransactionParameters<TChain>['value']> & {
+    /** Data to append to the end of the calldata. Useful for adding a ["domain" tag](https://opensea.notion.site/opensea/Seaport-Order-Attributions-ec2d69bf455041a5baa490941aad307f). */
+    dataSuffix?: Hex
+  }
 
 export type WriteContractReturnType = SendTransactionReturnType
 
@@ -94,6 +98,7 @@ export async function writeContract<
     abi,
     address,
     args,
+    dataSuffix,
     functionName,
     ...request
   }: WriteContractParameters<
@@ -110,7 +115,7 @@ export async function writeContract<
     functionName,
   } as unknown as EncodeFunctionDataParameters<TAbi, TFunctionName>)
   const hash = await sendTransaction(client, {
-    data,
+    data: `${data}${dataSuffix ? dataSuffix.replace('0x', '') : ''}`,
     to: address,
     ...request,
   } as unknown as SendTransactionParameters<TChain, TAccount, TChainOverride>)

package/src/chains.ts

@@ -10,7 +10,6 @@ import {
 } from './utils/index.js'
 
 export type { Chain } from './types/index.js'
-export { defineChain } from './utils/index.js'
 
 const celoFormatters = {
   block: defineBlock({

package/src/constants/address.ts

@@ -0,0 +1 @@
+export const zeroAddress = '0x0000000000000000000000000000000000000000' as const

package/src/constants/index.ts

@@ -1,3 +1,5 @@
+export { zeroAddress } from './address.js'
+
 export { multicall3Abi } from './abis.js'
 
 export { aggregate3Signature } from './contract.js'

package/src/errors/base.ts

@@ -59,4 +59,14 @@ export class BaseError extends Error {
     this.metaMessages = args.metaMessages
     this.shortMessage = shortMessage
   }
+
+  walk(fn?: (err: unknown) => boolean) {
+    return this.#walk(this, fn)
+  }
+
+  #walk(err: unknown, fn?: (err: unknown) => boolean): unknown {
+    if (fn?.(err)) return err
+    if ((err as Error).cause) return this.#walk((err as Error).cause, fn)
+    return err
+  }
 }

package/src/errors/ccip.ts

@@ -0,0 +1,74 @@
+import type { Address } from 'abitype'
+import { BaseError } from './base.js'
+import type { Hex } from '../types/index.js'
+import { getUrl } from './utils.js'
+
+export class OffchainLookupError extends BaseError {
+  override name = 'OffchainLookupError'
+  constructor({
+    callbackSelector,
+    cause,
+    data,
+    extraData,
+    sender,
+    urls,
+  }: {
+    callbackSelector: Hex
+    cause: BaseError
+    data: Hex
+    extraData: Hex
+    sender: Address
+    urls: readonly string[]
+  }) {
+    super(
+      cause.shortMessage ||
+        'An error occurred while fetching for an offchain result.',
+      {
+        cause,
+        metaMessages: [
+          ...(cause.metaMessages || []),
+          cause.metaMessages?.length ? '' : [],
+          'Offchain Gateway Call:',
+          urls && [
+            '  Gateway URL(s):',
+            ...urls.map((url) => `    ${getUrl(url)}`),
+          ],
+          `  Sender: ${sender}`,
+          `  Data: ${data}`,
+          `  Callback selector: ${callbackSelector}`,
+          `  Extra data: ${extraData}`,
+        ].flat(),
+      },
+    )
+  }
+}
+
+export class OffchainLookupResponseMalformedError extends BaseError {
+  override name = 'OffchainLookupResponseMalformedError'
+  constructor({ result, url }: { result: any; url: string }) {
+    super(
+      'Offchain gateway response is malformed. Response data must be a hex value.',
+      {
+        metaMessages: [
+          `Gateway URL: ${getUrl(url)}`,
+          `Response: ${JSON.stringify(result)}`,
+        ],
+      },
+    )
+  }
+}
+
+export class OffchainLookupSenderMismatchError extends BaseError {
+  override name = 'OffchainLookupSenderMismatchError'
+  constructor({ sender, to }: { sender: Address; to: Address }) {
+    super(
+      'Reverted sender address does not match target contract address (`to`).',
+      {
+        metaMessages: [
+          `Contract address: ${to}`,
+          `OffchainLookup sender address: ${sender}`,
+        ],
+      },
+    )
+  }
+}

package/src/errors/index.ts

@@ -41,6 +41,12 @@ export {
   InvalidChainIdError,
 } from './chain.js'
 
+export {
+  OffchainLookupError,
+  OffchainLookupResponseMalformedError,
+  OffchainLookupSenderMismatchError,
+} from './ccip.js'
+
 export {
   CallExecutionError,
   ContractFunctionExecutionError,

package/src/errors/request.ts

@@ -5,7 +5,7 @@ import { getUrl } from './utils.js'
 export class HttpRequestError extends BaseError {
   override name = 'HttpRequestError'
 
-  body: { [key: string]: unknown }
+  body?: { [key: string]: unknown }
   headers?: Headers
   status?: number
   url: string
@@ -17,7 +17,7 @@ export class HttpRequestError extends BaseError {
     status,
     url,
   }: {
-    body: { [key: string]: unknown }
+    body?: { [key: string]: unknown }
     details?: string
     headers?: Headers
     status?: number
@@ -28,7 +28,7 @@ export class HttpRequestError extends BaseError {
       metaMessages: [
         status && `Status: ${status}`,
         `URL: ${getUrl(url)}`,
-        `Request body: ${stringify(body)}`,
+        body && `Request body: ${stringify(body)}`,
       ].filter(Boolean) as string[],
     })
     this.body = body

package/src/errors/version.ts

@@ -1 +1 @@
-export const version = '0.3.12'
+export const version = '0.3.14'

package/src/index.ts

@@ -159,6 +159,7 @@ export {
   etherUnits,
   gweiUnits,
   weiUnits,
+  zeroAddress,
 } from './constants/index.js'
 
 export {
@@ -398,6 +399,7 @@ export {
   bytesToHex,
   bytesToNumber,
   bytesToString,
+  ccipFetch,
   concat,
   concatBytes,
   concatHex,
@@ -452,6 +454,9 @@ export {
   keccak256,
   numberToBytes,
   numberToHex,
+  offchainLookup,
+  offchainLookupAbiItem,
+  offchainLookupSignature,
   pad,
   padBytes,
   padHex,

package/src/utils/ccip.ts

@@ -0,0 +1,136 @@
+import { parseAbiItem, parseAbiParameters, type Address } from 'abitype'
+import type { PublicClient, Transport } from '../clients/index.js'
+import {
+  BaseError,
+  HttpRequestError,
+  OffchainLookupError,
+  OffchainLookupResponseMalformedError,
+  OffchainLookupSenderMismatchError,
+} from '../errors/index.js'
+import { call, type CallParameters } from '../public.js'
+import type { Chain, GetErrorArgs, Hex } from '../types/index.js'
+import { decodeErrorResult, encodeAbiParameters } from './abi/index.js'
+import { isAddressEqual } from './address/index.js'
+import { concat, isHex } from './data/index.js'
+import { stringify } from './stringify.js'
+
+export const offchainLookupSignature = '0x556f1830'
+export const offchainLookupAbiItem = parseAbiItem(
+  'error OffchainLookup(address sender, string[] urls, bytes callData, bytes4 callbackFunction, bytes extraData)',
+)
+
+export async function offchainLookup<TChain extends Chain | undefined>(
+  client: PublicClient<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(parseAbiParameters('bytes,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
+}