Viem

https://viem.sh/docs
Admin
Viem is a collection of lightweight, composable, and type-safe modules for building reliable...
Tokens:253,223
Snippets:2,006
Trust Score:9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Configuration Setup

Source: https://viem.sh/docs/actions/wallet/sendRawTransaction

Example configuration for initializing the wallet client and account.

```ts
// [!include ~/snippets/walletClient.ts]

export const [account] = await walletClient.getAddresses()
// @log: ↑ JSON-RPC Account

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

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

### Install Viem with bun

Source: https://viem.sh

Install the Viem library using bun.

```bash
bun i viem
```

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

### Install Viem with npm

Source: https://viem.sh

Install the Viem library using npm.

```bash
npm i viem
```

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

### Client Configuration

Source: https://viem.sh/docs/actions/public/fillTransaction

Setup for the public client and account used in the transaction example.

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

export const account = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'

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

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

### Install Viem with pnpm

Source: https://viem.sh

Install the Viem library using pnpm.

```bash
pnpm i viem
```

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

### Parameter Examples

Source: https://viem.sh/docs/contract/encodeEventTopics

Examples showing how to pass specific parameters to the function.

```ts
const data = encodeEventTopics({
  abi: wagmiAbi, // [!code focus]
  functionName: 'Transfer',
})
```

```ts
const data = encodeEventTopics({
  abi: wagmiAbi,
  eventName: 'Transfer', // [!code focus]
})
```

```ts
const data = encodeEventTopics({
  abi: wagmiAbi,
  eventName: 'Transfer',
  args: { // [!code focus:4]
    from: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
    to: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac'
  }
})
```

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

### Parameter Examples

Source: https://viem.sh/docs/eip7702/hashAuthorization

Examples demonstrating individual parameters for the hashAuthorization function.

```ts
import { hashAuthorization } from 'viem/utils'

hashAuthorization({
  contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045', // [!code focus]
  chainId: 1,
  nonce: 0,
}) 
```

```ts
import { hashAuthorization } from 'viem/utils'

hashAuthorization({
  contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
  chainId: 1, // [!code focus]
  nonce: 0,
}) 
```

```ts
import { hashAuthorization } from 'viem/utils'

hashAuthorization({
  contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
  chainId: 1,
  nonce: 0, // [!code focus]
}) 
```

```ts
import { hashAuthorization } from 'viem/utils'

hashAuthorization({
  contractAddress: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
  chainId: 1,
  nonce: 0, 
  to: 'bytes', // [!code focus]
}) 
```

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

### Install KZG Bindings

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

Installs necessary KZG bindings for blob commitment and proof generation.

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

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

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

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

### Parameter Definition Examples

Source: https://viem.sh/docs/abi/decodeAbiParameters

Examples showing how to define the params and data arguments.

```ts
const values = decodeAbiParameters(
  [{ name: 'x', type: 'uint32' }], // [!code focus]
  '0x0000000000000000000000000000000000000000000000000000000000010f2c',
)
```

```ts
const values = decodeAbiParameters(
  [{ name: 'x', type: 'uint32' }],
  '0x0000000000000000000000000000000000000000000000000000000000010f2c', // [!code focus]
)
```

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

### Parameter Examples

Source: https://viem.sh/docs/siwe/utilities/createSiweMessage

Examples demonstrating the configuration of various parameters for the SIWE message.

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e', // [!code focus]
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
  chainId: 1, // [!code focus]
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com', // [!code focus]
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz', // [!code focus]
  uri: 'https://example.com/path',
  version: '1',
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path', // [!code focus]
  version: '1',
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1', // [!code focus]
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
  expirationTime: new Date(),  // [!code focus]
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
  issuedAt: new Date(),  // [!code focus]
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
  notBefore: new Date(),  // [!code focus]
})
```

```ts
import { createSiweMessage } from 'viem/siwe'

const message = createSiweMessage({
  address: '0xa0cf798816d4b9b9866b5330eea46a18382f251e',
  chainId: 1,
  domain: 'example.com',
  nonce: 'foobarbaz',
  uri: 'https://example.com/path',
  version: '1',
  requestId: '123e4567-e89b-12d3-a456-426614174000', // [!code focus]
})
```

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

### Parameter examples

Source: https://viem.sh/docs/contract/encodeErrorResult

Individual parameter usage examples for abi, errorName, and args.

```ts
const value = decodeErrorResult({
  abi: wagmiAbi, // [!code focus]
  errorName: 'InvalidTokenError',
  args: ['sold out']
})
```

```ts
const value = encodeErrorResult({
  abi: wagmiAbi,
  errorName: 'InvalidTokenError', // [!code focus]
  args: ['sold out']
})
```

```ts
const value = encodeErrorResult({
  abi: wagmiAbi,
  errorName: 'InvalidTokenError',
  args: ['sold out'] // [!code focus]
})
```

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

### Import Trusted Setup Contents

Source: https://viem.sh/docs/utilities/setupKzg

Directly import the JSON contents of trusted setup files.

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

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

### Install viem

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

Install the viem package using your preferred JavaScript package manager.

```bash
npm i viem
```

```bash
pnpm i viem
```

```bash
bun i viem
```

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

### Install toFunctionHash

Source: https://viem.sh/docs/utilities/toFunctionHash

Import the utility from the viem package.

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

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

### getEnsAvatar Parameter Examples

Source: https://viem.sh/docs/ens/actions/getEnsAvatar

Examples demonstrating how to use optional parameters like asset gateways, block constraints, and resolver settings.

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

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'),
  assetGatewayUrls: { // [!code focus:3]
    ipfs: 'https://cloudflare-ipfs.com'
  }
})
```

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'),
  blockNumber: 15121123n, // [!code focus]
})
```

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'),
  blockTag: 'safe', // [!code focus]
})
```

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'), 
  gatewayUrls: ["https://ccip.ens.xyz"], // [!code focus]
})
```

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'), 
  strict: true, // [!code focus]
})
```

```ts
const ensText = await publicClient.getEnsAvatar({
  name: normalize('wevm.eth'),
  universalResolverAddress: '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376', // [!code focus]
})
```

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

### Install size utility

Source: https://viem.sh/docs/utilities/size

Import the size function from the viem package.

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

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

### Import Trusted Setup Paths

Source: https://viem.sh/docs/utilities/setupKzg

Access trusted setup file paths for Node.js environments.

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

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

### Installation

Source: https://viem.sh/docs/contract/encodeFunctionResult

Import the function from the viem package.

```ts
import { encodeFunctionResult } from 'viem';
```

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

### Install trim utility

Source: https://viem.sh/docs/utilities/trim

Import the trim function from the viem package.

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

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

### Parameter Examples

Source: https://viem.sh/docs/utilities/hashTypedData

Individual parameter usage examples for domain, types, primaryType, and message.

```ts
const hash = hashTypedData({
  domain: { // [!code focus:6]
    name: 'Ether Mail',
    version: '1',
    chainId: 1,
    verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
  },
  types,
  primaryType: 'Mail',
  message: {
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})
```

```ts
const hash = hashTypedData({
  domain,
  types: { // [!code focus:11]
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
    Mail: [
      { name: 'from', type: 'Person' },
      { name: 'to', type: 'Person' },
      { name: 'contents', type: 'string' },
    ],
  },
  primaryType: 'Mail',
  message: {
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})
```

```ts
const hash = hashTypedData({
  domain,
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
    Mail: [ // [!code focus:5]
      { name: 'from', type: 'Person' },
      { name: 'to', type: 'Person' },
      { name: 'contents', type: 'string' },
    ],
  },
  primaryType: 'Mail', // [!code focus]
  message: {
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})
```

```ts
const hash = hashTypedData({
  domain,
  types: {
    Person: [
      { name: 'name', type: 'string' },
      { name: 'wallet', type: 'address' },
    ],
    Mail: [
      { name: 'from', type: 'Person' },
      { name: 'to', type: 'Person' },
      { name: 'contents', type: 'string' },
    ],
  },
  primaryType: 'Mail', 
  message: { // [!code focus:11]
    from: {
      name: 'Cow',
      wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
    },
    to: {
      name: 'Bob',
      wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
    },
    contents: 'Hello, Bob!',
  },
})
```

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

### Install toFunctionSelector

Source: https://viem.sh/docs/utilities/toFunctionSelector

Import the utility from the viem package.

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

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

### Install toFunctionSignature

Source: https://viem.sh/docs/utilities/toFunctionSignature

Import the utility from the viem package.

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

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

### Install pad

Source: https://viem.sh/docs/utilities/pad

Import the pad function from the viem package.

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

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

### Create Contract Event Filter Setup

Source: https://viem.sh/docs/contract/createContractEventFilter

Basic setup for creating a contract event filter using a public client and ABI.

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

const filter = await publicClient.createContractEventFilter({
  abi: wagmiAbi
})
/**
 *  {
 *    abi: [...],
 *    id: '0x345a6572337856574a76364e457a4366',
 *    type: 'event'
 *  }
 */
```

```ts
export const wagmiAbi = [
  ...
  {
    inputs: [
      {
        indexed: true,
        name: "from",
        type: "address",
      },
      { indexed: true, name: "to", type: "address" },
      {
        indexed: true,
        name: "tokenId",
        type: "uint256",
      },
    ],
    name: "Transfer",
    type: "event",
  },
  ...
] as const;
```

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

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

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

### getTransaction Parameter Examples

Source: https://viem.sh/docs/actions/public/getTransaction

Examples demonstrating different ways to query transactions using hash, block identifiers, and indices.

```ts
// [!include ~/snippets/publicClient.ts]
// ---cut---
const transaction = await publicClient.getTransaction({
  hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d' // [!code focus]
})
```

```ts
// [!include ~/snippets/publicClient.ts]
// ---cut---
const transaction = await publicClient.getTransaction({
  blockHash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d', // [!code focus:2]
  index: 0
})
```

```ts
// [!include ~/snippets/publicClient.ts]
// ---cut---
const transaction = await publicClient.getTransaction({
  blockNumber: 69420n, // [!code focus:2]
  index: 0
})
```

```ts
// [!include ~/snippets/publicClient.ts]
// ---cut---
const transaction = await publicClient.getTransaction({
  blockTag: 'safe', // [!code focus:2]
  index: 0
})
```

```ts
// [!include ~/snippets/publicClient.ts]
// ---cut---
const transaction = await publicClient.getTransaction({
  blockTag: 'safe',
  index: 0 // [!code focus]
})
```

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

### Install toEventSelector

Source: https://viem.sh/docs/utilities/toEventSelector

Import the function from the viem package.

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

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

### Initialize Public Client

Source: https://viem.sh/docs/contract/parseEventLogs

Setup for the viem public client to interact with the blockchain.

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

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

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

### Install toEventSignature

Source: https://viem.sh/docs/utilities/toEventSignature

Import the function from the viem package.

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

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

### Install slice utility

Source: https://viem.sh/docs/utilities/slice

Import the slice function from the viem package.

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

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

### Install decodeErrorResult

Source: https://viem.sh/docs/contract/decodeErrorResult

Import the function from the viem package.

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

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

### Install toEventHash

Source: https://viem.sh/docs/utilities/toEventHash

Import the toEventHash function from the viem package.

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

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

### Install keccak256

Source: https://viem.sh/docs/utilities/keccak256

Import the keccak256 function from the viem package.

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

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

### Install concat

Source: https://viem.sh/docs/utilities/concat

Import the concat function from the viem package.

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

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

### Usage examples for slice

Source: https://viem.sh/docs/utilities/slice

Demonstrates slicing both Hex strings and Uint8Arrays.

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

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

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

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

### setupKzg(kzg, path)

Source: https://viem.sh/docs/utilities/setupKzg

Initializes the KZG interface with a provided implementation and a path to the trusted setup file.

```APIDOC
## setupKzg(kzg, path)

### Description
Sets up and defines an EIP-4844 compatible KZG interface used in the blob transaction signing process to generate KZG commitments and proofs.

### Parameters
- **kzg** (Kzg & { loadTrustedSetup(path: string): void }) - Required - The EIP-4844 compatible KZG interface implementation.
- **path** (string) - Required - The path to the trusted setup file.

### Returns
- **Kzg** - The initialized KZG interface.

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

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

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

### Install sha256

Source: https://viem.sh/docs/utilities/sha256

Import the sha256 function from the viem package.

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

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

### Install isBytes

Source: https://viem.sh/docs/utilities/isBytes

Import the isBytes function from the viem package.

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

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

### Basic Usage and Client Setup

Source: https://viem.sh/docs/actions/test/sendUnsignedTransaction

Demonstrates how to initialize a test client and execute an unsigned transaction.

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

const hash = await testClient.sendUnsignedTransaction({ // [!code focus:99]
  from: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
  value: 1000000000000000000n
})
// '0x...'
```

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

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

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

### watchAsset Parameters

Source: https://viem.sh/docs/actions/wallet/watchAsset

Examples demonstrating the configuration of specific parameters for the watchAsset action.

```typescript
// [!include ~/snippets/walletClient.ts]
// ---cut--
const success = await walletClient.watchAsset({
  type: 'ERC20', // [!code focus]
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH',
  },
});
```

```typescript
// [!include ~/snippets/walletClient.ts]
// ---cut---
const success = await walletClient.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', // [!code focus]
    decimals: 18,
    symbol: 'WETH',
  },
});
```

```typescript
// [!include ~/snippets/walletClient.ts]
// ---cut---
const success = await walletClient.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18, // [!code focus]
    symbol: 'WETH',
  },
});
```

```typescript
// [!include ~/snippets/walletClient.ts]
// ---cut---
const success = await walletClient.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH', // [!code focus]
  }
})
```

```typescript
// [!include ~/snippets/walletClient.ts]
// ---cut---
const success = await walletClient.watchAsset({
  type: 'ERC20',
  options: {
    address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    decimals: 18,
    symbol: 'WETH',
    image: 'https://weth.com/icon.png', // [!code focus]
  }
})
```

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

### Build and Link Viem from Source

Source: https://viem.sh/docs/installation

Clone the repository and link it globally for local development.

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

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

### Add Chain Example

Source: https://viem.sh/docs/actions/wallet/addChain

Demonstrates adding the Avalanche chain to a wallet client.

```ts
import { avalanche } from 'viem/chains'
import { walletClient } from './client'
 
await walletClient.addChain({ chain: avalanche })
```

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

### Address Parameter Example

Source: https://viem.sh/docs/actions/test/setCoinbase

Demonstrates the structure of the address parameter passed to setCoinbase.

```ts
await testClient.setCoinbase({
  address: '0xe846c6fcf817734ca4527b28ccb4aea2b6663c79', // [!code focus]
})
```

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

### Import setupKzg

Source: https://viem.sh/docs/utilities/setupKzg

Import the setupKzg function from the viem package.

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

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

### Initialize a Client

Source: https://viem.sh/docs/clients/custom

Set up a client by providing a chain and a transport configuration.

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

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

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

### Parameter Examples

Source: https://viem.sh/docs/contract/encodeFunctionResult

Examples highlighting specific parameters for the encodeFunctionResult function.

```ts
const data = encodeFunctionResult({
  abi: wagmiAbi, // [!code focus]
  functionName: 'ownerOf',
  result: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
});
```

```ts
const data = encodeFunctionResult({
  abi: wagmiAbi,
  functionName: 'ownerOf', // [!code focus]
  result: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
});
```

```ts
const data = encodeFunctionResult({
  abi: wagmiAbi,
  functionName: 'ownerOf',
  result: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac', // [!code focus]
});
```

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

### Parameter focus examples

Source: https://viem.sh/docs/contract/encodeFunctionData

Examples highlighting specific parameters for encodeFunctionData.

```ts
const data = encodeFunctionData({
  abi: wagmiAbi, // [!code focus]
  functionName: 'totalSupply',
})
```

```ts
const data = encodeFunctionData({
  abi: wagmiAbi,
  functionName: 'totalSupply', // [!code focus]
})
```

```ts
const data = encodeFunctionData({
  abi: wagmiAbi,
  functionName: 'balanceOf',
  args: ['0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC'] // [!code focus]
})
```

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

### Initialize Signer and Wallet Client

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

Compare Ethers JsonRpcSigner setup with Viem's Wallet Client implementation.

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

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

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

signer.sendTransaction(...) // [!code hl]
signer.signMessage(...) // [!code hl]
...
```

```ts
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({ ... }) // [!code hl]
client.signMessage({ ... }) // [!code hl]
...
```

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

### Deploying with Constructor Arguments

Source: https://viem.sh/docs/contract/deployContract

Deployment example including constructor arguments passed via the args parameter.

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

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

```ts
export const wagmiAbi = [
  ...
  {
    inputs: [{ name: "x", type: "uint32" }],
    stateMutability: "nonpayable",
    type: "constructor",
  },
  ...
] as const;
```

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

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

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

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

### Interval Parameter Example

Source: https://viem.sh/docs/actions/test/setIntervalMining

Demonstrates setting the interval parameter to 5 seconds.

```ts
await testClient.setIntervalMining({
  interval: 5 // [!code focus]
})
```

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

### Slice start parameter

Source: https://viem.sh/docs/utilities/slice

Defines the starting byte offset for the slice operation.

```ts
slice(
  '0x0123456789', 
  1 // [!code focus]
)
```

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

### Install Unreleased Commits

Source: https://viem.sh/docs/installation

Install specific pull requests or commits using the pkg.pr.new service.

```bash
pnpm add https://pkg.pr.new/viem@123
```

```bash
npm install https://pkg.pr.new/viem@123
```

```bash
yarn add https://pkg.pr.new/viem@123
```

```bash
bun add https://pkg.pr.new/viem@123
```

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

### Initialize Wallet Client

Source: https://viem.sh/docs/utilities/verifyTypedData

Setup for the wallet client used to sign typed data.

```ts
import { createWalletClient, custom } from 'viem'

export const account = '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266'

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

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

### Usage Example

Source: https://viem.sh/docs/contract/decodeDeployData

Demonstrates decoding deployment data using a contract ABI and bytecode.

```typescript
import { decodeDeployData } from 'viem'
import { wagmiAbi } from './abi.ts'

const { args } = decodeDeployData({
  abi: wagmiAbi,
  bytecode: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c63430008070033',
  data: '0x6080604052348015600f57600080fd5b50603f80601d6000396000f3fe6080604052600080fdfea2646970667358221220116554d4ba29ee08da9e97dc54ff9a2a65d67a648140d616fc225a25ff08c86364736f6c634300080700330000000000000000000000000000000000000000000000000000000000010f2c'
})
// { args: [69420n], bytecode: '0x6080604...' }
```

```typescript
export const wagmiAbi = [
  ...
  {
    inputs: [
      {
        name: 'a',
        type: 'uint256',
      },
    ],
    stateMutability: 'nonpayable',
    type: 'constructor',
  },
  ...
] as const;
```

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

### Define contract ABI

Source: https://viem.sh/docs/contract/multicall

Example ABI definition for the contract functions used in the multicall example.

```ts
export const wagmiAbi = [
  ...
  {
    inputs: [],
    name: "totalSupply",
    outputs: [{ name: "", type: "uint256" }],
    stateMutability: "view",
    type: "function",
  },
  {
    inputs: [{ name: "tokenId", type: "uint256" }],
    name: "ownerOf",
    outputs: [{ name: "", type: "address" }],
    stateMutability: "view",
    type: "function",
  },
  {
    inputs: [],
    name: "mint",
    outputs: [],
    stateMutability: "view",
    type: "function",
  },
  ...
] as const;
```

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

### fromHex with Options

Source: https://viem.sh/docs/utilities/fromHex

Examples of using fromHex with simple type arguments and configuration objects.

```ts
fromHex(
  '0x48656c6c6f20776f726c642e', 
  'string' // [!code focus]
)
// 'Hello world'
```

```ts
fromHex(
  '0x48656c6c6f20776f726c642e0000000000000000000000000000000000000000', 
  { // [!code focus]
    size: 32, // [!code focus]
    to: 'string' // [!code focus]
  } // [!code focus]
)
// 'Hello world'
```

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

### Set start block for filter

Source: https://viem.sh/docs/actions/public/getLogs

Define the starting block for log retrieval using the fromBlock parameter.

```ts
const filter = await publicClient.createEventFilter({
  fromBlock: 69420n // [!code focus]
})
```

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

### Mine Blocks Usage and Client Setup

Source: https://viem.sh/docs/actions/test/mine

Demonstrates how to initialize a test client and trigger the mining of blocks.

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

await testClient.mine({ // [!code focus:4]
  blocks: 1,
})
```

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

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

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

### Initialize Provider and Client

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

Compare Ethers provider initialization with Viem's Public Client setup.

```ts
import { getDefaultProvider } from 'ethers'

const provider = getDefaultProvider()

provider.getBlock(...) // [!code hl]
provider.getTransaction(...) // [!code hl]
...
```

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

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

client.getBlock(...) // [!code hl]
client.getTransaction(...) // [!code hl]
...
```

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

### slice(value, start, end, options)

Source: https://viem.sh/docs/utilities/slice

Returns a section of the hex or byte array given a start and end byte offset.

```APIDOC
## slice(value, start, end, options)

### Description
Returns a section of the hex or byte array given a start and end byte offset.

### Parameters
- **value** (Hex | ByteArray) - Required - The hex or byte array to slice.
- **start** (number) - Optional - The start offset (in bytes).
- **end** (number) - Optional - The end offset (in bytes).
- **options.strict** (boolean) - Optional - Whether or not the end offset should be inclusive of the bounds of the data. Defaults to false.

### Returns
- **Hex | ByteArray** - The section of the sliced value.
```

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

### Create and use a Contract Instance

Source: https://viem.sh/docs/contract/getContract

Initializes a contract instance with a public and wallet client, then demonstrates reading state, fetching events, and watching for events.

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

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

### Initialize a Wallet Client

Source: https://viem.sh/docs/accounts/local

Set up a wallet client using the HTTP transport to interact with the blockchain.

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

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

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

### Initialize a Wallet Client with custom transport

Source: https://viem.sh/docs/clients/wallet

Set up a Wallet Client using the custom transport to interface with a browser provider like window.ethereum.

```ts
import 'viem/window'
// ---cut---
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

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

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

### Wallet Client Configuration

Source: https://viem.sh/docs/actions/wallet/getCallsStatus

Sets up the wallet client using the Ethereum provider from the window object.

```ts
import 'viem/window'
// ---cut---
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()
```

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

### Install encodeFunctionData

Source: https://viem.sh/docs/contract/encodeFunctionData

Import the function from the viem package.

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

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

### Install encodeErrorResult

Source: https://viem.sh/docs/contract/encodeErrorResult

Import the function from the viem package.

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

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

### Set up KZG Interface

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

Configures the KZG interface for Viem using c-kzg bindings and the mainnet trusted setup.

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

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

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

### Wallet Client Configuration

Source: https://viem.sh/docs/utilities/recoverTransactionAddress

Examples for setting up a wallet client using either an EIP-1193 provider or a local private key account.

```ts
import { createWalletClient, custom } from 'viem'

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

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

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

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

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

### Install encodeEventTopics

Source: https://viem.sh/docs/contract/encodeEventTopics

Import the function from the viem package.

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

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

### Install encodeDeployData

Source: https://viem.sh/docs/contract/encodeDeployData

Import the function from the viem package.

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

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

### Basic Usage

Source: https://viem.sh/docs/actions/public/createAccessList

Demonstrates the basic implementation of createAccessList using a public client.

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

const result = await publicClient.createAccessList({ // [!code focus:7]
  data: '0xdeadbeef',
  to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8'
})
```

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

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

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

### Install decodeFunctionResult

Source: https://viem.sh/docs/contract/decodeFunctionResult

Import the function from the viem package.

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

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

### Basic Usage and Client Configuration

Source: https://viem.sh/docs/ens/actions/getEnsAddress

Demonstrates how to initialize a public client and use getEnsAddress to resolve an ENS name.

```ts
import { normalize } from 'viem/ens'
import { publicClient } from './client'
 
const ensAddress = await publicClient.getEnsAddress({
  name: normalize('wevm.eth'),
})
// '0xd2135CfB216b74109775236E36d4b433F1DF507B'
```

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

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

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

### Install decodeFunctionData

Source: https://viem.sh/docs/contract/decodeFunctionData

Import the function from the viem package.

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

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

### Initialize a JSON-RPC Account with a Browser Extension

Source: https://viem.sh/docs/accounts/jsonRpc

Extracts an address from a browser provider and initializes a wallet client using that address.

```ts
// @noErrors
import 'viem/window'
import { createWalletClient, custom } from 'viem'
import { mainnet } from 'viem/chains'

const [address] = await window.ethereum.request({ // [!code focus:3]
  method: 'eth_requestAccounts' 
})

const client = createWalletClient({
  account: address, // [!code focus]
  chain: mainnet,
  transport: custom(window.ethereum!)
})
```

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

### Parameter: proofs

Source: https://viem.sh/docs/utilities/toBlobSidecars

Example usage of the proofs parameter.

```ts
import { 
  blobsToCommitments, 
  blobsToProofs,
  toBlobSidecars, 
  toBlobs 
} from 'viem'
import { kzg } from './kzg'

const blobs = toBlobs({ data: '0x...' })
const commitments = blobsToCommitments({ blobs, kzg })
const proofs = blobsToProofs({ blobs, commitments, kzg })

const sidecars = toBlobSidecars({ 
  blobs,
  commitments,
  proofs,
})
```

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

### Import createWalletClient

Source: https://viem.sh/docs/clients/wallet

Import the function required to initialize a new Wallet Client.

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

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

### Parameter: kzg

Source: https://viem.sh/docs/utilities/toBlobSidecars

Example usage of the kzg parameter.

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

const kzg = setupKzg(cKzg, mainnetTrustedSetupPath)

const sidecars = toBlobSidecars({ 
  data: '0x...',
  kzg,
})
```

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

### Configure Path Parameter

Source: https://viem.sh/docs/utilities/setupKzg

Provide the path to the trusted setup file for the KZG interface.

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

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

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

### Parameter: data

Source: https://viem.sh/docs/utilities/toBlobSidecars

Example usage of the data parameter.

```ts
import { toBlobSidecars } from 'viem'
import { kzg } from './kzg'

const sidecars = toBlobSidecars({ 
  data: '0x...',
  kzg,
})
```
Tokens:
Raw