HandsOnChain

申込と締めの画面を作る

作るもの

このレッスンを終えると、投資家がブラウザから口数を入れて申し込み、払う額の円を決済のコントラクトに預けられます。
発行体のページでは、発行額に対する申込の進み具合と、投資家ごとの口数と預かった円を見られます。
締め切りの後に「募集を締める」を押すと、円と社債が1つの取引で入れ替わります。
ローカルノードでは締め切りの日まで待たずに、ボタン1つでチェーンの時刻を進められます。

背景

社債の募集の間、発行体は発行額に対してどれだけの申込が集まったかを見ながら締め切りを待ちます。
投資家は、自分が申し込んだ口数と払った額を確かめます。
この画面では、どちらの数も決済のコントラクトから直接読みます。
発行体のページと投資家のページが同じコントラクトを読むため、申込の数が食い違いません。

画面の操作 呼ぶ関数 押せる人
申し込む 円トークンのapproveと、決済のコントラクトのsubscribe 本人確認の済んだ投資家
募集を締める 決済のコントラクトのclose 誰でも押せる。
画面では発行体のページに置く
締め切りの後へ進める anvilのevm_setNextBlockTimestampとanvil_mine ローカルノードの時だけ出す

チェーンの時刻は、ブロックに付いた時刻で進みます。
締め切りは2026-01-14ですが、ローカルノードのanvilは2026-01-01から始まります。
テストではFoundryのvm.warpで時刻を進めました。
画面では、anvilに次のブロックの時刻を決めさせてから1ブロックを作り、チェーンの時刻を進めます。
Fujiのようなテストネットでは時刻を進められないため、このボタンはローカルノードの時だけ出します。

実装

まず、画面が決済のコントラクトのアドレスを読めるようにします。
starter/app/src/lib/deployments.tsで、Ignitionの記録から決済のコントラクトのアドレスも読みます。

    deployments[chainId] = {
      jpy: addresses["JpyTokenModule#JpyToken"],
      bond: addresses["DigitalBondModule#BondToken"],
      settlement: addresses["DigitalBondModule#BondSettlement"],
    };

次に、starter/app/src/components/use-bond.tsで決済のコントラクトの状態を読みます。
読み込みの行を、決済のコントラクトのABIと投資家の一覧を含む形にします。

import { bondSettlementAbi, bondTokenAbi, jpyTokenAbi } from "@contracts/generated/abi";
import type { Abi } from "viem";
import { zeroAddress } from "viem";
import { useBlock, useReadContracts } from "wagmi";

import { investors } from "@/lib/chains";

import { useSession } from "./session";

useBondの中で、円トークンの次に決済のコントラクトを置きます。

  const jpy = { address: contracts.jpy, abi: jpyTokenAbi as Abi };
  const settlement = { address: contracts.settlement, abi: bondSettlementAbi as Abi };

まとめて読む値の末尾に、募集の値と投資家ごとの申込の口数を足します。

      allowed: { ...jpy, functionName: "isAllowed", args: [me] },
      deadline: { ...settlement, functionName: "deadline" },
      issueAmount: { ...settlement, functionName: "issueAmount" },
      totalSubscribed: { ...settlement, functionName: "totalSubscribed" },
      closed: { ...settlement, functionName: "closed" },
      issued: { ...settlement, functionName: "issued" },
      ...Object.fromEntries(investors.map((investor) => [`subscribed:${investor.address}`, { ...settlement, functionName: "subscribed", args: [investor.address] }])),
    },

返す値の末尾にも、同じ名前で足します。

    coupons,
    deadline: base.deadline as bigint | undefined,
    issueAmount: base.issueAmount as bigint | undefined,
    totalSubscribed: base.totalSubscribed as bigint | undefined,
    closed: base.closed as boolean | undefined,
    issued: base.issued as boolean | undefined,
    subscribed: (account: `0x${string}`) => base[`subscribed:${account}`] as bigint | undefined,
  };
コード 意味
deadline、issueAmount 締め切りと発行額。
画面の説明の文と残りの口数に使う
totalSubscribed 申込の口数の和。
発行体のページの進み具合に使う
closed、issued 締めたかと、社債を発行したか。
社債の状態の札に使う
subscribed:${investor.address} 投資家ごとの申込の口数。
local.jsonの3人分を、ほかの値と一緒に1回で読む
subscribed: (account) => ... 投資家のアドレスを渡すと、その人の申込の口数を返す

社債の状態を札の文字と色にするstarter/app/src/components/bond-status.tsを新しく作ります。

import type { BondState } from "./use-bond";
import type { Tone } from "./ui";

// 社債の今の状態を、札の文字と色にする
export function statusOf(bond: BondState): { label: string; tone: Tone } {
  if (!bond.closed) return { label: "募集中", tone: "info" };
  if (!bond.issued) return { label: "募集不成立", tone: "warn" };
  return { label: "発行済み", tone: "good" };
}

締める前は「募集中」で、締めて30口に届いていれば「発行済み」、届かずに円を返していれば「募集不成立」になります。

starter/app/src/lib/format.tsには、決済のコントラクトが拒んだ時に出す文を足します。
reasonsの末尾の4行が、このレッスンで足す行です。

const reasons: Record<string, string> = {
  ERC20InsufficientBalance: "円トークンか社債の残高が足りません",
  ERC20InsufficientAllowance: "決済のコントラクトに任せた額が足りません",
  AccessControlUnauthorizedAccount: "このアカウントは、この操作をする役割を持っていません",
  NotAllowed: "円トークンの名簿で本人確認が済んでいないアカウントです",
  AccountFrozen: "円トークンの名簿で凍結されたアカウントです",
  OverIssueAmount: "発行額に達したので、これ以上は申し込めません",
  AfterDeadline: "申込の締め切りを過ぎています",
  BeforeDeadline: "締め切りの後に押せます",
  AlreadyClosed: "募集はもう締めました",
};

続けて、投資家のページのstarter/app/src/components/investor-view.tsxに申込の欄を足します。
読み込みの行を次の形にします。

"use client";

import { bondSettlementAbi, jpyTokenAbi } from "@contracts/generated/abi";
import { useState } from "react";
import type { Abi } from "viem";

import { formatDate, formatUnitsCount, formatWholeYen, formatYen, parseCount, shortAddress, YEN } from "@/lib/format";

import { statusOf } from "./bond-status";
import { NotDeployed } from "./not-deployed";
import { useSession } from "./session";
import { Amount, Badge, Card, Field, NoticeLine, lines } from "./ui";
import { useBond } from "./use-bond";
import { useSend } from "./use-send";

InvestorViewの頭に、取引を送るフックと、申込の口数と払う額を持つ値を足します。

export function InvestorView() {
  const session = useSession();
  const bond = useBond();
  const me = session.address;
  const { send, pending, notice } = useSend();
  const { contracts } = session;
  const jpy = { abi: jpyTokenAbi as Abi, address: contracts.jpy };
  const settlement = { abi: bondSettlementAbi as Abi, address: contracts.settlement };
  const status = statusOf(bond);
  const now = bond.now ?? 0n;
  const [applyUnits, setApplyUnits] = useState("");
  const applyCount = parseCount(applyUnits);
  const applyCost = applyCount !== undefined && bond.faceValue !== undefined ? applyCount * bond.faceValue * YEN : undefined;
  const open = bond.closed === false && now <= (bond.deadline ?? 0n);
  const stopped = false;
コード 意味
parseCount(applyUnits) 入力された口数を整数にする。
0以下と小数はundefinedになり、ボタンを押せない
applyCost 口数に額面と18桁のYENを掛けた、払う円の額
open 締めておらず、チェーンの時刻が締め切りまでの間だけ申し込める

アカウントの状態の一覧の末尾に、社債の状態の札を足します。

          <li>
            <span>本人確認</span>
            {bond.allowed ? <Badge tone="good">本人確認済み</Badge> : <Badge tone="warn">未確認</Badge>}
          </li>
          <li>
            <span>社債の状態</span>
            <Badge tone={status.tone}>{status.label}</Badge>
          </li>
        </ul>
      </div>

一覧の後に申込の欄と通知の行を置きます。

      <div className="grid-2">
        <Card title="申し込む" description={`1口${formatWholeYen(bond.faceValue)}で申し込みます。円は締め切りまで決済のコントラクトが預かります。`}>
          <form
            className="form"
            onSubmit={async (event) => {
              event.preventDefault();
              if (applyCount === undefined || applyCost === undefined) return;
              const ok = await send("apply", `${formatUnitsCount(applyCount)}を申し込みました`, [
                { ...jpy, functionName: "approve", args: [contracts.settlement, applyCost] },
                { ...settlement, functionName: "subscribe", args: [applyCount] },
              ]);
              if (ok) setApplyUnits("");
            }}
          >
            <div className="form-row">
              <Field label="口数" unit="口">
                <input inputMode="numeric" value={applyUnits} onChange={(event) => setApplyUnits(event.target.value)} placeholder="5" disabled={!open} />
              </Field>
              <Field label="払う額" unit="円">
                <input value={applyCost === undefined ? "0" : formatYen(applyCost).slice(0, -1)} readOnly />
              </Field>
            </div>
            {open ? null : <p className="notice notice-plain">募集は{formatDate(bond.deadline)}に締め切りました。</p>}
            <button className="button button-primary" type="submit" disabled={!open || applyCount === undefined || pending !== undefined}>
              {pending === "apply" ? "申し込んでいます" : "申し込む"}
            </button>
          </form>
        </Card>
      </div>

      <NoticeLine notice={notice} />
    </div>
  );
}
コード 意味
send("apply", 文, [approve, subscribe]) 円を任せるapproveと、申し込むsubscribeの2つの取引を順に送る
args: [contracts.settlement, applyCost] 決済のコントラクトに、払う額だけを任せる
formatYen(applyCost).slice(0, -1) 払う額を、末尾の円の字を除いて入力欄に出す。
円の字は欄の右端に添える
disabled={!open} 締め切りの後と締めた後は、口数を入れられないようにする

sendは、社債の条件の画面のレッスンで作ったuse-send.tsの関数です。
渡した取引を1つずつ試してから送り、ブロックに入るのを待ってから次を送ります。
subscribeが拒まれた時は円は動かず、任せた額が残るだけです。

ここから発行体のページです。
チェーンの時刻を進めるstarter/app/src/components/use-time-travel.tsを新しく作ります。

"use client";

import { useQueryClient } from "@tanstack/react-query";
import { useState } from "react";
import { createTestClient, http } from "viem";

import { localChain } from "@/lib/chains";

import { useSession } from "./session";

// anvil に次のブロックの時刻を決めさせてから1ブロック掘り、チェーンの時刻を進める
const anvil = createTestClient({ mode: "anvil", chain: localChain, transport: http() });

// ローカルノードの時だけ、締め切りや記録日を待たずに時刻を進める
export function useTimeTravel() {
  const { chainId } = useSession();
  const queryClient = useQueryClient();
  const [moving, setMoving] = useState(false);

  async function moveTo(time: number) {
    setMoving(true);
    try {
      await anvil.setNextBlockTimestamp({ timestamp: BigInt(time) });
      await anvil.mine({ blocks: 1 });
      await queryClient.invalidateQueries();
    } finally {
      setMoving(false);
    }
  }

  return { canTravel: chainId === localChain.id, moving, moveTo };
}
コード 意味
createTestClient({ mode: "anvil", ... }) anvilだけが持つ、テスト向けの関数を呼ぶviemのクライアント
setNextBlockTimestamp(...) 次に作るブロックの時刻を決める
mine({ blocks: 1 }) ブロックを1つ作り、チェーンの時刻を決めた時刻へ進める
invalidateQueries() 時刻が進んだ後の状態を、画面の読み取りに全て読み直させる
canTravel ローカルノードを選んでいる時だけtrueになる

starter/app/src/components/issuer-view.tsxの読み込みの行を次の形にします。

"use client";

import { bondSettlementAbi, jpyTokenAbi } from "@contracts/generated/abi";
import type { Abi } from "viem";

import { investors } from "@/lib/chains";
import { formatDate, formatRate, formatUnitsCount, formatWholeYen, formatYen, shortAddress } from "@/lib/format";

import { statusOf } from "./bond-status";
import { NotDeployed } from "./not-deployed";
import { useSession } from "./session";
import { Amount, Badge, Card, NoticeLine, lines } from "./ui";
import { useBond } from "./use-bond";
import { useSend } from "./use-send";
import { useTimeTravel } from "./use-time-travel";

IssuerViewの頭に、取引を送るフックと時刻を進めるフックと、申込の進み具合を足します。

export function IssuerView() {
  const session = useSession();
  const bond = useBond();
  const { send, pending, notice } = useSend();
  const travel = useTimeTravel();
  const { contracts } = session;
  const jpy = { abi: jpyTokenAbi as Abi, address: contracts.jpy };
  const settlement = { abi: bondSettlementAbi as Abi, address: contracts.settlement };
  const status = statusOf(bond);
  const now = bond.now ?? 0n;
  const filled = bond.issueAmount !== undefined && bond.totalSubscribed !== undefined ? Number((bond.totalSubscribed * 100n) / (bond.issueAmount || 1n)) : 0;

filledは、申込の口数の和が発行額の何%かを表し、進み具合の棒の長さに使います。

大きく出す数を、発行した社債の口数から社債の発行額に変えます。

          <p className="hero-label">社債の発行額</p>
          <p className="hero-value">
            <Amount text={formatUnitsCount(bond.issueAmount)} />
          </p>

社債の条件の一覧の末尾に、状態の札を足します。

          <li>
            <span>満期</span>
            <span className="mono">{formatDate(bond.maturity)}</span>
          </li>
          <li>
            <span>状態</span>
            <Badge tone={status.tone}>{status.label}</Badge>
          </li>
        </ul>
      </div>

一覧の後に、募集の欄と通知の行を置きます。

      <div className="grid-2">
        <Card title="募集" description={`締め切りの${formatDate(bond.deadline)}までに申し込んだ口数です。投資家の円は、申込の時に決済のコントラクトが預かります。`}>
          <div className="progress">
            <div className="progress-head">
              <span className="progress-count">
                {String(bond.totalSubscribed ?? 0n)}
                <small>/ {formatUnitsCount(bond.issueAmount)}</small>
              </span>
              <strong>残り{formatUnitsCount((bond.issueAmount ?? 0n) - (bond.totalSubscribed ?? 0n))}</strong>
            </div>
            <div className="progress-bar" aria-hidden="true">
              <span style={{ width: `${filled}%` }} />
            </div>
          </div>
          <div className="table-wrap">
            <table className="table">
              <thead>
                <tr>
                  <th>投資家</th>
                  <th className="num">口数</th>
                  <th className="num">預かった円</th>
                </tr>
              </thead>
              <tbody>
                {investors.map((investor) => {
                  const units = bond.subscribed(investor.address) ?? 0n;
                  return (
                    <tr key={investor.address}>
                      <td>
                        <span className="cell-title">{investor.label}</span>
                        <span className="cell-sub">{shortAddress(investor.address)}</span>
                      </td>
                      <td className="num">{formatUnitsCount(units)}</td>
                      <td className="num">{bond.closed ? "-" : formatWholeYen(units * (bond.faceValue ?? 0n))}</td>
                    </tr>
                  );
                })}
              </tbody>
            </table>
          </div>
          <p className="notice notice-plain">{bond.issueAmount ? `${formatUnitsCount(bond.issueAmount)}に届けば円と社債を交換し、届かなければ円を返します。` : null}</p>
          <div className="button-row">
            <button
              type="button"
              className="button button-primary"
              disabled={bond.closed !== false || now <= (bond.deadline ?? 0n) || pending !== undefined}
              onClick={() => send("close", "募集を締めました", [{ ...settlement, functionName: "close", args: [] }])}
            >
              {pending === "close" ? "締めています" : "募集を締める"}
            </button>
            {bond.closed || now > (bond.deadline ?? 0n) ? null : <span className="muted">締め切りの後に押せます</span>}
            {travel.canTravel && bond.closed === false && bond.deadline !== undefined && now <= bond.deadline ? (
              <button type="button" className="button button-small" disabled={travel.moving} onClick={() => travel.moveTo(Number(bond.deadline) + 86_400)}>
                締め切りの後へ進める
              </button>
            ) : null}
          </div>
        </Card>
      </div>

      <NoticeLine notice={notice} />
    </div>
  );
}
コード 意味
bond.subscribed(investor.address) 投資家ごとの申込の口数を読む
bond.closed ? "-" : ... 締めた後は、決済のコントラクトが円を預かっていないので-を出す
now <= (bond.deadline ?? 0n) チェーンの時刻が締め切りまでの間は、「募集を締める」を押せない
send("close", "募集を締めました", ...) closeを試してから送る。
締めた後は、社債の状態の札が変わる
travel.moveTo(Number(bond.deadline) + 86_400) チェーンの時刻を、締め切りの1日後の2026-01-15へ進める
travel.canTravel && ... ローカルノードで、締める前で締め切りより前の時だけ、時刻を進めるボタンを出す

確かめる

starter/appのディレクトリでpnpm devを実行し、ブラウザでhttp://localhost:3402を開きます。
右上で「投資家A」を選ぶと、円トークンに3,000,000円が出て、社債の状態は「募集中」です。
申込の欄の口数に10を入れると、払う額に1,000,000が出ます。
「申し込む」を押すと「10口を申し込みました」と出て、円トークンが2,000,000円に減ります。

投資家Aが10口を申し込み、決済のコントラクトが1,000,000円を預かったところ
投資家Aが10口を申し込み、決済のコントラクトが1,000,000円を預かったところ

続けて、右上で「投資家B」を選んで12口を、「投資家C」を選んで8口を申し込みます。
3人の口数の和が30口になり、発行額に達します。
この後に投資家Cがもう1口を申し込むと、「発行額に達したので、これ以上は申し込めません」と出ます。

上の「発行体」のページへ移り、右上で「発行体」を選びます。
募集の欄には、30と/ 30口と残り0口が出ます。
投資家ごとの口数と預かった円も並びます。
チェーンの時刻はまだ締め切りより前なので、「募集を締める」は押せません。
「締め切りの後へ進める」を押してチェーンの時刻を2026-01-15へ進め、「募集を締める」を押します。
「募集を締めました」と出て、状態の札が「発行済み」に変わり、預かった円の列は-になります。

投資家3人が30口を申し込み、締め切りの後に発行体が募集を締めたところ
投資家3人が30口を申し込み、締め切りの後に発行体が募集を締めたところ

上の「投資家」のページへ移り、右上で「投資家A」を選ぶと、持っている社債が10口になっています。
申込の欄には「募集は2026-01-14に締め切りました。」と出て、口数を入れられません。
円の移転と社債の発行は、「募集を締める」を押した1つの取引で済んでいます。

Ctrl+Cで止めてからpnpm devを実行し直すと、チェーンはデプロイした直後の状態に戻ります。
投資家Aと投資家Bだけが申し込んでから締めると、30口に届かないため状態の札は「募集不成立」になります。
この時は社債を発行せず、2人の円トークンは申し込む前の3,000,000円に戻ります。

これで節2は終わりです。
投資家が円を預けて申し込み、締め切りの後に円と社債を1つの取引で入れ替えるところまで、ブラウザから試せます。