Migrating from viem

If you're comfortable with viem, you'll find Oviato's EVM surface shaped almost identically — method names, parameter keys, and return shapes all match the viem convention where possible.

The one-minute map

Clients vs namespace

viem:

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

const balance = await publicClient.getBalance({ address });
const hash = await walletClient.sendTransaction({ to, value });

Oviato:

import { evm } from '@oviato/connect';

// No client to create — the namespace IS the client. Chain comes from the user's session.
const balance = await getBalance({ address }); // chain-agnostic
const r = await evm.sendTransaction({ to, value });

The envelope adapter

The biggest DX difference: Oviato returns a discriminated envelope, viem returns a raw value and throws on error.

try {
  const hash = await walletClient.sendTransaction({ to, value });
  console.log('Hash:', hash);
} catch (err) {
  console.error('Failed:', err);
}

const r = await evm.sendTransaction({ to, value });
if (r.status === 'success' && r.type === 'sendTransactionSuccess') {
  console.log('Hash:', r.data.hash);
} else if (r.status === 'error') {
  console.error('Failed:', r.message);
}

// One-line adapter — drop-in replacement for viem-style code
async function unwrap<T extends { status: string; data?: any; message?: string }>(p: Promise<T>) {
  const r = await p;
  if (r.status === 'success') return r.data;
  throw new Error(r.message ?? 'Unknown error');
}

const { hash } = await unwrap(evm.sendTransaction({ to, value }));

We keep the envelope by default because it makes "user cancelled popup" a first-class state instead of an exception — far easier to handle in UI code. Use the adapter if your codebase assumes the viem style.

ABI compatibility

viem's Abi type and ours are structurally compatible. Pass viem ABIs verbatim:

import { erc20Abi } from 'viem';
import { evm } from '@oviato/connect';

const balance = await evm.readContract<bigint>({
  address: USDC,
  abi: erc20Abi,
  functionName: 'balanceOf',
  args: [address],
});

Address + Hex types

Identical:

// viem
import type { Address, Hex } from 'viem';

// Oviato
import type { Address, Hex } from '@oviato/connect';

Both resolve to the TypeScript template literal type for 0x-prefixed hex strings.

bigint conventions

Identical — wei is always bigint, overflow-safe.

const value = 10n ** 18n; // 1 ETH

// parseUnits / formatUnits match viem's semantics exactly
import { parseUnits, formatUnits } from '@oviato/connect';
parseUnits('1.5', 18); // 1500000000000000000n
formatUnits(1_234_500n, 6); // '1.2345'

Chains

viem has explicit chain objects (mainnet, base, sepolia). Oviato uses string slugs on the session.

You don't pass the chain on each call — it's implicit from the session. Switch via switchNetwork(Network.X).

What Oviato adds over viem

• Account custody. Oviato manages keys via WebAuthn passkeys — no private-key juggling, no seed phrase UX.
• Server-side nonce tracker. Rapid-fire sends just work; no "pending count lag" race.
• Specialized confirmation sheets. writeContract with an ERC-20 ABI shows a "Transfer Token" sheet, not raw calldata.
• Bridge UI. The popup/iframe handles approval — you don't ship wallet UI.
• Multi-chain session. Same API on Bitcoin + EVM via sendTransfer / signMessage / getBalance.
• Curated token registry. evm.getTokens() returns canonical ERC-20s per chain, server-maintained.

What Oviato doesn't do (yet)

• simulateContract — v2. For now, call readContract with the same ABI to preview.
• watchBlocks / watchEvent / subscriptions — v2. Poll via getBlockNumber + getLogs if you need it now.
• Local ABI encoding. The SDK ships ABIs to the server for encoding. If you need pure-client encoding, wrap viem's encodeFunctionData and pass the result as data: to sendTransaction.
• Custom chains not in our supported list. See EVM Overview → Supported networks.

Side-by-side: a typical swap

viem

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

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

const hash = await walletClient.sendTransaction({
  to: '0x742d35Cc...',
  value: parseEther('0.01'),
});

const rx = await publicClient.waitForTransactionReceipt({ hash });

Oviato

import { evm, parseUnits } from '@oviato/connect';

const r = await evm.sendTransaction({
  to: '0x742d35Cc...',
  value: parseUnits('0.01', 18),
});

if (r.status !== 'success') return;
const rx = await evm.waitForTransactionReceipt({ hash: r.data.hash });

No client to set up, no wallet to connect — the session handles it.

Related

• EVM Overview — the mental model
• Migrating from ethers — if you're coming from ethers v5/v6 instead