HandsOnChain

猶予を過ぎた担保を割り引いて売る

作るもの

このレッスンを終えると、処分できる借り手の担保の社債を、本人確認済みの誰でもliquidateで全部買えます。
処分できるのは、担保維持率が100%を下回った時と、追加担保の請求から3日の猶予を過ぎても110%に戻らない時です。
買い手は、評価会社が入れた最新の価格から5%割り引いた額を払います。
払った円は利息、元本の順に充て、余りを借り手へ返します。
担保を売っても借金に届かない時は、足りない分が借り手の借金として残ります。

背景

追加担保を求められた借り手が猶予の間に担保を足さず、返しもしない時は、貸し手が担保を売って貸した円を取り戻します。
これを担保の処分や強制売却と呼びます。
借り手の同意を待たずに売れることは、借りる前の契約で決めておきます。

処分の時を待つほど、価格がさらに下がって取り戻せる額が減るかもしれません。
そのため、担保維持率が100%を下回った借り手は、請求と猶予を待たずにすぐ処分できるようにします。
100%を下回ると、担保を全て売っても元本と利息に届かないためです。

担保維持率 借り手の状態 このレッスンの後にできること
110%以上 正常 処分できない
100%以上110%未満 追加担保を請求できる 請求から3日の猶予を過ぎると処分できる
100%未満 担保の価値が借金に届かない 請求を待たずにすぐ処分できる

担保を早く売るには、すぐ買ってくれる人が要ります。
最新の価格から5%割り引くと、買い手は値下がりの危険を負う代わりに割安に社債を買えます。
割り引いた分は、借り手が負います。

このコースでは、買い手を貸し手に絞らず、本人確認済みの誰でも買えるようにします。
買い手は円トークンで払い、社債トークンを受け取るので、円トークンの許可リストに載っている必要があります。
貸し手が担保を売る相手を探すのではなく、処分できる状態になった時に買いたい人が自分で呼びます。

払われた円を何から先に充てるかも決めておきます。
民法は払われた額を費用、利息、元本の順に充てると定めています。
このコースのローンは費用を数えないので、利息、元本の順に充てます。

処分できるかを決める
ない100%未満過ぎていない110%以上始まり終わりliquidateを呼ぶ担保と借金がある?担保維持率は100%未満?請求から3日を過ぎた?担保維持率は110%未満?担保を5%割り引いて全部売るNotLiquidatableで断る112233445566あるあるある100%以上100%以上100%以上過ぎた過ぎた過ぎた110%未満

実装

starter/contracts/contracts/SecuritiesLoan.solのGRACEの下に、処分の境目と割引の定数を足します。

    /// @notice 請求から処分できるまでの猶予
    uint256 public constant GRACE = 3 days;
    /// @notice 担保維持率がこれを下回ると、猶予を待たずに処分できる (100%)
    uint256 public constant LIQUIDATE_BPS = 10_000;
    /// @notice 処分で担保を買う時の、最新の価格からの割引 (5%)
    uint256 public constant DISCOUNT_BPS = 500;

帳簿のrepaidの下に、処分で受け取った円の合計を足します。

    /// @notice 借り手が返した利息と元本の合計
    uint256 public repaid;
    /// @notice 処分で買い手が払い、利息と元本に充てた円の合計
    uint256 public recovered;

Curedのイベントの下にイベントを、StillBelowCallLevelのエラーの下にエラーを足します。

    event Cured(address indexed borrower);
    event Liquidated(address indexed borrower, address indexed buyer, uint256 paid, uint256 toInterest, uint256 toPrincipal);
    error StillBelowCallLevel(address borrower, uint256 ratioBps);
    error NotLiquidatable(address borrower);
行 意味
LIQUIDATE_BPS 担保維持率がこの値を下回ると、請求と猶予を待たずに処分できる。
1万分率で100%
DISCOUNT_BPS 処分で買う時に、最新の価格から割り引く率。
1万分率で5%
recovered 処分で受け取り、利息と元本に充てた円の合計。
借り手へ返した余りは数えない
Liquidated 誰の担保を誰がいくらで買い、利息と元本にいくら充てたかを残す
NotLiquidatable 処分できない借り手の担保を買おうとした

処分で取り戻した円は、また別の借り手へ貸せます。
cashの説明と式を書き換え、recoveredも貸せる円に足します。

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

最後に、ファイルの末尾のcureの後に、処分の3つの関数を足します。

    // 担保の処分

    /// @notice 処分できるか。100%を下回ったか、請求から猶予を過ぎても110%に戻らない時に処分できる
    function liquidatable(address borrower) public view returns (bool) {
        Position storage p = _positions[borrower];
        if (p.units == 0 || debtOf(borrower) == 0) return false;
        uint256 ratio = ratioBps(borrower);
        if (ratio < LIQUIDATE_BPS) return true;
        return p.calledAt != 0 && block.timestamp > p.calledAt + GRACE && ratio < CALL_BPS;
    }

    /// @notice 処分で買い手が払う額 (円)。預けた口数に、最新の価格から5%割り引いた額を掛けて1円未満を切り捨てる
    function liquidationPrice(address borrower) public view returns (uint256) {
        return (_positions[borrower].units * priceFeed.currentPrice() * (10_000 - DISCOUNT_BPS)) / 10_000;
    }
行 意味
p.units == 0 || debtOf(borrower) == 0 担保を預けていないか、元本も利息も残っていない借り手は処分できない
ratio < LIQUIDATE_BPS 担保維持率が100%を下回ったら、請求がなくてもすぐ処分できる
block.timestamp > p.calledAt + GRACE 請求を記録してから3日の猶予を過ぎたか。
猶予の終わりちょうどはまだ処分できない
ratio < CALL_BPS 猶予を過ぎても110%に戻っていない時だけ処分できる。
価格が戻った借り手は処分しない
priceFeed.currentPrice() 評価会社の最新の価格を読む。
3日を過ぎた価格はStalePriceで断られ、処分もできない
(10_000 - DISCOUNT_BPS) 最新の価格の95%で買う。
掛けてから1万で割り、1円未満を切り捨てる

liquidatableはratioBpsを読み、ratioBpsは最新の価格を読みます。
評価会社の価格が古い間は、処分できるかを決められずに断られます。
古い価格で担保を安く買われないための決まりです。

続けて、liquidationPriceの下にliquidateを足します。

    /// @notice 本人確認済みの誰でも、処分できる借り手の担保を全部買う。
    ///         払った円は利息、元本の順に貸し手の側へ充て、余りを借り手へ返し、足りない分は借り手の借金として残す
    function liquidate(address borrower) external {
        if (!jpy.isAllowed(msg.sender) || jpy.isFrozen(msg.sender)) revert NotAllowed(msg.sender);
        if (!liquidatable(borrower)) revert NotLiquidatable(borrower);
        Position storage p = _positions[borrower];
        uint256 paid = liquidationPrice(borrower);
        _accrue(p);
        uint256 toInterest = paid < p.unpaidInterest ? paid : p.unpaidInterest;
        uint256 toPrincipal = paid - toInterest < p.principal ? paid - toInterest : p.principal;
        p.unpaidInterest -= toInterest;
        p.principal -= toPrincipal;
        recovered += toInterest + toPrincipal;
        uint256 units = p.units;
        p.units = 0;
        p.calledAt = 0;
        jpy.transferFrom(msg.sender, address(this), paid * YEN);
        uint256 refund = paid - toInterest - toPrincipal;
        if (refund > 0) jpy.transfer(borrower, refund * YEN);
        bond.transfer(msg.sender, units);
        emit Liquidated(borrower, msg.sender, paid, toInterest, toPrincipal);
    }
行 意味
jpy.isAllowed(msg.sender) 買い手が円トークンの許可リストに載り、凍結されていないかを確かめる。
担保を預けるpledgeと同じ決まり
_accrue(p) 前に数えた時から経った日数の利息を、払っていない利息へ移す。
充てる前に利息を確定させる
toInterest 払った額のうち利息に充てる額。
払った額が利息より少なければ、払った額の全てを利息に充てる
toPrincipal 利息に充てた残りのうち、元本に充てる額。
元本より多ければ元本の分だけ充てる
recovered += toInterest + toPrincipal 貸し手の側に入った額だけを数える。
借り手へ返す余りは数えない
p.units = 0 担保の社債は全て買い手へ渡すので、預けた口数を0にする
p.calledAt = 0 請求の記録を消す。
担保がなくなったので、もう請求も処分もできない
jpy.transferFrom(msg.sender, ...) 買い手から払う額の全てを受け取る。
買い手は先にapproveでローンのコントラクトに任せておく
refund 払った額から利息と元本に充てた額を引いた余り。
0より多ければ借り手へ返す
bond.transfer(msg.sender, units) 預かっていた担保の社債を全て買い手へ渡す

払う額が利息と元本の合計に届かない時は、refundは0になり、p.principalに足りない分が残ります。
p.borrowedはtrueのままなので、借り手は新しく借りられず、残った借金をrepayで返します。
担保がなくなっても、借金は消えません。

処分の1つの取引で円と社債が動く
チェーンに残る値借り手Aの借金701,879円0円処分で受け取った円0円701,879円借り手Bliquidateを呼ぶ買い手ローンのコントラクトSecuritiesLoan円トークンJpyToken借り手A10口を預けて700,000円を借りた11223344liquidate(借り手A)liquidate(借り手A)transferFrom(借り手B, ローン, 722,000円)transferFrom(借り手B, ローン, 722,000円)722,000 HJPY722,000 HJPY20,121 HJPY社債10口利息、元本の順に充てる利息、元本の順に充てる

次に、starter/contracts/test/SecuritiesLoan.t.solのSecuritiesLoanTestの末尾に、処分のテストを7つ足します。
前のレッスンの_fallBelowCallLevelは、借り手aliceが10口を預けて700,000円を借り、46日後の2026-03-02に価格が76,000円へ下がって請求を記録した状態を作ります。

    function test_RevertWhen_LiquidateDuringGrace() public {
        uint256 calledAt = _fallBelowCallLevel();
        // 猶予の終わりちょうどは、まだ処分できない
        vm.warp(calledAt + 3 days);
        _setPrice(76_000);
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.NotLiquidatable.selector, alice));
        vm.prank(bob);
        loan.liquidate(alice);
        assertEq(loan.positionOf(alice).units, 10);
        assertEq(bond.balanceOf(bob), 10);
    }

    function test_LiquidateAfterGrace() public {
        uint256 calledAt = _fallBelowCallLevel();
        vm.warp(calledAt + 3 days + 1);
        _setPrice(76_000);
        uint256 before = jpy.balanceOf(bob);
        vm.prank(bob);
        loan.liquidate(alice);
        // bobは 76,000円から5%割り引いた72,200円で10口を買う
        assertEq(before - jpy.balanceOf(bob), 722_000 * YEN);
        assertEq(bond.balanceOf(bob), 20);
        assertEq(loan.positionOf(alice).units, 0);
        assertEq(bond.balanceOf(address(loan)), 0);
    }

    function test_LiquidateBelowHundredPercent() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        vm.warp(ISSUE_DATE + 50 days);
        // 680,000 ÷ 701,917 = 96.87%。請求を待たずに処分できる
        _setPrice(68_000);
        assertEq(loan.positionOf(alice).calledAt, 0);
        vm.prank(bob);
        loan.liquidate(alice);
        assertEq(bond.balanceOf(bob), 20);
    }
テスト 確かめること
test_RevertWhen_LiquidateDuringGrace 猶予の終わりの2026-03-05ちょうどは、NotLiquidatableで断られ、担保の10口が残る
test_LiquidateAfterGrace 猶予の終わりの1秒後には、bobが722,000円を払って10口を買い、ローンの社債が0口になる
test_LiquidateBelowHundredPercent 請求を記録していなくても、担保維持率が96.87%なら処分できる

_setPrice(76_000)で、時刻を進めた後に評価会社が価格を入れ直します。
入れ直さないと最後の価格から3日を過ぎ、処分はStalePriceで断られます。
bobはsetUpで社債を10口受け取っているので、買った後は20口になります。

続けて、充てる順と足りない分を確かめるテストを足します。

    function test_LiquidationPaysInterestThenPrincipal() public {
        uint256 calledAt = _fallBelowCallLevel();
        vm.warp(calledAt + 3 days + 1);
        _setPrice(76_000);
        // 49日の利息は 700,000 × 2% × 49 / 365 = 1,879円
        assertEq(loan.interestOf(alice), 1_879);
        uint256 before = jpy.balanceOf(alice);
        vm.prank(bob);
        loan.liquidate(alice);
        // 722,000円のうち1,879円が利息、700,000円が元本に充たり、余りの20,121円が借り手へ戻る
        assertEq(loan.recovered(), 701_879);
        assertEq(jpy.balanceOf(alice) - before, 20_121 * YEN);
        assertEq(loan.debtOf(alice), 0);
        assertEq(loan.cash(), FUNDED + 1_879);
    }

    function test_ShortfallStaysAsDebt() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        vm.warp(ISSUE_DATE + 50 days);
        _setPrice(68_000);
        vm.prank(bob);
        loan.liquidate(alice);
        // 646,000円を利息1,917円と元本644,083円に充て、足りない55,917円が借金として残る
        assertEq(loan.recovered(), 646_000);
        assertEq(loan.positionOf(alice).principal, 55_917);
        assertEq(loan.debtOf(alice), 55_917);
        assertEq(loan.positionOf(alice).units, 0);
    }
テスト 確かめること
test_LiquidationPaysInterestThenPrincipal 722,000円を利息1,879円、元本700,000円の順に充て、余りの20,121円がaliceへ戻る。
貸せる円は利息の分だけ増える
test_ShortfallStaysAsDebt 1口68,000円の95%で買われた646,000円では借金に届かず、足りない55,917円が元本として残る

test_ShortfallStaysAsDebtでは、50日分の利息1,917円を先に払い終え、残りの644,083円を元本に充てます。
700,000円の元本から644,083円を引いた55,917円が、担保のない借金として残ります。

最後に、処分できない時のテストを2つ足します。

    function test_RevertWhen_LiquidateHealthy() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.NotLiquidatable.selector, alice));
        vm.prank(bob);
        loan.liquidate(alice);
        assertEq(loan.positionOf(alice).units, 10);
    }

    function test_RevertWhen_LiquidateWithStalePrice() public {
        _pledgeAndBorrow(alice, 10, 700_000);
        _setPrice(68_000);
        vm.warp(ISSUE_DATE + 3 days + 1);
        vm.expectRevert(abi.encodeWithSelector(CollateralPrice.StalePrice.selector, ISSUE_DATE, ISSUE_DATE + 3 days + 1));
        vm.prank(bob);
        loan.liquidate(alice);
        assertEq(loan.positionOf(alice).units, 10);
    }
テスト 確かめること
test_RevertWhen_LiquidateHealthy 担保維持率が142.8%の借り手の担保は買えない
test_RevertWhen_LiquidateWithStalePrice 価格が68,000円に下がっていても、最後の価格から3日を過ぎていればStalePriceで断られる

確かめる

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

forge test --match-contract SecuritiesLoanTest

次の行が出れば、処分は正しく動いています。

[PASS] test_LiquidateAfterGrace()
[PASS] test_LiquidateBelowHundredPercent()
[PASS] test_LiquidationPaysInterestThenPrincipal()
[PASS] test_RevertWhen_LiquidateDuringGrace()
[PASS] test_RevertWhen_LiquidateHealthy()
[PASS] test_RevertWhen_LiquidateWithStalePrice()
[PASS] test_ShortfallStaysAsDebt()
Suite result: ok. 23 passed; 0 failed; 0 skipped

猶予の終わりちょうどを処分できないことも確かめます。
liquidatableのblock.timestamp > p.calledAt + GRACEの>を>=に変えて実行します。
test_RevertWhen_LiquidateDuringGraceが[FAIL: next call did not revert as expected]で失敗します。
猶予の終わりちょうどに担保を足そうとした借り手が、同じ時刻に処分されてしまうと分かります。
試したら>に戻しておきます。

forge testで全てのテストを実行すると、評価会社の価格のテストと合わせて25個のテストが通ります。
次のレッスンで、どの順に操作してもローンの社債と円が帳簿と合うことを、invariantのテストで確かめます。