HandsOnChain

注文の画面を作る

作るもの

このレッスンを終えると、投資家のページから円の額で申し込み、口数で解約する注文を出せます。
注文の表には注文した時刻と約定日と状態が並び、締め切りの前の注文は行の「取り消す」で取り消せます。
運用会社のページには、純資産を入れる約定日の注文を投資家ごとに並べた表が加わります。

ローカルノードの時だけ、ヘッダーの下にチェーンの日付と今日の締め切りを出す帯が出ます。
帯の「締め切りの後へ進める」と「次の営業日へ進める」を押すとanvilの時刻が進み、注文の状態と次の注文が入る約定日がその場で変わります。

背景

販売会社のオンラインの画面では、投資家はファンドを選び、申込の金額か解約の口数を入れて注文を出します。
出した注文は注文の一覧に並び、約定日や受渡日と、受付中か約定済みかの状態を確かめられます。
締め切りの前の注文は、この一覧から取り消せます。
締め切りを過ぎた注文は、その日の分として委託会社へ伝える手続きに入るため、取り消せなくなります。

販売会社は締め切りの後に、その日の申込と解約をまとめて委託会社へ伝えます。
委託会社が受け取るのは販売会社ごとにまとめた申込と解約の量で、投資家1人ずつの名前は販売会社の帳簿にあります。
委託会社はこの量からファンドへ入る円と出ていく円を見込み、組み入れた資産の売り買いを決めます。

このコースでは、販売会社の注文の一覧の代わりに、ファンドのコントラクトが持つ約定日ごとの注文の列を画面が直接読みます。
投資家のページは列から自分の注文を拾って新しい順に並べ、運用会社のページは約定日の注文を全て並べます。
どちらも同じ列を読むため、投資家が取り消した注文は運用会社のページでも取り消したと出ます。
運用会社のページの行に出るのは投資家のアドレスで、投資家Aのような名前は画面がlocal.jsonから添えたものです。

注文の状態は、コントラクトのStatusとチェーンの時刻から、2つのページで次の札にします。

注文 投資家のページの札 運用会社のページの札
約定の前で、約定日の15時ちょうどまで 締め切りの前。
行に「取り消す」が出る
まだ約定していない
約定の前で、約定日の15時を過ぎた 約定を待つ まだ約定していない
取り消した 取り消した 取り消した
約定した 約定した 約定した

注文した日と約定日が違う行には、札の下に理由を添えます。
投資家のページは「15時を過ぎたため次の営業日」か「土日のため次の営業日」と出し、運用会社のページは3/5の15:20に注文のように注文した日時を出します。

本物のファンドでは、締め切りや次の営業日は時計が進むのを待つしかありません。
ローカルノードのanvilは時刻を進めるテスト用の呼び出しを持つので、帯のボタンでチェーンの時刻を進めます。
帯の時刻は、パソコンの時計ではなく最新のブロックの時刻です。
anvil以外のチェーンでは時刻を進められないので、帯は出しません。

ボタン 進める先 2026-03-05 (木)の10時に押した時
締め切りの後へ進める 次に来る締め切りの1秒後 2026-03-05 (木)の15:00:01
次の営業日へ進める 次の営業日の朝9時 2026-03-06 (金)の9:00
帯のボタンで時刻を進めると注文の札が変わる
画面に出る値今日の締め切り15:00 (あと4時間)15:00 (締め切りの後)15:00 (あと6時間)木曜の申込締め切りの前約定を待つ次の注文の約定日2026-03-05 (木)2026-03-06 (金)投資家A投資家のページ帯のボタンband.tsxローカルノードanvilファンドTokenizedFund112233subscribe(300000)subscribe(300000)setNextBlockTimestamp と minesetNextBlockTimestamp と minesetNextBlockTimestamp と mine

実装

このレッスンでは、starter/app/src/の下の次のファイルを作るか書き換えます。

ファイル 書くこと
lib/days.ts 新しく作る。
日付と営業日と締め切りを、コントラクトと同じ決まりで数える
lib/format.ts 時刻の表示と、注文と取り消しのエラーの文を足す
components/use-fund.ts 円の残高と、約定日ごとの注文の列を読む
components/order-text.ts 新しく作る。
注文の表に出す種類と額と、次の営業日へ回った理由の文字
components/investor-view.tsx 申込と解約の欄と、注文の表を足す
components/manager-view.tsx 純資産を入れる約定日を注文から選び、約定日の注文の表を足す
lib/band.tsとcomponents/use-local-chain.tsとcomponents/band.tsx 新しく作る。
時刻を進める帯
app/layout.tsx ヘッダーの下に帯を置く

日付と締め切りの関数

まず、starter/app/src/lib/days.tsを作ります。
コントラクトの日付と締め切りの決まりを、画面の側でも同じ式で数えます。

// 日本時間の日付と締め切りを、ファンドのコントラクトと同じ決まりで数える。
// 日付は、コントラクトの dayOf と同じ1970-01-01からの日の通し番号で表す。時刻はUnix時刻の秒

const DAY = 86_400;
// 日本時間と協定世界時の差
const JST = 9 * 3_600;
// 申込と解約の締め切り (日本時間の15時)
const CUTOFF = 15 * 3_600;
// 帯のボタンで進める、営業日の朝 (日本時間の9時)
const OPEN = 9 * 3_600;

export function dayOf(time: number): number {
  return Math.floor((time + JST) / DAY);
}

// 土日を休みにし、月曜から金曜を営業日とする。1970-01-01は木曜なので、4を足して7で割った余りが0なら日曜、6なら土曜
export function isBusinessDay(day: number): boolean {
  const weekday = (day + 4) % 7;
  return weekday !== 0 && weekday !== 6;
}

export function nextBusinessDay(day: number): number {
  let next = day + 1;
  while (!isBusinessDay(next)) next += 1;
  return next;
}

// 約定日の締め切りの時刻
export function cutoffAt(day: number): number {
  return day * DAY + CUTOFF - JST;
}

// 営業日の朝9時の時刻
export function openAt(day: number): number {
  return day * DAY + OPEN - JST;
}

// 注文した時刻の約定日。営業日の15時ちょうどまではその日、15時を過ぎた注文と土日の注文は次の営業日
export function tradeDayOf(time: number): number {
  const day = dayOf(time);
  return isBusinessDay(day) && time <= cutoffAt(day) ? day : nextBusinessDay(day);
}

// 締め切りを過ぎた最後の営業日。運用会社はこの日までの純資産を入れられる
export function closedDayOf(time: number): number {
  let day = dayOf(time);
  if (isBusinessDay(day) && time > cutoffAt(day)) return day;
  do {
    day -= 1;
  } while (!isBusinessDay(day));
  return day;
}
コード 意味
dayOfとisBusinessDayとnextBusinessDay コントラクトの同じ名前の関数と同じ式。
日付の番号と営業日の決まりを画面とコントラクトでそろえる
cutoffAt(day) 約定日の15時のUnix時刻。
注文ごとに、まだ取り消せるかをこの時刻と比べる
tradeDayOf(time) その時刻に注文すると入る約定日。
time <= cutoffAt(day)なので、15時ちょうどの注文はまだその日に入る
openAt(day) 営業日の朝9時のUnix時刻。
帯の「次の営業日へ進める」の行き先にする
closedDayOf(time) 締め切りを過ぎた最後の営業日。
木曜の10時なら前の水曜を、木曜の15時より後なら木曜を返す

このファイルはReactもチェーンも使わない、数を受けて数を返すだけの関数です。
表の行ごとにコントラクトを呼ばずに締め切りを比べられ、帯のボタンの行き先もチェーンを読まずに決められます。

starter/app/src/lib/format.tsのformatMonthDayの後に、時刻を文字にする関数を足します。

const clock = new Intl.DateTimeFormat("ja-JP", { timeZone: "Asia/Tokyo", hour: "2-digit", minute: "2-digit", hourCycle: "h23" });

// Unix時刻を、日本時間の時刻 (14:20 の形) にする
export function formatTime(time: bigint | number | undefined): string {
  if (time === undefined) return "-";
  return clock.format(new Date(Number(time) * 1000));
}
コード 意味
timeZone: "Asia/Tokyo" ブラウザがどの国の時刻で動いていても、日本時間で出す
hourCycle: "h23" 0時から23時の24時間の形で出す。
午後3時は15:00になる
Number(time) * 1000 ブロックの時刻は秒なので、Dateが使うミリ秒に直す

分までしか出さないので、15:00:01の注文も15:00と出ます。

同じファイルのreasonsの末尾に、注文と取り消しのエラーの文を足します。

  NavOutOfOrder: "この約定日か、より後の約定日の純資産はもう入れました",
  ZeroNav: "基準価額が0円になる純資産は入れられません",
  ZeroAmount: "1以上の数を入れてください",
  NotBusinessDay: "土日の約定日の純資産は入れられません",
  NotYourOrder: "自分の注文だけを取り消せます",
  NotPending: "この注文は、もう取り消したか約定しました",
  CancelAfterCutoff: "締め切りの15時を過ぎたので、もう取り消せません",
};
コード 意味
ZeroAmount 0円の申込と0口の解約を拒んだ時の文
NotBusinessDay 土日の約定日に純資産を入れようとした時の文
NotYourOrderとNotPendingとCancelAfterCutoff 前のレッスンで足した、取り消しを拒む3つのエラーの文

注文を読む

starter/app/src/components/use-fund.tsで、約定日ごとの注文の列を読めるようにします。
頭の読み込みに、円トークンのABIを足します。

import { jpyTokenAbi, tokenizedFundAbi } from "@contracts/generated/abi";

useNamedReadsの後に、注文の種類と状態の番号と、注文の型を足します。

// 注文の種類と状態。コントラクトの Kind と Status の並びと同じ番号
export const SUBSCRIBE = 0;
export const REDEEM = 1;
export const PENDING = 0;
export const CANCELLED = 1;
export const SETTLED = 2;

// 約定日の1件の注文。額は1円単位の整数で、口数は1口単位の整数で数える
export type FundOrder = {
  day: bigint;
  // 約定日の注文の列での位置。取り消しの時に使う
  index: number;
  investor: `0x${string}`;
  kind: number;
  status: number;
  // 申込は預けた円、解約は預けた口数
  amount: bigint;
  placedAt: bigint;
};

// 注文のある約定日ごとの、注文の列
export type FundDay = {
  day: bigint;
  orders: FundOrder[];
};
コード 意味
SUBSCRIBEとREDEEM コントラクトのenum Kindは書いた順に0と1になる。
その番号に名前を付ける
PENDINGとCANCELLEDとSETTLED enum Statusの0と1と2。
約定の前と取り消したと約定した
FundOrder コントラクトのOrderの5つの値に、約定日dayと列での位置indexを足した形
index: number 取り消す時にcancel(day, index)へ渡す。
コントラクトは注文を約定日と番号の組で名指す
FundDay 注文のある約定日1つと、その日の注文の列

useFundの中で、fundの行の後に円トークンを足します。

  const fund = { address: contracts.fund, abi: tokenizedFundAbi as Abi };
  const jpy = { address: contracts.jpy, abi: jpyTokenAbi as Abi };

1つ目のまとまりに、今のアカウントの円と、注文のある約定日の一覧を足します。

      units: { ...fund, functionName: "balanceOf", args: [me] },
      yen: { ...jpy, functionName: "balanceOf", args: [me] },
      orderDays: { ...fund, functionName: "orderDays" },

2つ目のまとまりに、今注文すると入る約定日を足します。

      lastNav: { ...fund, functionName: "navOf", args: [lastNavDay ?? 0n] },
      tradeDay: { ...fund, functionName: "tradeDayOf", args: [now ?? 0n] },

2つ目のまとまりの後に、約定日ごとの注文の列を読む3つ目のまとまりを足します。

  // 注文のある約定日ごとに、注文の列を読む
  const orderDays = (base.orderDays as readonly bigint[] | undefined) ?? [];
  const perDay = useNamedReads(
    Object.fromEntries(
      orderDays.flatMap((day) => [
        [`orders:${day}`, { ...fund, functionName: "ordersOf", args: [day] }],
      ]),
    ),
    enabled && orderDays.length > 0,
  );
  const days: FundDay[] = orderDays.map((day) => ({
    day,
    orders: ((perDay[`orders:${day}`] as Omit<FundOrder, "day" | "index">[] | undefined) ?? []).map((order, index) => ({ ...order, day, index })),
  }));
  const tradeDay = dated.tradeDay as bigint | undefined;

最後に、返す値に3つを足します。

    today: dated.today as bigint | undefined,
    yen: base.yen as bigint | undefined,
    tradeDay,
    days,
  };
コード 意味
yen 円トークンのbalanceOf。
18桁の最小単位の残高で、申込の欄に円の残高として出す
orderDays 前のレッスンまでに作った、注文のある約定日を古い順に並べた配列
tradeDayOf 今の時刻に注文すると入る約定日をコントラクトに出させる。
申込と解約の欄に出す
Object.fromEntries(...) 約定日ごとにordersOfの読み取りを1つずつ並べ、orders:20517のような名前で引けるようにする
enabled && orderDays.length > 0 注文のある約定日がまだない時は読まない
Omit<FundOrder, "day" | "index"> viemはOrderの構造体を、investorやamountの名前を持つ値で返す。
列の約定日と位置はまだ持たない
.map((order, index) => ({ ...order, day, index })) 返った列の順番を位置として持たせ、約定日も添える

注文の列は、約定日が増えるたびに読み取りが1つずつ増えます。
1日分の注文を1回のordersOfで読むので、注文の数が増えても読み取りの数は約定日の数だけです。

注文の表の文字

投資家と運用会社の2つのページで同じ書き方にする文字を、starter/app/src/components/order-text.tsにまとめます。

import { dayOf, isBusinessDay } from "@/lib/days";
import { formatUnitsCount, formatWholeYen } from "@/lib/format";

import { SUBSCRIBE, type FundOrder } from "./use-fund";

// 注文の表の文字。投資家と運用会社のページで同じ書き方にする

export function kindLabel(order: FundOrder): string {
  return order.kind === SUBSCRIBE ? "申込" : "解約";
}

// 申込は預けた円、解約は預けた口数
export function amountText(order: FundOrder): string {
  return order.kind === SUBSCRIBE ? formatWholeYen(order.amount) : formatUnitsCount(order.amount);
}

// 注文した日と約定日が違う時に、次の営業日へ回った理由を返す。同じ日なら undefined
export function movedReason(order: FundOrder): string | undefined {
  const placed = dayOf(Number(order.placedAt));
  if (placed === Number(order.day)) return undefined;
  return isBusinessDay(placed) ? "15時を過ぎたため次の営業日" : "土日のため次の営業日";
}
コード 意味
kindLabel 種類の番号から、申込か解約の字を返す
amountText 申込は300,000円、解約は100,000口の形にする。
どちらもamountに入っているので、種類で単位を分ける
dayOf(Number(order.placedAt)) 注文した時刻の日付の番号。
約定日の番号と比べる
isBusinessDay(placed) ? ... : ... 注文した日が営業日なら15時を過ぎたから、土日なら休みだから次の営業日へ回ったとわかる

投資家のページ

starter/app/src/components/investor-view.tsxに、申込と解約の欄と注文の表を足します。
頭の読み込みを、次の形に書き換えます。

"use client";

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

import { sameAddress } from "@/lib/chains";
import { cutoffAt, dayOf, isBusinessDay } from "@/lib/days";
import { formatDate, formatDay, formatMonthDay, formatTime, formatUnitsCount, formatWholeYen, formatYen, parseCount, YEN } from "@/lib/format";

import { NotDeployed } from "./not-deployed";
import { amountText, kindLabel, movedReason } from "./order-text";
import { useSession } from "./session";
import { Amount, Badge, Card, Field, NoticeLine, type Tone } from "./ui";
import { CANCELLED, PENDING, REDEEM, SETTLED, useFund, type FundOrder } from "./use-fund";
import { useSend } from "./use-send";

InvestorViewの前に、欄の説明の文と、受け付けの状態と注文の札を決める2つの関数を足します。

const redeemNote = "持分の口数で解約します。代金は約定日の基準価額で決まります。";
const ordersNote = "締め切りの前なら、注文を取り消して預けた円か口数を戻せます。15時を過ぎた注文と土日の注文は、次の営業日の約定日に入ります。";

// 営業日の15時までは、今日の約定日の注文を受け付ける
function intakeOf(now: number): { label: string; tone: Tone } {
  const today = dayOf(now);
  if (!isBusinessDay(today)) return { label: "休みの日", tone: "plain" };
  if (now <= cutoffAt(today)) return { label: "受け付け中", tone: "good" };
  return { label: "締め切りの後", tone: "warn" };
}

// 注文の表に出す状態
function statusOf(order: FundOrder, now: number): { label: string; tone: Tone } {
  if (order.status === CANCELLED) return { label: "取り消した", tone: "plain" };
  if (order.status === SETTLED) return { label: "約定した", tone: "good" };
  if (now <= cutoffAt(Number(order.day))) return { label: "締め切りの前", tone: "warn" };
  return { label: "約定を待つ", tone: "plain" };
}
コード 意味
intakeOf(now) 今日が土日なら休みの日、営業日の15時ちょうどまでは受け付け中、15時を過ぎたら締め切りの後を返す
tone 札の色の名前。
色は雛形のglobals.cssのbadge-goodとbadge-warnとbadge-plainが持つ
statusOf(order, now) 取り消した注文と約定した注文はコントラクトのstatusで決め、約定の前の注文は約定日の15時と今の時刻を比べて決める
cutoffAt(Number(order.day)) 注文した日ではなく約定日の締め切りと比べる。
土曜の注文は月曜の15時まで締め切りの前になる

navLabelの行の後に、取引を送るフックと入力欄の値と、自分の注文の並びを足します。

  const navLabel = state.lastNavDay ? `基準価額 (${formatMonthDay(state.lastNavDay)})` : "基準価額";
  const { send, pending, notice } = useSend();
  const fund = { abi: tokenizedFundAbi as Abi, address: session.contracts.fund };
  const jpy = { abi: jpyTokenAbi as Abi, address: session.contracts.jpy };
  const [subscribeAmount, setSubscribeAmount] = useState("");
  const [redeemAmount, setRedeemAmount] = useState("");
  const subscribeValue = parseCount(subscribeAmount);
  const redeemValue = parseCount(redeemAmount);
  const now = Number(state.now ?? 0n);
  // 今のアカウントの注文を、新しい順に並べる
  const mine = state.days
    .flatMap((day) => day.orders.map((order) => ({ order, day })))
    .filter(({ order }) => sameAddress(order.investor, me))
    .sort((a, b) => Number(b.order.placedAt - a.order.placedAt) || b.order.index - a.order.index);
  const held = mine.filter(({ order }) => order.kind === REDEEM && order.status === PENDING).reduce((sum, { order }) => sum + order.amount, 0n);
  const intake = intakeOf(now);
コード 意味
parseCount(...) 申込の額と解約の口数は1以上の整数だけを受け付ける。
0と小数と空の時はボタンを押せなくする
state.days.flatMap(...) 約定日ごとの列を1本の並びにする
sameAddress(order.investor, me) 今のアカウントが出した注文だけを残す
.sort(...) 注文した時刻の新しい順に並べる。
同じ時刻の時は、列の後ろの注文を先にする
held 解約で預けた口数。
約定の前の解約の口数を足す。
取り消した解約は戻っているので数えない

上の段の一覧の頭に解約で預けた口数を、末尾に受け付けの状態を足します。

        <ul className="status-list" aria-label="持分の状態">
          <li>
            <span>解約で預けた口数</span>
            <span className="mono">{formatUnitsCount(held)}</span>
          </li>
          <li>
            <span>{navLabel}</span>
          <li>
            <span>評価額</span>
            <span className="mono">{formatWholeYen(value)}</span>
          </li>
          <li>
            <span>状態</span>
            <Badge tone={intake.tone}>{intake.label}</Badge>
          </li>
        </ul>
      </div>

上の段の後に、申し込む欄と解約する欄を並べます。

      <div className="grid-2">
        <Card title="申し込む" description="円の額で申し込みます。口数は、締め切りの後に決まる約定日の基準価額で決まります (ブラインド方式)。">
          <form
            className="form form-inline"
            onSubmit={async (event) => {
              event.preventDefault();
              if (subscribeValue === undefined) return;
              const ok = await send("subscribe", `${formatWholeYen(subscribeValue)}で申し込みました`, [
                { ...jpy, functionName: "approve", args: [session.contracts.fund, subscribeValue * YEN] },
                { ...fund, functionName: "subscribe", args: [subscribeValue] },
              ]);
              if (ok) setSubscribeAmount("");
            }}
          >
            <Field label="申し込む額" unit="円">
              <input inputMode="numeric" value={subscribeAmount} onChange={(event) => setSubscribeAmount(event.target.value)} placeholder="0" />
            </Field>
            <button className="button" type="submit" disabled={subscribeValue === undefined || pending !== undefined}>
              {pending === "subscribe" ? "申し込んでいます" : "申し込む"}
            </button>
          </form>
          <dl className="facts">
            <div>
              <dt>円の残高</dt>
              <dd>{formatYen(state.yen)}</dd>
            </div>
            <div>
              <dt>約定日</dt>
              <dd>{formatDay(state.tradeDay)}</dd>
            </div>
          </dl>
        </Card>

        <Card title="解約する" description={redeemNote}>
          <form
            className="form form-inline"
            onSubmit={async (event) => {
              event.preventDefault();
              if (redeemValue === undefined) return;
              const ok = await send("redeem", `${formatUnitsCount(redeemValue)}を解約しました`, [{ ...fund, functionName: "redeem", args: [redeemValue] }]);
              if (ok) setRedeemAmount("");
            }}
          >
            <Field label="解約する口数" unit="口">
              <input inputMode="numeric" value={redeemAmount} onChange={(event) => setRedeemAmount(event.target.value)} placeholder="0" />
            </Field>
            <button className="button" type="submit" disabled={redeemValue === undefined || pending !== undefined}>
              {pending === "redeem" ? "解約しています" : "解約する"}
            </button>
          </form>
          <dl className="facts">
            <div>
            <dt>約定日</dt>
            <dd>{formatDay(state.tradeDay)}</dd>
            </div>
          </dl>
        </Card>
      </div>
コード 意味
{ ...jpy, functionName: "approve", args: [session.contracts.fund, subscribeValue * YEN] } 申し込む額だけを、円トークンのapproveでファンドに任せる。
円トークンは18桁なのでYENを掛ける
{ ...fund, functionName: "subscribe", args: [subscribeValue] } 任せた円で申し込む。
ファンドは額を1円単位の整数で受け取り、transferFromで円を預かる
[{ ...fund, functionName: "redeem", args: [redeemValue] }] 解約は1つの取引だけを送る。
持分のトークンはファンドのコントラクトそのものなので、任せずに口数を移せる
formatYen(state.yen) 円トークンの18桁の残高を、1,000,000円の形にする
formatDay(state.tradeDay) 今注文すると入る約定日。
15時を過ぎると次の営業日に変わる
description="... (ブラインド方式)。" 申し込む時点では口数が決まっていないことを、欄の説明で知らせる

最後に、注文の表を置いてページを閉じます。

      <Card title="注文" description={ordersNote}>
        <div className="table-wrap">
          <table className="table">
            <thead>
              <tr>
                <th>注文した時刻</th>
                <th>種類</th>
                <th className="num">額か口数</th>
                <th>約定日</th>
                <th>状態</th>
                <th>操作</th>
              </tr>
            </thead>
            <tbody>
              {mine.map(({ order, day }) => {
                const status = statusOf(order, now);
                const moved = movedReason(order);
                const key = `${order.day}-${order.index}`;
                const cancellable = order.status === PENDING && now <= cutoffAt(Number(order.day));
                return (
                  <tr key={key}>
                    <td>
                      <span className="cell-title">{formatDate(order.placedAt)}</span>
                      <span className="cell-sub">{formatTime(order.placedAt)}</span>
                    </td>
                    <td>{kindLabel(order)}</td>
                    <td className="num">{amountText(order)}</td>
                    <td>{formatDay(order.day)}</td>
                    <td>
                      <Badge tone={status.tone}>{status.label}</Badge>
                      {moved ? <span className="cell-note">{moved}</span> : null}
                    </td>
                    <td className="num">
                      {cancellable ? (
                        <button
                          type="button"
                          className="button button-small"
                          disabled={pending !== undefined}
                          onClick={() =>
                            send(`cancel-${key}`, `${formatDate(order.placedAt)} ${formatTime(order.placedAt)}の注文を取り消しました`, [
                              { ...fund, functionName: "cancel", args: [order.day, BigInt(order.index)] },
                            ])
                          }
                        >
                          {pending === `cancel-${key}` ? "取り消しています" : "取り消す"}
                        </button>
                      ) : null}
                    </td>
                  </tr>
                );
              })}
              {mine.length === 0 ? (
                <tr>
                  <td colSpan={6} className="muted">
                    まだ注文はありません
                  </td>
                </tr>
              ) : null}
            </tbody>
          </table>
        </div>
      </Card>

      <NoticeLine notice={notice} />
コード 意味
key 約定日と列の位置をつないだ20517-0のような字。
コントラクトが注文を名指す組と同じなので、行を見分ける鍵にも使う
cancellable 約定の前で、約定日の15時ちょうどまでの注文だけに「取り消す」を出す。
コントラクトのcancelが通る条件と同じ
formatDateとformatTime 注文した時刻を、日付の行と時刻の行に分けて出す
movedReason(order) 次の営業日へ回った注文だけ、札の下に理由を添える
args: [order.day, BigInt(order.index)] 約定日と列の位置を渡してcancelを送る。
位置はnumberで持っているので、uint256へ渡す前にbigintへ直す
sendの1つ目の引数 cancel-20517-0のように行のkeyを付け、送っている行だけボタンの字を「取り消しています」にする。
他の行のボタンもpendingで押せなくなる

締め切りを過ぎた注文の「取り消す」は画面が消しますが、取り消せるかを決めるのはコントラクトです。
画面を開いたまま15時をまたいでから押しても、コントラクトがCancelAfterCutoffで拒むので、締め切りの後に取り消されることはありません。

運用会社のページ

starter/app/src/components/manager-view.tsxに、約定日の注文の表を足します。
頭の読み込みを、次の形に書き換えます。

import { labelOf, sameAddress } from "@/lib/chains";
import { closedDayOf, dayOf } from "@/lib/days";
import { formatDay, formatMonthDay, formatTime, formatUnitsCount, formatWholeYen, parseAmount, shortAddress } from "@/lib/format";

import { NotDeployed } from "./not-deployed";
import { amountText, kindLabel, movedReason } from "./order-text";
import { useSession } from "./session";
import { Amount, Badge, Card, Field, NoticeLine, type Tone } from "./ui";
import { CANCELLED, SETTLED, useFund, type FundOrder } from "./use-fund";
import { useSend } from "./use-send";

navNoteの後に、表の説明の文と注文の札を決める関数を足します。

const navNote = "運用会社の役を持つアカウントが、約定日の純資産の総額を入れます。口数で割り、1万口あたりの基準価額を出します。";
const dayNote = "締め切りまでに投資家が出した注文です。15時を過ぎた注文と土日の注文は、次の営業日の約定日に入ります。";

// 運用会社の注文の表に出す状態
function statusOf(order: FundOrder): { label: string; tone: Tone } {
  if (order.status === CANCELLED) return { label: "取り消した", tone: "plain" };
  if (order.status === SETTLED) return { label: "約定した", tone: "good" };
  return { label: "まだ約定していない", tone: "warn" };
}

運用会社の札は締め切りの前と後を分けず、約定の前の注文を全てまだ約定していないにします。
運用会社が見たいのは、純資産を入れて約定する時に残っている注文だからです。

前のレッスンで今日の約定日にしていたnavDayの2行を、注文のある約定日から選ぶ形に書き換えます。

  const isManager = sameAddress(address, state.manager);
  const now = Number(state.now ?? 0n);
  // まだ純資産を入れていない、注文のある一番古い約定日
  const orderDay = state.days.find((entry) => entry.day > lastNavDay);
  // 注文のない時は、締め切りを過ぎた最後の営業日か、次に締め切る約定日に入れる
  const closedDay = BigInt(closedDayOf(now));
  const navDay = state.now === undefined ? undefined : (orderDay?.day ?? (closedDay > lastNavDay ? closedDay : state.tradeDay));
  // 注文の表に出す約定日。純資産を待つ約定日がない時は、最後の約定日の注文を出し続ける
  const target = orderDay ?? state.days.at(-1);
  const orders = target?.orders ?? [];
  // 入れようとする約定日の純資産を、もう入れたか
  const entered = navDay !== undefined && navDay <= lastNavDay;
今の様子 純資産を入れる約定日 2026-03-05 (木)の例
純資産を待つ注文のある約定日がある 注文のある一番古い約定日 10時に誰かが申し込んだ後は2026-03-05 (木)
注文がなく、締め切りを過ぎた最後の営業日をまだ入れていない その営業日 10時に注文がない時は前の日の2026-03-04 (水)
注文がなく、締め切りを過ぎた最後の営業日も入れた 次に締め切る約定日 水曜の分を入れた後の10時なら2026-03-05 (木)
コード 意味
state.days.find((entry) => entry.day > lastNavDay) 注文のある約定日は古い順に並ぶので、最後に純資産を入れた日より後の最初の日が、純資産を待つ一番古い約定日になる
closedDayOf(now) lib/days.tsの、締め切りを過ぎた最後の営業日
state.tradeDay 今注文すると入る約定日。
締め切りを過ぎた日を全て入れた後は、次に締め切る日を出す
target 表に出す約定日。
全ての約定日を入れ終えた後は、最後の約定日の注文を出し続ける

純資産は約定日の順にしか入れられないので、ページは注文の溜まった一番古い約定日を選びます。
運用会社が日付を選ばずに済み、入れ忘れた約定日を飛ばして後の日を入れることもありません。

最後に、純資産を入れるの欄の後に約定日の注文の表を置きます。

      <Card title={`約定日の注文 ${formatDay(target?.day ?? navDay)}`} description={dayNote}>
        <div className="table-wrap">
          <table className="table">
            <thead>
              <tr>
                <th>投資家</th>
                <th>種類</th>
                <th className="num">額か口数</th>
                <th>状態</th>
              </tr>
            </thead>
            <tbody>
              {orders.map((order) => {
                const status = statusOf(order);
                return (
                  <tr key={order.index}>
                    <td>
                      <span className="cell-title">{labelOf(order.investor) ?? "投資家"}</span>
                      <span className="cell-sub">{shortAddress(order.investor)}</span>
                    </td>
                    <td>{kindLabel(order)}</td>
                    <td className="num">{amountText(order)}</td>
                    <td>
                      <Badge tone={status.tone}>{status.label}</Badge>
                      {movedReason(order) ? (
                        <span className="cell-note">
                          {formatMonthDay(dayOf(Number(order.placedAt)))}の{formatTime(order.placedAt)}に注文
                        </span>
                      ) : null}
                    </td>
                  </tr>
                );
              })}
              {orders.length === 0 ? (
                <tr>
                  <td colSpan={4} className="muted">
                    この約定日の注文はまだありません
                  </td>
                </tr>
              ) : null}
            </tbody>
          </table>
        </div>
      </Card>
コード 意味
Cardのtitle 欄の見出しに、表に出す約定日を2026-03-05 (木)の形で添える
labelOf(order.investor) ?? "投資家" local.jsonに名前があれば投資家Aと出し、ない時は投資家と出す
shortAddress(order.investor) 注文した投資家のアドレスを0x7099…79C8の形で添える
movedReason(order) ? ... : null 次の営業日へ回った注文だけ、3/5の15:20に注文のように注文した日時を添える
colSpan={4} 注文がない時は、4つの列をまとめた1つの欄に知らせを出す

時刻を進める帯

ヘッダーの下の帯に並べるボタンを決める関数を、starter/app/src/lib/band.tsとして作ります。

// ヘッダーの下の帯に並べるボタンを決める。どのボタンも進める先の時刻を持ち、
// 締め切りの1秒後と、次の営業日の朝9時へ進める。
// ローカルノード (anvil) だけが時刻を進められるので、それ以外のチェーンでは何も返さない
import { cutoffAt, dayOf, nextBusinessDay, openAt, tradeDayOf } from "./days.ts";

export const LOCAL_CHAIN_ID = 31337;

export type BandButton = {
  label: "締め切りの後へ進める" | "次の営業日へ進める";
  // 進める先のUnix時刻。もう進める先がない時は null にし、ボタンを押せなくする
  time: number | null;
};

export function bandButtons(chainId: number, now: number): BandButton[] {
  if (chainId !== LOCAL_CHAIN_ID) return [];
  return [
    // 15時ちょうどの注文はまだその日の約定日に入るので、次に来る締め切りの1秒後へ進める
    { label: "締め切りの後へ進める", time: cutoffAt(tradeDayOf(now)) + 1 },
    { label: "次の営業日へ進める", time: openAt(nextBusinessDay(dayOf(now))) },
  ];
}
コード 意味
import ... from "./days.ts" 拡張子まで書き、Node.jsがこのファイルを直接読み込めるようにする。
画面を開かずに、ボタンの行き先を確かめられる
LOCAL_CHAIN_ID anvilのチェーンの番号。
それ以外のチェーンでは空の配列を返し、帯を出さない
cutoffAt(tradeDayOf(now)) + 1 今注文すると入る約定日の締め切りの1秒後。
金曜の15時より後に押すと、次に来る締め切りは月曜なので月曜の15:00:01へ進む
openAt(nextBusinessDay(dayOf(now))) 今日の次の営業日の朝9時。
金曜に押すと、土日を飛ばして月曜の9時へ進む
time: number | null 押せないボタンの形。
後のレッスンで、進める先がない時に押せなくするボタンを足す

続けて、帯のボタンからanvilの時刻を進める仕組みを、starter/app/src/components/use-local-chain.tsとして作ります。

"use client";

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

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

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

// ローカルノードの時だけ、帯のボタンから時刻を進める。締め切りや受渡日を待たずに試せる
export function useLocalChain() {
  const queryClient = useQueryClient();
  const [busy, setBusy] = useState(false);

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

  return { busy, moveTo };
}
コード 意味
createTestClient({ mode: "anvil", ... }) anvilだけが持つ、時刻を変える呼び出しを送るクライアント。
取引ではないので鍵も署名も要らない
setNextBlockTimestamp 次に掘るブロックの時刻を決める。
anvilのevm_setNextBlockTimestampを呼ぶ
mine({ blocks: 1 }) 1ブロックを掘る。
ここでチェーンの時刻が進み、画面が読むblock.timestampも変わる
queryClient.invalidateQueries() 画面の読み取りを全て読み直す。
4秒を待たずに新しい時刻と札が出る
busy 進めている間はtrueにし、帯のボタンを押せなくする

帯そのものは、starter/app/src/components/band.tsxとして作ります。
帯の色と並びは、雛形のglobals.cssのtime-bandが最初から持っています。

"use client";

import { bandButtons } from "@/lib/band";
import { cutoffAt, dayOf, isBusinessDay } from "@/lib/days";
import { formatDay, formatTime } from "@/lib/format";

import { useSession } from "./session";
import { useFund } from "./use-fund";
import { useLocalChain } from "./use-local-chain";

// 今日の締め切りまでの残り。1時間より長い時は時間で、短い時は分で数える
function cutoffText(now: number): string {
  const today = dayOf(now);
  if (!isBusinessDay(today)) return "なし (土日)";
  const left = cutoffAt(today) - now;
  if (left < 0) return "15:00 (締め切りの後)";
  return left >= 3_600 ? `15:00 (あと${Math.floor(left / 3_600)}時間)` : `15:00 (あと${Math.ceil(left / 60)}分)`;
}
コード 意味
if (!isBusinessDay(today)) return "なし (土日)" 土日は締め切りがないのでなし (土日)と出す
left < 0 15時を1秒でも過ぎたら15:00 (締め切りの後)と出す。
15時ちょうどはまだ締め切りの前
Math.floor(left / 3_600) 1時間以上残る時は、時間に満たない分を切り捨てる。
10時ちょうどはあと5時間、10時を1秒でも過ぎるとあと4時間になる
Math.ceil(left / 60) 1時間を切った後は分で数え、端数を切り上げる。
残り30秒でもあと1分と出す

続けて、帯を描くBandを書きます。

// ローカルノードの時だけ、ヘッダーの下に出す時刻の帯。締め切りや次の営業日を待たずに時刻を進めて試せる
export function Band() {
  const { chainId, contracts } = useSession();
  const fund = useFund();
  const { busy, moveTo } = useLocalChain();

  const now = Number(fund.now ?? 0n);
  const buttons = contracts.fund && fund.now !== undefined ? bandButtons(chainId, now) : [];
  if (buttons.length === 0) return null;

  return (
    <div className="time-band">
      <div className="time-band-inner">
        <div className="time-band-meta">
          <p className="time-band-date">
            <svg width="16" height="16" viewBox="0 0 16 16" aria-hidden="true">
              <rect x="2" y="3" width="12" height="11" rx="2" fill="none" stroke="currentColor" strokeWidth="1.4" />
              <path d="M2 6.5h12M5.5 1.5v3M10.5 1.5v3" fill="none" stroke="currentColor" strokeWidth="1.4" />
            </svg>
            チェーンの日付{" "}
            <time>
              {formatDay(dayOf(now))} {formatTime(now)}
            </time>
          </p>
          <span className="time-band-divider" aria-hidden="true" />
          <p className="time-band-date">
            <svg width="16" height="16" viewBox="0 0 16 16" aria-hidden="true">
              <circle cx="8" cy="9" r="5.5" fill="none" stroke="currentColor" strokeWidth="1.4" />
              <path d="M8 6v3.2l2 1.3M6.5 1.5h3" fill="none" stroke="currentColor" strokeWidth="1.4" />
            </svg>
            今日の締め切り <strong>{cutoffText(now)}</strong>
          </p>
        </div>
        <div className="time-band-actions">
          {buttons.map((button) => (
            <button
              key={button.label}
              type="button"
              className="button button-small"
              disabled={button.time === null || busy}
              title={button.time === null ? undefined : `${formatDay(dayOf(button.time))} ${formatTime(button.time)}へ進めます`}
              onClick={() => button.time !== null && moveTo(button.time)}
            >
              {button.label}
            </button>
          ))}
        </div>
      </div>
    </div>
  );
}
コード 意味
useFund() 投資家と運用会社のページと同じフックで、最新のブロックの時刻nowを読む
bandButtons(chainId, now) 今のチェーンと時刻から、並べるボタンを決める。
ファンドをデプロイする前と時刻を読む前は空にする
if (buttons.length === 0) return null anvil以外のチェーンとデプロイする前は、帯ごと出さない
<svg ...> 日付の前に暦の絵を、締め切りの前に時計の絵を出す。
aria-hiddenで読み上げからは外す
formatDay(dayOf(now)) lib/days.tsのdayOfで今日の番号を出し、2026-03-05 (木)の形にする
title={...} ボタンに指を乗せると、進める先の日時を出す
onClick={() => button.time !== null && moveTo(button.time)} 押すとuseLocalChainのmoveToで、ボタンの時刻へ進める

最後に、starter/app/src/app/layout.tsxで帯を読み込み、ヘッダーの下に置きます。

import { Header } from "@/components/header";
import { Band } from "@/components/band";
          <Header />
          <Band />
          <main className="main">{children}</main>

帯は全てのページで同じものを出すので、ページごとでなくlayout.tsxに置きます。
投資家のページでも運用会社のページでも、同じ時刻を進められます。

確かめる

starter/appのディレクトリで動いているpnpm devを止め、もう一度実行します。
anvilが空のチェーンから立ち上がり、デプロイの後にチェーンの時刻は2026-03-05 (木)の10時へ進みます。
ブラウザでポート3404の画面を開くと、ヘッダーの下に帯が出て、チェーンの日付 2026-03-05 (木) 10:00と今日の締め切り 15:00 (あと5時間)が並びます。

右上のアカウントは最初「投資家A」です。
上の段の状態は受け付け中で、「申し込む」の欄には円の残高の1,000,000円と約定日の2026-03-05 (木)が出ます。
申し込む額に300000を入れて「申し込む」を押すと、「300,000円で申し込みました」と出ます。
円の残高は700,000円に減り、注文の表に約定日2026-03-05 (木)の申込が締め切りの前の札で並びます。

取引を送ると新しいブロックの時刻が10時を少し過ぎるので、帯の残りはあと4時間に変わります。

投資家Aが10時に300,000円を申し込み、2026-03-05 (木)の約定日の注文が締め切りの前の札で並ぶ
投資家Aが10時に300,000円を申し込み、2026-03-05 (木)の約定日の注文が締め切りの前の札で並ぶ

「解約する」の欄の解約する口数に100000を入れて「解約する」を押すと、「円トークンか持分の残高が足りません」と出ます。
まだ誰の申込も約定していないので、投資家Aは持分を1口も持っていないためです。
次の節で約定すると口数が入り、解約も通るようになります。

300,000円の行の「取り消す」を押します。
「2026-03-05 10:00の注文を取り消しました」のように注文した時刻を添えた知らせが出て、札は取り消したに変わります。
預けた300,000円は戻り、円の残高は1,000,000円に戻ります。
取り消した行は消えずに残り、「取り消す」だけが消えます。

申し込む額に100000を入れて、申し込み直します。
注文の表の一番上に100,000円の行が締め切りの前の札で増え、円の残高は900,000円になります。
続けて右上で「投資家B」を選び、500000を申し込みます。
「500,000円で申し込みました」と出たら、右上を「投資家A」に戻します。

帯の「締め切りの後へ進める」を押します。
帯は2026-03-05 (木) 15:00と15:00 (締め切りの後)になり、上の段の状態は締め切りの後に変わります。
100,000円の申込の札は約定を待つに変わり、「取り消す」は消えます。
「申し込む」の欄の約定日は2026-03-06 (金)に変わります。

この時刻に200000を申し込むと、新しい行の約定日は2026-03-06 (金)になります。
札は金曜の締め切りの前なので締め切りの前で、下に「15時を過ぎたため次の営業日」と添えられます。
注文した時刻は15:00:01より後ですが、分までの表示なので15:00と出ます。

締め切りの後の投資家Aの注文の表。取り消した300,000円と約定を待つ100,000円が並び、15時の後の200,000円は2026-03-06 (金)の約定日に入る
締め切りの後の投資家Aの注文の表。取り消した300,000円と約定を待つ100,000円が並び、15時の後の200,000円は2026-03-06 (金)の約定日に入る

ヘッダーの「運用会社」のタブを押し、右上で「運用会社」を選びます。
「純資産を入れる」の欄の名前は2026-03-05 (木) の純資産の総額で、その下の欄の見出しは約定日の注文 2026-03-05 (木)です。
表には投資家Aの100,000円と投資家Bの500,000円の申込がまだ約定していないの札で並び、投資家Aが取り消した300,000円の申込も取り消したの札で残ります。
投資家Aの200,000円は金曜の約定日の注文なので、この表には出ません。

締め切りの後の運用会社のページ。2026-03-05 (木)の約定日の注文に投資家Aの100,000円と投資家Bの500,000円がまだ約定していない札で並び、取り消した300,000円も残る
締め切りの後の運用会社のページ。2026-03-05 (木)の約定日の注文に投資家Aの100,000円と投資家Bの500,000円がまだ約定していない札で並び、取り消した300,000円も残る

帯の「次の営業日へ進める」を押すと、帯は2026-03-06 (金) 09:00と15:00 (あと6時間)になります。
投資家のページの状態は受け付け中に戻り、200,000円の申込は金曜の15時まで取り消せます。
木曜の申込は約定を待ったままで、運用会社のページの表も2026-03-05 (木)の注文を出し続けます。
金曜にもう一度「次の営業日へ進める」を押すと、土日を飛ばして2026-03-09 (月)の9時へ進みます。

帯のボタンの行き先は、画面を開かずにNode.jsからも確かめられます。
starter/appのディレクトリで、2026-03-05 (木)の10時のUnix時刻を渡してbandButtonsを呼びます。

node --input-type=module -e "import { bandButtons } from './src/lib/band.ts'; console.log(bandButtons(31337, 1772672400)); console.log(bandButtons(43113, 1772672400));"
[
  { label: '締め切りの後へ進める', time: 1772690401 },
  { label: '次の営業日へ進める', time: 1772755200 }
]
[]

1772690401は2026-03-05 (木)の15:00:01で、1772755200は2026-03-06 (金)の9時です。
Fujiのチェーンの番号43113を渡すと空の配列が返り、帯は出ません。
次の節で、締め切りの後に運用会社が純資産を入れ、溜まった注文を基準価額でまとめて約定できるようにします。