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

# Skills

> Copyable reference implementations instead of rigid library abstractions

Voltaire provides minimal, close-to-spec utilities and avoids opinionated abstractions. For higher-level patterns like providers and contracts, we offer **Skills**—copyable reference implementations you can use as-is or customize.

## Philosophy

Voltaire is intentionally low-level. We provide:

* Primitives (Address, Hash, Uint, etc.)
* Cryptography (Keccak256, secp256k1, etc.)
* Encoding (RLP, ABI, etc.)

We deliberately avoid:

* Provider abstractions (like ethers `JsonRpcProvider`)
* Contract wrappers (like viem `getContract`)
* React bindings (like wagmi)

For complex abstractions like a full EVM, we provide separate libraries like [Guillotine](https://github.com/evmts/guillotine).

## Tevm 1.0.0

Coming soon: **Tevm 1.0.0** wraps Voltaire in an opinionated, batteries-included API. Inspired by James Prestwich's [Client Monogamy](https://www.youtube.com/watch?v=d0MtuJh1PGU) philosophy—build clients tailored to your specific contracts rather than generic one-size-fits-all abstractions.

## Why Skills Instead of Libraries?

Traditional libraries must balance abstraction level vs customizability. For any individual use case, a library will:

1. **Lack customizability** — Rigid APIs that don't fit your exact needs
2. **Bloat your codebase** — Unused features increase bundle size
3. **Expand security surface** — More code means more potential vulnerabilities

Think of abstractions like ethers `Provider` or viem `PublicClient` as **off-the-rack clothing**. They work for most people, but they're never a perfect fit.

Skills are **custom-fitted clothing**. Copy the pattern, tailor it to your contracts.

### The shadcn Approach

Skills follow the [shadcn/ui](https://ui.shadcn.com/) philosophy:

| Traditional Library   | Skills                   |
| --------------------- | ------------------------ |
| Install as dependency | Copy into your codebase  |
| Update via npm        | Modify directly          |
| One-size-fits-all     | Tailored to your needs   |
| Hidden implementation | Visible, debuggable code |

This approach works exceptionally well with **agentic coding**. AI assistants can read, understand, and modify Skills directly in your codebase.

## Stock vs Custom

Every Skill is:

* **Tested** — Full test coverage, ready to use
* **Documented** — Clear API and usage examples
* **Copyable** — One click to add to your project

You can use Skills with zero customization. They work out of the box. But when you need to:

* Add caching to a provider
* Change error handling in a contract wrapper
* Add custom retry logic

...you modify the code directly. No library limitations.

## How to Use Skills

### Option 1: Copy Button

Each Skill page has a copy button. Paste into your project and customize as needed.

### Option 2: Voltaire MCP Server

Use the [Voltaire MCP Server](/model-context-protocol) with your AI coding assistant to:

* Generate custom Skills tailored to your contracts
* Modify existing Skills for your use case
* Build new patterns from Voltaire primitives

## API vs Skill

| Type      | What It Is              | Examples                                    |
| --------- | ----------------------- | ------------------------------------------- |
| **API**   | Core library exports    | `Address`, `Hex.toBytes()`, `Abi.encode()`  |
| **Skill** | Copyable implementation | ethers-provider, viem-contract, react-query |

APIs are imported from `@tevm/voltaire`. Skills are copied into your codebase.

## Available Skill Guides

Our skill guides walk you through building common Ethereum patterns using Voltaire's low-level primitives. Each guide provides a full, copyable reference implementation that you can use as-is or customize.

### Provider & Signer Skills

Learn how to build abstractions compatible with popular libraries like ethers and viem. These guides cover creating `JsonRpcProvider`, `PublicClient`, `WalletClient`, and `Signer` wrappers around Voltaire's JSON-RPC interface. You can also learn patterns for request batching and fallback providers.

### Contract Skills

Discover how to build powerful, type-safe contract interaction wrappers. Guides cover creating ethers- and viem-compatible `Contract` objects, enabling familiar APIs for your project without adding external dependencies.

### Wallet & Account Skills

Build your own wallet and account management logic, from HD wallet derivation to transaction nonce management, compatible with both ethers and viem patterns.

### Utility & Pattern Skills

Explore guides for implementing common patterns like `multicall` for batching contract reads, or how to integrate Voltaire with libraries like TanStack Query for building custom React hooks.

## Learn More

<CardGroup cols={2}>
  <Card title="MCP Server" icon="robot" href="/model-context-protocol">
    AI-assisted Skill generation
  </Card>

  <Card title="Browse Skills" icon="wand-magic-sparkles" href="/skills">
    All available Skills
  </Card>
</CardGroup>