> ## Documentation Index
> Fetch the complete documentation index at: https://developers.avacloud.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Using Viem

## Making C-Chain RPC Calls Using Viem

In this guide, you will learn how to make JSON-RPC calls to Avalanche's C-Chain using [viem](https://viem.sh/), a TypeScript interface for Ethereum that works seamlessly with Avalanche's EVM-compatible C-Chain.

### Prerequisites

* Node.js (v14+) installed
* Basic familiarity with TypeScript/JavaScript
* Understanding of Ethereum/EVM concepts

### Step 1: Install Dependencies

```bash theme={null}
# Create a new project
mkdir avalanche-viem-example
cd avalanche-viem-example
npm init -y

# Install viem
npm install viem

# Install TypeScript (optional)
npm install -D typescript @types/node tsx
```

### Step 2: Use Built-in Avalanche Chains

Viem includes Avalanche chain definitions out of the box:

```typescript theme={null}
import { avalanche, avalancheFuji } from 'viem/chains'

// avalanche = Avalanche Mainnet (Chain ID: 43114)
// avalancheFuji = Avalanche Fuji Testnet (Chain ID: 43113)
```

### Step 3: Reading Blockchain Data

Create a file called `readData.ts`:

```typescript theme={null}
import { createPublicClient, http, formatEther } from 'viem'
import { avalanche } from 'viem/chains'

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

async function readData() {
  // Get the latest block
  const block = await client.getBlock()
  console.log('Latest block:', block.number)
  
  // Get AVAX balance
  const balance = await client.getBalance({ 
    address: '0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC' 
  })
  console.log('Balance:', formatEther(balance), 'AVAX')
  
  // Get gas price
  const gasPrice = await client.getGasPrice()
  console.log('Gas price:', formatEther(gasPrice), 'AVAX')
}

readData()
```

### Step 4: Sending Transactions

Create a file called `sendTransaction.ts`:

```typescript theme={null}
import { createWalletClient, createPublicClient, http, parseEther } from 'viem'
import { privateKeyToAccount } from 'viem/accounts'
import { avalancheFuji } from 'viem/chains'

// Use environment variable for private key
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`)

const walletClient = createWalletClient({
  account,
  chain: avalancheFuji,
  transport: http(),
})

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

async function sendAvax() {
  // Send 0.001 AVAX
  const hash = await walletClient.sendTransaction({
    to: '0x0000000000000000000000000000000000000000',
    value: parseEther('0.001'),
  })
  
  console.log('Transaction hash:', hash)
  
  // Wait for confirmation
  const receipt = await publicClient.waitForTransactionReceipt({ hash })
  console.log('Transaction confirmed:', receipt.status)
}

sendAvax()
```

### Step 5: Smart Contract Interaction

Create a file called `contractCall.ts`:

```typescript theme={null}
import { createPublicClient, http, parseAbi, formatUnits } from 'viem'
import { avalanche } from 'viem/chains'

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

// ERC20 ABI (minimal)
const abi = parseAbi([
  'function balanceOf(address) view returns (uint256)',
  'function decimals() view returns (uint8)',
  'function symbol() view returns (string)',
])

async function readToken() {
  // USDC on Avalanche
  const usdcAddress = '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E'
  const userAddress = '0x8db97C7cEcE249c2b98bDC0226Cc4C2A57BF52FC'
  
  // Read multiple values at once
  const [balance, decimals, symbol] = await Promise.all([
    client.readContract({
      address: usdcAddress,
      abi,
      functionName: 'balanceOf',
      args: [userAddress],
    }),
    client.readContract({
      address: usdcAddress,
      abi,
      functionName: 'decimals',
    }),
    client.readContract({
      address: usdcAddress,
      abi,
      functionName: 'symbol',
    }),
  ])
  
  console.log(`${symbol} Balance:`, formatUnits(balance, decimals))
}

readToken()
```

### Environment Variables

Create a `.env` file for sensitive data:

```env theme={null}
PRIVATE_KEY=0x... # Never commit this!
```

### Running the Examples

```bash theme={null}
# Read blockchain data
npx tsx readData.ts

# Send transaction (requires PRIVATE_KEY)
npx tsx sendTransaction.ts

# Read smart contract
npx tsx contractCall.ts
```

### Best Practices

1. **Security**: Never hardcode private keys
2. **Gas Management**: Always estimate gas before sending transactions
3. **Error Handling**: Wrap async operations in try-catch blocks
4. **Network Selection**: Use testnet (Fuji) for development

### Conclusion

Viem provides a clean, type-safe interface for Avalanche C-Chain development with:

* Built-in Avalanche chain configurations
* Full EVM compatibility
* Excellent TypeScript support
* Efficient multicall and batching

For P-Chain and X-Chain operations, use the [Avalanche SDK](/rpc-api/using-avalanche-sdk).

### Resources

* [Viem Documentation](https://viem.sh/)
* [Avalanche Faucet](https://faucet.avax.network/)