HandsOnChain

約定と受渡しの画面を作る

作るもの

このレッスンを終えると、運用会社のページで約定日の純資産を入れた後に、溜まった注文を「約定する」で件数ごとに約定できます。
純資産を入れる「入れる」のボタンは、その約定日の15時の締め切りを過ぎるまで押せません。
約定し終えた約定日に解約があると、「解約の代金を入れる」の表に代金の合計が出て、「代金を入れる」で円トークンを入れられます。

投資家のページには「約定した注文」の枠が付き、約定日の基準価額と申込で受け取った口数が出ます。
注文の表には、約定した申込の口数と解約の代金の列が加わります。
「解約の代金を受け取る」の枠では、受渡日を迎えて運用会社が代金を入れた後に「受け取る」を押せます。
ヘッダーの下の帯には「受渡日へ進める」が加わり、3営業日を待たずにチェーンの時刻を受渡日の0時へ進められます。

背景

投資家は、証券会社や銀行のような販売会社を通じて投資信託を申し込み、解約します。
販売会社はその日の締め切りまでに受けた注文をまとめて、ファンドの運用会社 (委託会社) へ伝えます。
運用会社は市場が閉じた後に基準価額を出し、ファンドの資産を預かる信託銀行 (受託会社) が別に出した値と突き合わせます。
一致を確かめた基準価額は販売会社へ届き、注文の口数と代金はこの値で決まります。

約定の後に、販売会社は約定日と受渡日と基準価額と口数と金額を書いた取引報告書を投資家へ渡します。
投資家は取引報告書か販売会社のサイトで、申込が何口になったか、解約の代金がいくらになったかを確かめます。
解約の代金は、運用会社の指図で信託銀行がファンドの資産から払い、販売会社を通じて受渡日に投資家へ届きます。

オンチェーンでは、取引報告書に書く値をファンドのコントラクトが注文ごとに持っています。
約定で渡した口数と返した円と解約の代金は、この節の前のレッスンで注文の記録に残すようにしました。
画面はその記録を読んで並べるだけなので、投資家のページと運用会社のページで値が食い違いません。
解約の代金は、運用会社が約定日ごとにまとめて入れ、投資家が受渡日から自分で受け取ります。

画面の操作 ページ 呼ぶ関数 呼べる人
入れる 運用会社 setNav 運用会社の役を持つアカウント
約定する 運用会社 settle 運用会社の役を持つアカウント
代金を入れる 運用会社 円トークンのapproveとファンドのfundProceeds 運用会社の役を持つアカウント
受け取る 投資家 claim その約定日の代金が残っている投資家
受渡日へ進める ヘッダーの下の帯 anvilの時刻を進めるevm_setNextBlockTimestampとevm_mine ローカルノードだけ

画面は、送っても通らない時にはボタンを押せなくします。
「入れる」は締め切りの15時を過ぎるまで、「受け取る」は受渡日を迎えて代金が入るまで押せません。
それでも、送ってよいかを最後に決めるのはコントラクトです。
画面の判断がずれていても、setNavはNavBeforeCutoffで、claimはBeforeDeliveryDateで断ります。

金曜に解約した100,000口の代金を水曜の受渡日に受け取る
チェーンに残る値時刻金曜の15時過ぎ水曜の0時基準価額10,068円投資家Aの代金0円100,680円0円運用会社のページ運用会社ファンドのコントラクトTokenizedFund投資家Aのページ100,000口を解約した11223344setNav(金曜, 302,040)setNav(金曜, 302,040)settle(金曜, 50)settle(金曜, 50)fundProceeds(金曜)fundProceeds(金曜)100,680 HJPY100,680 HJPYclaim(金曜)100,680 HJPY

実装

まず、starter/app/src/components/use-fund.tsで、約定の結果と受渡しの値を読めるようにします。
注文の型のFundOrderの末尾に、unitsとyenを足します。

  // 申込は預けた円、解約は預けた口数
  amount: bigint;
  placedAt: bigint;
  // 約定で渡した口数 (申込) か、約定で消した口数 (解約)
  units: bigint;
  // 約定で返した円 (申込) か、解約の代金 (解約)
  yen: bigint;
};

ordersOfが返す注文には、約定のレッスンでコントラクトのOrderに足した2つの欄が入っています。
画面の型にも同じ名前で足し、表に出せるようにします。

約定日ごとのFundDayには、約定と受渡しの値を6つ足します。

// 注文のある約定日ごとの、注文の列
export type FundDay = {
  day: bigint;
  orders: FundOrder[];
  // その日の基準価額。純資産を入れる前は0
  nav: bigint;
  // 約定し終えた注文の数
  settledCount: bigint;
  // 解約の代金の受渡日が始まる時刻
  deliveryAt: bigint;
  // 解約の代金の合計と、運用会社が入れたか
  proceedsDue: bigint;
  proceedsFunded: boolean;
  // 今のアカウントがまだ受け取っていない解約の代金
  proceeds: bigint;
};
欄 読むコントラクトの値 意味
nav navOf(day) その約定日の基準価額。
純資産を入れる前は0
settledCount settledCount(day) 前から何件目まで約定したか
deliveryAt deliveryAt(day) 受渡日の日本時間の0時の時刻
proceedsDue proceedsDue(day) その約定日の解約の代金の合計。
運用会社が入れる額
proceedsFunded proceedsFunded(day) 運用会社がその約定日の代金を入れたか
proceeds proceedsOf(day, me) 選んだアカウントのまだ受け取っていない代金。
受け取ると0になる

ファンド全体の読み取りのbaseには、次に約定する約定日の位置のdayCursorを足します。

      orderDays: { ...fund, functionName: "orderDays" },
      dayCursor: { ...fund, functionName: "dayCursor" },
    },

約定日ごとの読み取りには、表の6つの値を読む関数を足します。

      orderDays.flatMap((day) => [
        [`orders:${day}`, { ...fund, functionName: "ordersOf", args: [day] }],
        [`nav:${day}`, { ...fund, functionName: "navOf", args: [day] }],
        [`settled:${day}`, { ...fund, functionName: "settledCount", args: [day] }],
        [`delivery:${day}`, { ...fund, functionName: "deliveryAt", args: [day] }],
        [`due:${day}`, { ...fund, functionName: "proceedsDue", args: [day] }],
        [`funded:${day}`, { ...fund, functionName: "proceedsFunded", args: [day] }],
        [`proceeds:${day}`, { ...fund, functionName: "proceedsOf", args: [day, me] }],
      ]),

読んだ値を、約定日ごとのFundDayに詰めます。
読めるまでの間は、0かfalseにしておきます。

  const days: FundDay[] = orderDays.map((day) => ({
    day,
    orders: ((perDay[`orders:${day}`] as Omit<FundOrder, "day" | "index">[] | undefined) ?? []).map((order, index) => ({ ...order, day, index })),
    nav: (perDay[`nav:${day}`] as bigint | undefined) ?? 0n,
    settledCount: (perDay[`settled:${day}`] as bigint | undefined) ?? 0n,
    deliveryAt: (perDay[`delivery:${day}`] as bigint | undefined) ?? 0n,
    proceedsDue: (perDay[`due:${day}`] as bigint | undefined) ?? 0n,
    proceedsFunded: (perDay[`funded:${day}`] as boolean | undefined) ?? false,
    proceeds: (perDay[`proceeds:${day}`] as bigint | undefined) ?? 0n,
  }));

tradeDayの下で、今注文すると入る約定日の受渡日を読みます。

  const tradeDay = dated.tradeDay as bigint | undefined;

  // 今の注文が入る約定日の受渡日と、その日に注文した解約の口数を読む
  const trade = useNamedReads(
    {
      delivery: { ...fund, functionName: "deliveryAt", args: [tradeDay ?? 0n] },
    },
    enabled && tradeDay !== undefined,
  );

deliveryAtに渡す約定日はtradeDayの読み取りが済むまで決まらないので、datedとは分けて後から読みます。
コメントにある解約の口数は、最後の節の画面のレッスンで同じ読み取りに足します。

返す値の末尾に、2つの値を加えます。

    tradeDay,
    days,
    dayCursor: base.dayCursor as bigint | undefined,
    tradeDelivery: trade.delivery as bigint | undefined,
  };

次に、starter/app/src/lib/format.tsのformatTimeの下に、2つの書き方を足します。

  return clock.format(new Date(Number(time) * 1000));
}

// Unix時刻を、その時刻を含む日本時間の日付と曜日 (2026-03-10 (火) の形) にする
export function formatDayAt(time: bigint | number | undefined): string {
  if (time === undefined) return "-";
  return formatDay(Math.floor((Number(time) + 9 * 3_600) / 86_400));
}

export function formatCount(value: bigint | number | undefined): string {
  if (value === undefined) return "-";
  return `${number.format(value)}件`;
}
関数 意味
formatDayAt Unix時刻に9時間を足して1日の秒数で割り、日本時間の日の番号にしてからformatDayで書く。
受渡日の0時を、その日の日付で出す
formatCount 注文の件数を2件の形で書く

formatDayは約定日の番号を受け取る関数で、deliveryAtが返すのはUnix時刻です。
そのため、受渡日はformatDayAtで日の番号に直してから書きます。

reasonsの末尾には、約定と受渡しの関数が断った時の理由の文を足します。

  CancelAfterCutoff: "締め切りの15時を過ぎたので、もう取り消せません",
  NavBeforeCutoff: "約定日の締め切りの15時を過ぎてから入れられます",
  NavNotSet: "この約定日の純資産をまだ入れていません",
  AlreadySettled: "この約定日の注文は全て約定しました",
  NavSkipsDay: "前の約定日を約定し終えるまで、次の約定日の純資産は入れられません",
  NotSettled: "この約定日の注文をまだ約定し終えていません",
  AlreadyFunded: "この約定日の代金はもう入れました",
  BeforeDeliveryDate: "受渡日から受け取れます",
  ProceedsNotFunded: "運用会社がまだ代金を入れていません",
  NothingToClaim: "この約定日に受け取る代金はありません",
};
エラー 断る関数 断る時
NavBeforeCutoff setNav 約定日の15時ちょうどまでに純資産を入れようとした
NavNotSet settle 純資産を入れていない約定日を約定しようとした
AlreadySettled settle 約定し終えた約定日を、もう一度約定しようとした
NavSkipsDay setNav 前の約定日を約定し終える前に、次の約定日の純資産を入れようとした
NotSettled fundProceeds 約定し終えていない約定日の代金を入れようとした
AlreadyFunded fundProceeds 同じ約定日の代金を2回入れようとした
BeforeDeliveryDate claim 受渡日の0時より前に受け取ろうとした
ProceedsNotFunded claim 運用会社が代金を入れる前に受け取ろうとした
NothingToClaim claim その約定日に受け取る代金のない投資家が受け取ろうとした

画面は送る前にsimulateContractで試すので、断られた時はこの表の文が画面の下に出ます。

続けて、starter/app/src/components/order-text.tsで、注文の表に足す列の文字を決めます。
読み込みにSETTLEDを足します。

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

末尾に、約定の結果を書く関数を足します。

// 約定した申込は受け取った口数、約定した解約は代金。約定の前は決まっていない
export function resultText(order: FundOrder): string {
  if (order.status !== SETTLED) return "—";
  return order.kind === SUBSCRIBE ? formatUnitsCount(order.units) : formatWholeYen(order.yen);
}

約定の前の注文と取り消した注文は、口数も代金もまだ決まっていないので—を出します。
投資家のページと運用会社のページで、同じ関数を使います。

運用会社のページのstarter/app/src/components/manager-view.tsxを書き換えます。
頭の読み込みを、次の形にします。

"use client";

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

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

import { NotDeployed } from "./not-deployed";
import { amountText, kindLabel, movedReason, resultText } from "./order-text";
import { useSession } from "./session";
import { Amount, Badge, Card, Field, NoticeLine, type Tone } from "./ui";
import { CANCELLED, PENDING, REDEEM, SETTLED, SUBSCRIBE, useFund, type FundDay, type FundOrder } from "./use-fund";
import { useSend } from "./use-send";
足した名前 使う所
jpyTokenAbi 代金を入れる前に、円トークンのapproveを送る
cutoffAt 純資産を入れる約定日の締め切りの時刻を出す
formatCountとformatDayAt 件数と受渡日を書く
parseCountとYEN 件数の欄を読み、代金を円トークンの18桁の単位に直す
resultText 注文の表に足す列の文字
PENDINGとREDEEMとSUBSCRIBEとFundDay 約定の前の注文を選び、申込と解約を分ける

純資産を入れる枠と注文の表の説明を書き換えます。

const navNote = "運用会社の役を持つアカウントが、締め切りの後に約定日の純資産の総額を入れます。口数で割り、1万口あたりの基準価額を出します。";
const dayNote = "前の約定日を約定し終えるまで、次の約定日の純資産は入れられません。";

statusOfの下に、約定日に約定した解約の口数を足し合わせる関数を足します。

// 約定日に約定した解約の口数の合計
function redeemedUnits(day: FundDay): bigint {
  return day.orders.filter((order) => order.kind === REDEEM && order.status === SETTLED).reduce((sum, order) => sum + order.units, 0n);
}

fundの下に、円トークンを呼ぶ時のjpyを足します。

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

純資産を入れる約定日のorderDayを、dayCursorの指す約定日に書き換えます。

  const now = Number(state.now ?? 0n);
  // 約定し終えていない一番古い約定日。コントラクトはその日より後の純資産を断る
  const orderDay = state.dayCursor === undefined ? undefined : state.days[Number(state.dayCursor)];

前のレッスンまでは、純資産をまだ入れていない一番古い約定日をstate.days.findで選んでいました。
その選び方では、純資産を入れた途端に次の約定日へ移り、約定し終える前の注文が表から消えます。
dayCursorは約定し終えるまで同じ約定日を指すので、純資産を入れた後も約定する枠と注文の表は同じ約定日を出し続けます。
コントラクトのsetNavがNavSkipsDayで断る約定日とも合います。

enteredの下で、締め切りの前かを見ます。

  // 入れようとする約定日の純資産を、もう入れたか
  const entered = navDay !== undefined && navDay <= lastNavDay;
  // 純資産は、約定日の締め切りの後に入れる
  const beforeCutoff = navDay !== undefined && now <= cutoffAt(Number(navDay));
  const canEnter = netValue !== undefined && navDay !== undefined && !entered && !beforeCutoff;
  const navHint = entered
    ? "この約定日の純資産は入れました"
    : beforeCutoff
      ? "締め切りの15時を過ぎると入れられます"
      : isManager
        ? undefined
        : "右上で運用会社のアカウントを選ぶと入れられます";
コード 意味
now <= cutoffAt(Number(navDay)) 15時ちょうどまでは締め切りの前。
コントラクトのsetNavがNavBeforeCutoffで断る線と同じ
!beforeCutoff 締め切りの前は「入れる」を押せなくする
navHint 押せない理由を欄の下に出す。
もう入れた時、締め切りの前、運用会社でない時の順に見る

previewNavの下に、約定する枠と代金の表に使う値を足します。

  const previewNav = netValue !== undefined && !entered ? preview.data : undefined;
  const [countInput, setCountInput] = useState("50");
  const countValue = parseCount(countInput);
  const total = BigInt(orders.length);
  const settled = target?.settledCount ?? 0n;
  const targetNav = target?.nav ?? 0n;
  const canSettle = targetNav > 0n && settled < total;
  // 約定し終えた後の発行済みの口数。申込は1口未満を切り捨てた口数が増え、解約は預けた口数が消える
  const unitsAfter =
    state.supply === undefined || targetNav === 0n
      ? undefined
      : orders
          .filter((order) => order.status === PENDING)
          .reduce((sum, order) => (order.kind === SUBSCRIBE ? sum + (order.amount * state.navUnits) / targetNav : sum - order.amount), state.supply);
  // 約定し終えた約定日のうち、解約のあった日を新しい順に並べる
  const proceedRows = state.days
    .slice(0, Number(state.dayCursor ?? 0n))
    .map((day) => ({ day, units: redeemedUnits(day) }))
    .filter((row) => row.units > 0n)
    .reverse();
コード 意味
useState("50") 1回に約定する件数の欄。
最初は50件にしておく
canSettle 純資産を入れていて、まだ約定していない注文が残る時だけ「約定する」を押せる
order.status === PENDING 約定の前の注文だけを数える。
分けて約定する途中では、約定した分は既にstate.supplyに入っている
(order.amount * state.navUnits) / targetNav 申込で渡す口数。
コントラクトの_settleSubscriptionと同じ式で、1口未満を切り捨てる
sum - order.amount 解約は預けた口数が消える
.slice(0, Number(state.dayCursor ?? 0n)) 約定し終えた約定日だけを選ぶ。
fundProceedsは約定し終えていない約定日を断る
.filter((row) => row.units > 0n) 解約のなかった約定日は、入れる代金がないので除く
.reverse() 新しい約定日を上に並べる

ヒーローの下で、純資産を入れる枠と次に足す約定する枠をgrid-2で横に並べます。

      </div>

      <div className="grid-2">
        <Card title="純資産を入れる" description={navNote}>

純資産を入れる枠の後に、約定する枠を足してgrid-2を閉じます。

        </Card>

        <Card title="約定する" description="純資産を入れた後、溜まった注文を前から順にまとめて約定します。1回で終わらない時は、もう一度押すと続きから約定します。">
          <form
            className="form form-inline"
            onSubmit={async (event) => {
              event.preventDefault();
              if (countValue === undefined || target === undefined) return;
              await send("settle", `${formatDay(target.day)}の注文を${formatCount(countValue)}まで約定しました`, [
                { ...fund, functionName: "settle", args: [target.day, countValue] },
              ]);
            }}
          >
            <Field label="1回に約定する件数" unit="件">
              <input inputMode="numeric" value={countInput} onChange={(event) => setCountInput(event.target.value)} placeholder="50" />
            </Field>
            <button className="button" type="submit" disabled={!canSettle || countValue === undefined || pending !== undefined}>
              {pending === "settle" ? "約定しています" : "約定する"}
            </button>
          </form>
          <dl className="facts">
            <div>
              <dt>溜まった注文 ({formatDay(target?.day ?? navDay, false)})</dt>
              <dd>{formatCount(total)}</dd>
            </div>
            <div>
              <dt>約定した注文</dt>
              <dd>
                {formatCount(settled)} / {formatCount(total)}
              </dd>
            </div>
            <div>
              <dt>約定した後の口数</dt>
              <dd>{unitsAfter === undefined ? "純資産を入れると決まる" : formatUnitsCount(unitsAfter)}</dd>
            </div>
          </dl>
        </Card>
      </div>
コード 意味
args: [target.day, countValue] 約定日と1回に約定する件数をsettleに渡す。
2回目からは、コントラクトがsettledCountの続きから約定する
formatCount(countValue) 知らせの文には、欄に入れた件数を出す。
残りが件数より少ない時は、残りだけを約定する
formatDay(target?.day ?? navDay, false) 曜日を外した約定日を、溜まった注文の見出しに添える
formatCount(settled) / formatCount(total) 溜まった注文のうち、何件を約定し終えたか
"純資産を入れると決まる" 純資産を入れる前は基準価額がないので、渡す口数を数えられない

約定日の注文の表には、約定の結果の列を足します。
見出しの額か口数の後に、列の見出しを足します。

                <th className="num">額か口数</th>
                <th className="num">受け取る口数か代金</th>
                <th>状態</th>

行のamountTextの後に、resultTextの列を足します。

                    <td className="num">{amountText(order)}</td>
                    <td className="num">{resultText(order)}</td>
                    <td>

注文のない時の行は、列が5つになったのでcolSpanを5にします。

                  <td colSpan={5} className="muted">

約定日の注文の枠の後に、解約の代金を入れる枠を足します。

      <Card title="解約の代金を入れる" description="解約の代金は、運用会社が受渡日までにファンドのコントラクトへ入れます。入れた後に、投資家が受け取れます。">
        <div className="table-wrap">
          <table className="table">
            <thead>
              <tr>
                <th>約定日</th>
                <th>受渡日</th>
                <th className="num">解約の口数</th>
                <th className="num">基準価額</th>
                <th className="num">代金</th>
                <th>状態</th>
                <th>操作</th>
              </tr>
            </thead>
            <tbody>
              {proceedRows.map(({ day, units }) => (
                <tr key={String(day.day)}>
                  <td>{formatDay(day.day)}</td>
                  <td>{formatDayAt(day.deliveryAt)}</td>
                  <td className="num">{formatUnitsCount(units)}</td>
                  <td className="num">{formatWholeYen(day.nav)}</td>
                  <td className="num">{formatWholeYen(day.proceedsDue)}</td>
                  <td>{day.proceedsFunded ? <Badge tone="good">入れた</Badge> : <Badge tone="warn">まだ入れていない</Badge>}</td>
                  <td className="num">
                    {day.proceedsFunded ? null : (
                      <button
                        type="button"
                        className="button button-small"
                        disabled={pending !== undefined}
                        onClick={() =>
                          send(`fund-${day.day}`, `${formatDay(day.day)}の解約の代金${formatWholeYen(day.proceedsDue)}を入れました`, [
                            { ...jpy, functionName: "approve", args: [contracts.fund, day.proceedsDue * YEN] },
                            { ...fund, functionName: "fundProceeds", args: [day.day] },
                          ])
                        }
                      >
                        {pending === `fund-${day.day}` ? "入れています" : "代金を入れる"}
                      </button>
                    )}
                  </td>
                </tr>
              ))}
              {proceedRows.length === 0 ? (
                <tr>
                  <td colSpan={7} className="muted">
                    約定した解約はまだありません
                  </td>
                </tr>
              ) : null}
            </tbody>
          </table>
        </div>
      </Card>
コード 意味
formatDayAt(day.deliveryAt) 受渡日の0時の時刻を、その日の日付で出す
day.proceedsDue その約定日の解約の代金の合計。
運用会社が入れる額
day.proceedsFunded ? null : (...) もう入れた約定日はボタンを出さない。
コントラクトもAlreadyFundedで2回目を断る
approveの後にfundProceeds 先に代金の合計をファンドのコントラクトに任せてから入れる。
fundProceedsがtransferFromで運用会社の円を受け取るため
day.proceedsDue * YEN 1円単位の額を、円トークンの18桁の単位に直す
`fund-${day.day}` 送っている間の印を約定日ごとに分け、押した行のボタンだけを「入れています」にする

投資家のページのstarter/app/src/components/investor-view.tsxを書き換えます。
読み込みに、受渡日の書き方と約定の結果の文字と申込の種類の番号を足します。

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

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

解約の枠と注文の表の説明に受渡日を足し、約定した注文の枠の説明を加えます。

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

注文の表の状態を決めるstatusOfに約定日を渡し、約定した解約に2つの札を足します。

// 注文の表に出す状態
function statusOf(order: FundOrder, day: FundDay, now: number): { label: string; tone: Tone } {
  if (order.status === CANCELLED) return { label: "取り消した", tone: "plain" };
  if (order.status === SETTLED && order.kind === REDEEM) {
    // 1つの約定日の代金はまとめて受け取るので、受け取った後は残りが0になる
    if (day.proceeds === 0n && order.yen > 0n) return { label: "受け取った", tone: "info" };
    if (day.proceedsFunded && now >= Number(day.deliveryAt)) return { label: "受け取れる", tone: "good" };
  }
  if (order.status === SETTLED) return { label: "約定した", tone: "good" };
  if (now <= cutoffAt(Number(order.day))) return { label: "締め切りの前", tone: "warn" };
  return { label: "約定を待つ", tone: "plain" };
}
札 出す時
取り消した 投資家が締め切りの前に取り消した
受け取った 約定した解約で、その約定日の受け取っていない代金が0円になった
受け取れる 約定した解約で、運用会社が代金を入れ、チェーンの時刻が受渡日の0時を過ぎた
約定した 約定した申込か、受渡日の前か代金の入る前の解約
締め切りの前 約定の前で、約定日の15時ちょうどまで
約定を待つ 約定の前で、締め切りを過ぎた

札は上の行から順に調べ、最初に当てはまった札を返します。
proceedsは約定日と投資家ごとの代金なので、同じ約定日に2件を解約した投資家は、1回のclaimで2件の代金をまとめて受け取ります。
そのため、受け取った後は同じ約定日の解約が全て「受け取った」になります。
order.yen > 0nは、代金が1円未満を切り捨てて0円になった解約を「受け取った」にしないための条件です。

投資家の注文の表で、解約の札を上から順に決める
取り消したそれ以外0円まだ始まり終わり注文の行取り消した?約定した解約?代金の残りが0円?代金が入り受渡日を迎えた?受け取れる取り消した前のレッスンの札約定した、締め切りの前、約定を待つ受け取った約定した1122334455していないしていないしていない約定した解約約定した解約約定した解約残っている迎えた

statusOfの下に、受け取るボタンの横に添える文を決める関数を足します。

// 解約の代金を受け取るボタンの横に添える、受け取れるまでの条件
function claimHintOf(day: FundDay, now: number): string {
  if (day.proceeds === 0n) return "この約定日の代金は受け取りました";
  if (now < Number(day.deliveryAt)) return `受渡日の${formatDayAt(day.deliveryAt)}から受け取れます`;
  if (!day.proceedsFunded) return "運用会社が代金を入れた後に受け取れます";
  return `受け取ると、${formatWholeYen(day.proceeds)}の円トークンが届きます`;
}

受渡日の前と代金の入る前は、コントラクトのclaimがBeforeDeliveryDateとProceedsNotFundedで断る時と同じ順に調べます。
押せない時も、押せるまでに何を待てばよいかが分かります。

intakeの下で、約定した注文の枠と代金を受け取る枠に出す値を決めます。

  const intake = intakeOf(now);
  const settledBy = (order: FundOrder) => sameAddress(order.investor, me) && order.status === SETTLED;
  // 今のアカウントの注文を約定した、一番新しい約定日
  const settledDay = state.days.findLast((day) => day.orders.some(settledBy));
  const subscriptions = settledDay?.orders.filter((order) => settledBy(order) && order.kind === SUBSCRIBE) ?? [];
  const refund = subscriptions.reduce((sum, order) => sum + order.yen, 0n);
  // 受け取る解約の代金は、まだ受け取っていない一番古い約定日にし、全て受け取った後は最後に解約を約定した日を出す
  const redeemedDays = state.days.filter((day) => day.orders.some((order) => settledBy(order) && order.kind === REDEEM));
  const claimDay = redeemedDays.find((day) => day.proceeds > 0n) ?? redeemedDays.at(-1);
  const claimOrders = claimDay?.orders.filter((order) => settledBy(order) && order.kind === REDEEM) ?? [];
  const claimUnits = claimOrders.reduce((sum, order) => sum + order.units, 0n);
  const claimYen = claimOrders.reduce((sum, order) => sum + order.yen, 0n);
  const claimPrice = claimDay?.nav;
  const claimable = claimDay !== undefined && claimDay.proceeds > 0n && claimDay.proceedsFunded && now >= Number(claimDay.deliveryAt);
コード 意味
settledBy 選んだアカウントの約定した注文か
state.days.findLast(...) 約定日は古い順に並んでいるので、後ろから探して一番新しい約定日を選ぶ
subscriptions その約定日の、選んだアカウントの約定した申込
refund その約定日の申込で返した円の合計
redeemedDays.find((day) => day.proceeds > 0n) まだ受け取っていない代金のある、一番古い約定日
?? redeemedDays.at(-1) 全て受け取った後は、最後に解約を約定した日を出し続ける
claimUnitsとclaimYen その約定日に約定した解約の口数と代金の合計
claimable 代金が残り、運用会社が入れ、受渡日の0時を過ぎた時だけ押せる。
claimが断らない3つの条件と同じ

解約する枠の約定日の行を、受渡日の行に替えます。

          <dl className="facts">
            <div>
              <dt>受渡日</dt>
              <dd>{formatDayAt(state.tradeDelivery)}</dd>
            </div>
          </dl>

今解約すると、state.tradeDeliveryの受渡日から代金を受け取れます。
約定日は申し込む枠に出ているので、解約する枠には受渡日だけを出します。

申し込む枠と解約する枠のgrid-2の後に、約定した注文の枠と代金を受け取る枠を並べます。

      {settledDay ? (
        <div className="grid-2">
          <Card title={`約定した注文 ${formatDay(settledDay.day)}`} description={settledNote}>
            <dl className="facts">
              <div>
                <dt>基準価額</dt>
                <dd>{formatWholeYen(settledDay.nav)}</dd>
              </div>
              {subscriptions.map((order) => (
                <div key={order.index}>
                  <dt>申込 {formatWholeYen(order.amount)}で受け取った口数</dt>
                  <dd>{formatUnitsCount(order.units)}</dd>
                </div>
              ))}
              {subscriptions.length > 0 ? (
                <div>
                  <dt>申込で返した円</dt>
                  <dd>{formatWholeYen(refund)}</dd>
                </div>
              ) : null}
            </dl>
          </Card>

          <Card title="解約の代金を受け取る" description="受渡日を過ぎ、運用会社が代金を入れた後に受け取れます。">
            {claimDay ? (
              <>
                <dl className="facts">
                  <div>
                    <dt>解約した口数</dt>
                    <dd>{formatUnitsCount(claimUnits)}</dd>
                  </div>
                  <div>
                    <dt>
                      代金 ({formatUnitsCount(claimUnits)} × {formatWholeYen(claimPrice)} ÷ 1万口)
                    </dt>
                    <dd>{formatWholeYen(claimYen)}</dd>
                  </div>
                  <div>
                    <dt>受渡日</dt>
                    <dd>{formatDayAt(claimDay.deliveryAt)}</dd>
                  </div>
                  <div>
                    <dt>運用会社の入金</dt>
                    <dd>{claimDay.proceedsFunded ? "入れた" : "まだ入れていない"}</dd>
                  </div>
                </dl>
                <div className="button-row">
                  {claimDay.proceeds > 0n ? (
                    <button
                      type="button"
                      className="button button-primary"
                      disabled={!claimable || pending !== undefined}
                      onClick={() =>
                        send("claim", `${formatWholeYen(claimDay.proceeds)}の解約の代金を受け取りました`, [
                          { ...fund, functionName: "claim", args: [claimDay.day] },
                        ])
                      }
                    >
                      {pending === "claim" ? "受け取っています" : "受け取る"}
                    </button>
                  ) : null}
                  <span className="muted">{claimHintOf(claimDay, now)}</span>
                </div>
              </>
            ) : (
              <p className="muted">約定した解約はまだありません</p>
            )}
          </Card>
        </div>
      ) : null}
コード 意味
settledDay ? (...) : null 約定した注文が1件もない間は、2つの枠を出さない
formatWholeYen(settledDay.nav) 約定日の基準価額。
注文の口数と代金はこの値で決まった
申込 {formatWholeYen(order.amount)}で受け取った口数 申込ごとに、預けた円と受け取った口数を並べる
代金 (... × ... ÷ 1万口) 代金の式を見出しに出し、口数と基準価額から数え直せるようにする
claimDay.proceeds > 0n 受け取った後はボタンを出さず、横の文だけを残す
args: [claimDay.day] どの約定日の代金を受け取るかをclaimに渡す

最後に、注文の表に約定の結果の列を足します。
見出しの約定日の後に、列の見出しを足します。

                <th>約定日</th>
                <th className="num">受け取る口数か代金</th>
                <th>状態</th>

行ごとのstatusOfに約定日のdayを渡し、約定日の列の後にresultTextの列を足します。

              {mine.map(({ order, day }) => {
                const status = statusOf(order, day, now);
                    <td>{formatDay(order.day)}</td>
                    <td className="num">{resultText(order)}</td>

注文のない時の行は、列が7つになったのでcolSpanを7にします。

                  <td colSpan={7} className="muted">

ヘッダーの下の帯には、受渡日へ進めるボタンを足します。
starter/app/src/lib/band.tsの頭のコメントに1行を足し、帯へ渡す値の型を作ります。

// ヘッダーの下の帯に並べるボタンを決める。どのボタンも進める先の時刻を持ち、
// 締め切りの1秒後と、次の営業日の朝9時へ進める。
// 解約の代金の受渡日が来ていない時は、その日の0時へ進めるボタンも持つ。
// ローカルノード (anvil) だけが時刻を進められるので、それ以外のチェーンでは何も返さない
export const LOCAL_CHAIN_ID = 31337;

export type BandState = {
  // 選んだ投資家が受け取る解約の代金の受渡日の時刻。受け取る代金のない時は0
  deliveryDate: number;
};

ボタンの名前に受渡日へ進めるを足し、bandButtonsが帯の値を受け取って3つ目のボタンを返すようにします。

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

export function bandButtons(chainId: number, now: number, state: BandState): BandButton[] {
  if (chainId !== LOCAL_CHAIN_ID) return [];
  return [
    // 15時ちょうどの注文はまだその日の約定日に入るので、次に来る締め切りの1秒後へ進める
    { label: "締め切りの後へ進める", time: cutoffAt(tradeDayOf(now)) + 1 },
    { label: "次の営業日へ進める", time: openAt(nextBusinessDay(dayOf(now))) },
    // 過ぎた受渡日へは戻れない
    { label: "受渡日へ進める", time: state.deliveryDate > now ? state.deliveryDate : null },
  ];
}
コード 意味
state.deliveryDate 受渡日の日本時間の0時の時刻。
コントラクトのclaimは0時ちょうどから受け取れるので、1秒後ではなく0時ちょうどへ進める
state.deliveryDate > now 受渡日がまだ来ていない時だけ進める。
受け取る代金のない時は0なので、押せなくなる

starter/app/src/components/band.tsxでは、選んだアカウントの受渡日を帯へ渡します。

  const now = Number(fund.now ?? 0n);
  // 受渡日は、選んだ投資家がまだ受け取っていない解約の代金のうち、これから来る一番早いもの
  const deliveryDate = fund.days
    .filter((day) => day.proceeds > 0n)
    .map((day) => Number(day.deliveryAt))
    .filter((time) => time > now)
    .sort((a, b) => a - b)[0];
  const buttons = contracts.fund && fund.now !== undefined ? bandButtons(chainId, now, { deliveryDate: deliveryDate ?? 0 }) : [];
コード 意味
.filter((day) => day.proceeds > 0n) 選んだアカウントがまだ受け取っていない代金のある約定日だけを残す
.filter((time) => time > now) 受渡日を過ぎた約定日は、もう進める先がないので除く
.sort((a, b) => a - b)[0] 残った受渡日のうち、一番早いものを選ぶ
deliveryDate ?? 0 進める先がない時は0を渡し、ボタンを押せなくする

proceedsは約定した時に決まるので、運用会社が代金を入れる前でも受渡日へ進められます。
運用会社のアカウントは解約の代金を受け取らないので、運用会社を選んでいる間は押せません。

確かめる

starter/appのディレクトリで動いているpnpm devを止め、もう一度実行します。
別のターミナルでanvilを動かしている時は、それも止めておきます。
anvilが空の状態から立ち上がり、デプロイが済むと、チェーンの日付は2026-03-05 (木) の10時になります。
ブラウザでポート3404の画面を開きます。

まず、2026-03-05 (木) の申込を約定します。
「投資家」のページで右上のアカウントを「投資家A」にし、「申し込む」の枠の申し込む額に300000を入れて「申し込む」を押します。
「300,000円で申し込みました」と出たら、帯の「締め切りの後へ進める」を押します。
チェーンの時刻が15時の1秒後へ進み、今日の締め切りは「15:00 (締め切りの後)」に変わります。

ヘッダーの「運用会社」のページへ移り、アカウントを「運用会社」に切り替えます。
「2026-03-05 (木) の純資産の総額」に0を入れて「入れる」を押すと、「2026-03-05 (木)の純資産の総額を0円で入れました」と出ます。
口数が0の日なので、基準価額は10,000円です。
「約定する」の枠で件数を50のまま「約定する」を押すと、投資家Aは300,000円で300,000口を受け取ります。

次に、2026-03-06 (金) の注文を出します。
帯の「次の営業日へ進める」を押すと、チェーンの日付が2026-03-06 (金) の9時に進みます。
このまま運用会社のページを見ると、純資産を入れる枠の「入れる」は押せず、欄の下に「締め切りの15時を過ぎると入れられます」と出ます。

「投資家」のページへ戻り、「投資家A」で「解約する」の枠の解約する口数に100000を入れて「解約する」を押します。
解約する枠の受渡日には、金曜から土日を除いて3営業日後の2026-03-11 (水) が出ています。
注文の表では、3/5の申込の受け取る口数か代金の列に300,000口が出て、まだ約定していない3/6の解約は—です。
続けて「投資家C」に切り替え、200000円を申し込みます。

帯の「締め切りの後へ進める」を押してから、「運用会社」のページで「運用会社」を選びます。
純資産の総額に302040を入れると、基準価額 (1万口あたり) に10,068円が出ます。
302,040 × 10,000 ÷ 300,000で、解約で預かった10万口も含む30万口で割った値です。
「入れる」を押すと、約定する枠の約定した後の口数が398,649口になります。

投資家Cの申込で渡す口数は、200,000 × 10,000 ÷ 10,068 = 198,649.18口の1口未満を切り捨てた198,649口です。
投資家Aの解約で10万口が消えるので、300,000 + 198,649 − 100,000 = 398,649口になります。

「1回に約定する件数」を1にして「約定する」を押すと、「2026-03-06 (金)の注文を1件まで約定しました」と出ます。
約定した注文は「1件 / 2件」になり、先に注文した投資家Aの解約だけが「約定した」に変わります。
投資家Cの申込は「まだ約定していない」のままで、解約の代金を入れる表もまだ空です。
もう一度「約定する」を押すと、続きの投資家Cの申込が約定して「2件 / 2件」になります。

約定し終えたので、解約の代金を入れる表に2026-03-06 (金) の行が出ます。
受渡日は2026-03-11 (水) で、代金は100,000 × 10,068 ÷ 10,000 = 100,680円です。
状態の札は「まだ入れていない」で、行の右に「代金を入れる」のボタンがあります。
純資産を入れる欄は次の約定日の2026-03-09 (月) に移り、締め切りの前なので「入れる」は押せません。

運用会社のページで2026-03-06 (金) の注文2件を1件ずつ約定し終え、解約の代金100,680円を入れる行が出たところ
運用会社のページで2026-03-06 (金) の注文2件を1件ずつ約定し終え、解約の代金100,680円を入れる行が出たところ

「投資家」のページへ移り、「投資家C」に切り替えます。
約定した注文の枠に、2026-03-06 (金) の基準価額10,068円と、200,000円の申込で受け取った198,649口が出ます。
198,649口の価値は198,649 × 10,068 ÷ 10,000 = 199,999.8132円で、1円未満を切り上げた200,000円を払ったので返した円は0円です。
持っている口数も198,649口になり、評価額は1円未満を切り捨てた199,999円です。

2026-03-06 (金) に200,000円を申し込んだ投資家Cのページに、基準価額10,068円で受け取った198,649口が出たところ
2026-03-06 (金) に200,000円を申し込んだ投資家Cのページに、基準価額10,068円で受け取った198,649口が出たところ

「投資家A」に切り替えると、解約の代金を受け取る枠に100,000口と100,680円が出ます。
運用会社の入金は「まだ入れていない」で、「受け取る」は押せません。
ボタンの横には「受渡日の2026-03-11 (水)から受け取れます」と出ます。
帯の「受渡日へ進める」は、投資家Aにまだ受け取っていない代金があるので押せるようになっています。

先に運用会社が代金を入れます。
「運用会社」のページで「運用会社」を選び、解約の代金を入れる表の「代金を入れる」を押します。
画面が円トークンのapproveとfundProceedsを順に送り、「2026-03-06 (金)の解約の代金100,680円を入れました」と出ます。
状態の札は「入れた」に変わり、ボタンは消えます。

「投資家」のページで「投資家A」に切り替え、帯の「受渡日へ進める」を押します。
チェーンの日付が2026-03-11 (水) の0時に進み、注文の表の解約の札が「受け取れる」に変わります。
「受け取る」を押すと「100,680円の解約の代金を受け取りました」と出て、円の残高は800,680円になります。
札は「受け取った」に変わり、ボタンの横には「この約定日の代金は受け取りました」と出ます。

受渡日の2026-03-11 (水) へ進め、投資家Aが2026-03-06 (金) の解約の代金100,680円を受け取ったところ
受渡日の2026-03-11 (水) へ進め、投資家Aが2026-03-06 (金) の解約の代金100,680円を受け取ったところ

受け取る代金がなくなったので、帯の「受渡日へ進める」は押せなくなります。
代金を入れる前に受渡日へ進めた時は、ボタンの横の文が「運用会社が代金を入れた後に受け取れます」に変わり、「受け取る」は押せないままです。
次の節で、前の約定日からの日数で信託報酬を差し引いてから基準価額を出します。