HandsOnChain

残高と送金の画面を作る

作るもの

このレッスンを終えると、ブラウザでアカウントを選んで円トークンの残高を見て、別のアカウントへ送金できます。
ローカルノードでは画面の右上でanvilのアカウントを選ぶだけで操作でき、ウォレットを入れる必要はありません。
円トークンをデプロイした発行体のアカウントが100万円分を持っているので、そこから利用者へ送り、残高が変わる様子を確かめます。

背景

銀行のアプリには、残高の表示と振込の画面があります。
円トークンの画面にも同じものがありますが、残高は銀行のサーバーからではなく、チェーンの上のコントラクトから直接読みます。
誰が作った画面でも同じコントラクトを読むため、同じ残高が出ます。

画面からコントラクトを読み書きするには、次の2つの道具を使います。

道具 役割
viem チェーンとの読み書きを行うTypeScriptのライブラリ
wagmi viemをReactから使うためのフックをまとめたライブラリ

ローカルノードでは、wagmiのmockコネクタを使います。
mockコネクタは署名の依頼をそのままanvilへ渡し、anvilが最初から持つアカウントの鍵で署名します。
鍵を画面やブラウザに置かずに、アカウントを選ぶだけで取引を送れます。

実装

雛形のapp/src/には、次のファイルが最初から入っています。
このレッスンでは、これらを土台に、残高を読むフックと取引を送るフックと画面を足します。

ファイル 役割
lib/chains.ts ローカルノードのanvilとFujiのチェーンの定義と、anvilのアカウントの名前
lib/wagmi.ts wagmiの設定。
ローカルノードはmock、Fujiはブラウザのウォレットでつなぐ
lib/deployments.ts Ignitionの記録から、円トークンのアドレスを読む
lib/format.ts 円の額の表示と入力を扱う。
コントラクトが拒んだ理由も日本語の文にする
lib/theme.ts 画面の色味の名前と、選んだ色味をブラウザに残す時の鍵
components/session.tsx 今のネットワーク、操作しているアカウント、円トークンのアドレスを持つ。
Fujiへの切り替えは最後の節で画面に出す
components/header.tsx 右上に、濃紺と紙と朱の色味を切り替えるボタンと、操作するアカウントを選ぶ欄を持つ
components/ui.tsx カードと入力欄と金額を表示し、状態のバッジと通知の行も出すコンポーネント
components/not-deployed.tsx 円トークンをまだデプロイしていない時に、デプロイのコマンドを示す

まず、残高を読むapp/src/components/use-token.tsを作ります。
useReadContractsは複数の読み取り用の関数をまとめて呼び、結果を呼んだ順の配列で返します。

"use client";

import { jpyTokenAbi } from "@contracts/generated/abi";
import { useReadContracts } from "wagmi";

import { useSession } from "./session";

// 発行した円トークンの合計と、アカウントごとの残高をまとめて読む。4秒ごとに読み直す
export function useTokenState(addresses: readonly `0x${string}`[]) {
  const { token, chainId } = useSession();
  const contract = { address: token, abi: jpyTokenAbi, chainId } as const;

  const result = useReadContracts({
    allowFailure: true,
    contracts: [
      { ...contract, functionName: "totalSupply" },
      ...addresses.map((address) => ({ ...contract, functionName: "balanceOf", args: [address] }) as const),
    ],
    query: { enabled: Boolean(token), refetchInterval: 4_000 },
  });

  const data = result.data ?? [];
  return {
    totalSupply: data[0]?.result as bigint | undefined,
    // addresses と同じ順の残高。読めていない間は undefined
    balances: addresses.map((_, index) => data[1 + index]?.result as bigint | undefined),
  };
}
コード 意味
{ ...contract, functionName: "totalSupply" } 発行した円トークンの合計を読む
functionName: "balanceOf", args: [address] アカウントごとの残高を読む。
argsの型はABIから決まり、引数の数や型を誤ると型チェックでエラーになる
refetchInterval: 4_000 4秒ごとに読み直す。
別のアカウントから届いた送金も、待てば画面に出る
enabled: Boolean(token) 円トークンのアドレスが分かるまで読まない

次に、取引を送るapp/src/components/use-send.tsを作ります。
sendは送る前にsimulateContractで同じ取引を試します。
このシミュレーションはブロックに入らない読み取りの呼び出しで、コントラクトが拒む時はそのエラーの名前を返します。

試さずに送ると、anvilは拒まれる取引もブロックに入れます。
結果は「失敗した」だけになり、拒んだ理由を画面に出せません。

"use client";

import { jpyTokenAbi } from "@contracts/generated/abi";
import { useQueryClient } from "@tanstack/react-query";
import { useState } from "react";
import type { ContractFunctionArgs, ContractFunctionName } from "viem";
import { useConfig } from "wagmi";
import { simulateContract, waitForTransactionReceipt, writeContract } from "wagmi/actions";

import { explainError } from "@/lib/format";

import { useSession } from "./session";
import type { Notice } from "./ui";

type WriteName = ContractFunctionName<typeof jpyTokenAbi, "nonpayable">;

// 送る前に同じ取引を試し、コントラクトが拒む時は送らずに理由を出す。
// 通る時だけ送り、ブロックに入るまで待ってから、画面の読み取りを全て読み直す
export function useSend() {
  const config = useConfig();
  const queryClient = useQueryClient();
  const { chainId, address, token } = useSession();
  const [pending, setPending] = useState<string>();
  const [notice, setNotice] = useState<Notice>();

  async function send<name extends WriteName>(
    key: string,
    done: string,
    functionName: name,
    args: ContractFunctionArgs<typeof jpyTokenAbi, "nonpayable", name>,
  ) {
    if (!token || !address) return false;
    setPending(key);
    setNotice(undefined);
    try {
      const { request } = await simulateContract(config, {
        abi: jpyTokenAbi,
        address: token,
        functionName,
        args,
        account: address,
        chainId,
      } as Parameters<typeof simulateContract>[1]);
      const hash = await writeContract(config, request);
      const receipt = await waitForTransactionReceipt(config, { hash, chainId });
      if (receipt.status !== "success") throw new Error("reverted");
      setNotice({ kind: "ok", text: done });
      await queryClient.invalidateQueries();
      return true;
    } catch (error) {
      setNotice({ kind: "error", text: explainError(error) });
      return false;
    } finally {
      setPending(undefined);
    }
  }

  return { send, pending, notice };
}
コード 意味
simulateContract(...) 取引を送らずに試す。
拒まれる時はここでエラーになり、取引は送られない
writeContract(config, request) シミュレーションが通った取引を、操作しているアカウントで送る
waitForTransactionReceipt(...) 取引がブロックに入るまで待つ
queryClient.invalidateQueries() 残高の読み取りを全てやり直す
explainError(error) 拒んだ理由をlib/format.tsの文に変える。
残高が足りない時は「残高が足りません」になる

続けて、残高と送金の欄を持つapp/src/components/holder-view.tsxを作ります。

"use client";

import { useState } from "react";
import { isAddress } from "viem";

import { localAccounts } from "@/lib/chains";
import { formatYen, parseYen, shortAddress } from "@/lib/format";

import { NotDeployed } from "./not-deployed";
import { useSession } from "./session";
import { Amount, Card, Field, NoticeLine } from "./ui";
import { useSend } from "./use-send";
import { useTokenState } from "./use-token";

const OTHER = "other";

export function HolderView() {
  const session = useSession();
  const { send, pending, notice } = useSend();
  const me = session.address;
  const state = useTokenState(me ? [me] : []);
  const balance = state.balances[0];

  const recipients = localAccounts.filter((account) => account.address !== me);
  const [recipient, setRecipient] = useState<string>(recipients[0]?.address ?? OTHER);
  const [otherAddress, setOtherAddress] = useState("");
  const [sendAmount, setSendAmount] = useState("");

  if (!session.token) return <NotDeployed />;
  if (!me) return null;

  // アカウントを切り替えて、選んでいた送り先が自分になった時は、最初の候補へ戻す
  const listed = recipients.some((account) => account.address === recipient);
  const picked = recipient === OTHER || listed ? recipient : (recipients[0]?.address ?? OTHER);
  const to = picked === OTHER ? otherAddress.trim() : picked;
  const sendValue = parseYen(sendAmount);
  const canSend = isAddress(to) && sendValue !== undefined;

  return (
    <div className="stack">
      <div className="hero">
        <div>
          <p className="hero-label">{session.label ?? "このアカウント"}の残高</p>
          <p className="hero-value">
            <Amount value={balance} />
          </p>
          <p className="hero-sub">{shortAddress(me)}</p>
        </div>
      </div>

      <div className="grid-2">
        <Card title="送金する" description="選んだアカウントへ円トークンを送ります。">
          <form
            className="form"
            onSubmit={async (event) => {
              event.preventDefault();
              if (!canSend) return;
              const ok = await send("transfer", `${formatYen(sendValue)}を送りました`, "transfer", [to as `0x${string}`, sendValue]);
              if (ok) setSendAmount("");
            }}
          >
            <Field label="送り先">
              <select value={picked} onChange={(event) => setRecipient(event.target.value)}>
                {recipients.map((account) => (
                  <option key={account.address} value={account.address}>
                    {account.label} {shortAddress(account.address)}
                  </option>
                ))}
                <option value={OTHER}>アドレスを入力する</option>
              </select>
            </Field>
            {picked === OTHER ? (
              <Field label="送り先のアドレス">
                <input
                  value={otherAddress}
                  onChange={(event) => setOtherAddress(event.target.value)}
                  placeholder="0x"
                  spellCheck={false}
                />
              </Field>
            ) : null}
            <Field label="額 (円)" hint="1円単位で入力します" unit="円">
              <input inputMode="numeric" value={sendAmount} onChange={(event) => setSendAmount(event.target.value)} placeholder="1000" />
            </Field>
            <button className="button button-primary" type="submit" disabled={!canSend || pending !== undefined}>
              {pending === "transfer" ? "送っています" : "送る"}
            </button>
          </form>
        </Card>
      </div>

      <NoticeLine notice={notice} />
    </div>
  );
}
コード 意味
useTokenState(me ? [me] : []) 操作しているアカウントの残高を読む
<Amount value={balance} /> 雛形のui.tsxが持つ、金額を大きく出すコンポーネント。
数字の後の円の字を一回り小さく添える
recipients 自分を除いたanvilのアカウントを送り先の候補にする。
候補にないアカウントへは、アドレスを入力して送れる
picked 右上でアカウントを切り替えた時に、送り先が自分のままにならないようにする
parseYen(sendAmount) 入力された円の額を18桁の整数にする。
1円未満と0以下はundefinedになり、ボタンを押せない
unit="円" 入力欄の右端に円の字を添える
send("transfer", 文, "transfer", [to, sendValue]) ERC-20のtransferを試してから送り、ブロックに入った後に結果の文を出す
className="grid-2" 欄を横に並べる枠。
今は送金の欄だけなので横いっぱいに出し、次の節で償還の欄を隣に足す

最後に、app/src/app/page.tsxを、残高と送金の画面を出す形に書き換えます。

import { HolderView } from "@/components/holder-view";

export default function HolderPage() {
  return <HolderView />;
}

確かめる

starter/appのディレクトリでpnpm devを実行し、ブラウザでhttp://localhost:3400を開きます。
右上のアカウントは最初「発行体」で、円トークンをデプロイしたアカウントなので、残高に1,000,000円が出ます。
送り先に「利用者A」を選び、額に2500を入力して「送る」を押します。
「2,500円を送りました」と出て、残高が997,500円に減ります。

発行体のアカウントから利用者Aへ2,500円を送ったところ
発行体のアカウントから利用者Aへ2,500円を送ったところ

右上で「利用者A」に切り替えると、受け取った2,500円が残高に出ます。
送り先に「利用者B」を選び、残高より多い5000を入力して「送る」を押します。
送る前のシミュレーションでコントラクトが拒み、「残高が足りません」と出ます。
シミュレーションで止まった取引はブロックに入らないため、残高は変わりません。

利用者Aが残高より多い額を送ろうとして断られたところ
利用者Aが残高より多い額を送ろうとして断られたところ

これで節1は終わりです。
円トークンをデプロイし、ブラウザから送金できるところまで進みました。