Viem

https://viem.sh/docs/getting-started
Admin
Viem is a TypeScript interface for Ethereum, providing low-level stateless primitives for...
Tokens:199,208
Snippets:1,381
Trust Score:9
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Viem Library via npm

Source: https://viem.sh/docs/getting-started/getting-started

This snippet shows the command to install the viem library using the npm package manager, which is essential for starting any viem project.

```bash
npm i viem
```

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

### Configure KZG and generate proofs with blobsToProofs

Source: https://viem.sh/docs/getting-started/utilities/blobsToProofs

This advanced example shows how to set up a KZG implementation using `setupKzg` from `viem` with `c-kzg` and a trusted setup path, then integrate it into the `blobsToProofs` function call.

```TypeScript
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)
const commitments = blobsToCommitments({ blobs, kzg })

const proofs = blobsToProofs({
  blobs,
  commitments,
  kzg,
})
```

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

### Fetch Ethereum Block Number using Viem Public Client

Source: https://viem.sh/docs/getting-started/getting-started

After setting up the viem client, this example illustrates how to consume public actions. It uses the configured client to asynchronously retrieve the current block number from the Ethereum blockchain, showcasing a basic interaction.

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

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

const blockNumber = await client.getBlockNumber()
```

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

### Configure Viem Public Client and HTTP Transport

Source: https://viem.sh/docs/getting-started/getting-started

This code demonstrates how to set up a viem public client. It imports `createPublicClient` and `http` from `viem`, and `mainnet` from `viem/chains`, then initializes a client connected to the Ethereum mainnet via HTTP. This client is the foundation for interacting with the blockchain.

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

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

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

### Deploying Smart Contracts with Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

This section provides examples for deploying new smart contracts to the blockchain. It shows how to use a contract factory (Ethers.js) or a wallet client (Viem) along with ABI and bytecode to deploy a contract.

```Ethers.js
import { ContractFactory, providers } from 'ethers'
import { abi, bytecode } from './abi'

const provider = new providers.Web3Provider(window.ethereum)

const [address] = await provider.listAccounts()
const signer = provider.getSigner(address)

const contract = new ContractFactory(abi, bytecode, signer)
await contract.deploy()
```

```Viem
import { createWalletClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { abi, bytecode } from './abi'

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

const [address] = await walletClient.getAddresses()

await walletClient.deployContract({
  abi,
  account: address,
  bytecode,
})
```

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

### Import trusted setup contents from viem/trusted-setups

Source: https://viem.sh/docs/getting-started/utilities/setupKzg

Demonstrates how to directly import the JSON contents of trusted setup files (mainnet and minimal) from the `viem/trusted-setups` entrypoint. This provides the raw trusted setup data.

```TypeScript
import mainnetTrustedSetup from 'viem/trusted-setups/mainnet.json'
import minimalTrustedSetup from 'viem/trusted-setups/minimal.json'
```

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

### Initialize KZG interface with setupKzg and c-kzg

Source: https://viem.sh/docs/getting-started/utilities/setupKzg

Illustrates how to use `setupKzg` to initialize a KZG interface, providing a `c-kzg` implementation and a trusted setup path from `viem/node`. This setup is essential for EIP-4844 blob operations.

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

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

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

### Build and Globally Link Viem from Source

Source: https://viem.sh/docs/getting-started/installation

Provides a sequence of shell commands to clone the Viem repository, install its dependencies, build the project, and link it globally on your system. This is useful for local development or contributing to Viem.

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

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

### Install Viem Canary Release via pnpm

Source: https://viem.sh/docs/getting-started/installation

Installs the latest unreleased version of Viem from the `canary` tag using pnpm. This version tracks the `main` branch and is useful for testing new features.

```bash
pnpm add viem@canary
```

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

### Install Viem via pnpm

Source: https://viem.sh/docs/getting-started/installation

Installs the stable release of the Viem library using the pnpm package manager, adding it to your project's dependencies.

```bash
pnpm add viem
```

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

### Import trusted setup paths from viem/node

Source: https://viem.sh/docs/getting-started/utilities/setupKzg

Shows how to import paths to trusted setup files (mainnet and minimal) from the `viem/node` entrypoint. This method is designed for environments that support Node.js' `node:fs` module.

```TypeScript
import {
  mainnetTrustedSetupPath,
  minimalTrustedSetupPath,
} from 'viem/node'
```

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

### Link Globally Built Viem to a Local Project

Source: https://viem.sh/docs/getting-started/installation

Instructs how to link the globally installed Viem package (which was built from source) to a specific local project using pnpm. This allows your project to use the locally compiled version of Viem.

```bash
pnpm link --global viem
```

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

### Reading Data from Smart Contracts with Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

This section illustrates how to interact with smart contracts to read public state variables or call view functions. It shows examples for fetching contract data using both Ethers.js and Viem, typically requiring a provider or public client.

```Ethers.js
import { getDefaultProvider } from 'ethers'
import { wagmiContractConfig } from './abi'

const provider = getDefaultProvider()

const { abi, address } = wagmiContractConfig
const contract = new Contract(address, abi, provider)
const supply = await contract.totalSupply()
```

```Viem
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { wagmiContractConfig } from './abi'

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

const supply = await client.readContract({
  ...wagmiContractConfig,
  functionName: 'totalSupply'
})
```

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

### Viem publicClient.getProof Usage Examples

Source: https://viem.sh/docs/getting-started/actions/public/getProof

Examples demonstrating how to use the `publicClient.getProof` method in Viem to retrieve an account's proof, specifying either a `blockNumber` or a `blockTag`.

```TypeScript
const proof = await publicClient.getProof({
  address: '0x4200000000000000000000000000000000000016',
  storageKeys: [
    '0x4a932049252365b3eedbc5190e18949f2ec11f39d3bef2d259764799a1b27d99'
  ],
  blockNumber: 42069n
})
```

```TypeScript
const proof = await publicClient.getProof({
  address: '0x4200000000000000000000000000000000000016',
  storageKeys: [
    '0x4a932049252365b3eedbc5190e18949f2ec11f39d3bef2d259764799a1b27d99'
  ],
  blockTag: 'latest'
})
```

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

### Basic Viem simulateCalls Usage Example

Source: https://viem.sh/docs/getting-started/actions/public/simulateCalls

A fundamental example demonstrating the `client.simulateCalls` method with basic `account` and `calls` array configuration, including `to` and `value` fields. This snippet serves as a base for many parameter examples.

```TypeScript
const { results } = await client.simulateCalls({
  account: '0x5a0b54d5dc17e482fe8b0bdca5320161b95fb929',
  calls: [
    {
      to: '0xcb98643b8786950F0461f3B0edf99D88F274574D',
      value: parseEther('2'),
    },
  ],
})
```

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

### Install viem toFunctionSelector

Source: https://viem.sh/docs/getting-started/utilities/toFunctionSelector

Import the `toFunctionSelector` utility from the `viem` library.

```TypeScript
import { toFunctionSelector } from 'viem'
```

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

### Install KZG Bindings

Source: https://viem.sh/docs/getting-started/guides/blob-transactions

This command installs the necessary KZG bindings for computing blob commitments and generating proofs. It provides options for `c-kzg` (Node.js bindings) or `kzg-wasm` (WebAssembly bindings), both essential for serializing and signing Blob Transactions.

```Shell
npm i c-kzg
# or
npm i kzg-wasm
```

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

### Extend Viem Client with Custom Actions (Geth Debug Example)

Source: https://viem.sh/docs/getting-started/clients/custom

Provides an example of extending a Viem client to include custom actions, specifically a `traceCall` method that interacts with the `debug_traceCall` RPC method, mimicking a Geth Debug Client. This showcases how to add bespoke functionality to a client.

```typescript
import {
  createClient,
  http,
  formatTransactionRequest,
  type CallParameters
} from 'viem'
import { mainnet } from 'viem/chains'

const debugClient = createClient({
  chain: mainnet,
  transport: http()
}).extend(client => ({
  // ...
  async traceCall(args: CallParameters) {
    return client.request({
      method: 'debug_traceCall',
      params: [formatTransactionRequest(args), 'latest', {}]
    })
  },
  // ...
}))

const response = await debugClient.traceCall({
  account: '0xdeadbeef29292929192939494959594933929292',
  to: '0xde929f939d939d393f939393f93939f393929023',
  gas: 69420n,
  data: '0xf00d4b5d00000000000000000000000001291230982139282304923482304912923823920000000000000000000000001293123098123928310239129839291010293810'
})
// { failed: false, gas: 69420, returnValue: '...', structLogs: [] }
```

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

### Viem Wallet Client: Sign Transaction Example

Source: https://viem.sh/docs/getting-started/actions/wallet/signTransaction

Example demonstrating how to use `walletClient.signTransaction` to sign an Ethereum transaction, including setting the recipient address, transaction value using `parseEther`, and a nonce.

```JavaScript
const signature = await walletClient.signTransaction({
  account,
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: parseEther('1'),
  nonce: 69
})
```

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

### Get Logs with `parseAbiItem` and Full Scoping

Source: https://viem.sh/docs/getting-started/actions/public/getLogs

Demonstrates how to fetch logs using `publicClient.getLogs`, specifying an address, an event parsed from a human-readable ABI string using `parseAbiItem`, indexed arguments, and a block range. This example shows a comprehensive log filtering setup.

```TypeScript
import { parseAbiItem } from 'viem'
import { publicClient } from './client'

const logs = await publicClient.getLogs({
  address: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
  event: parseAbiItem('event Transfer(address indexed from, address indexed to, uint256)'),
  args: {
    from: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
    to: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac'
  },
  fromBlock: 16330000n,
  toBlock: 16330050n
})
```

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

### Example: Passing blobs Parameter

Source: https://viem.sh/docs/getting-started/utilities/blobsToCommitments

Shows a practical example of providing the `blobs` parameter to `blobsToCommitments`, demonstrating how `toBlobs` can be used inline to generate the required input.

```typescript
import { blobsToCommitments, toBlobs } from 'viem'

const commitments = blobsToCommitments({
  blobs: toBlobs({ data: '0x1234' }),
  kzg,
})
```

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

### Example: Providing kzg Implementation

Source: https://viem.sh/docs/getting-started/utilities/blobsToCommitments

Illustrates how to set up and provide a `kzg` implementation using `setupKzg` from `viem` and `c-kzg`, then passing it to `blobsToCommitments`.

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

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath)

const commitments = blobsToCommitments({
  blobs: toBlobs({ data: '0x1234' }),
  kzg,
})
```

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

### Get Transaction Count for an Account (Viem TypeScript)

Source: https://viem.sh/docs/getting-started/actions/public/getTransactionCount

This TypeScript example demonstrates how to use the `publicClient.getTransactionCount` method from the Viem library to fetch the total number of transactions an Ethereum address has broadcast. It shows a basic asynchronous call with an example address.

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

const transactionCount = await publicClient.getTransactionCount({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})

> 420
```

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

### Start watchEvent from a specific fromBlock (TypeScript)

Source: https://viem.sh/docs/getting-started/actions/public/watchEvent

This example shows how to configure `publicClient.watchEvent` to begin listening for logs from a particular block number using the `fromBlock` parameter. This is useful for fetching historical event data, ensuring that logs are retrieved starting from the specified blockchain height.

```TypeScript
const unwatch = publicClient.watchEvent(
  {
    fromBlock: 1n,
    onLogs: logs => console.log(logs),
  }
)
```

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

### Configure Wallet Client with a Chain

Source: https://viem.sh/docs/getting-started/clients/wallet

Example of initializing `createWalletClient` with a specific blockchain chain, such as `mainnet`.

```javascript
const client = createWalletClient({
  chain: mainnet,
  transport: custom(window.ethereum!)
})
```

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

### Create Event Filter from Specific Block with viem

Source: https://viem.sh/docs/getting-started/actions/public/getLogs

Example of using `publicClient.createEventFilter` with the `fromBlock` parameter to start including logs from a particular block number.

```javascript
const filter = await publicClient.createEventFilter({
  fromBlock: 69420n
})
```

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

### API Reference for setupKzg function

Source: https://viem.sh/docs/getting-started/utilities/setupKzg

Detailed API documentation for the `setupKzg` function, including its parameters, their types, descriptions, and the function's return type. This function configures the KZG interface for EIP-4844.

```APIDOC
Function: setupKzg

Parameters:
  kzg:
    Type: Kzg & { loadTrustedSetup(path: string): void }
    Description: The EIP-4844 compatible KZG interface. This object must implement specific functions for KZG operations.
    Required functions:
      - loadTrustedSetup(path: string): Initializes the KZG trusted setup.
      - blobToKzgCommitment(blob: Blob): Takes a blob and returns its KZG commitment.
      - computeBlobKzgProof(blob: Blob, commitment: Commitment): Takes a blob and its commitment, and returns the KZG proof.
  path:
    Type: string
    Description: The path to the trusted setup file (e.g., 'mainnetTrustedSetupPath').

Returns:
  Type: Kzg
  Description: The initialized KZG interface, ready for use in blob transaction signing.
```

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

### Get Chain ID with Viem Public Client

Source: https://viem.sh/docs/getting-started/actions/public/getChainId

Example demonstrating how to fetch the chain ID of the connected network using the `getChainId` method available on a Viem public client.

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

const chainId = await publicClient.getChainId()
```

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

### Create and Use Viem Contract Instance

Source: https://viem.sh/docs/getting-started/contract/getContract

Demonstrates how to initialize a contract instance using `getContract` with `publicClient` and `walletClient`. It then shows examples of reading contract state, fetching past events, and setting up a real-time event watcher.

```typescript
import { getContract } from 'viem'
import { wagmiAbi } from './abi'
import { publicClient, walletClient } from './client'

// 1. Create contract instance
const contract = getContract({
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: wagmiAbi,
  // 1a. Insert a single client
  client: publicClient,
  // 1b. Or public and/or wallet clients
  client: { public: publicClient, wallet: walletClient }
})

// 2. Call contract methods, fetch events, listen to events, etc.
const result = await contract.read.totalSupply()
const logs = await contract.getEvents.Transfer()
const unwatch = contract.watchEvent.Transfer(
  { from: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e' },
  { onLogs(logs) { console.log(logs) } }
)
```

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

### Get Call Batch Status (TypeScript)

Source: https://viem.sh/docs/getting-started/actions/wallet/getCallsStatus

Demonstrates how to use `walletClient.getCallsStatus` to retrieve the status of a previously sent call batch using its ID. The example shows the expected input and the structure of the returned result.

```TypeScript
import { walletClient } from './config'

const result = await walletClient.getCallsStatus({
  id: '0x1234567890abcdef',
})

{

atomic: false,

chainId: 1,

id: '0x1234567890abcdef',

statusCode: 200,

status: 'success',

receipts: [{ ... }],

}
```

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

### Import setupKzg function in Viem

Source: https://viem.sh/docs/getting-started/utilities/setupKzg

Demonstrates how to import the `setupKzg` utility from the `viem` library for use in your application.

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

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

### Get Proof for Account and Storage Keys (TypeScript)

Source: https://viem.sh/docs/getting-started/actions/public/getProof

Demonstrates how to use `publicClient.getProof` to retrieve the Merkle-proof for a specific account address and a list of storage keys. This example uses a hardcoded address and storage key.

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

const proof = await publicClient.getProof({
  address: '0x4200000000000000000000000000000000000016',
  storageKeys: [
    '0x4a932049252365b3eedbc5190e18949f2ec11f39d3bef2d259764799a1b27d99'
  ]
})
```

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

### Set up Private Key Account with viem

Source: https://viem.sh/docs/getting-started/clients/wallet

Illustrates how to instantiate a private key account using `privateKeyToAccount` from `viem/accounts` and associate it with a viem Wallet Client. This account can then be used for signing transactions.

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

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

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

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

### Get EIP-712 Domain from Contract

Source: https://viem.sh/docs/getting-started/actions/public/getEip712Domain

This TypeScript example demonstrates how to use the `publicClient.getEip712Domain` function from the Viem library. It retrieves the EIP-712 domain, extensions, and fields from a contract at a specified address, adhering to the ERC-5267 specification.

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

const { domain, extensions, fields } = await publicClient.getEip712Domain({
  address: '0x57ba3ec8df619d4d243ce439551cce713bb17411',
})
```

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

### Get Block Transaction Count using viem with Block Tag

Source: https://viem.sh/docs/getting-started/actions/public/getBlockTransactionCount

Example demonstrating how to use the `publicClient.getBlockTransactionCount` method from the viem library to fetch the number of transactions in a block, specifying a 'safe' block tag.

```JavaScript
const block = await publicClient.getBlockTransactionCount({
  blockTag: 'safe'
})
```

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

### Instantiate a Private Key Local Account in Viem

Source: https://viem.sh/docs/getting-started/accounts/local

This example shows how to set up a local account using `privateKeyToAccount` from `viem/accounts`. It builds upon the previously initialized Wallet Client, preparing a private key-based account for signing operations.

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

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

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

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

### Filter Events from a Specific Block in Viem

Source: https://viem.sh/docs/getting-started/actions/public/createEventFilter

This example illustrates how to set a starting block for event queries using the `fromBlock` parameter. It ensures that `createEventFilter` only retrieves or listens for events from the specified block number onwards.

```javascript
const filter = await publicClient.createEventFilter({
  fromBlock: 69420n
})
```

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

### Viem: Example `accessList` parameter

Source: https://viem.sh/docs/getting-started/accounts/local/signTransaction

This example demonstrates how to include an `accessList` array in the transaction object when calling `account.signTransaction`. An access list specifies addresses and storage keys that are expected to be accessed during transaction execution, potentially reducing gas costs.

```javascript
const signature = await account.signTransaction({
  accessList: [
    {
      address: '0x1',
      storageKeys: ['0x1'],
    },
  ],
  chainId: 1,
})
```

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

### Install decodeAbiParameters in Viem

Source: https://viem.sh/docs/getting-started/abi/decodeAbiParameters

Import the `decodeAbiParameters` function from the `viem` library for use in your project.

```TypeScript
import { decodeAbiParameters } from 'viem'
```

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

### Force Polling with `poll` in `watchBlocks`

Source: https://viem.sh/docs/getting-started/actions/public/watchBlocks

Illustrates how to explicitly force `watchBlocks` to use a polling mechanism instead of a WebSocket subscription, even when a WebSocket transport is available. This example also shows the necessary setup for a `publicClient` with a WebSocket transport.

```JavaScript
import { createPublicClient, webSocket } from 'viem'
import { mainnet } from 'viem/chains'

const publicClient = createPublicClient({
  chain: mainnet,
  transport: webSocket()
})

const unwatch = publicClient.watchBlocks(
  {
    onBlock: block => console.log(block),
    poll: true,
  }
)
```

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

### Import Viem via ESM CDN

Source: https://viem.sh/docs/getting-started/installation

Demonstrates how to import Viem's `createClient` function directly in an HTML file using an ESM-compatible CDN like esm.sh, suitable for browser environments without a build step.

```html
<script type="module">
  import { createClient } from 'https://esm.sh/viem'
</script>
```

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

### Get Transaction Confirmations with Viem

Source: https://viem.sh/docs/getting-started/actions/public/getTransactionConfirmations

Demonstrates how to retrieve the number of block confirmations for a transaction using Viem's `publicClient.getTransactionConfirmations` function. It shows examples for using both a transaction receipt and a transaction hash as input, along with its API specification.

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

const transactionReceipt = await publicClient.getTransactionReceipt({ hash: '...' })
const confirmations = await publicClient.getTransactionConfirmations({
  transactionReceipt
})
// 15n
```

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

const confirmations = await publicClient.getTransactionConfirmations({
  hash: '0x...'
})

15n
```

```APIDOC
getTransactionConfirmations:
  Returns:
    Type: bigint
    Description: The number of blocks passed since the transaction was processed. If confirmations is 0, then the Transaction has not been confirmed & processed yet.
  Parameters:
    (No parameters listed in the provided text)
```

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

### Install viem sha256 utility

Source: https://viem.sh/docs/getting-started/utilities/sha256

Instructions to import the `sha256` function from the `viem` library for use in your project.

```TypeScript
import { sha256 } from 'viem'
```

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

### JavaScript: Example of a Conforming Ethereum Log

Source: https://viem.sh/docs/getting-started/glossary/terms

Illustrates a JavaScript object representing a conforming Ethereum log. It shows how the `data` field contains the non-indexed argument (`baz`) and the `topics` array contains the event signature and all indexed arguments (`foo`, `bar`, `barry`), matching the event definition.

```JavaScript
const log = {
  ...
  data: '0x\n    00...23c346 // ✅ non-indexed argument (baz)\n  ',
  topics: [
    '0xdd...23b3ef', // event signature
    '0x00...000001', // ✅ indexed argument (foo)
    '0xae...e1cc58', // ✅ indexed argument (bar)
    '0x00...000000', // ✅ indexed argument (barry)
  ],
  ...
}
```

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

### Get the byte length of hex data

Source: https://viem.sh/docs/getting-started/ethers-migration

Demonstrates how to determine the byte length of a hexadecimal string (excluding the '0x' prefix) using Ethers.js's `hexDataLength` and Viem's `size`.

```TypeScript
import { utils } from 'ethers'

utils.hexDataLength('0x00000069')
```

```TypeScript
import { size } from 'viem'

size('0x00000069')
```

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

### API Documentation: createClient Function Parameters

Source: https://viem.sh/docs/getting-started/clients/custom

Detailed documentation for the configuration parameters of the `createClient` function in Viem. This includes types, descriptions, default values, and nested properties for advanced settings like batching.

```APIDOC
createClient(options: object): Client
  options:
    transport: Transport
      Description: The Transport of the Public Client.
    account (optional): Account | Address
      Description: The Account to use for the Client. This will be used for Actions that require an `account` as an argument. Accepts a JSON-RPC Account or Local Account (Private Key, etc).
    chain (optional): Chain
      Description: The Chain of the Public Client.
    batch (optional): object
      Description: Flags for batch settings.
      Properties:
        multicall (optional): boolean | MulticallBatchOptions
          Default: false
          Description: Toggle to enable `eth_call` multicall aggregation.
          Properties:
            batchSize (optional): number
              Default: 1_024
              Description: The maximum size (in bytes) for each multicall (`aggregate3`) calldata chunk. Note: Some RPC Providers limit the amount of calldata that can be sent in a single request. It is best to check with your RPC Provider to see if there are any calldata size limits to `eth_call` requests.
            wait (optional): number
              Default: 0
              Description: The maximum number of milliseconds to wait before sending a batch.
    key (optional): string
      Default: "public"
      Description: A key for the Client.
    name (optional): string
      Default: "Public Client"
      Description: A name for the Client.
    pollingInterval (optional): number
      Default: 4_000
      Description: Frequency (in ms) for polling enabled Actions.
    rpcSchema (optional): RpcSchema
      Default: WalletRpcSchema
      Description: Typed JSON-RPC schema for the client.
```

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

### Get Transaction by Hash using Viem Public Client

Source: https://viem.sh/docs/getting-started/actions/public/getTransaction

Demonstrates how to retrieve transaction details using the `getTransaction` public action with a Viem public client, specifying the transaction hash. The example shows the structure of the returned transaction object.

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

const transaction = await publicClient.getTransaction({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d'
})

{
blockHash: '0xaf1dadb8a98f1282e8f7b42cc3da8847bfa2cf4e227b8220403ae642e1173088',
blockNumber: 15132008n,
from: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
...
}
```

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

### Install ripemd160 utility in viem

Source: https://viem.sh/docs/getting-started/utilities/ripemd160

Shows how to import the `ripemd160` function from the `viem` library.

```TypeScript
import { ripemd160 } from 'viem'
```

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

### Get Function Signature Hash (Sighash)

Source: https://viem.sh/docs/getting-started/ethers-migration

Shows how to compute the 4-byte function signature hash (sighash) for a given function signature. Ethers.js uses `Interface.getSighash` with `FunctionFragment`, while viem uses `toFunctionHash`.

```Ethers.js
import { Interface, FunctionFragment } from '@ethersproject/abi';

const hash = Interface.getSighash(FunctionFragment.from('function ownerOf(uint256)'));
```

```Viem
import { toFunctionHash } from 'viem'

const hash = toFunctionHash('function ownerOf(uint256)')
```

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

### Initialize and Use a Wallet/Account with Private Key in Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

Demonstrates how to create and use a wallet (Ethers.js) or an account (Viem) from a private key for sending transactions. Viem uses `privateKeyToAccount` to derive the account from a private key string.

```javascript
import { providers, Wallet } from 'ethers'

const provider = new providers.Web3Provider(window.ethereum)

const wallet = new Wallet('0x...', provider)

wallet.sendTransaction({ ... })
```

```javascript
import { createWalletClient, custom } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { mainnet } from 'viem/chains'

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

const client = createWalletClient({
  account,
  chain: mainnet,
  transport: custom(window.ethereum)
})

client.sendTransaction({ ... })
```

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

### Decode Error Result

Source: https://viem.sh/docs/getting-started/ethers-migration

Demonstrates how to decode an error result from a smart contract call. The viem example uses `decodeErrorResult` directly, requiring the contract's ABI and the raw error data.

```Viem
import { decodeErrorResult, parseEther } from 'viem'
import { abi } from './abi'

const result = decodeErrorResult({
  abi,
  data: '0xf7c3865a0000000000000000000000008ba1f109551bd432803012645ac136ddd64dba720000000000000000000000000000000000000000000000000de0b6b3a7640000'
})
```

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

### Decode ABI Parameters with Ethers and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

Demonstrates how to decode ABI-encoded data using Ethers.js's `defaultAbiCoder` and Viem's `decodeAbiParameters`. Examples include decoding both object and human-readable formats.

```javascript
import { utils } from 'ethers'

const abiCoder = utils.defaultAbiCoder()

// Object
abiCoder.decode(
  [{ type: 'uint', name: 'x' }, { type: 'string', name: 'y' }],
  '0x00000000000000000000000000000000000000000000000000000000000004d20000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000'
)

// Human Readable
abiCoder.decode(
  ['uint', 'string'],
  '0x00000000000000000000000000000000000000000000000000000000000004d20000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000'
);
```

```javascript
import { decodeAbiParameters, parseAbiParameters } from 'viem'

// Object
decodeAbiParameters(
  [{ type: 'uint', name: 'x' }, { type: 'string', name: 'y' }],
  '0x00000000000000000000000000000000000000000000000000000000000004d20000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000'
)

// Human Readable
decodeAbiParameters(
  parseAbiParameters('uint, string'),
  '0x00000000000000000000000000000000000000000000000000000000000004d20000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000b48656c6c6f20576f726c64000000000000000000000000000000000000000000'
)
```

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

### Deploy Smart Contract with Viem walletClient

Source: https://viem.sh/docs/getting-started/contract/deployContract

This JavaScript code snippet demonstrates how to deploy a smart contract using Viem's `walletClient.deployContract` method. It illustrates passing the contract's ABI, the deploying account, the bytecode, and any required constructor arguments (e.g., `[69]`) to initiate the deployment transaction.

```javascript
const hash = await walletClient.deployContract({
  abi: wagmiAbi,
  account: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
  args: [69]
})
```

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

### Execute a contract write function with simulateContract and writeContract

Source: https://viem.sh/docs/getting-started/contract/writeContract

This example demonstrates how to safely execute a contract write function by first simulating it with `publicClient.simulateContract` to get the request, and then broadcasting the transaction using `walletClient.writeContract`. This pattern ensures the transaction is likely to succeed before sending it.

```ts
import { account, publicClient, walletClient } from './config'
import { wagmiAbi } from './abi'

const { request } = await publicClient.simulateContract({
  account,
  address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
  abi: wagmiAbi,
  functionName: 'mint',
})
await walletClient.writeContract(request)
```

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

### Deploying a contract using Viem's `deployContract`

Source: https://viem.sh/docs/getting-started/contract/deployContract

This example demonstrates the basic usage of `walletClient.deployContract` to deploy a smart contract to the network. It requires the contract's ABI, an account for deployment, and the contract's bytecode.

```typescript
import { wagmiAbi } from './abi'
import { account, walletClient } from './config'

const hash = await walletClient.deployContract({
  abi,
  account,
  bytecode: '0x608060405260405161083e38038061083e833981016040819052610...'
})
```

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

### Get account balance using Viem public client

Source: https://viem.sh/docs/getting-started/actions/public/getBalance

Demonstrates how to retrieve the balance of a specified Ethereum address in wei using the `getBalance` public action from Viem's public client. This example shows a basic call without specifying a block number.

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

const balance = await publicClient.getBalance({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
})
```

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

### Viem createTestClient Function Parameters

Source: https://viem.sh/docs/getting-started/clients/test

Detailed API documentation for the parameters accepted by the `createTestClient` function in Viem, including their types, descriptions, and usage examples.

```APIDOC
createTestClient(options: object): Client
  Parameters:
    mode: "anvil" | "hardhat" | "ganache"
      Description: Mode of the Test Client.
      Example:
        const client = createTestClient({
          chain: foundry,
          mode: 'anvil',
          transport: http(),
        })
    transport: Transport
      Description: Transport of the Test Client.
      Example:
        const client = createTestClient({
          chain: foundry,
          mode: 'anvil',
          transport: http(),
        })
    account (optional): Account | Address
      Description: The Account to use for the Client. This will be used for Actions that require an `account` as an argument. Accepts a JSON-RPC Account or Local Account (Private Key, etc).
      Example:
        import { privateKeyToAccount } from 'viem/accounts'

        const client = createTestClient({
          account: privateKeyToAccount('0x...'),
          chain: foundry,
          mode: 'anvil',
          transport: http(),
        })
    chain (optional): Chain
      Description: Chain of the Test Client.
      Example:
        const client = createTestClient({
          chain: foundry,
          mode: 'anvil',
          transport: http(),
        })
```

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

### Set up Viem Wallet Client

Source: https://viem.sh/docs/getting-started/guides/blob-transactions

This code sets up a Viem Wallet Client for interacting with the Ethereum network. It imports necessary modules like `createWalletClient`, `http`, `privateKeyToAccount`, and `mainnet`. It exports an `account` derived from a private key and a `client` configured with the account, mainnet chain, and HTTP transport.

```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()
})
```

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

### Decode Event Log

Source: https://viem.sh/docs/getting-started/ethers-migration

Shows how to decode event logs emitted by smart contracts. The Ethers.js example uses `utils.Interface` and `decodeEventLog`, while viem uses `decodeEventLog` directly. Both require the contract's ABI, event data, and topics.

```Ethers.js
import { utils } from 'ethers'
import { abi } from './abi'

const iface = new utils.Interface(abi);
const result = iface.decodeEventLog(
  'Transfer',
  data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
  topics: [
    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
    '0x0000000000000000000000008ba1f109551bd432803012645ac136ddd64dba72',
    '0x000000000000000000000000ab7c8803962c0f2f5bbbe3fa8bf41cd82aa1923c'
  ]
);
```

```Viem
import { decodeEventLog, parseEther } from 'viem'
import { abi } from './abi'

const result = decodeEventLog({
  abi,
  data: '0x0000000000000000000000000000000000000000000000000de0b6b3a7640000',
  topics: [
    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
    '0x0000000000000000000000008ba1f109551bd432803012645ac136ddd64dba72',
    '0x000000000000000000000000ab7c8803962c0f2f5bbbe3fa8bf41cd82aa1923c'
  ]
})
```

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

### Consolidating Viem Entrypoint Imports in 2.x.x

Source: https://viem.sh/docs/getting-started/migration-guide

Illustrates the removal of specific `viem/abi`, `viem/contract`, `viem/public`, `viem/test`, and `viem/wallet` entrypoints. Imports should now be directly from the main `viem` package.

```javascript
import { encodeAbiParameters } from 'viem/abi'
import { getContract } from 'viem/contract'
import { getBlock } from 'viem/public'
import { mine } from 'viem/test'
import { sendTransaction } from 'viem/wallet'
import {
  encodeAbiParameters,
  getContract,
  getBlock,
  mine,
  sendTransaction,
} from 'viem'
```

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

### Estimating Gas for Smart Contract Interactions with Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

This section provides examples for estimating the gas required for smart contract transactions. It shows how to use provider/public client methods to calculate gas costs before sending a transaction, using both Ethers.js and Viem.

```Ethers.js
import { getDefaultProvider } from 'ethers'
import { wagmiContractConfig } from './abi'

const provider = getDefaultProvider()

const { abi, address } = wagmiContractConfig
const contract = new Contract(address, abi, provider)
const gas = await contract.estimateGas.mint()
```

```Viem
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { wagmiContractConfig } from './abi'

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

const gas = await client.estimateContractGas({
  ...wagmiContractConfig,
  functionName: 'mint'
})
```

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

### Get and Use a Signer/Account from Injected Provider with Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

Illustrates how to obtain a signer (Ethers.js) or an account (Viem) from an injected Web3 provider and use it to send transactions. Viem uses the term 'Account' instead of 'Signer' and directly requests accounts from `window.ethereum`.

```javascript
import { providers } from 'ethers'

const provider = new providers.Web3Provider(window.ethereum)

const [address] = await provider.listAccounts()
const signer = provider.getSigner(address)

signer.sendTransaction({ ... })
```

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

const [account] = await window.ethereum.request({ method: 'eth_requestAccounts' })

const client = createWalletClient({
  account,
  chain: mainnet,
  transport: custom(window.ethereum)
})

client.sendTransaction({ ... })
```

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

### Initialize Viem Wallet Client

Source: https://viem.sh/docs/getting-started/actions/wallet/watchAsset

Shows how to create a `walletClient` instance using `createWalletClient` from Viem, configured for the Ethereum mainnet and a custom transport like `window.ethereum`.

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

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

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

### Initialize Mnemonic Account and Wallet Client

Source: https://viem.sh/docs/getting-started/accounts/local/mnemonicToAccount

Demonstrates how to initialize a Mnemonic Account using `mnemonicToAccount` with a sample mnemonic phrase and then create a `WalletClient` configured with this account for interacting with the Ethereum mainnet.

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

const account = mnemonicToAccount('legal winner thank year wave sausage worth useful legal winner thank yellow')

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

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

### Migrate InfuraProvider from Ethers v5 to viem

Source: https://viem.sh/docs/getting-started/ethers-migration

This example shows how to migrate from Ethers v5's `InfuraProvider` to viem. viem does not provide dedicated API provider clients; instead, you directly pass the Infura RPC URL to the `http` transport within `createPublicClient`.

```TypeScript
import { providers } from 'ethers'

const provider = new providers.InfuraProvider('homestead', '<apiKey>')
```

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

const client = createPublicClient({
  chain: mainnet,
  transport: http('https://mainnet.infura.io/v3/<apiKey>')
})
```

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

### Retrieve Transaction Pool Content in TypeScript

Source: https://viem.sh/docs/getting-started/actions/test/getTxpoolContent

This example demonstrates how to use the `getTxpoolContent` method from the `testClient` to retrieve the current state of the transaction pool. It imports `testClient` and then calls the asynchronous `getTxpoolContent` function to get pending and queued transactions. The function returns the transaction pool content, which includes details about pending and queued transactions.

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

const content = await testClient.getTxpoolContent()
```

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

### Viem Client Tree-shaking with Direct Action Imports

Source: https://viem.sh/docs/getting-started/clients/custom

This example demonstrates how to achieve maximum tree-shaking by importing Viem actions directly and injecting the client as the first parameter, rather than relying on decorated actions. This approach helps minimize bundle size by only including the actions explicitly used.

```javascript
import { createClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { getBlock, sendTransaction } from 'viem/actions'

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

const blockNumber = await getBlock(client, { blockTag: 'latest' })
const hash = await sendTransaction(client, { ... })
```

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

### Viem's Approach to ABI Fragments and Interfaces

Source: https://viem.sh/docs/getting-started/ethers-migration

Explains Viem's philosophy regarding ABI fragments and interfaces, emphasizing its direct approach to ABIs without middleware abstractions. It lists utilities like `getAbiItem`, `parseAbi`, `parseAbiItem`, `parseAbiParameters`, and `parseAbiParameter` as alternatives to Ethers' fragment concept.

```APIDOC
In viem, there is no concept of "fragments" & "interfaces". We want to stick as close to the wire as possible and not introduce middleware abstractions and extra layers over ABIs. Instead of working with "fragments", we encourage you to work with the ABI itself.
We provide utilities such as `getAbiItem`, `parseAbi` `parseAbiItem`, `parseAbiParameters` and `parseAbiParameter` which covers the use cases of interfaces & fragments.
```

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

### Basic viem Utility Functions

Source: https://viem.sh/docs/getting-started/ethers-migration

Demonstrates fundamental utility functions in viem, including generating a function selector from a signature and hashing UTF-8 data using `keccak256`.

```TypeScript
import { toFunctionSelector, keccak256, toHex } from 'viem'

toFunctionSelector('function ownerOf(uint256 tokenId)')

// hash utf-8 data
keccak256(toHex('hello world'))
```

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

### Listening to Smart Contract Events with Ethers.js and Viem

Source: https://viem.sh/docs/getting-started/ethers-migration

This section demonstrates how to subscribe to and handle events emitted by smart contracts. It shows how to set up event listeners and how to unsubscribe using both Ethers.js and Viem.

```Ethers.js
import { getDefaultProvider } from 'ethers'
import { wagmiContractConfig } from './abi'

const provider = getDefaultProvider()

const { abi, address } = wagmiContractConfig
const contract = new Contract(address, abi, provider)

const listener = (from, to, amount, event) => {
  // ...
}
contract.on('Transfer', listener)

// unsubscribe
contract.off('Transfer', listener)
```

```Viem
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
import { wagmiContractConfig } from './abi'

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

const unwatch = client.watchContractEvent({
  ...wagmiContractConfig,
  eventName: 'Transfer',
  onLogs: logs => {
    const { args: { from, to, amount }, eventName } = logs[0]
    // ...
  },
})

// unsubscribe
unwatch()
```
Tokens:
Raw