Viem

https://github.com/wevm/viem
Admin
Viem is a TypeScript interface for Ethereum, offering abstractions over the JSON-RPC API,...
Tokens:1,808,885
Snippets:9,166
Trust Score:8.5
Update:5 days ago
Show doc for...
Tokens:
Raw
### Synchronous channel.topUp with viem.config.ts setup

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/actions/channel.topUp.mdx

This example shows the synchronous usage of channel.topUp, which waits for the transaction to be included before returning. It includes the viem.config.ts setup and channel configuration.

```ts
// [!include ~/snippets/tempo/viem.config.ts:setup]
// [!include ~/snippets/tempo/viem.config.ts:channel]
```

--------------------------------

### Initialize KZG interface

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/setupKzg.md

Example of setting up the KZG interface using the c-kzg library and the mainnet trusted setup path.

```ts
import * as cKzg from 'c-kzg'
import { setupKzg } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath)
```

--------------------------------

### Setup KZG with c-kzg and trusted setup file

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/blobsToProofs.md

Exports a kzg instance configured with the c-kzg library and a trusted setup file. This is required for the blobsToProofs example.

```ts
// @noErrors
import * as cKzg from 'c-kzg'
import { setupKzg } from 'viem'

export const kzg = setupKzg('./trusted-setup.json', cKzg)
```

--------------------------------

### Generating KZG proofs with blobsToProofs

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/blobsToProofs.md

This example demonstrates how to generate proofs using the blobsToProofs utility. It requires a configured KZG instance, typically set up using setupKzg with a trusted setup file.

```ts
// @twoslash-cache: {"v":2,"hash":"754e3d6d65b0476f308cace01a63ccef5b05e844dc976ea385a2f5f7ed12d154","data":"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"}
// @noErrors
import * as cKzg from 'c-kzg'
import { blobsToProofs, setupKzg } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const blobs = toBlobs({ data: '0x...' })
const kzg = setupKzg(cKzg, mainnetTrustedSetupPath) // [!code focus]
const commitments = blobsToCommitments({ blobs, kzg })

const proofs = blobsToProofs({ 
  blobs,
  commitments,
  kzg, // [!code focus]
}) 
```

--------------------------------

### Preparing a Blob Transaction with KZG

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/wallet/prepareTransactionRequest.md

This example demonstrates how to configure a blob transaction using the KZG implementation. It requires setting up the KZG instance with a trusted setup path before passing it to the prepareTransactionRequest action.

```ts
import * as cKzg from 'c-kzg'
import { toBlobs, setupKzg, stringToHex } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath) // [!code focus]

const request = await walletClient.prepareTransactionRequest({
  account,
  blobs: toBlobs({ data: stringToHex('blobby blob!') }), // [!code focus]
  kzg, // [!code focus]
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
})
```

--------------------------------

### Set up a Client

Source: https://github.com/wevm/viem/blob/main/site/pages/account-abstraction.mdx

Creates a viem client to connect to the network, required for querying smart account state like nonce and address.

```ts
import { createClient } from 'viem'
import { mainnet } from 'viem/chains'

const client = createClient({
  chain: mainnet,
  transport: http(),
})
```

--------------------------------

### Set up a viem client and get block number

Source: https://github.com/wevm/viem/blob/main/site/pages/index.mdx

Shows the basic setup for a viem public client using the mainnet chain and HTTP transport, then calls getBlockNumber to fetch the latest block number. This is the standard starting point for interacting with Ethereum via viem.

```typescript
// 1. Import modules.
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

// 2. Set up your client with desired chain & transport.
const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

// 3. Consume an action!
const blockNumber = await client.getBlockNumber()
```

--------------------------------

### Set up Client

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/guides/blob-transactions.md

Initializes a wallet client with a private key account and the mainnet chain.

```typescript
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

export const account = privateKeyToAccount('0x...')

export const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### Set up project and install Bridge Kit dependencies

Source: https://github.com/wevm/viem/blob/main/site/pages/circle-usdc/guides/bridge-kit.mdx

Creates a new project directory, initializes a Node.js project, and installs Bridge Kit and its dependencies including @circle-fin/bridge-kit, @circle-fin/adapter-viem-v2, viem, typescript, tsx, and dotenv.

```bash
mkdir bridge-kit-quickstart-transfer-base-to-eth
cd bridge-kit-quickstart-transfer-base-to-eth
npm init -y

# Install Bridge Kit and tools
npm install @circle-fin/bridge-kit @circle-fin/adapter-viem-v2 viem typescript tsx dotenv
```

--------------------------------

### propAmm.baseToken usage example

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/actions/propAmm.baseToken.mdx

Calls `client.propAmm.baseToken` with a pool address to get the base token address. The example logs the returned address.

```ts
import { client } from './viem.config'

const base = await client.propAmm.baseToken({
  pool: '0x0000000000000000000000000000000000000002',
})
// @log: '0x0000000000000000000000000000000000000001'
```

```ts
// [!include ~/snippets/tempo/viem.config.ts:setup]
```

--------------------------------

### Tempo client setup

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/guides/token-rewards.mdx

Setup for the Tempo client used in the token rewards guide. This configuration is required before using any reward actions.

```ts
import { createTempoClient, http } from 'viem/tempo'
import { tempo } from 'viem/chains'

export const tempoClient = createTempoClient({
  chain: tempo,
  transport: http(),
})
```

--------------------------------

### watchAdminUpdated usage example

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/actions/policy.watchAdminUpdated.mdx

Example of using watchAdminUpdated to subscribe to policy admin update events. The setup imports the viem client and the watchAdminUpdated action from the tempo module.

```ts
import { createClient, http } from 'viem'
import { watchAdminUpdated } from './tempo/actions'

const client = createClient({
  transport: http('https://rpc.tempo.com'),
})

const unwatch = watchAdminUpdated(client, {
  onAdminUpdated: (args, log) => {
    console.log('Admin updated:', args, log)
  },
})

// Later, to stop watching:
unwatch()
```

--------------------------------

### Build and link Viem from source

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/installation.mdx

Clone the repository, build the project, and link it globally for local development.

```bash
gh repo clone wevm/viem
cd viem
pnpm install
pnpm build
pnpm link --global
```

--------------------------------

### Initialize Bundler Client and Smart Account

Source: https://github.com/wevm/viem/blob/main/site/pages/account-abstraction/guides/sending-user-operations.md

This example shows how to create a public client, define a smart account owner, initialize a Coinbase smart account, and configure the bundler client.

```typescript
import { createPublicClient, http } from 'viem'
import { 
  createBundlerClient, 
  toCoinbaseSmartAccount 
} from 'viem/account-abstraction'
import { mainnet } from 'viem/chains'
import { privateKeyToAccount } from 'viem/accounts' 
 
const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
 
const owner = privateKeyToAccount('0x...')
 
const account = await toCoinbaseSmartAccount({ 
  client, 
  owners: [owner],
  version: '1.1',
}) 

export const bundlerClient = createBundlerClient({
  account,
  client,
  transport: http('https://public.pimlico.io/v2/1/rpc'),
})
```

--------------------------------

### Usage with c-kzg

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/defineKzg.md

Loads the trusted setup from the mainnet path and defines a KZG interface using the `c-kzg` library. This example shows the typical setup for using KZG in blob transactions.

```ts
import * as cKzg from 'c-kzg'
import { defineKzg } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

cKzg.loadTrustedSetup(mainnetTrustedSetupPath)

const kzg = defineKzg(cKzg)
```

--------------------------------

### Initialize Wallet Client

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/eip7702/prepareAuthorization.md

Setup a wallet client using a private key and the mainnet chain.

```typescript
import { createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

export const walletClient = createWalletClient({
  account: privateKeyToAccount('0x...'),
  chain: mainnet,
  transport: http(),
})
```

--------------------------------

### getEnsText usage with client setup

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/ens/actions/getEnsText.md

Shows how to call `getEnsText` with a normalized ENS name and key, along with the required client setup. The example uses `normalize` from 'viem/ens' and a public client on mainnet.

```ts
import { normalize } from 'viem/ens'
import { publicClient } from './client'
 
const ensText = await publicClient.getEnsText({
  name: normalize('wevm.eth'),
  key: 'com.twitter',
})
// 'wevm_dev'
```

```ts
import { createPublicClient, http } from 'viem'

import { mainnet } from 'viem/chains'

export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### getStorageAt usage with client setup

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/contract/getStorageAt.md

Shows how to call getStorageAt on a public client, along with the client setup required. The example imports toHex and the ABI, and uses a publicClient created with createPublicClient and an HTTP transport.

```ts
import { toHex } from 'viem'
import { wagmiAbi } from './abi'
import { publicClient } from './client'

const data = await publicClient.getStorageAt({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  slot: toHex(0)
})
```

```ts
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### buildInitiateWithdrawal and initiateWithdrawal with config

Source: https://github.com/wevm/viem/blob/main/site/pages/op-stack/actions/initiateWithdrawal.md

Shows how to build the withdrawal parameters on the L1 using `buildInitiateWithdrawal` and then use the resulting `args` to initiate the withdrawal on the L2. The `config.ts` file sets up both the L1 public client and L2 wallet client with the required actions.

```ts
import { account, publicClientL1, walletClientL2 } from './config'

const args = await publicClientL1.buildInitiateWithdrawal({ // [!code hl]
  account, // [!code hl]
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', // [!code hl]
  value: parseEther('1'), // [!code hl]
}) // [!code hl]
 
const hash = await walletClientL2.initiateWithdrawal(args)
```

```ts
import { createPublicClient, createWalletClient, custom, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet, optimism } from 'viem/chains'
import { publicActionsL1, walletActionsL2 } from 'viem/op-stack'

export const publicClientL1 = createPublicClient({
  chain: mainnet,
  transport: http()
}).extend(publicActionsL1())

export const walletClientL2 = createWalletClient({
  chain: optimism,
  transport: custom(window.ethereum)
}).extend(walletActionsL2())

// JSON-RPC Account
export const [account] = await walletClientL1.getAddresses()
// Local Account
export const account = privateKeyToAccount(...)
```

--------------------------------

### Convert blobs to commitments

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/blobsToCommitments.md

This example demonstrates how to initialize a KZG instance using setupKzg and then use it to generate commitments from blobs.

```ts
// @twoslash-cache: {"v":2,"hash":"aad9adcb259a896e5304fabcc98f543030ba51a32d0318b86b9fffe32c69e544","data":"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"}
// @noErrors
import * as cKzg from 'c-kzg'
import { blobsToCommitments, setupKzg, toBlobs } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath) // [!code focus]

const commitments = blobsToCommitments({ 
  blobs: toBlobs({ data: '0x1234' }),  
  kzg, // [!code focus]
}) 
```

--------------------------------

### Usage examples for slice

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/slice.md

Demonstrates slicing a hex string and a byte array with start and end offsets.

```ts
import { slice } from 'viem'

slice('0x0123456789', 1, 4)
// 0x234567

slice(new Uint8Array([1, 122, 51, 123]), 1, 3)
// Uint8Array [122, 51]
```

--------------------------------

### Setup Public Client and Account

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/public/call.md

Creates a public client for the mainnet and defines an account. The account is a JSON-RPC account by default, with a commented-out alternative for a local account using privateKeyToAccount.

```ts
import { createPublicClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

// @log: ↓ JSON-RPC Account
export const account = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'

// @log: ↓ Local Account
// export const account = privateKeyToAccount(...)

export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### Sign a message with a smart account

Source: https://github.com/wevm/viem/blob/main/site/pages/account-abstraction/accounts/smart/signMessage.md

Example setup for a smart account client and owner to sign a message.

```typescript
import { http, createPublicClient } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

export const owner = privateKeyToAccount('0x...')
 
export const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})
```

--------------------------------

### Wallet Client Setup

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/wallet/sendCallsSync.mdx

Initializes a wallet client using the window.ethereum provider and retrieves the user's addresses.

```typescript
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

export const walletClient = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum!),
})

export const [account] = await walletClient.getAddresses()
```

--------------------------------

### Tempo channel configuration with close request setup

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/guides/payment-channels/close.mdx

Configuration for the Tempo channel, including the setup and channel definitions. The channel.requestCloseSync action is used by the payer to start the close timer, giving the payee a window to settle outstanding vouchers.

```TypeScript
// [!include ~/snippets/tempo/viem.config.ts:setup]

// [!include ~/snippets/tempo/viem.config.ts:channel]
```

--------------------------------

### Import setupKzg

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/setupKzg.md

Import the setupKzg function from the viem package.

```ts
import { setupKzg } from 'viem'
```

--------------------------------

### Sending a blob transaction

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/wallet/sendTransaction.md

This example shows how to send a transaction with blobs, requiring a KZG setup for blob data handling.

```typescript
import * as cKzg from 'c-kzg'
import { toBlobs, setupKzg, stringToHex } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath) 

const hash = await walletClient.sendTransaction({
  account,
  blobs: toBlobs({ data: stringToHex('blobby blob!') }), // [!code focus]
  kzg,
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
})
```

--------------------------------

### setupKzg with c-kzg and mainnetTrustedSetupPath

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/utilities/setupKzg.md

Sets up the KZG interface for EIP-4844 using the c-kzg library and the mainnet trusted setup path. The kzg parameter must be a Kzg-compatible object with a loadTrustedSetup method, and the path parameter is the file path to the trusted setup file.

```ts
import * as cKzg from 'c-kzg' // [!code focus]
import { setupKzg } from 'viem'
import { mainnetTrustedSetupPath } from 'viem/node'

const kzg = setupKzg(
  cKzg, // [!code focus]
  mainnetTrustedSetupPath
)
```

--------------------------------

### setAutomine Usage

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/test/setAutomine.md

Configures the test client to automatically mine blocks. This example shows the client setup and the action invocation.

```ts
import { testClient } from './client'

await testClient.setAutomine(true) // [!code focus]
```

```ts
import { createTestClient, http } from 'viem'
import { foundry } from 'viem/chains'

export const testClient = createTestClient({
  chain: foundry,
  mode: 'anvil',
  transport: http(), 
})
```

--------------------------------

### Install KZG bindings with bun

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/guides/blob-transactions.md

Install the required KZG bindings using bun.

```bash
bun i c-kzg
# or
bun i kzg-wasm
```

--------------------------------

### Bundler client setup in client.ts

Source: https://github.com/wevm/viem/blob/main/site/pages/account-abstraction/actions/bundler/waitForUserOperationReceipt.md

Defines the bundler client used in the example. This file is imported by the main usage snippet.

```ts
import { createBundlerClient, http } from 'viem'
import { mainnet } from 'viem/chains'
 
export const bundlerClient = createBundlerClient({
  chain: mainnet,
  transport: http(),
})

```

--------------------------------

### Initialize Viem Clients

Source: https://github.com/wevm/viem/blob/main/site/pages/circle-usdc/guides/integrating.mdx

Sets up public and wallet clients using the Sepolia testnet and a private key account.

```typescript
import { createPublicClient, createWalletClient, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { sepolia } from 'viem/chains'

export const account = privateKeyToAccount('0x...')

export const publicClient = createPublicClient({
  chain: sepolia,
  transport: http(),
})

export const walletClient = createWalletClient({
  account,
  chain: sepolia,
  transport: http(),
})
```

--------------------------------

### getEnsText with key parameter

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/ens/actions/getEnsText.md

Example showing the `key` parameter, which is the ENS key to get the text for. The line with `key` is highlighted.

```ts
const ensText = await publicClient.getEnsText({
  name: normalize('wevm.eth'),
  key: 'com.twitter', // [!code focus]
})
```

--------------------------------

### Setup Public Client and Account

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/contract/simulateContract.md

Initializes the public client and account required for contract interactions.

```typescript
import { createPublicClient, custom, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

export const account = privateKeyToAccount('0x...')
 
export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### getEnsText with name parameter

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/ens/actions/getEnsText.md

Example showing the `name` parameter, which is the ENS name to get the text for. The line with `name` is highlighted.

```ts
const ensText = await publicClient.getEnsText({
  name: normalize('wevm.eth'), // [!code focus]
  key: 'com.twitter',
})
```

--------------------------------

### Get Delegation Usage

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/eip7702/getDelegation.md

Demonstrates how to use getDelegation with a public client. The example includes the client configuration and the function call.

```ts
import { publicClient } from './client'

const delegation = await publicClient.getDelegation({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})
// '0x1234...5678' or undefined
```

```ts
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'

export const publicClient = createPublicClient({
  chain: mainnet,
  transport: http()
})
```

--------------------------------

### Sponsor User Operation

Source: https://github.com/wevm/viem/blob/main/site/pages/account-abstraction.mdx

This example demonstrates how to initialize a public client and create a Coinbase Smart Account using a private key as the owner.

```typescript
// @noErrors
import { createPublicClient, http, parseEther } from 'viem'
import { createBundlerClient, toCoinbaseSmartAccount } from 'viem/account-abstraction'
import { mainnet } from 'viem/chains'
import { privateKeyToAccount } from 'viem/accounts' 

export const client = createPublicClient({
  chain: mainnet,
  transport: http(),
})

const owner = privateKeyToAccount('0x...')

export const account = await toCoinbaseSmartAccount({ 
  client, 
  owners: [owner],
  version: '1.1',
}) 
```

--------------------------------

### Import parseEther and config

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/wallet/sendCallsSync.mdx

Imports the parseEther utility and the account and walletClient from a local config file. This is the setup for the compatibility fallback example.

```ts
import { parseEther } from 'viem'
import { account, walletClient } from './config'

```

--------------------------------

### Initialize a Wallet Client

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/accounts/local.md

Set up a Wallet Client with the http transport to begin using Wallet Actions.

```ts
import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'

const client = createWalletClient({
  chain: mainnet,
  transport: http(),
})
```

--------------------------------

### Account Hoisting Example

Source: https://github.com/wevm/viem/blob/main/site/pages/op-stack/actions/buildInitiateWithdrawal.md

Shows how to hoist an account on the wallet client to avoid passing it to every buildInitiateWithdrawal call.

```ts
import { publicClientL1, walletClientL2 } from './config'

const args = await publicClientL1.buildInitiateWithdrawal({
  mint: parseEther('1')
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
})
 
const hash = await walletClientL2.initiateWithdrawal(args)
```

```ts
import { createPublicClient, createWalletClient, custom, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet, optimism } from 'viem/chains'
import { publicActionsL1, walletActionsL2 } from 'viem/op-stack'

// Retrieve Account from an EIP-1193 Provider. // [!code hl]
const [account] = await window.ethereum.request({ // [!code hl]
  method: 'eth_requestAccounts' // [!code hl]
}) // [!code hl]

export const publicClientL1 = createPublicClient({
  chain: mainnet,
  transport: http()
}).extend(publicActionsL1())

export const walletClientL2 = createWalletClient({
  chain: optimism,
  account, // [!code hl]
  transport: custom(window.ethereum)
}).extend(walletActionsL2())
```

```ts
import { createPublicClient, createWalletClient, custom, http } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet, optimism } from 'viem/chains'
import { publicActionsL1, walletActionsL2 } from 'viem/op-stack'

export const publicClientL1 = createPublicClient({
  chain: mainnet,
  transport: http()
}).extend(publicActionsL1())

export const walletClientL2 = createWalletClient({
  account: privateKeyToAccount('0x...'), // [!code hl]
  chain: optimism,
  transport: custom(window.ethereum)
}).extend(walletActionsL2())
```

--------------------------------

### impersonateAccount usage with client setup

Source: https://github.com/wevm/viem/blob/main/site/pages/docs/actions/test/impersonateAccount.md

This example shows how to configure a test client and use the impersonateAccount action to impersonate a specific address.

```ts
import { testClient } from './client'

await testClient.impersonateAccount({ // [!code focus:4]
  address: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'
})
```

```ts
import { createTestClient, http } from 'viem'
import { foundry } from 'viem/chains'

export const testClient = createTestClient({
  chain: foundry,
  mode: 'anvil',
  transport: http(), 
})
```

--------------------------------

### Get Sell Quote

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/actions/dex.getSellQuote.mdx

Retrieves a quote for selling a specified amount of a token. The example uses parseUnits to define the input amount.

```typescript
import { parseUnits } from 'viem'
import { client } from './viem.config'

const amountOut = await client.dex.getSellQuote({
  amountIn: parseUnits('100', 6),
  tokenIn: '0x20c0000000000000000000000000000000000001',
  tokenOut: '0x20c0000000000000000000000000000000000002',
})

console.log('Amount received:', amountOut)
// @log: Amount received: 99700000n
```

--------------------------------

### Setup: viem.config.ts

Source: https://github.com/wevm/viem/blob/main/site/pages/tempo/actions/accessKey.verifyHash.mdx

Sets up a viem wallet client for the Tempo chain, required before using the verifyHash action.

```ts
import { createWalletClient, http } from 'viem'
import { tempo } from 'viem/tempo'

export const walletClient = createWalletClient({
  chain: tempo,
  transport: http(),
})
```
Tokens:
Raw