HandsOnChain

担保を預けて掛け目の枠まで借りる

作るもの

このレッスンを終えると、ローンのコントラクトができます。
貸し手の銀行が円を入れ、借り手が社債を担保に預けると、担保の評価額の80%までの円を1回だけ借りられます。
枠を超える借入と、円トークンの許可リストにない人の預け入れは断ります。
返済の期限が担保の社債の満期より後になるローンは、デプロイそのものを断ります。

背景

貸し手は、担保の評価額の全てを貸すわけではありません。
借りている間に担保の価格が下がると、担保を売っても貸したお金に足りなくなるためです。
評価額のうち貸す割合を掛け目と呼び、残りの分を価格が下がった時のゆとりにします。
掛け目は担保の値動きの大きさで決まり、値動きの大きい株は低く、値動きの小さい国債は高くします。
このコースでは、社債の掛け目を80%にします。

値 このコースの例
預けた口数 10口
1口の価格 100,000円 (評価会社が入れた価格)
担保の評価額 10口 × 100,000円 = 1,000,000円
借入枠 1,000,000円 × 80% = 800,000円

借りられるのは1回だけにします。
借り足しを許すと、借りた日ごとに利息を数える日が分かれ、後のレッスンの利息の数え方が複雑になるためです。
借りる額は、借入枠の中で借り手が決めます。

貸し手は、借り手へ貸す円を先にローンのコントラクトへ入れておきます。
ローンのコントラクトが貸せるのは、貸し手が入れた円のうち、まだ貸していない分だけです。
銀行が貸し出しに充てる円は限られているため、借入枠の中でも、残りが足りなければ断ります。

担保を預けられるのは、1作目の円トークンの許可リストに載り、凍結されていない人だけです。
借りた円は円トークンで受け取るため、許可リストにない人は円を受け取れません。
預ける時に先に断れば、社債だけを預けて借りられない状態を作らずに済みます。

円を入れて担保を預け、枠の中で借りる
チェーンに残る値貸せる残り1,000,000円200,000円担保の口数0口10口借りた元本0円800,000円銀行貸し手借り手A社債を10口持つローンのコントラクトSecuritiesLoan価格のコントラクト1口 100,000円11223344fund(1,000,000)fund(1,000,000)pledge(10)pledge(10)currentPrice()currentPrice()100,000円100,000円borrow(800,000)800,000 HJPY

返済の期限は、担保の社債の満期より前に置きます。
満期が来ると社債は償還されて消えるため、満期より後まで貸すと、担保のない借入が残ってしまいます。
そこで、返済の期限が満期より後のローンは、デプロイする時に断ります。

実装

starter/contracts/contracts/SecuritiesLoan.solを新しく作ります。
まず、円トークンと社債トークンと決済のコントラクトと前のレッスンの価格のコントラクトを読み込み、ローンの条件を並べます。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {JpyToken} from "@handsonchain/jpy-stablecoin-contracts/contracts/JpyToken.sol";
import {BondToken} from "@handsonchain/digital-bond-contracts/contracts/BondToken.sol";
import {BondSettlement} from "@handsonchain/digital-bond-contracts/contracts/BondSettlement.sol";
import {CollateralPrice} from "./CollateralPrice.sol";

/// @title 証券担保ローン
/// @notice 借り手が社債トークンを担保に預け、評価額に掛け目を掛けた枠まで、貸し手の入れた円トークンを1回だけ借りる。
///         額は全て円で数え、円トークンを送る時に18桁の最小単位へ直す
contract SecuritiesLoan {
    /// @notice 円トークンの1円 (18桁)
    uint256 public constant YEN = 1e18;
    /// @notice 掛け目。担保の評価額のうち借りられる割合 (80%)
    uint256 public constant LTV_BPS = 8_000;

    JpyToken public immutable jpy;
    BondToken public immutable bond;
    /// @notice 担保の社債の決済のコントラクト。担保の利金を受け取る時に使う
    BondSettlement public immutable settlement;
    /// @notice 評価会社が社債1口の価格を入れるコントラクト
    CollateralPrice public immutable priceFeed;
    /// @notice 円を入れる貸し手の銀行
    address public immutable lender;
    /// @notice 年の金利 (1万分率。200で年2.00%)
    uint256 public immutable rateBps;
    /// @notice 返済の期限。担保の社債の満期より前に置く
    uint64 public immutable dueDate;
行 意味
YEN 円トークンは18桁を持つ。
ローンは額を円の整数で数え、円トークンを送る時にYENを掛ける
LTV_BPS 掛け目を1万分の1を単位にした整数で持つ。
8,000で80%になる
jpyとbond 借りる円の円トークンと、担保に預ける社債トークン
settlement 2作目の決済のコントラクト。
担保の社債の利金を受け取るレッスンで使う
priceFeed 前のレッスンで作った価格のコントラクト。
担保の評価額を出すのに読む
lender 円を入れられる貸し手の銀行のアカウント
rateBps 年の金利。
利息は価格と担保維持率の節で数える
dueDate 返済の期限のUnix時刻。
この時刻からは新しく借りられない

続けて、借り手ごとの担保と借入の形と貸し手の円の帳簿、イベントとエラーを並べます。

    /// @notice 借り手ごとの担保と借入
    struct Position {
        // 預けた社債の口数
        uint256 units;
        // 借りている元本 (円)
        uint256 principal;
        // 1回借りたか。借りられるのは1回だけ
        bool borrowed;
    }

    mapping(address borrower => Position) private _positions;
    mapping(address borrower => bool) private _listed;
    address[] private _borrowers;

    /// @notice 貸し手が入れた円の合計
    uint256 public funded;
    /// @notice 貸した元本の合計
    uint256 public lent;

    event Funded(uint256 amount);
    event Pledged(address indexed borrower, uint256 units);
    event Borrowed(address indexed borrower, uint256 amount);

    error DueDateAfterMaturity(uint64 dueDate, uint64 maturity);
    error OnlyLender();
    error NotAllowed(address account);
    error ZeroAmount();
    error AlreadyBorrowed();
    error PastDueDate(uint64 dueDate);
    error OverBorrowLimit(uint256 amount, uint256 limit);
    error OverLenderCash(uint256 amount, uint256 cash);
行 意味
Position 借り手1人の担保と借入。
後のレッスンで、利息と追加担保の請求の値を足していく
borrowed 1回借りたかの印。
返し終えて元本が0になってもtrueのままにし、2回目の借入を断る
_listedと_borrowers 担保を預けたことのある借り手の一覧。
貸し手の画面が借り手を並べるのに使う
fundedとlent 貸し手が入れた円の合計と、貸した元本の合計。
差が今貸せる円になる
OverBorrowLimit 借入枠を超える額を借りようとした。
借りようとした額と枠を残す
OverLenderCash 貸し手の円の残りを超える額を借りようとした

constructorでは、返済の期限を担保の社債の満期と比べます。

    constructor(
        JpyToken jpy_,
        BondToken bond_,
        BondSettlement settlement_,
        CollateralPrice priceFeed_,
        address lender_,
        uint256 rateBps_,
        uint64 dueDate_
    ) {
        // 担保の社債が満期で消える前に返してもらう
        if (dueDate_ >= bond_.maturity()) revert DueDateAfterMaturity(dueDate_, bond_.maturity());
        jpy = jpy_;
        bond = bond_;
        settlement = settlement_;
        priceFeed = priceFeed_;
        lender = lender_;
        rateBps = rateBps_;
        dueDate = dueDate_;
    }
行 意味
dueDate_ >= bond_.maturity() 返済の期限が満期の日か、その後の時に断る。
社債トークンが持つ満期を読んで比べる
jpy = jpy_からdueDate = dueDate_ 渡した値をimmutableに書く。
デプロイした後は貸し手も書き換えられない

次に、貸し手が円を入れる関数と、今貸せる円を読む関数を足します。

    // 貸し手

    /// @notice 貸し手の銀行が、借り手へ貸す円を入れておく
    function fund(uint256 amount) external {
        if (msg.sender != lender) revert OnlyLender();
        if (amount == 0) revert ZeroAmount();
        funded += amount;
        jpy.transferFrom(msg.sender, address(this), amount * YEN);
        emit Funded(amount);
    }

    /// @notice 今貸せる円。入れた円から貸した元本を引く
    function cash() public view returns (uint256) {
        return funded - lent;
    }
行 意味
msg.sender != lender 貸し手の銀行のほかは、円を入れられない
jpy.transferFrom(...) 貸し手が先にapproveで任せた円を、ローンのコントラクトへ移す。
額はYENを掛けて18桁の単位にする
funded - lent 入れた円から、貸した元本を引いた額。
このレッスンではまだ返済がないので、この2つだけで数える

返された額と、担保の処分で受け取った額は、後のレッスンでcashに足します。

続けて、担保を預ける関数と借りる関数を足します。

    // 担保と借入

    /// @notice 借り手が社債を担保に預ける。円トークンの許可リストにない人と凍結された人は預けられない
    function pledge(uint256 units) external {
        if (!jpy.isAllowed(msg.sender) || jpy.isFrozen(msg.sender)) revert NotAllowed(msg.sender);
        if (units == 0) revert ZeroAmount();
        if (!_listed[msg.sender]) {
            _listed[msg.sender] = true;
            _borrowers.push(msg.sender);
        }
        Position storage p = _positions[msg.sender];
        p.units += units;
        bond.transferFrom(msg.sender, address(this), units);
        emit Pledged(msg.sender, units);
    }

    /// @notice 担保の評価額に掛け目を掛けた枠の中で、1回だけ借りる
    function borrow(uint256 amount) external {
        if (amount == 0) revert ZeroAmount();
        Position storage p = _positions[msg.sender];
        if (p.borrowed) revert AlreadyBorrowed();
        if (block.timestamp >= dueDate) revert PastDueDate(dueDate);
        uint256 limit = borrowLimit(msg.sender);
        if (amount > limit) revert OverBorrowLimit(amount, limit);
        uint256 available = cash();
        if (amount > available) revert OverLenderCash(amount, available);
        p.borrowed = true;
        p.principal = amount;
        lent += amount;
        jpy.transfer(msg.sender, amount * YEN);
        emit Borrowed(msg.sender, amount);
    }
行 意味
jpy.isAllowed(msg.sender) 1作目の円トークンの許可リストを読む。
載っていない人と凍結された人をNotAllowedで断る
_borrowers.push(msg.sender) 初めて預けた借り手だけを一覧に足す。
2回目からは_listedで見分けて足さない
p.units += units 預けた口数を足す。
借りた後に預け足すこともできる
bond.transferFrom(...) 借り手が先にapproveで任せた社債を、ローンのコントラクトへ移す。
社債は1口を1トークンで数えるので、YENを掛けない
if (p.borrowed) revert AlreadyBorrowed() 2回目の借入を断る
block.timestamp >= dueDate 返済の期限からは借りられない
amount > limit 借入枠を超える額を断る
amount > available 貸し手の円の残りを超える額を断る
p.borrowed = trueとlent += amount 円を送る前に、借りた印と帳簿を書く
jpy.transfer(msg.sender, amount * YEN) 借りた額の円トークンを借り手へ送る

borrowは、断る条件を次の順に調べます。

借りられるかを順に確かめる
借りた過ぎた超える超える始まり終わりborrowを呼ぶもう借りた?返済の期限を過ぎた?借入枠を超える?貸せる残りを超える?円を借り手へ送る断る112233445566まだまだまだ前前前収まる収まる収まる収まる

最後に、担保の評価額と借入枠と借り手ごとの値を読む関数を足して、コントラクトを閉じます。

    /// @notice 担保の評価額 (円)。預けた口数に最新の価格を掛ける
    function collateralValue(address borrower) public view returns (uint256) {
        return _positions[borrower].units * priceFeed.currentPrice();
    }

    /// @notice 借入枠 (円)。担保の評価額に掛け目80%を掛ける
    function borrowLimit(address borrower) public view returns (uint256) {
        return (collateralValue(borrower) * LTV_BPS) / 10_000;
    }

    function positionOf(address borrower) external view returns (Position memory) {
        return _positions[borrower];
    }

    /// @notice 担保を預けたことのある借り手の一覧
    function borrowers() external view returns (address[] memory) {
        return _borrowers;
    }
}
行 意味
priceFeed.currentPrice() 評価会社が入れた最新の価格を読む。
まだ価格がない時はNoPriceで断るので、価格のない担保で借りることはない
* LTV_BPS) / 10_000 掛け目の80%を掛ける。
先に掛けてから割り、1円未満を切り捨てる
positionOf 借り手1人の口数と元本と借りた印をまとめて返す。
画面が読む
borrowers 担保を預けたことのある借り手の一覧を返す

次に、starter/contracts/test/SecuritiesLoan.t.solを新しく作り、テストの土台を書きます。
SecuritiesLoanBaseは、この後のレッスンのテストも使う共通の準備です。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {Test} from "forge-std/Test.sol";

import {JpyToken} from "@handsonchain/jpy-stablecoin-contracts/contracts/JpyToken.sol";
import {BondToken} from "@handsonchain/digital-bond-contracts/contracts/BondToken.sol";
import {BondSettlement} from "@handsonchain/digital-bond-contracts/contracts/BondSettlement.sol";
import {CollateralPrice} from "../contracts/CollateralPrice.sol";
import {SecuritiesLoan} from "../contracts/SecuritiesLoan.sol";

// 2作目の社債を発行して借り手3人へ10口ずつ渡し、ローンを置く。日付は日本時間の0時
contract SecuritiesLoanBase is Test {
    uint256 internal constant YEN = 1e18;
    uint64 internal constant START = 1767193200; // 2026-01-01
    uint64 internal constant DEADLINE = 1768316400; // 2026-01-14
    uint64 internal constant ISSUE_DATE = 1768402800; // 2026-01-15
    uint64 internal constant RECORD_1 = 1783609200; // 2026-07-10
    uint64 internal constant PAY_1 = 1784041200; // 2026-07-15
    uint64 internal constant RECORD_2 = 1799506800; // 2027-01-10
    uint64 internal constant MATURITY = 1799938800; // 2027-01-15
    uint64 internal constant DUE_DATE = 1797260400; // 2026-12-15
    uint256 internal constant RATE_BPS = 200;
    uint256 internal constant FUNDED = 1_000_000;
    uint256 internal constant PRICE = 100_000;

    JpyToken internal jpy;
    BondToken internal bond;
    BondSettlement internal settlement;
    CollateralPrice internal price;
    SecuritiesLoan internal loan;

    address internal issuer = makeAddr("issuer");
    address internal lender = makeAddr("lender");
    address internal valuer = makeAddr("valuer");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    address internal carol = makeAddr("carol");
    address internal stranger = makeAddr("stranger");
コード 意味
STARTからMATURITY 2作目の社債の日程と同じ日付。
日本時間の0時のUnix時刻
DUE_DATE 返済の期限の2026-12-15。
満期の2027-01-15より前に置く
RATE_BPS 年の金利2.00%
FUNDED 貸し手がローンのコントラクトへ入れる1,000,000円
PRICE 評価会社が入れる社債1口の価格100,000円
issuer 円トークンと社債の発行体。
価格のコントラクトの管理の役割も持たせる
stranger 許可リストに載せないアカウント。
預け入れを断られる人として使う

同じファイルの続きに、土台のsetUpと手助けの関数を書きます。

    function setUp() public virtual {
        vm.warp(START);
        uint64[] memory payments = new uint64[](2);
        payments[0] = PAY_1;
        payments[1] = MATURITY;
        uint64[] memory records = new uint64[](2);
        records[0] = RECORD_1;
        records[1] = RECORD_2;
        jpy = new JpyToken(issuer);
        bond = new BondToken(jpy, issuer, 100_000, 80, ISSUE_DATE, payments, records);
        settlement = new BondSettlement(jpy, bond, issuer, 30, DEADLINE);
        price = new CollateralPrice(issuer, valuer);
        loan = new SecuritiesLoan(jpy, bond, settlement, price, lender, RATE_BPS, DUE_DATE);

        vm.startPrank(issuer);
        bond.grantRole(bond.SETTLEMENT_ROLE(), address(settlement));
        address[7] memory allowed = [address(settlement), address(loan), issuer, lender, alice, bob, carol];
        for (uint256 i = 0; i < allowed.length; i++) jpy.setAllowed(allowed[i], true);
        jpy.issue(issuer, 1_000_000 * YEN, keccak256("issuer"));
        jpy.issue(lender, 10_000_000 * YEN, keccak256("lender"));
        jpy.issue(alice, 2_000_000 * YEN, keccak256("alice"));
        jpy.issue(bob, 2_000_000 * YEN, keccak256("bob"));
        jpy.issue(carol, 2_000_000 * YEN, keccak256("carol"));
        vm.stopPrank();

        // 2作目の手順で社債を発行し、借り手3人が10口ずつ持つ
        address[3] memory holders = [alice, bob, carol];
        for (uint256 i = 0; i < holders.length; i++) {
            vm.startPrank(holders[i]);
            jpy.approve(address(settlement), 10 * 100_000 * YEN);
            settlement.subscribe(10);
            bond.approve(address(loan), type(uint256).max);
            jpy.approve(address(loan), type(uint256).max);
            vm.stopPrank();
        }
        vm.warp(ISSUE_DATE);
        settlement.close();

        // 貸し手が円を入れ、評価会社が1口100,000円の価格を入れる
        vm.startPrank(lender);
        jpy.approve(address(loan), type(uint256).max);
        loan.fund(FUNDED);
        vm.stopPrank();
        _setPrice(PRICE);
    }

    function _setPrice(uint256 price_) internal {
        vm.prank(valuer);
        price.setPrice(price_);
    }

    function _pledgeAndBorrow(address borrower, uint256 units, uint256 amount) internal {
        vm.startPrank(borrower);
        loan.pledge(units);
        loan.borrow(amount);
        vm.stopPrank();
    }
}
コード 意味
new BondToken(jpy, issuer, 100_000, 80, ...) 2作目の完成版の社債を、額面100,000円、年0.80%の条件でテストの中にデプロイする
new BondSettlement(jpy, bond, issuer, 30, DEADLINE) 発行額30口、締め切り2026-01-14の決済のコントラクトを置く
new SecuritiesLoan(...) 円トークンと社債と決済と価格を渡し、返済の期限を2026-12-15にしたローンを置く
jpy.setAllowed(...) 決済のコントラクトとローンのコントラクトと、発行体と貸し手と借り手3人を許可リストに載せる。
strangerは載せない
jpy.issue(lender, 10_000_000 * YEN, ...) 貸し手の銀行に1,000万円を渡す
settlement.subscribe(10) 借り手3人が10口ずつ申し込み、30口の発行額に届かせる
bond.approve(address(loan), ...)とjpy.approve(address(loan), ...) 借り手が担保の社債と返す円を、ローンのコントラクトに任せておく
vm.warp(ISSUE_DATE)とsettlement.close() 払込日へ進めて募集を締め、3人へ社債を10口ずつ発行する
loan.fund(FUNDED) 貸し手が1,000,000円をローンのコントラクトへ入れる
_pledgeAndBorrow 借り手のアカウントで、預けてから借りるまでを続けて行う手助けの関数

続けて、テストの本体を書きます。

contract SecuritiesLoanTest is SecuritiesLoanBase {
    function test_BorrowUpToEightyPercent() public {
        uint256 before = jpy.balanceOf(alice);
        // 10口 × 100,000円 = 1,000,000円の担保で、掛け目80%の800,000円まで借りられる
        vm.prank(alice);
        loan.pledge(10);
        assertEq(loan.borrowLimit(alice), 800_000);
        vm.prank(alice);
        loan.borrow(800_000);
        assertEq(jpy.balanceOf(alice) - before, 800_000 * YEN);
        assertEq(bond.balanceOf(address(loan)), 10);
        assertEq(loan.positionOf(alice).principal, 800_000);
        assertEq(loan.lent(), 800_000);
    }

    function test_RevertWhen_BorrowOverEightyPercent() public {
        vm.startPrank(alice);
        loan.pledge(10);
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.OverBorrowLimit.selector, 800_001, 800_000));
        loan.borrow(800_001);
        vm.stopPrank();
        assertEq(loan.positionOf(alice).principal, 0);
    }

    function test_RevertWhen_BorrowTwice() public {
        _pledgeAndBorrow(alice, 10, 300_000);
        vm.expectRevert(SecuritiesLoan.AlreadyBorrowed.selector);
        vm.prank(alice);
        loan.borrow(100_000);
        assertEq(loan.positionOf(alice).principal, 300_000);
    }

    function test_RevertWhen_DepositNotAllowed() public {
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.NotAllowed.selector, stranger));
        vm.prank(stranger);
        loan.pledge(1);
        // 凍結された借り手も預けられない
        vm.prank(issuer);
        jpy.setFrozen(alice, true);
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.NotAllowed.selector, alice));
        vm.prank(alice);
        loan.pledge(10);
        assertEq(bond.balanceOf(address(loan)), 0);
    }

    function test_RevertWhen_BorrowOverLenderCash() public {
        // 貸し手が入れた1,000,000円のうち800,000円を貸すと、残りは200,000円
        _pledgeAndBorrow(alice, 10, 800_000);
        vm.startPrank(bob);
        loan.pledge(10);
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.OverLenderCash.selector, 800_000, 200_000));
        loan.borrow(800_000);
        vm.stopPrank();
        assertEq(loan.cash(), 200_000);
    }

    function test_RevertWhen_DueDateAfterMaturity() public {
        vm.expectRevert(abi.encodeWithSelector(SecuritiesLoan.DueDateAfterMaturity.selector, MATURITY, MATURITY));
        new SecuritiesLoan(jpy, bond, settlement, price, lender, RATE_BPS, MATURITY);
        // 満期の1日前なら置ける
        SecuritiesLoan early = new SecuritiesLoan(jpy, bond, settlement, price, lender, RATE_BPS, MATURITY - 1 days);
        assertEq(early.dueDate(), MATURITY - 1 days);
    }
}
テスト 確かめること
test_BorrowUpToEightyPercent 10口を預けると借入枠が800,000円になり、800,000円を借りると円が借り手へ届き、社債がローンのコントラクトに移る
test_RevertWhen_BorrowOverEightyPercent 枠より1円多い800,001円はOverBorrowLimitで断られ、元本は0円のまま
test_RevertWhen_BorrowTwice 300,000円を借りた後の2回目は、枠が残っていてもAlreadyBorrowedで断られる
test_RevertWhen_DepositNotAllowed 許可リストにないstrangerと、凍結されたaliceの預け入れがNotAllowedで断られる
test_RevertWhen_BorrowOverLenderCash 貸し手の残りが200,000円の時に、bobの800,000円が枠の中でもOverLenderCashで断られる
test_RevertWhen_DueDateAfterMaturity 返済の期限を満期の日にしたローンはデプロイを断られ、満期の1日前なら置ける

確かめる

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

forge test --match-contract SecuritiesLoanTest

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

[PASS] test_BorrowUpToEightyPercent()
[PASS] test_RevertWhen_BorrowOverEightyPercent()
[PASS] test_RevertWhen_BorrowOverLenderCash()
[PASS] test_RevertWhen_BorrowTwice()
[PASS] test_RevertWhen_DepositNotAllowed()
[PASS] test_RevertWhen_DueDateAfterMaturity()
Suite result: ok. 6 passed; 0 failed; 0 skipped

借入枠の決まりが効いていることも確かめます。
borrowの中の次の行を消して、テストを実行します。

        if (amount > limit) revert OverBorrowLimit(amount, limit);

test_RevertWhen_BorrowOverEightyPercentが失敗し、次の行が出ます。

[FAIL: next call did not revert as expected] test_RevertWhen_BorrowOverEightyPercent()

枠を超えた800,001円が断られずに貸されたことを示します。
この形のままだと、担保の評価額の全てか、それ以上を借りられてしまいます。
そうなると、価格が少し下がっただけで担保を売っても貸したお金に足りなくなります。
確かめたら、消した行を戻しておきます。