Chain-Agnostic Overview

This is what Oviato does that no other wallet SDK does cleanly: one API that works across chain families. Same function names, same return shapes — the SDK routes by the session's active network.

import { signMessage, sendTransfer, switchNetwork, getBalance } from '@oviato/connect';

// Same code, different chain each run
const bal = await getBalance({ address: session.address });
await signMessage('Hello from Oviato');
await sendTransfer({ recipient: { address, amount } });

No branches on network === 'eth' vs network === 'bitcoin'. The SDK dispatches internally.

What's chain-agnostic

What's chain-specific (lives elsewhere)

When you're doing something that genuinely only works on one chain family, use the dedicated namespace:

• EVM: contract calls, token reads, NFTs, typed data, gas fees → evm.*
• UTXO: PSBT signing → utxo.*

The namespaces exist precisely so you don't accidentally call an EVM method on a Bitcoin session. Runtime errors become impossible compile-time mistakes.

The dispatch model

Every chain-agnostic method inspects the session's network and chooses the right backend path:

sendTransfer({ recipient })
   ↓
session.network
   ├─ 'bitcoin' / 'bitcointestnet' → UTXO prepare path (PSBT, fee_rate, multi-recipient supported)
   └─ 'eth' / 'base' / 'basesepolia' / 'ethsepolia' → EVM prepare path (nonce, gas, value as wei)

Return shapes are aligned where possible:

• sendTransfer → { txid, network, explorerUrl } — same across both chain families
• getBalance → discriminated union: { chainType: 'utxo', raw: number, confirmed, unconfirmed, ... } OR { chainType: 'evm', raw: bigint, ... } so your code narrows explicitly

Amount unit conventions

Different chains have different native units. The SDK uses whatever's overflow-safe for the chain:

// Bitcoin — satoshis as number
await sendTransfer({
  recipient: { address: 'bc1q...', amount: 10000 }, // 0.0001 BTC
});

// Ethereum — wei as bigint
await sendTransfer({
  recipient: { address: '0x...', amount: 10n ** 15n }, // 0.001 ETH
});

When "chain-agnostic" isn't quite true

A few caveats worth calling out:

• sendTransfer on EVM sends native coin (ETH/Base ETH/etc.) only. For ERC-20 / NFT / contract calls, use evm.writeContract.
• sendTransfer with multiple recipients works only on UTXO (Bitcoin supports multi-output natively; EVM doesn't in one tx).
• signMessage produces different signature formats: EIP-191 on EVM, Bitcoin message signing on UTXO. Verification needs to know which.

When to use chain-agnostic vs chain-specific

Chain-agnostic when you're writing code that should work across chain families — a generic "connect + send" UI, a faucet, a multi-chain dashboard.

Chain-specific when you're doing something that genuinely only makes sense for one chain — a DeFi app (EVM), a PSBT-heavy Bitcoin flow, a DEX swap.

Mixing is fine:

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

async function sendUsdcWithAuthProof(amount: bigint, recipient: `0x${string}`) {
  // Chain-agnostic: fetch balance for a pre-check
  const { balance } = await getBalance({ address: session.address });

  // Chain-agnostic: sign an auth message for off-chain logging
  await signMessage(`Authorize transfer of ${amount} at ${Date.now()}`);

  // Chain-specific: the actual USDC transfer (EVM-only)
  return evm.writeContract({
    address: USDC,
    abi: ERC20_ABI,
    functionName: 'transfer',
    args: [recipient, amount],
  });
}

Explore