HandsOnChain

経過利息を足して売買する

作るもの

このレッスンを終えると、社債を持つ投資家が口数と1口の値段を決めて売りの注文を出し、別の投資家がその注文を買えます。
買う人は、値段に前の利払い日からの経過利息を足した円を払います。
記録日を過ぎてから利払い日までの間に買う時は、利払い日までの日数の分を値段から引きます。
円と社債トークンは決済のコントラクトの1つの取引の中で入れ替わり、どちらか片方だけが動くことはありません。

背景

社債は満期まで持ち続けるだけでなく、途中で投資家どうしが売り買いできます。
日本の社債の多くは、社債、株式等の振替に関する法律による振替制度で受け渡します。
売り買いした社債は、証券保管振替機構(ほふり)の帳簿の記録を書き換えて売る人から買う人へ移ります。
証券の受け渡しと代金の支払いを同時に行う決済の仕方をDvPと呼びます。
片方だけが済んで相手が払わない危険(元本リスク)をなくすために使います。

社債を利払い日の間に売り買いする時は、買う人が売る人へ経過利息を払います。
次の利金は、記録日に社債を持っている人が受け取ります。
記録日より前に売ると、売る人は前の利払い日から売る日まで社債を持っていたのに、その間の利金を受け取れません。
そこで買う人が、売る人の持っていた日数の分の利金を経過利息として値段に足して払います。
買う人は次の利払い日に、前の利払い日から数えた全ての日数の分の利金を受け取ります。
差し引くと、売る人と買う人はそれぞれ社債を持っていた日数の分を受け取ることになります。

記録日を過ぎてから売ると、向きが逆になります。
次の利金は記録日に持っていた売る人が受け取るので、売る人は売った日から利払い日までの分の利金も受け取ります。
その日数を持つのは買う人なので、このコースでは利払い日までの日数の分を負の経過利息として値段から引きます。
もし前の利払い日からの日数の分を足すと、売る人は経過利息と利金の両方で同じ日数の分を受け取ってしまいます。

日本の普通社債の利息は年2回払いが多く、日割りの計算は実際の日数を365で割る形が多く使われます。
このコースの社債も同じ形で、1口の経過利息を次の式で計算し、どちらの向きでも1円未満を切り捨てます。

売る日 1口の経過利息
記録日まで 額面 × 年の利率 × 前の利払い日からの日数 / 365
記録日の後から利払い日の前まで -(額面 × 年の利率 × 利払い日までの日数 / 365)

額面の100,000円に年0.80%を掛けると、1口の1年分の利金は800円です。
例えば、前の利払い日の2026-07-15から32日後の2026-08-16に売る時は、次の記録日の2027-01-10より前です。
32日の分は800 × 32 / 365 = 70.13…で、1円未満を切り捨てて70円を足します。
1回目の記録日の2026-07-10の後の2026-07-12に売る時は、利払い日の2026-07-15まで3日です。
3日の分は800 × 3 / 365 = 6.57…で、1円未満を切り捨てて6円を引きます。
1口99,900円の値段で3口を買う人は、それぞれ次の額を払います。

売る日 値段 経過利息 払う総額
2026-08-16 99,900円 × 3口 = 299,700円 70円 × 3口 = 210円 299,910円
2026-07-12 99,900円 × 3口 = 299,700円 -6円 × 3口 = -18円 299,682円

このレッスンでは、経過利息を決済のコントラクトがチェーンの時刻と社債の日程から計算します。
売る人と買う人が同じコントラクトの同じ式を読むため、払う額が食い違いません。
円と社債は、決済のコントラクトが1つの取引の中で動かします。
どちらかの移転が拒まれると取引の全てが元に戻るため、円だけが動いて社債が届かない状態は起きません。

1口の経過利息を決める
始まり終わり終わり前の利払い日を探す次の記録日を過ぎた?前の利払い日からの日数の分を足す利払い日までの日数の分を引く11223344過ぎていない過ぎていない過ぎていない過ぎた
経過利息を足して社債を買う
社債の口数売る人12口9口買う人10口13口売る人bobが12口を持つ買う人aliceが10口を持つ決済のコントラクトBondSettlement円トークンJpyToken社債トークンBondToken11223344approve(決済のコントラクト, 3)approve(決済のコントラクト, 3)list(3, 99,900)list(3, 99,900)approve(決済のコントラクト, 299,910円)approve(決済のコントラクト, 299,910円)buy(0)buy(0)transferFrom(買う人, 売る人, 299,910円)transferFrom(買う人, 売る人, 299,910円)299,910円299,910円transferFrom(売る人, 買う人, 3)3口0番の注文を残す0番の注文を残す3 × (99,900 + 70) = 299,910円3 × (99,900 + 70) = 299,910円

実装

starter/contracts/contracts/BondSettlement.solの先頭のimportに、OpenZeppelin ContractsのSafeCastを足します。
経過利息は負の値にもなるので、符号のある整数と符号のない整数の間を安全に変換するために使います。

import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";

couponClaimedの宣言の後に、売りの注文を表す構造体と、注文を並べる配列を足します。

    /// @notice 売りの注文。値段は1口あたりの円で、経過利息を含めない
    struct Order {
        address seller;
        uint256 units;
        uint256 price;
        bool open;
    }

    Order[] private _orders;
行 意味
seller 売りに出した人のアドレス
units 売る口数
price 1口の値段。
1円単位の整数で持ち、経過利息を含めない
open まだ買われていない注文か。
買われるとfalseになる
Order[] private _orders 出した注文の配列。
配列の位置を注文の番号にする

前のレッスンまでのイベントの後に、売買のイベントを足します。

    event Listed(uint256 indexed id, address indexed seller, uint256 units, uint256 price);
    event Traded(uint256 indexed id, address indexed buyer, uint256 total);

エラーも、NothingToClaimの後に2つ足します。

    error NotEnoughBond(uint256 units, uint256 balance);
    error OrderClosed(uint256 id);
行 意味
Listed 注文を出した時に、注文の番号と売り手と口数と値段を残す
Traded 注文が買われた時に、注文の番号と買い手と払った総額を残す
NotEnoughBond 持っている口数より多くを売りに出そうとした
OrderClosed もう買われた注文を買おうとした

claimCouponの後に、売買の関数を足します。
まず、売りの注文を出すlistです。

    // 売買

    /// @notice 売りの注文を出す。売り手は先に社債の`approve`でこのコントラクトに口数を任せる
    function list(uint256 units, uint256 price) external returns (uint256 id) {
        if (units == 0) revert ZeroUnits();
        uint256 balance = bond.balanceOf(msg.sender);
        if (balance < units) revert NotEnoughBond(units, balance);
        id = _orders.length;
        _orders.push(Order({seller: msg.sender, units: units, price: price, open: true}));
        emit Listed(id, msg.sender, units, price);
    }
行 意味
bond.balanceOf(msg.sender) 売り手が今持っている口数を読む。
売る口数に足りなければNotEnoughBondで拒む
id = _orders.length 注文の番号は、配列に足す前の長さになる。
最初の注文は0番
_orders.push(...) 注文をopen: trueの形で配列に足す

注文を出した時は、社債を決済のコントラクトへ移さず、売り手が持ったままにします。
売り手は先に社債トークンのapproveで口数を決済のコントラクトに任せておき、買われた時に決済のコントラクトがその口数を動かします。
注文を出した後に売り手が社債を手放していた時は、買う時の移転が拒まれて取引の全てが元に戻ります。

次に、今日の1口の経過利息を返すaccruedPerUnitを足します。
記録日までは前の節のcouponPerUnitと同じ式で、日数を数え終える日だけを今日に替えます。
記録日の後は、今日から利払い日までの日数で同じ式を計算し、負の値にして返します。

    /// @notice 今日の1口の経過利息 (円)。前の利払い日 (1回目は払込日) から今日までの日数で日割りにし、1円未満を切り捨てる。
    /// 記録日を過ぎた後は次の利金を売り手が受け取るため、今日から利払い日までの日数の分を負の値で返し、買い手の払う額から引く
    function accruedPerUnit() public view returns (int256) {
        uint256 start = bond.issueDate();
        uint256 n = 0;
        while (n < bond.couponCount() && bond.paymentDate(n) <= block.timestamp) {
            start = bond.paymentDate(n);
            n++;
        }
        if (block.timestamp <= start) return 0;
        uint256 perYear = bond.faceValue() * bond.rateBps();
        if (n < bond.couponCount() && block.timestamp > bond.recordDate(n)) {
            uint256 daysLeft = (bond.paymentDate(n) - block.timestamp) / 1 days;
            return -SafeCast.toInt256((perYear * daysLeft) / (10_000 * 365));
        }
        uint256 days_ = (block.timestamp - start) / 1 days;
        return SafeCast.toInt256((perYear * days_) / (10_000 * 365));
    }
行 意味
returns (int256) 負の値も返せるように、符号のある整数で返す
start = bond.issueDate() 数え始める日。
まだ1回も利払い日が来ていない時は、払込日から数える
while (...) 今の時刻までに来た利払い日を順に見て、最後に来た利払い日をstartにする。
抜けた時のnは次に払う回になる
block.timestamp <= start 払込日の前と利払い日ちょうどの時は0を返す
perYear 額面に利率を掛けた値。
利率は1万分の1の単位なので、後で10,000で割ると1口の1年分の利金になる
block.timestamp > bond.recordDate(n) 次に払う回の記録日を過ぎたかを見る。
過ぎた時は次の利金を売り手が受け取る
daysLeft 今日から利払い日までの日数。
1日に満たない分は切り捨てる
-SafeCast.toInt256(...) 利払い日までの日数の分を負の値にして返す。
int256に収まらない値の時は拒む
days_ 前の利払い日から今日までの日数。
記録日までの時はこの日数の分を正の値で返す
/ (10_000 * 365) 10,000で割って利率の単位を戻し、365で割る。
整数の割り算なので1円未満は切り捨てになる

最後に、注文を買うbuyと、画面が注文を読むための2つの関数を足します。

    /// @notice 売りの注文を買う。値段に経過利息を足した円を買い手から売り手へ、社債を売り手から買い手へ1つの取引で移す
    function buy(uint256 id) external {
        Order storage order = _orders[id];
        if (!order.open) revert OrderClosed(id);
        order.open = false;
        uint256 total = order.units * SafeCast.toUint256(SafeCast.toInt256(order.price) + accruedPerUnit()) * YEN;
        jpy.transferFrom(msg.sender, order.seller, total);
        bond.transferFrom(order.seller, msg.sender, order.units);
        emit Traded(id, msg.sender, total);
    }

    /// @notice 出した注文の数
    function orderCount() external view returns (uint256) {
        return _orders.length;
    }

    /// @notice 注文の中身
    function orderAt(uint256 id) external view returns (Order memory) {
        return _orders[id];
    }
行 意味
if (!order.open) revert OrderClosed(id) 買われた注文をもう1度買おうとした時に拒む
order.open = false 円と社債を動かす前に注文を閉じ、同じ注文を2回買えないようにする
SafeCast.toInt256(order.price) + accruedPerUnit() 値段を符号のある整数にして1口の経過利息を足す。
記録日の後は経過利息が負なので、値段から引く形になる
SafeCast.toUint256(...) 1口の額を符号のない整数に戻す。
負になる時は拒む
order.units * ... * YEN 1口の額に口数を掛け、YENを掛けて円トークンの18桁の単位にする
jpy.transferFrom(msg.sender, order.seller, total) 買い手がapproveで任せた円を、買い手から売り手へ移す
bond.transferFrom(order.seller, msg.sender, order.units) 売り手が任せた社債を、売り手から買い手へ移す
orderCount() 出した注文の数を返す。
画面はこの数だけorderAtを呼ぶ
orderAt(id) 注文の中身を構造体のまま返す。
_ordersはprivateなので、読む関数を別に置く

2つの移転は同じ取引の中で行います。
円が足りない時は円トークンが拒み、社債の口数が足りない時は社債トークンが拒みます。
どちらで拒まれても、order.open = falseの書き換えまで含めて取引の全てが元に戻ります。
節1で社債トークンの移転を円トークンの名簿で絞ったので、本人確認の済んでいない人は買えません。

starter/contracts/test/DigitalBond.t.solの最後に、売買のテストを3つ足します。
節2で足した_issueBondは、aliceに10口とbobに12口とcarolに8口を発行します。

    // 節4 投資家どうしの売買

    function test_TradeAddsAccruedInterest() public {
        _issueBond();
        // 2026-08-16は前の利払い日の2026-07-15から32日。1口の経過利息は 800 × 32 / 365 = 70.13... で70円
        vm.warp(PAY_1 + 32 days);
        vm.startPrank(bob);
        bond.approve(address(settlement), 3);
        uint256 id = settlement.list(3, 99_900);
        vm.stopPrank();
        assertEq(settlement.accruedPerUnit(), 70);
        uint256 total = 3 * (99_900 + 70) * YEN;
        uint256 aliceBefore = jpy.balanceOf(alice);
        uint256 bobBefore = jpy.balanceOf(bob);
        vm.startPrank(alice);
        jpy.approve(address(settlement), total);
        settlement.buy(id);
        vm.stopPrank();
        assertEq(jpy.balanceOf(alice), aliceBefore - total);
        assertEq(jpy.balanceOf(bob), bobBefore + total);
        assertEq(bond.balanceOf(alice), 13);
        assertEq(bond.balanceOf(bob), 9);
    }

    function test_TradeAfterRecordDateSubtractsInterest() public {
        _issueBond();
        // 2026-07-12は記録日の2026-07-10の後。7-15の利金は記録日に持っていたbobが受け取るので、
        // 利払い日までの3日の分 800 × 3 / 365 = 6.57... で6円を、買い手の払う額から引く
        vm.warp(RECORD_1 + 2 days);
        vm.startPrank(bob);
        bond.approve(address(settlement), 3);
        uint256 id = settlement.list(3, 99_900);
        vm.stopPrank();
        assertEq(settlement.accruedPerUnit(), -6);
        uint256 total = 3 * (99_900 - 6) * YEN;
        uint256 bobBefore = jpy.balanceOf(bob);
        vm.startPrank(alice);
        jpy.approve(address(settlement), total);
        settlement.buy(id);
        vm.stopPrank();
        assertEq(jpy.balanceOf(bob), bobBefore + total);
        // 利払い日の利金は、記録日の口数のとおりbobが12口分を受け取る
        _fundCoupon(0, settlement.couponDue(0));
        vm.warp(PAY_1);
        vm.prank(bob);
        settlement.claimCoupon(0);
        assertEq(jpy.balanceOf(bob), bobBefore + total + 12 * 396 * YEN);
    }

    function test_RevertWhen_TradeBuyerCannotPay() public {
        _issueBond();
        vm.warp(PAY_1 + 32 days);
        vm.startPrank(bob);
        bond.approve(address(settlement), 12);
        uint256 id = settlement.list(12, 100_100);
        vm.stopPrank();
        // carolは残りの1,200,000円では、12口の1,201,200円と経過利息の840円を払えない
        uint256 total = 12 * (100_100 + 70) * YEN;
        assertLt(jpy.balanceOf(carol), total);
        vm.startPrank(carol);
        jpy.approve(address(settlement), total);
        vm.expectRevert();
        settlement.buy(id);
        vm.stopPrank();
        assertEq(bond.balanceOf(bob), 12);
        assertEq(bond.balanceOf(carol), 8);
        assertTrue(settlement.orderAt(id).open);
    }

1つ目のテストは、記録日より前に買うと経過利息を足すことを確かめます。

行 意味
vm.warp(PAY_1 + 32 days) チェーンの時刻を、1回目の利払い日の2026-07-15から32日後の2026-08-16にする
settlement.list(3, 99_900) bobが3口を1口99,900円で売りに出す
assertEq(settlement.accruedPerUnit(), 70) 背景で計算した1口70円と同じかを確かめる
3 * (99_900 + 70) * YEN aliceが払う299,910円を、円トークンの18桁の単位にした額
assertEq(bond.balanceOf(alice), 13) aliceの10口に、買った3口が足されている

2つ目のテストは、記録日の後に買うと利払い日までの日数の分を引き、利金は売ったbobが受け取ることを確かめます。

行 意味
vm.warp(RECORD_1 + 2 days) チェーンの時刻を、1回目の記録日の2026-07-10から2日後の2026-07-12にする
assertEq(settlement.accruedPerUnit(), -6) 利払い日までの3日の分の6円が、負の値で返る
3 * (99_900 - 6) * YEN aliceが払う299,682円を、円トークンの18桁の単位にした額
_fundCoupon(0, settlement.couponDue(0)) 発行体が1回目の利金の総額を入れる
settlement.claimCoupon(0) 利払い日の2026-07-15に、bobが1回目の利金を受け取る
12 * 396 * YEN bobが記録日に持っていた12口の利金。
売った3口の分もbobが受け取る

bobは売った3口について、利払い日までの3日の分を値段から引かれ、代わりに利金の396円を受け取ります。
aliceは利金を受け取らない代わりに、その3日の分だけ安く買えます。

3つ目のテストでは、円の足りないcarolがbobの12口の注文を買おうとして拒まれます。
carolは申込で800,000円を払ったので、残りは1,200,000円です。
12口の値段の1,201,200円に経過利息の840円を足すと1,202,040円になり、残りの円では払えません。
拒まれた後もbobとcarolの口数は変わらず、注文も開いたままです。
buyの中でorder.open = falseを書いた後に円の移転で拒まれても、注文を閉じた書き換えまで元に戻ると分かります。

確かめる

starter/contractsのディレクトリで、売買のテストを実行します。

forge test --match-test Trade

次の行が出れば、テストは通っています。

[PASS] test_RevertWhen_TradeBuyerCannotPay()
[PASS] test_TradeAddsAccruedInterest()
[PASS] test_TradeAfterRecordDateSubtractsInterest()
Suite result: ok. 3 passed; 0 failed; 0 skipped

accruedPerUnitのif (n < bond.couponCount() && block.timestamp > bond.recordDate(n))から始まる4行のまとまりを消して実行すると、test_TradeAfterRecordDateSubtractsInterestが失敗します。
記録日の後も前の利払い日からの日数を数えるようになるため、次の行が出ます。

[FAIL: assertion failed: 390 != -6] test_TradeAfterRecordDateSubtractsInterest()

左の390円は払込日の2026-01-15から2026-07-12までの178日の分で、売る人が利金と経過利息の両方で同じ日数の分を受け取る額です。
確かめたら元に戻し、forge testで全てのテストを実行します。
この時点で、21個のテストが全て通ります。

Suite result: ok. 21 passed; 0 failed; 0 skipped

次のレッスンで、売りに出すことと買うことをブラウザから行う画面を作ります。