viem 2.22.23 → 2.23.1

package/actions/public/{simulate.ts → simulateBlocks.ts}

@@ -67,7 +67,7 @@ type CallExtraProperties = ExactPartial<
   account?: Account | Address | undefined
 }
 
-export type SimulateParameters<
+export type SimulateBlocksParameters<
   calls extends readonly unknown[] = readonly unknown[],
 > = {
   /** Blocks to simulate. */
@@ -80,11 +80,11 @@ export type SimulateParameters<
     stateOverrides?: StateOverride | undefined
   }[]
   /** Whether to return the full transactions. */
-  returnFullTransactions?: boolean
+  returnFullTransactions?: boolean | undefined
   /** Whether to trace transfers. */
-  traceTransfers?: boolean
+  traceTransfers?: boolean | undefined
   /** Whether to enable validation mode. */
-  validation?: boolean
+  validation?: boolean | undefined
 } & (
   | {
       /** The balance of the account at a block number. */
@@ -101,7 +101,7 @@ export type SimulateParameters<
     }
 )
 
-export type SimulateReturnType<
+export type SimulateBlocksReturnType<
   calls extends readonly unknown[] = readonly unknown[],
 > = readonly (Block & {
   calls: MulticallResults<
@@ -119,7 +119,7 @@ export type SimulateReturnType<
   >
 })[]
 
-export type SimulateErrorType =
+export type SimulateBlocksErrorType =
   | AssertRequestErrorType
   | DecodeFunctionResultErrorType
   | EncodeFunctionDataErrorType
@@ -171,16 +171,16 @@ export type SimulateErrorType =
  * ```
  *
  * @param client - Client to use.
- * @param parameters - {@link SimulateParameters}
- * @returns Simulated blocks. {@link SimulateReturnType}
+ * @param parameters - {@link SimulateBlocksParameters}
+ * @returns Simulated blocks. {@link SimulateBlocksReturnType}
  */
-export async function simulate<
+export async function simulateBlocks<
   chain extends Chain | undefined,
   const calls extends readonly unknown[],
 >(
   client: Client<Transport, chain>,
-  parameters: SimulateParameters<calls>,
-): Promise<SimulateReturnType<calls>> {
+  parameters: SimulateBlocksParameters<calls>,
+): Promise<SimulateBlocksReturnType<calls>> {
   const {
     blockNumber,
     blockTag = 'latest',
@@ -281,7 +281,7 @@ export async function simulate<
               }),
         }
       }),
-    })) as unknown as SimulateReturnType<calls>
+    })) as unknown as SimulateBlocksReturnType<calls>
   } catch (e) {
     const cause = e as BaseError
     const error = getNodeError(cause, {})

package/actions/public/simulateCalls.ts

@@ -0,0 +1,414 @@
+import type { AbiStateMutability, Address, Narrow } from 'abitype'
+import * as AbiConstructor from 'ox/AbiConstructor'
+import * as AbiFunction from 'ox/AbiFunction'
+
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import { ethAddress, zeroAddress } from '../../constants/address.js'
+import { deploylessCallViaBytecodeBytecode } from '../../constants/contracts.js'
+import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Account } from '../../types/account.js'
+import type { Block } from '../../types/block.js'
+import type { Call, Calls } from '../../types/calls.js'
+import type { Chain } from '../../types/chain.js'
+import type { Log } from '../../types/log.js'
+import type { Hex } from '../../types/misc.js'
+import type { MulticallResults } from '../../types/multicall.js'
+import type { StateOverride } from '../../types/stateOverride.js'
+import type { Mutable } from '../../types/utils.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../utils/abi/encodeFunctionData.js'
+import { hexToBigInt } from '../../utils/index.js'
+import {
+  type CreateAccessListErrorType,
+  createAccessList,
+} from './createAccessList.js'
+import {
+  type SimulateBlocksErrorType,
+  type SimulateBlocksParameters,
+  simulateBlocks,
+} from './simulateBlocks.js'
+
+const getBalanceCode =
+  '0x6080604052348015600e575f80fd5b5061016d8061001c5f395ff3fe608060405234801561000f575f80fd5b5060043610610029575f3560e01c8063f8b2cb4f1461002d575b5f80fd5b610047600480360381019061004291906100db565b61005d565b604051610054919061011e565b60405180910390f35b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100aa82610081565b9050919050565b6100ba816100a0565b81146100c4575f80fd5b50565b5f813590506100d5816100b1565b92915050565b5f602082840312156100f0576100ef61007d565b5b5f6100fd848285016100c7565b91505092915050565b5f819050919050565b61011881610106565b82525050565b5f6020820190506101315f83018461010f565b9291505056fea26469706673582212203b9fe929fe995c7cf9887f0bdba8a36dd78e8b73f149b17d2d9ad7cd09d2dc6264736f6c634300081a0033'
+
+export type SimulateCallsParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+  account extends Account | Address | undefined = Account | Address | undefined,
+> = Omit<SimulateBlocksParameters, 'blocks' | 'returnFullTransactions'> & {
+  /** Account attached to the calls (msg.sender). */
+  account?: account | undefined
+  /** Calls to simulate. */
+  calls: Calls<Narrow<calls>>
+  /** State overrides. */
+  stateOverrides?: StateOverride | undefined
+  /** Whether to trace asset changes. */
+  traceAssetChanges?: boolean | undefined
+}
+
+export type SimulateCallsReturnType<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Asset changes. */
+  assetChanges: readonly {
+    token: {
+      address: Address
+      decimals?: number | undefined
+      symbol?: string | undefined
+    }
+    value: { pre: bigint; post: bigint; diff: bigint }
+  }[]
+  /** Block results. */
+  block: Block
+  /** Call results. */
+  results: MulticallResults<
+    Narrow<calls>,
+    true,
+    {
+      extraProperties: {
+        data: Hex
+        gasUsed: bigint
+        logs?: Log[] | undefined
+      }
+      error: Error
+      mutability: AbiStateMutability
+    }
+  >
+}
+
+export type SimulateCallsErrorType =
+  | AbiFunction.encodeData.ErrorType
+  | AbiFunction.from.ErrorType
+  | CreateAccessListErrorType
+  | EncodeFunctionDataErrorType
+  | SimulateBlocksErrorType
+  | ErrorType
+
+/**
+ * Simulates execution of a batch of calls.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SimulateCallsParameters}
+ * @returns Results. {@link SimulateCallsReturnType}
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient, http, parseEther } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { simulateCalls } from 'viem/actions'
+ *
+ * const client = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const result = await simulateCalls(client, {
+ *   account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
+ *   calls: [{
+ *     {
+ *       data: '0xdeadbeef',
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *     },
+ *     {
+ *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *       value: parseEther('1'),
+ *     },
+ *   ]
+ * })
+ * ```
+ */
+export async function simulateCalls<
+  const calls extends readonly unknown[],
+  chain extends Chain | undefined,
+  account extends Account | Address | undefined = undefined,
+>(
+  client: Client<Transport, chain>,
+  parameters: SimulateCallsParameters<calls, account>,
+): Promise<SimulateCallsReturnType<calls>> {
+  const {
+    blockNumber,
+    blockTag,
+    calls,
+    stateOverrides,
+    traceAssetChanges,
+    traceTransfers,
+    validation,
+  } = parameters
+
+  const account = parameters.account
+    ? parseAccount(parameters.account)
+    : undefined
+
+  if (traceAssetChanges && !account)
+    throw new BaseError(
+      '`account` is required when `traceAssetChanges` is true',
+    )
+
+  // Derive bytecode to extract ETH balance via a contract call.
+  const getBalanceData = account
+    ? AbiConstructor.encode(AbiConstructor.from('constructor(bytes, bytes)'), {
+        bytecode: deploylessCallViaBytecodeBytecode,
+        args: [
+          getBalanceCode,
+          AbiFunction.encodeData(
+            AbiFunction.from('function getBalance(address)'),
+            [account.address],
+          ),
+        ],
+      })
+    : undefined
+
+  // Fetch ERC20/721 addresses that were "touched" from the calls.
+  const assetAddresses = traceAssetChanges
+    ? await Promise.all(
+        parameters.calls.map(async (call: any) => {
+          if (!call.data && !call.abi) return
+          const { accessList } = await createAccessList(client, {
+            account: account!.address,
+            ...call,
+            data: call.abi ? encodeFunctionData(call) : call.data,
+          })
+          return accessList.map(({ address, storageKeys }) =>
+            storageKeys.length > 0 ? address : null,
+          )
+        }),
+      ).then((x) => x.flat().filter(Boolean))
+    : []
+
+  const resultsStateOverrides = stateOverrides?.map((override) => {
+    if (override.address === account?.address)
+      return {
+        ...override,
+        nonce: 0,
+      }
+    return override
+  })
+
+  const blocks = await simulateBlocks(client, {
+    blockNumber,
+    blockTag: blockTag as undefined,
+    blocks: [
+      ...(traceAssetChanges
+        ? [
+            // ETH pre balances
+            {
+              calls: [{ data: getBalanceData }],
+              stateOverrides,
+            },
+
+            // Asset pre balances
+            {
+              calls: assetAddresses.map((address, i) => ({
+                abi: [
+                  AbiFunction.from(
+                    'function balanceOf(address) returns (uint256)',
+                  ),
+                ],
+                functionName: 'balanceOf',
+                args: [account!.address],
+                to: address,
+                from: zeroAddress,
+                nonce: i,
+              })),
+              stateOverrides: [
+                {
+                  address: zeroAddress,
+                  nonce: 0,
+                },
+              ],
+            },
+          ]
+        : []),
+
+      {
+        calls: [...calls, {}].map((call, index) => ({
+          ...(call as Call),
+          from: account?.address,
+          nonce: index,
+        })) as any,
+        stateOverrides: resultsStateOverrides,
+      },
+
+      ...(traceAssetChanges
+        ? [
+            // ETH post balances
+            {
+              calls: [{ data: getBalanceData }],
+            },
+
+            // Asset post balances
+            {
+              calls: assetAddresses.map((address, i) => ({
+                abi: [
+                  AbiFunction.from(
+                    'function balanceOf(address) returns (uint256)',
+                  ),
+                ],
+                functionName: 'balanceOf',
+                args: [account!.address],
+                to: address,
+                from: zeroAddress,
+                nonce: i,
+              })),
+              stateOverrides: [
+                {
+                  address: zeroAddress,
+                  nonce: 0,
+                },
+              ],
+            },
+
+            // Decimals
+            {
+              calls: assetAddresses.map((address, i) => ({
+                to: address,
+                abi: [
+                  AbiFunction.from('function decimals() returns (uint256)'),
+                ],
+                functionName: 'decimals',
+                from: zeroAddress,
+                nonce: i,
+              })),
+              stateOverrides: [
+                {
+                  address: zeroAddress,
+                  nonce: 0,
+                },
+              ],
+            },
+
+            // Token URI
+            {
+              calls: assetAddresses.map((address, i) => ({
+                to: address,
+                abi: [
+                  AbiFunction.from(
+                    'function tokenURI(uint256) returns (string)',
+                  ),
+                ],
+                functionName: 'tokenURI',
+                args: [0n],
+                from: zeroAddress,
+                nonce: i,
+              })),
+              stateOverrides: [
+                {
+                  address: zeroAddress,
+                  nonce: 0,
+                },
+              ],
+            },
+
+            // Symbols
+            {
+              calls: assetAddresses.map((address, i) => ({
+                to: address,
+                abi: [AbiFunction.from('function symbol() returns (string)')],
+                functionName: 'symbol',
+                from: zeroAddress,
+                nonce: i,
+              })),
+              stateOverrides: [
+                {
+                  address: zeroAddress,
+                  nonce: 0,
+                },
+              ],
+            },
+          ]
+        : []),
+    ],
+    traceTransfers,
+    validation,
+  })
+
+  const block_results = traceAssetChanges ? blocks[2] : blocks[0]
+  const [
+    block_ethPre,
+    block_assetsPre,
+    ,
+    block_ethPost,
+    block_assetsPost,
+    block_decimals,
+    block_tokenURI,
+    block_symbols,
+  ] = traceAssetChanges ? blocks : []
+
+  // Extract call results from the simulation.
+  const { calls: block_calls, ...block } = block_results
+  const results = block_calls.slice(0, -1) ?? []
+
+  // Extract pre-execution ETH and asset balances.
+  const ethPre = block_ethPre?.calls ?? []
+  const assetsPre = block_assetsPre?.calls ?? []
+  const balancesPre = [...ethPre, ...assetsPre].map((call) =>
+    call.status === 'success' ? hexToBigInt(call.data) : null,
+  )
+
+  // Extract post-execution ETH and asset balances.
+  const ethPost = block_ethPost?.calls ?? []
+  const assetsPost = block_assetsPost?.calls ?? []
+  const balancesPost = [...ethPost, ...assetsPost].map((call) =>
+    call.status === 'success' ? hexToBigInt(call.data) : null,
+  )
+
+  // Extract asset symbols & decimals.
+  const decimals = (block_decimals?.calls ?? []).map((x) =>
+    x.status === 'success' ? x.result : null,
+  ) as (number | null)[]
+  const symbols = (block_symbols?.calls ?? []).map((x) =>
+    x.status === 'success' ? x.result : null,
+  ) as (string | null)[]
+  const tokenURI = (block_tokenURI?.calls ?? []).map((x) =>
+    x.status === 'success' ? x.result : null,
+  ) as (string | null)[]
+
+  const changes: Mutable<SimulateCallsReturnType<calls>['assetChanges']> = []
+  for (const [i, balancePost] of balancesPost.entries()) {
+    const balancePre = balancesPre[i]
+
+    if (typeof balancePost !== 'bigint') continue
+    if (typeof balancePre !== 'bigint') continue
+
+    const decimals_ = decimals[i - 1]
+    const symbol_ = symbols[i - 1]
+    const tokenURI_ = tokenURI[i - 1]
+
+    const token = (() => {
+      if (i === 0)
+        return {
+          address: ethAddress,
+          decimals: 18,
+          symbol: 'ETH',
+        }
+
+      return {
+        address: assetAddresses[i - 1]! as Address,
+        decimals: tokenURI_ || decimals_ ? Number(decimals_ ?? 1) : undefined,
+        symbol: symbol_ ?? undefined,
+      }
+    })()
+
+    if (changes.some((change) => change.token.address === token.address))
+      continue
+
+    changes.push({
+      token,
+      value: {
+        pre: balancePre,
+        post: balancePost,
+        diff: balancePost - balancePre,
+      },
+    })
+  }
+
+  return {
+    assetChanges: changes,
+    block,
+    results,
+  } as unknown as SimulateCallsReturnType<calls>
+}

package/chains/definitions/0g.ts

@@ -0,0 +1,19 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const zeroG = /*#__PURE__*/ defineChain({
+  id: 16_600,
+  name: '0G Newton Testnet',
+  nativeCurrency: { name: 'A0GI', symbol: 'A0GI', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://evmrpc-testnet.0g.ai'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: '0G BlockChain Explorer',
+      url: 'https://chainscan-newton.0g.ai',
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/berachain.ts

@@ -12,6 +12,14 @@ export const berachain = /*#__PURE__*/ defineChain({
       address: '0xcA11bde05977b3631167028862bE2a173976CA11',
       blockCreated: 0,
     },
+    ensRegistry: {
+      address: '0x5b22280886a2f5e09a49bea7e320eab0e5320e28',
+      blockCreated: 877007,
+    },
+    ensUniversalResolver: {
+      address: '0xddfb18888a9466688235887dec2a10c4f5effee9',
+      blockCreated: 877008,
+    },
   },
   rpcUrls: {
     default: { http: ['https://rpc.berachain.com'] },

package/chains/definitions/story.ts

@@ -0,0 +1,15 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const story = /*#__PURE__*/ defineChain({
+  id: 1514,
+  name: 'Story',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'IP Token',
+    symbol: 'IP',
+  },
+  rpcUrls: {
+    default: { http: ['https://mainnet.storyrpc.io'] },
+  },
+  testnet: false,
+})

package/chains/definitions/unichain.ts

@@ -0,0 +1,25 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const unichain = /*#__PURE__*/ defineChain({
+  id: 130,
+  name: 'Unichain',
+  nativeCurrency: { name: 'Unichain', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://mainnet.unichain.org/'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Uniscan',
+      url: 'https://uniscan.xyz',
+      apiUrl: 'https://api.uniscan.xyz/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 0,
+    },
+  },
+})

package/chains/definitions/worldchainSepolia.ts

@@ -11,12 +11,12 @@ export const worldchainSepolia = /*#__PURE__*/ defineChain({
   nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
   rpcUrls: {
     default: { http: ['https://worldchain-sepolia.g.alchemy.com/public'] },
-    public: { http: ['https://worldchain-sepolia.g.alchemy.com/public'] },
   },
   blockExplorers: {
     default: {
       name: 'Worldscan Sepolia',
       url: 'https://sepolia.worldscan.org',
+      apiUrl: 'https://api-sepolia.worldscan.org/api',
     },
     blockscout: {
       name: 'Blockscout',

package/chains/index.ts

@@ -440,6 +440,7 @@ export { sophon } from './definitions/sophon.js'
 export { sophonTestnet } from './definitions/sophonTestnet.js'
 export { spicy } from './definitions/spicy.js'
 export { step } from './definitions/step.js'
+export { story } from './definitions/story.js'
 export { storyOdyssey } from './definitions/storyOdyssey.js'
 export { storyTestnet } from './definitions/storyTestnet.js'
 export { stratis } from './definitions/stratis.js'
@@ -482,6 +483,7 @@ export { ultra } from './definitions/ultra.js'
 export { ultraTestnet } from './definitions/ultraTestnet.js'
 export { ultron } from './definitions/ultron.js'
 export { ultronTestnet } from './definitions/ultronTestnet.js'
+export { unichain } from './definitions/unichain.js'
 export { unichainSepolia } from './definitions/unichainSepolia.js'
 export { unique } from './definitions/unique.js'
 export { uniqueOpal } from './definitions/uniqueOpal.js'
@@ -519,6 +521,7 @@ export { yooldoVerse } from './definitions/yooldoVerse.js'
 export { yooldoVerseTestnet } from './definitions/yooldoVerseTestnet.js'
 export { zenchainTestnet } from './definitions/zenchainTestnet.js'
 export { zeniq } from './definitions/zeniq.js'
+export { zeroG } from './definitions/0g.js'
 export { zetachain } from './definitions/zetachain.js'
 export { zetachainAthensTestnet } from './definitions/zetachainAthensTestnet.js'
 export { zhejiang } from './definitions/zhejiang.js'