Skip to content

スマートコントラクトのフロントエンド統合アーキテクチャ:Web3 DApp のエンジニアリングプラクティス

Web3 DApp のフロントエンドアーキテクチャは従来の Web アプリケーションと根本的に異なる。従来アプリケーションのデータは中央集権的な API サーバーから取得し、認証は Cookie/Token で行い、リクエスト・レスポンスモデルは同期的で予測可能である。一方 DApp は非中央集権的なブロックチェーンネットワークに直面する:データソースは複数の RPC ノード、認証はウォレット署名に依存し、トランザクション送信後はブロック確定を待つ必要がある——プロセス全体に非同期性、不確実性、ネットワーク遅延が伴っている。

これらの差異は、従来のフロントエンドアーキテクチャをそのまま DApp に適用すると至る所で壁にぶつかることを意味する。状態管理はオンチェーンデータの非同期同期を処理する必要があり、エラーハンドリングはユーザーの署名拒否とオンチェーンのトランザクションリバートを区別する必要があり、パフォーマンス最適化は大量の ABI エンコード/デコードのオーバーヘッドに対応する必要がある。本記事はエンジニアリングプラクティスの観点から、実践可能な DApp フロントエンドアーキテクチャを整理する。

DApp フロントエンドアーキテクチャの中核的な差異 ​

DApp フロントエンドと従来フロントエンドのいくつかの重要な違いを明確にする:

データソース:従来アプリケーションは REST/GraphQL API からデータを取得するが、DApp はオンチェーン(RPC ノード経由でコントラクト状態を読み取り)とオフチェーン(The Graph などのインデックスサービスやバックエンド API 経由)の二つのチャネルからデータを取得する必要がある。オンチェーン読み取りは強い一貫性を持つ(ブロック確定数に依存)が、遅延が比較的高い。

アイデンティティモデル:従来アプリケーションはユーザー名・パスワードや OAuth でサーバー側が発行した Token を取得するが、DApp のアイデンティティはウォレットアドレス自体である——ユーザーは署名によってそのアドレスの秘密鍵を所有することを証明し、中央集権的な登録プロセスを必要としない。

書き込み操作モデル:従来アプリケーションの書き込み操作は同期的である(POST リクエストが即座に結果を返す)が、DApp の書き込み操作は非同期である——トランザクション送信後にブロックへのパッケージングを待つ必要があり、数秒から数分かかる可能性があり、その間にトランザクションが失敗、置換、リバートする可能性がある。

不変性:オンチェーンデータの改ざん不可能性は利点だが、フロントエンドが従来アプリケーションのようにバックエンドの「データ修正」に依存できないことも意味する。コントラクトデプロイ後のロジックは変更不可能で、フロントエンドはバージョン互換性を確保する必要がある。

これらの差異は DApp フロントエンドにブロックチェーンの複雑さを隔離する専用のアーキテクチャ層が必要であることを決定づける。

イーサリアム相互作用レイヤー:ethers.js v7 と viem の選定 ​

2026 年のイーサリアムフロントエンド相互作用レイヤーの主流な選択は ethers.js v7 と viem である。両者の設計哲学は全く異なる。

ethers.js v7 は伝統的な OOP スタイルを継続しており、Provider/Signer/Contract はすべてクラスインスタンスで、オブジェクト指向思考に慣れた開発者に適している。エコシステムが最も成熟しており、ドキュメントも豊富だが、型推導は比較的弱い——多くの操作で手動の型アサーションが必要である。

viem は関数型設計を採用し、すべての操作が純粋関数で、TypeScript と組み合わせて優れた型推導体験を提供する。バンドルサイズが小さく(Tree-shaking に優しい)、バッチ呼び出しの場面でパフォーマンスが良い。viem の Actions パターンにより、巨大な Provider インスタンスを導入するのではなく、必要な機能だけを必要に応じて導入できる。

typescript
// viem の関数型スタイル
import { createPublicClient, http, getContract, parseEther } from 'viem';
import { mainnet } from 'viem/chains';
import { erc20Abi } from 'viem/abis';

const client = createPublicClient({
  chain: mainnet,
  transport: http('https://eth-mainnet.example.com'),
});

// 型安全:erc20Abi が完全な関数シグネチャの型推導を提供
const usdc = getContract({
  address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
  abi: erc20Abi,
  client,
});

// 戻り値の型が bigint に自動推導される、手動アサーション不要
const balance = await usdc.read.balanceOf([
  '0x1234567890123456789012345678901234567890',
]);
console.log(balance); // bigint

私のアドバイスは:新プロジェクトは viem を第一選択とする。関数型設計は React Hooks や Vue Composition API のメンタルモデルにより合致し、型安全性も一段と高い。ただしプロジェクトにすでに大量の ethers.js コードの蓄積がある場合、v7 への移行コストは評価が必要——ethers-to-viem 移行ツールで段階的に置き換えることもできる。

ウォレット接続管理:マルチウォレット適応と状態同期 ​

DApp のユーザーエントリーポイントはウォレットである。2026 年のウォレットエコシステムは MetaMask 一強から多ウォレット並立へと変化した:MetaMask、WalletConnect、Coinbase Wallet、Rabby、Phantom(Solana エコシステム)がそれぞれユーザー層を持つ。フロントエンドには統一的なウォレット接続管理層が必要である。

EIP-6963(マルチインジェクションウォレット発見プロトコル)の普及により、window.ethereum が最後にインジェクトされたウォレットで上書きされる問題が解決された。EIP-1193 標準と組み合わせることで、特定のウォレット実装に依存しないマルチウォレット適応層を構築できる。

typescript
// wallet/connection-manager.ts
import { createStore } from 'zustand/vanilla';

interface WalletState {
  status: 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
  address: string | null;
  chainId: number | null;
  provider: EIP1193Provider | null;
  error: Error | null;
}

interface WalletAdapter {
  name: string;
  icon: string;
  rdns: string; // EIP-6963 recommended wallet id
  connect(): Promise<{ address: string; chainId: number; provider: EIP1193Provider }>;
  disconnect(): Promise<void>;
  getProvider(): EIP1193Provider | null;
}

// EIP-6963 ウォレット発見
function discoverWallets(): WalletAdapter[] {
  const wallets: WalletAdapter[] = [];
  const handlers: ((event: EIP6963AnnounceProviderEvent) => void)[] = [];

  return new Promise((resolve) => {
    let timeoutId: number;

    const handler = (event: EIP6963AnnounceProviderEvent) => {
      wallets.push(createAdapter(event.detail));
    };

    window.addEventListener('eip6963:announceProvider', handler);
    window.dispatchEvent(new Event('eip6963:requestProvider'));

    // ウォレットに 500ms の応答時間を与える
    timeoutId = window.setTimeout(() => {
      window.removeEventListener('eip6963:announceProvider', handler);
      resolve(wallets);
    }, 500);
  });
}

状態同期はウォレット管理で最もバグが出やすい箇所である。ユーザーは DApp の実行中にアカウントを切り替えたり、ネットワークを切り替えたり、ウォレット接続を切断したりする可能性がある。これらのイベントは正しくリスニングされアプリケーション状態に同期される必要がある:

typescript
// ウォレットイベントのリスニング
function setupWalletEventListeners(
  provider: EIP1193Provider,
  store: WalletStore,
) {
  provider.on('accountsChanged', (accounts: string[]) => {
    if (accounts.length === 0) {
      store.setState({ status: 'disconnected', address: null });
    } else {
      store.setState({ address: accounts[0] });
    }
  });

  provider.on('chainChanged', (chainId: string) => {
    // chainChanged はページリフレッシュまたは状態リセットをトリガーする必要がある
    // チェーン切り替え後すべてのコントラクトアドレスと状態が変わるため
    store.setState({ chainId: parseInt(chainId, 16) });
    store.getState().onChainChanged?.();
  });

  provider.on('disconnect', () => {
    store.setState({ status: 'disconnected', address: null, provider: null });
  });
}

実践でよくある落とし穴:chainChanged イベントは一部のウォレットで自動的にページをリフレッシュしない。アプリケーションが特定のチェーンのコントラクトデータをキャッシュしている場合、チェーン切り替え後にこれらのデータはすべて無効になり、強制リフレッシュまたはキャッシュクリアが必要である。

スマートコントラクト ABI 型安全性:TypeScript 型生成 ​

ABI(Application Binary Interface)はコントラクトとフロントエンドの相互作用の契約である。手書きの ABI 型は煩雑でエラーが起きやすい。2026 年の標準的なやり方は wagmi/cli や typechain で ABI から TypeScript 型を自動生成することである。

typescript
// wagmi.config.ts - Etherscan / Foundry out ディレクトリから ABI を取得し型を生成
import { defineConfig } from '@wagmi/cli';
import { etherscan } from '@wagmi/cli/plugins';

export default defineConfig({
  out: 'src/generated/',
  plugins: [
    etherscan({
      apiKey: process.env.ETHERSCAN_API_KEY!,
      contracts: [
        {
          name: 'VestingVault',
          address: {
            1: '0xabc...', // mainnet
            8453: '0xdef...', // base
          },
        },
      ],
    }),
  ],
});

生成された型により、コントラクトメソッド呼び出し時に完全なパラメータと戻り値の型推導が得られる。これは開発体験の向上だけでなく、セキュリティの確保にもつながる——コントラクトのアップグレード後に ABI が変化した場合、フロントエンドのコンパイル時に不互換を発見できる。

オンチェーンデータ読み取り戦略:マルチ RPC ノードラウンドロビンとキャッシュ ​

RPC ノードは DApp のデータの命綱である。単一ノードには単一障害点とレート制限のリスクがある。本番環境ではマルチノードのフォールバックとロードバランシングが必要である。

viem の fallback transport はすぐに使えるマルチノードサポートを提供する:

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

const transport = fallback(
  [
    http('https://mainnet.infura.io/v3/xxx', { timeout: 5000 }),
    http('https://eth-mainnet.alchemyapi.io/v2/xxx', { timeout: 5000 }),
    http('https://cloudflare-eth.com', { timeout: 10000 }),
  ],
  {
    rank: true, // レイテンシと成功率で自動ソート
    retryCount: 2, // 各ノードのリトライ回数
  },
);

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

オンチェーンデータ読み取りのパフォーマンスボトルネックは大量の eth_call リクエストにある。高頻度で読み取るデータ(トークン残高、価格情報など)はフロントエンドでキャッシュレイヤーを設ける必要がある。しかしオンチェーンデータのキャッシュには微妙な問題がある:キャッシュの有効期限をどう知るか?

ブロックチェーンの「キャッシュ無効化」は新しいブロックの生成に依存する。イーサリアムは平均 12 秒ごとにブロックを生成するため、キャッシュの TTL は 12 秒(一ブロック周期)に設定できる。より正確なやり方は blockNumber イベントをサブスクライブし、新しいブロックが到着したら関連キャッシュをクリアすることである。

typescript
// ブロック番号ベースのキャッシュレイヤー
class BlockBasedCache {
  private cache = new Map<string, { value: unknown; blockNumber: bigint }>();
  private currentBlock: bigint = 0n;

  constructor(client: PublicClient) {
    // 新しいブロックをリスニング
    client.watchBlockNumber({
      onBlockNumber: (blockNumber) => {
        this.currentBlock = blockNumber;
        // 3 ブロック超のキャッシュをクリア
        for (const [key, entry] of this.cache) {
          if (this.currentBlock - entry.blockNumber > 3n) {
            this.cache.delete(key);
          }
        }
      },
      poll: true,
      pollingInterval: 4000,
    });
  }

  async read<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
    const cached = this.cache.get(key);
    if (cached && this.currentBlock - cached.blockNumber < 3n) {
      return cached.value as T;
    }
    const value = await fetcher();
    this.cache.set(key, { value, blockNumber: this.currentBlock });
    return value;
  }
}

より複雑なデータクエリ(履歴イベント、集計統計など)では、直接 RPC 呼び出しの効率は低い。この場合は The Graph などの Subgraph インデックスサービスを導入し、オンチェーンイベントをクエリ可能な GraphQL API にインデックス化する。

トランザクション状態管理とユーザーフィードバック ​

トランザクションは DApp で最も慎重にユーザー体験を設計する必要がある環節である。一筆のトランザクションの完全なライフサイクルは:トランザクション構築 → Gas 見積もり → 署名要求 → ブロックへの取り込み待ち → 成功/失敗の確認。プロセス全体が数十秒続く可能性があり、ユーザーには継続的な状態フィードバックが必要である。

typescript
// トランザクション状態マシン
type TransactionStatus =
  | { stage: 'idle' }
  | { stage: 'preparing' }
  | { stage: 'estimating_gas'; estimatedGas?: bigint }
  | { stage: 'awaiting_signature' }
  | { stage: 'submitted'; hash: string }
  | { stage: 'confirming'; hash: string; confirmations: number }
  | { stage: 'success'; hash: string; receipt: TransactionReceipt }
  | { stage: 'failed'; hash: string; error: TransactionError }
  | { stage: 'rejected'; error: UserRejectedError };

async function executeTransaction(
  walletClient: WalletClient,
  params: WriteContractParameters,
  onStatusChange: (status: TransactionStatus) => void,
): Promise<TransactionStatus> {
  try {
    onStatusChange({ stage: 'preparing' });

    // Gas 見積もり
    onStatusChange({ stage: 'estimating_gas' });
    const gasEstimate = await walletClient.estimateGas(params);
    // 20% バッファを追加、チェーン上の状態変化で Gas 不足を防ぐ
    const gas = (gasEstimate * 120n) / 100n;
    onStatusChange({ stage: 'estimating_gas', estimatedGas: gas });

    // ユーザー署名を要求
    onStatusChange({ stage: 'awaiting_signature' });
    const hash = await walletClient.writeContract({ ...params, gas });

    // パッケージング待ち
    onStatusChange({ stage: 'submitted', hash });
    const receipt = await waitForTransactionReceipt(walletClient, { hash });

    if (receipt.status === 'success') {
      onStatusChange({ stage: 'success', hash, receipt });
      return { stage: 'success', hash, receipt };
    } else {
      onStatusChange({ stage: 'failed', hash, error: { code: 'REVERTED' } });
      return { stage: 'failed', hash, error: { code: 'REVERTED' } };
    }
  } catch (error) {
    if (isUserRejectedError(error)) {
      onStatusChange({ stage: 'rejected', error });
      return { stage: 'rejected', error };
    }
    throw error;
  }
}

UI 層はトランザクション状態に応じて異なるフィードバックを表示する必要がある:awaiting_signature 時は「ウォレットで確認してください」と提示し、submitted 時はトランザクションハッシュとブロックエクスプローラーのリンクを表示し、confirming 時は確認進捗を表示する。これらの状態フィードバックはオプションではない——なければユーザーは DApp がフリーズしたと思うだろう。

Gas 代見積もりと最適化 ​

Gas 代は DApp ユーザー体験の悩みの種の一つである。フロントエンドでできる最適化は以下の通り:

EIP-1559 の Gas 見積もり:gasPrice ではなく maxFeePerGas と maxPriorityFeePerGas を使用する。viem の estimateFeesPerGas が現在のネットワークの推奨料金を返す。

バッチトランザクション:一つの操作で複数回のコントラクト呼び出しが発生する場合、multicall コントラクト(Multicall3 など)で複数回の呼び出しを一筆のトランザクションに統合し、Gas コストを分担する。

L2 優先:高頻度でインタラクションを行う場面では、Layer 2(Base、Arbitrum、Optimism)にデプロイすることで Gas 代を 1〜2 桁下げられる。フロントエンドはユーザーに正しいチェーンへの切り替えを優雅に提示する必要がある。

完全なコントラクト相互作用カプセル化層 ​

これまでの各部分を組み合わせると、完全なコントラクト相互作用カプセル化層は以下の通り:

typescript
// lib/contract-manager.ts
import {
  createPublicClient,
  createWalletClient,
  custom,
  fallback,
  http,
  type PublicClient,
  type WalletClient,
} from 'viem';
import { mainnet, base } from 'viem/chains';
import { getContract } from 'viem';
import type { Abi } from 'viem';

interface ContractManagerConfig {
  abi: Abi;
  address: Record<number, `0x${string}`>;
  chains?: typeof mainnet[];
}

export function createContractManager<TAbi extends Abi>(
  config: ContractManagerConfig,
) {
  const chains = config.chains ?? [mainnet, base];
  const clients = new Map<number, { public: PublicClient; wallet: WalletClient | null }>();

  // 各チェーンに public client を作成
  for (const chain of chains) {
    const transport = fallback([
      http(`https://${chain.id}.example-rpc.com`),
      http(`https://${chain.id}.fallback-rpc.com`),
    ]);
    clients.set(chain.id, {
      public: createPublicClient({ chain, transport }),
      wallet: null,
    });
  }

  function getContractForChain(chainId: number, walletClient?: WalletClient) {
    const entry = clients.get(chainId);
    if (!entry) throw new Error(`Unsupported chain: ${chainId}`);
    const address = config.address[chainId];
    if (!address) throw new Error(`No contract address for chain ${chainId}`);

    return getContract({
      address,
      abi: config.abi,
      client: {
        public: entry.public,
        wallet: walletClient ?? entry.wallet ?? undefined,
      },
    });
  }

  return { getContractForChain, clients };
}

DApp フロントエンドのパフォーマンス課題 ​

DApp フロントエンドのパフォーマンスボトルネックは従来アプリケーションとは異なる:

バンドルサイズ:viem/ethers.js 自体が小さくなく、マルチチェーン設定と ABI ファイルが加わると初画面の JS が膨らみやすい。解決策はチェーンごとの遅延ロード——ユーザー接続前はウォレット発見ロジックのみロードし、接続後に対応チェーンの設定を必要に応じてロードする。

大量の eth_call の並行制御:一つのページで 20 のコントラクト状態を読み取る必要がある場合、20 の並行 RPC リクエストがノードのレート制限をトリガーする。Multicall3 コントラクトで複数回の eth_call を一回に統合する。

WebSocket vs HTTP ポーリング:オンチェーンイベントのリアルタイムリスニングには WebSocket(よりタイムリー)または HTTP ポーリング(より安定)が使える。本番環境では HTTP ポーリングを主、WebSocket を補助とするのが推奨される——WebSocket はネットワーク不安定時に頻繁に切断・再接続し、メンテナンスコストがポーリングより高い。

メリット・デメリット分析と実践的アドバイス ​

このアーキテクチャの利点は:関心の分離が明確(相互作用層、ウォレット層、状態層が各々の役割を担う)、型安全性が全体を通じて一貫し、マルチチェーン・マルチウォレットサポートが拡張可能。代償は初期構築コストが高めなこと——シンプルな単一チェーン DApp では過剰設計になる可能性がある。

いくつかの実践的アドバイス:

  1. 業務コンポーネント内で viem/ethers.js を直接呼び出さない、カプセル化層経由でアクセスし、後の基盤ライブラリ置き換えを容易にする
  2. トランザクション状態はユーザーに可視でなければならない、各段階で UI フィードバックを用意
  3. RPC ノードは少なくとも 3 ソースを設定、異なるサービスプロバイダに分散
  4. ABI 型生成を CI に組み込む、コントラクトアップグレード後に ABI 変更を自動検出
  5. エラーメッセージはユーザー操作可能なもの(残高不足など)とシステムレベルのもの(RPC ノード障害など)を区別

まとめ ​

Web3 DApp のフロントエンドアーキテクチャの中核の課題は:ブロックチェーンネットワークの非同期性と不確実性の処理、マルチウォレット・マルチチェーンエコシステムの適応、コントラクト相互作用の型安全性の保証である。viem を相互作用層として選択し、EIP-6963 でウォレット発見を行い、自動生成された ABI 型で型安全性を保証し、ブロック番号ベースのキャッシュで読み取りパフォーマンスを最適化し、状態マシンでトランザクションライフサイクルを管理する——これらを組み合わせることで、2026 年に実践可能な DApp フロントエンドエンジニアリングのアプローチが構成される。DApp フロントエンドは車輪の再発明をする必要はないが、従来フロントエンドの各環節を一つひとつ見直す必要がある、底層の前提がすでに完全に異なるからである。

MIT Licensed