HandsOnChain

利息を日割りで数えて返す

作るもの

このレッスンを終えると、借りた元本に年の金利を掛け、借りた日からの実際の日数で日割りにした利息を数えられます。
借り手はrepayで返せるようになり、返した額は利息に充ててから元本に充てます。
元本と利息を全て返すと、預けた担保の社債が借り手へ戻ります。
担保の評価額を元本と利息の合計で割った担保維持率も読めるようにします。
700,000円を年2.00%で30日借りると、利息は1,150円になり、返す額の合計は701,150円になります。

背景

銀行の貸出の利息は、借りた額に年の金利を掛け、借りていた日数を365で割って日割りにする形が多くなっています。
このコースのローンも、年2.00%の金利を実際の日数で日割りにし、1円未満を切り捨てます。
1日に満たない時間は数えず、次に数える時に回します。

借りてから 計算 利息
29日と23時間 700,000 × 2.00% × 29 / 365 = 1,112.32… 1,112円
30日 700,000 × 2.00% × 30 / 365 = 1,150.68… 1,150円

29日と23時間は、1日に満たない23時間を数えずに29日として数えます。
捨てた23時間は消えず、1日に届いた時に次の日の分として数えます。
割り算は2作目の利金と同じく、元本と金利と日数を全て掛けてから最後に1回だけ行います。

返した額は、利息に先に充て、残りを元本に充てます。
日本の民法も、全てを返すのに足りない額は費用と利息と元本の順に充てると定めています。
元本と利息を全て返した時に、ローンのコントラクトは預かっていた担保の社債を借り手へ戻します。

返した円を利息、元本の順に充てる
ローンに残る値元本700,000円0円払っていない利息1,150円150円0円担保10口0口借り手A700,000円を借りたローンのコントラクトSecuritiesLoan円トークンJpyToken社債トークンBondToken11223344repay(1,000)repay(1,000)transferFrom(借り手A, ローン, 1,000円)transferFrom(借り手A, ローン, 1,000円)repay(700,150)repay(700,150)transferFrom(借り手A, ローン, 700,150円)transferFrom(借り手A, ローン, 700,150円)transfer(借り手A, 10口)10口700,000 × 2% × 30 / 365 = 1,150.68円を切り捨てる700,000 × 2% × 30 / 365 = 1,150.68円を切り捨てる

担保維持率は、担保の評価額を元本と利息の合計で割った割合です。
10口の担保が1口100,000円なら評価額は1,000,000円で、返す額の合計が701,150円なら担保維持率は142.62%です。
社債の価格が下がるか利息が増えると、担保維持率は下がります。
次の節では、担保維持率が110%を下回った借り手に追加担保を求めます。

実装

starter/contracts/contracts/SecuritiesLoan.solを開きます。
pragmaの行の後に、時刻を64ビットの整数へ安全に縮めるOpenZeppelinのSafeCastを読み込みます。

pragma solidity ^0.8.28;

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

import {JpyToken} from "@handsonchain/jpy-stablecoin-contracts/contracts/JpyToken.sol";

OpenZeppelinの読み込みと、1作目と2作目のコントラクトの読み込みの間には、空行を1つ置きます。

借り手ごとのPositionに、払っていない利息と、次に利息を数え始める時刻を足します。

    struct Position {
        // 預けた社債の口数
        uint256 units;
        // 借りている元本 (円)
        uint256 principal;
        // 1回借りたか。借りられるのは1回だけ
        bool borrowed;
        // 数え終えて、まだ払っていない利息 (円)
        uint256 unpaidInterest;
        // 次に利息を数え始める時刻
        uint64 interestFrom;
    }
行 意味
unpaidInterest 返した時に数え終えた利息のうち、まだ払っていない額。
1円単位で持つ
interestFrom 次に利息を数え始める時刻。
借りた時に今の時刻を入れ、返した時に数えた日数の分だけ進める

lentの後に返された額の合計を、イベントとエラーの末尾に返済の分を足します。

    /// @notice 貸した元本の合計
    uint256 public lent;
    /// @notice 借り手が返した利息と元本の合計
    uint256 public repaid;

    event Funded(uint256 amount);
    event Pledged(address indexed borrower, uint256 units);
    event Borrowed(address indexed borrower, uint256 amount);
    event Repaid(address indexed borrower, uint256 toInterest, uint256 toPrincipal);
    event Released(address indexed borrower, uint256 units);
    error OverLenderCash(uint256 amount, uint256 cash);
    error NothingToRepay();
行 意味
repaid 借り手が返した利息と元本の合計。
返された円は貸し手の側に残り、また貸せる
Repaid 返した額のうち、利息に充てた額と元本に充てた額を分けて残す
Released 全て返した借り手へ、担保の社債を戻した口数を残す
NothingToRepay 返す元本も利息もない借り手が返そうとした

cashは、返された額も貸せる円に数えます。
上の説明の行も、返された額を足す形に書き換えます。

    /// @notice 今貸せる円。入れた円に返された額を足し、貸した元本を引く
    function cash() public view returns (uint256) {
        return funded + repaid - lent;
    }

先に足してから引くのは、返された円をまた貸すとlentがfundedより大きくなりうるためです。
funded - lentを先に計算すると、その時に引き算が0を下回り、取引が拒まれます。

borrowでは、元本を書いた次の行で、利息を数え始める時刻を残します。

        p.borrowed = true;
        p.principal = amount;
        p.interestFrom = SafeCast.toUint64(block.timestamp);
        lent += amount;

SafeCast.toUint64は、64ビットに収まらない値の時に取引を拒みます。
Unixの時刻は64ビットに十分収まるので、ここで拒まれることはありません。

borrowersの関数の後に、利息と返済の関数を足します。

    // 利息と返済

    /// @notice 今払う利息 (円)。元本 × 年の金利 × 日数 / 365 を1円未満で切り捨て、払っていない分に足す
    function interestOf(address borrower) public view returns (uint256) {
        Position storage p = _positions[borrower];
        return p.unpaidInterest + _interestSince(p);
    }

    /// @notice 元本と利息の合計 (円)
    function debtOf(address borrower) public view returns (uint256) {
        return _positions[borrower].principal + interestOf(borrower);
    }

    /// @notice 担保維持率 (1万分率)。担保の評価額 ÷ 元本と利息。借りていない時は最大の値を返す
    function ratioBps(address borrower) public view returns (uint256) {
        uint256 debt = debtOf(borrower);
        if (debt == 0) return type(uint256).max;
        return (collateralValue(borrower) * 10_000) / debt;
    }
行 意味
p.unpaidInterest + _interestSince(p) 前に数え終えた利息に、その後に経った日数の利息を足す。
読むだけなので、チェーンの値は変えない
debtOf 元本と利息の合計。
借り手が全て返すのに要る額
* 10_000 担保維持率を1万分率で返す。
14,262は142.62%を表す
type(uint256).max 借りていない借り手は0で割れないので、一番大きい値を返す。
後の節で110%と比べた時に、借りていない人は下回らない

続けて、返済の関数と、利息を数える内側の関数を足します。

    /// @notice 借り手が返す。返した額は利息に充ててから元本に充て、全て返すと担保の社債が戻る
    function repay(uint256 amount) external {
        if (amount == 0) revert ZeroAmount();
        Position storage p = _positions[msg.sender];
        _accrue(p);
        uint256 owed = p.unpaidInterest + p.principal;
        if (owed == 0) revert NothingToRepay();
        if (amount > owed) amount = owed;
        uint256 toInterest = amount < p.unpaidInterest ? amount : p.unpaidInterest;
        p.unpaidInterest -= toInterest;
        p.principal -= amount - toInterest;
        repaid += amount;
        jpy.transferFrom(msg.sender, address(this), amount * YEN);
        emit Repaid(msg.sender, toInterest, amount - toInterest);
        if (amount == owed) _release(msg.sender, p);
    }

    // 前に数えた時から経った日数の利息。1日に満たない分は次に回す
    function _interestSince(Position storage p) private view returns (uint256) {
        uint256 days_ = (block.timestamp - p.interestFrom) / 1 days;
        return (p.principal * rateBps * days_) / (10_000 * 365);
    }

    // 経った日数の利息を払っていない利息へ移し、数え始めを日数の分だけ進める
    function _accrue(Position storage p) private {
        uint256 days_ = (block.timestamp - p.interestFrom) / 1 days;
        p.unpaidInterest += _interestSince(p);
        p.interestFrom += SafeCast.toUint64(days_ * 1 days);
    }

    // 全て返した借り手へ担保の社債を戻す
    function _release(address borrower, Position storage p) private {
        uint256 units = p.units;
        p.units = 0;
        if (units > 0) bond.transfer(borrower, units);
        emit Released(borrower, units);
    }
行 意味
_accrue(p) 返す前に、経った日数の利息を払っていない利息へ移す。
この後の計算は今の時刻で確定した額で行う
if (amount > owed) amount = owed 元本と利息の合計より多い額は、合計の額に減らす。
払いすぎた円は受け取らない
toInterest 返した額のうち利息に充てる額。
返した額が利息より少なければ、全てを利息に充てる
p.principal -= amount - toInterest 利息に充てた残りを元本に充てる
/ 1 days 秒の差を日数にする。
割り算は小数点以下を捨てるので、1日に満たない時間は数えない
days_ * 1 days 数え始めを、数えた日数の分だけ進める。
捨てた端の時間は次に数える時の分に残る
_release 全て返した時に、担保の口数を0にしてから社債を借り手へ送る

_accrueで数え始めを今の時刻まで進めないのは、端の時間を捨てないためです。
もし今の時刻まで進めると、1日に満たない時間の利息は、返すたびに消えてしまいます。

返済の流れを図にすると、次の形になります。

返した額を充てる順
ない合計まで残る始まり終わり終わりrepayを呼ぶ返す額がある?合計より多い?合計の額に減らす利息に充て、残りを元本に充てる全て返した?担保の社債を戻すNothingToRepayで拒む1122334455あるあるある多い多い多い全て

最後に、starter/contracts/test/SecuritiesLoan.t.solのSecuritiesLoanTestの末尾に、利息と返済のテストを2つ足します。

    function test_InterestIsActualOver365RoundedDown() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        // 29日と23時間は29日として数える。700,000 × 2% × 29 / 365 = 1,112.32円
        vm.warp(ISSUE_DATE + 30 days - 1 hours);
        assertEq(loan.interestOf(alice), 1_112);
        // 30日で1,150.68円。1円未満を切り捨てる
        vm.warp(ISSUE_DATE + 30 days);
        assertEq(loan.interestOf(alice), 1_150);
        assertEq(loan.debtOf(alice), 701_150);
        // 評価会社が同じ価格を入れ直すと、担保維持率は 1,000,000 ÷ 701,150 = 142.62%
        _setPrice(PRICE);
        assertEq(loan.ratioBps(alice), 14_262);
    }

    function test_RepayReturnsCollateral() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        vm.warp(ISSUE_DATE + 30 days);
        // 利息より少ない1,000円は全て利息に充たり、元本は減らない
        vm.prank(alice);
        loan.repay(1_000);
        assertEq(loan.interestOf(alice), 150);
        assertEq(loan.positionOf(alice).principal, 700_000);
        assertEq(bond.balanceOf(alice), 0);
        // 残りの元本と利息を返すと、担保の10口が戻る
        vm.prank(alice);
        loan.repay(700_150);
        assertEq(loan.debtOf(alice), 0);
        assertEq(loan.positionOf(alice).units, 0);
        assertEq(bond.balanceOf(alice), 10);
        assertEq(loan.repaid(), 701_150);
        assertEq(loan.cash(), FUNDED + 1_150);
    }
テスト 確かめること
test_InterestIsActualOver365RoundedDown 29日と23時間は29日分の1,112円になり、30日で切り捨てた1,150円になる。
担保維持率は14,262 (142.62%) になる
test_RepayReturnsCollateral 1,000円は全て利息に充たり、残りの700,150円を返すとaliceに担保の10口が戻る。
貸せる円は入れた100万円に利息の1,150円を足した額になる

_setPrice(PRICE)の行は、評価会社が同じ価格を入れ直す操作です。
今はなくても通りますが、次のレッスンで3日を過ぎた価格を断るようにした後も、このテストが通るように置いておきます。

確かめる

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

forge test --match-contract SecuritiesLoanTest

次の行が出れば、利息と返済のテストは通っています。

[PASS] test_InterestIsActualOver365RoundedDown()
[PASS] test_RepayReturnsCollateral()
Suite result: ok. 8 passed; 0 failed; 0 skipped

1日に満たない時間を数えないと、利息がどう変わるかも試しておきます。
_interestSinceのreturnの行を、秒のまま数える次の行に書き換えて実行します。

        return (p.principal * rateBps * (block.timestamp - p.interestFrom)) / (10_000 * 365 days);

29日と23時間の分を秒のまま数えるため、1,149円になってテストが失敗します。

[FAIL: assertion failed: 1149 != 1112] test_InterestIsActualOver365RoundedDown()

30日ちょうどの利息は、日数で数えても秒で数えても1,150円なので、test_RepayReturnsCollateralは通ったままです。
確かめたら、元の行に戻しておきます。
次のレッスンで、評価会社が入れてから3日を過ぎた古い価格での借入を断ります。