Question about using viem with very small Solidity contracts

[omiaydin1]

What is the type of issue?

No response

What is the issue?

Hello 👋

I’m experimenting with very small Solidity contracts
(mainly counters and simple payable examples).

When using viem for this purpose, are there any
recommended patterns or things to be aware of?

Thanks!

Where did you find it?

Hello 👋

I’m experimenting with very small Solidity contracts
(mainly counters and simple payable examples).

When using viem for this purpose, are there any
recommended patterns or things to be aware of?

Thanks!

[christianalberto]

Hello @omiaydin1, Working with simple or lightweight Solidity contracts (like counters, basic storage, or simple payable functions) is where Viem shines, because it provides end-to-end TypeScript type inference directly from your contract ABIs without needing heavy wrapper classes.

Here are the key recommended patterns and best practices to keep in mind:

---

1. Leverage const Assertion for ABIs (Instant Type Safety)

Always declare your Solidity ABI as a const assertion (as const). Viem uses TypeScript's const contexts to automatically infer function names, argument types, and return types at compile time.

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

// Define ABI with `as const`
const counterAbi = [
  {
    inputs: [],
    name: 'number',
    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
    stateMutability: 'view',
    type: 'function',
  },
  {
    inputs: [],
    name: 'increment',
    outputs: [],
    stateMutability: 'nonpayable',
    type: 'function',
  },
  {
    inputs: [],
    name: 'deposit',
    outputs: [],
    stateMutability: 'payable',
    type: 'function',
  },
] as const;

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

// `functionName` and return types are fully autocompleted and type-checked!
const count = await publicClient.readContract({
  address: '0x...',
  abi: counterAbi,
  functionName: 'number',
});

2. Handling Payable Functions & Value Transfers
   When interacting with payable functions or deploying contracts that accept Ether on deployment:

import { parseEther } from 'viem';

// Sending ETH with a payable function call
const hash = await walletClient.writeContract({
  address: '0x...',
  abi: counterAbi,
  functionName: 'deposit',
  value: parseEther('0.01'), // Use parseEther for clean unit conversions
});

3. Deploying Bytecode Directly
   For small contracts, you can deploy them directly without full framework setups by using deployContract:

import { createWalletClient, http, parseEther } from 'viem';

const hash = await walletClient.deployContract({
  abi: counterAbi,
  bytecode: '0x608060405234801561001057600080fd5b50...', // Your compiled bytecode
  args: [], // Deployment constructor arguments (if any)
  // value: parseEther('0.1'), // Optional if constructor is payable
});

4. Grouping Actions with getContract
   If you perform multiple calls against the same small contract instance, you can use getContract to bind the address, ABI, and clients together:

import { getContract } from 'viem';

const counter = getContract({
  address: '0x...',
  abi: counterAbi,
  client: { public: publicClient, wallet: walletClient },
});

// Clean object-oriented calls:
const currentCount = await counter.read.number();
const txHash = await counter.write.increment();

5. BigInt Handling
   Remember that Solidity uint256 values are always returned as native JavaScript bigint types (e.g., 10n instead of 10). Be sure to use standard BigInt operations or formatters (formatEther, formatUnits) when displaying values in frontends.

If these patterns help you get started with lightweight contracts in Viem, please consider marking this response as the accepted answer! 🟢

By the way, if you are building EVM tools, working with contract derivations, or scanning wallet balances, feel free to check out my open-source project Wallet Hunter — if you find it helpful, dropping a ⭐️ star on the repo is always appreciated!