HandsOnChain

締め切りの後に円と社債を交換する

作るもの

このレッスンを終えると、締め切りの後にcloseを呼んで募集を締められます。
申込が発行額の30口に届いていれば、預かった円を発行体へ渡し、投資家へ申し込んだ口数の社債トークンを発行します。
届いていなければ、預かった円を投資家へ返します。
どちらも1つの取引の中で行うため、円と社債の片方だけが動いた状態は残りません。
Hardhat Ignitionの手順には決済のコントラクトを足し、社債を発行する役割を渡して、発行体と投資家に円を足します。

背景

社債の受け渡しと代金の支払いを別々に行うと、片方だけが済んで相手が払わない危険が残ります。
投資家が先に代金を払えば、発行体が社債を渡さないまま代金だけを受け取るかもしれません。
この危険を元本リスクと呼びます。
証券の受け渡しと代金の支払いを同時に行う決済の仕方をDvPと呼び、元本リスクをなくすために使います。

チェーンの上では、1つの取引の中で複数のコントラクトを呼べます。
取引は最後まで通れば全ての変更がチェーンに残り、途中で1つでも拒まれれば全ての変更が元に戻ります。
そのため、円の移転と社債の発行を同じ取引に入れると、片方だけが済んだ状態は起こりえません。
決済を取り持つ仲介を置かなくても、コントラクトのコードがDvPの約束を守ります。

締めの1つの取引で円と社債を入れ替える
チェーンに残る値預かった円3,000,000円0円投資家の社債0口30口発行体closeを呼ぶ決済のコントラクト3,000,000円を預かる円トークンJpyToken社債トークンBondToken投資家A・B・C10口と12口と8口を申し込んだ11223344close()close()transfer(発行体, 3,000,000円)transfer(発行体, 3,000,000円)3,000,000 HJPY3,000,000 HJPYmint(投資家, 口数) を3回mint(投資家, 口数) を3回10口、12口、8口10口、12口、8口全てが通ったら確定する

このコースでは、締めの時に申込が発行額に届いていなければ、募集を不成立にします。
その時は社債を発行せず、預かった円を投資家へそのまま返します。

実装

starter/contracts/contracts/BondSettlement.solに、締めた印とイベントとエラーを足します。

    address[] private _subscribers;
    /// @notice 募集を締めたか
    bool public closed;

    event Subscribed(address indexed investor, uint256 units);
    event Issued(uint256 units);
    event Refunded(uint256 units);

    error NotAllowed(address account);
    error ZeroUnits();
    error OverIssueAmount(uint256 units, uint256 left);
    error AfterDeadline(uint64 deadline);
    error BeforeDeadline(uint64 deadline);
    error AlreadyClosed();
行 意味
closed 募集を締めたかの印。
2回目の締めを拒むのに使う
Issued 届いて社債を発行した時に、発行した口数を残す
Refunded 届かずに円を返した時に、申込の口数を残す
BeforeDeadline 締め切りより前に締めようとした
AlreadyClosed もう締めた募集を、もう一度締めようとした

subscribeの後に、締めの関数と、発行したかを読む関数を足します。

    /// @notice 締め切りの後に募集を締める。発行額に届けば預かった円を発行体へ送って社債を発行し、届かなければ円を返す
    function close() external {
        if (block.timestamp <= deadline) revert BeforeDeadline(deadline);
        if (closed) revert AlreadyClosed();
        closed = true;
        uint256 price = bond.faceValue() * YEN;
        if (totalSubscribed == issueAmount) {
            jpy.transfer(issuer, totalSubscribed * price);
            for (uint256 i = 0; i < _subscribers.length; i++) {
                bond.mint(_subscribers[i], subscribed[_subscribers[i]]);
            }
            emit Issued(totalSubscribed);
        } else {
            for (uint256 i = 0; i < _subscribers.length; i++) {
                jpy.transfer(_subscribers[i], subscribed[_subscribers[i]] * price);
            }
            emit Refunded(totalSubscribed);
        }
    }

    /// @notice 募集を締め、発行額の社債を発行したか
    function issued() public view returns (bool) {
        return closed && totalSubscribed == issueAmount;
    }
行 意味
block.timestamp <= deadline 締め切りの時刻まではBeforeDeadlineで拒む。
申込を受けている間は締めない
if (closed) revert AlreadyClosed() 2回目の締めを拒む。
同じ円を2回送ることも、社債を2回発行することもない
closed = true 円と社債を動かす前に、締めた印を書く
totalSubscribed == issueAmount 申込が発行額に届いたかを見る。
subscribeが発行額を超える申込を拒むため、届いた時はちょうど等しくなる
jpy.transfer(issuer, ...) 預かった円を全て発行体へ送る
bond.mint(...) 申し込んだ投資家へ、申し込んだ口数の社債を発行する。
決済のコントラクトがSETTLEMENT_ROLEを持つので呼べる
jpy.transfer(_subscribers[i], ...) 届かなかった時に、投資家ごとに預かった円を返す
issued() 締めて社債を発行したかを返す。
画面と後のレッスンが読む

closeは誰が呼んでも同じ結果になるため、呼べる人を絞りません。
画面では、次のレッスンで発行体のページにボタンを置きます。

締めで交換するか円を返すか
まだ締めた届かない始まり終わり終わりcloseを呼ぶ締め切りを過ぎた?もう締めた?30口に届いた?円を発行体へ送り、社債を発行する拒む預かった円を投資家へ返す1122334455過ぎた過ぎた過ぎたまだまだまだ届いた

mintは投資家の数だけ順に呼びます。
どれか1つのmintが拒まれると、先に済ませた発行体への円の移転も含めて、closeの取引の全てが元に戻ります。

次に、starter/contracts/test/DigitalBond.t.solの_subscribeの後に、30口を集めて締める_issueBondを足します。

    // alice 10口、bob 12口、carol 8口で30口に届かせ、締め切りの後に締める
    function _issueBond() internal {
        _subscribe(alice, 10);
        _subscribe(bob, 12);
        _subscribe(carol, 8);
        vm.warp(DEADLINE + 1);
        settlement.close();
    }

vm.warpは、テストのチェーンの時刻を変えます。
締め切りの1秒後へ進めてから締めます。

DigitalBondTestの末尾に、締めのテストを3つ足します。

    function test_RevertWhen_CloseBeforeDeadline() public {
        _subscribe(alice, 20);
        _subscribe(bob, 10);
        vm.warp(DEADLINE);
        vm.expectRevert(abi.encodeWithSelector(BondSettlement.BeforeDeadline.selector, DEADLINE));
        settlement.close();
        assertFalse(settlement.closed());
        assertEq(bond.totalSupply(), 0);
    }

    function test_CloseExchangesWhenFilled() public {
        uint256 issuerBefore = jpy.balanceOf(issuer);
        _issueBond();
        assertTrue(settlement.issued());
        assertEq(jpy.balanceOf(issuer), issuerBefore + ISSUE_AMOUNT * FACE * YEN);
        assertEq(jpy.balanceOf(address(settlement)), 0);
        assertEq(bond.balanceOf(alice), 10);
        assertEq(bond.balanceOf(bob), 12);
        assertEq(bond.balanceOf(carol), 8);
        assertEq(bond.totalSupply(), ISSUE_AMOUNT);
    }

    function test_CloseRefundsWhenShort() public {
        uint256 issuerBefore = jpy.balanceOf(issuer);
        _subscribe(alice, 10);
        _subscribe(bob, 12);
        vm.warp(DEADLINE + 1);
        settlement.close();
        assertTrue(settlement.closed());
        assertFalse(settlement.issued());
        assertEq(jpy.balanceOf(alice), 2_000_000 * YEN);
        assertEq(jpy.balanceOf(bob), 2_000_000 * YEN);
        assertEq(jpy.balanceOf(issuer), issuerBefore);
        assertEq(jpy.balanceOf(address(settlement)), 0);
        assertEq(bond.totalSupply(), 0);
    }
テスト 確かめること
test_RevertWhen_CloseBeforeDeadline 締め切りの時刻ちょうどでは締められず、社債も発行されない
test_CloseExchangesWhenFilled 30口に届いた時に、発行体の円が3,000,000円増え、3人が申し込んだ口数の社債を持つ
test_CloseRefundsWhenShort 22口で届かない時に、aliceとbobの円が申込の前の200万円に戻り、社債は発行されない

続けて、ローカルノードへのデプロイの手順に決済のコントラクトを足します。
starter/contracts/ignition/modules/DigitalBond.tsの頭で、役割の名前を作る関数とlocal.jsonを読み込みます。

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
import { keccak256, toHex } from "viem";

import JpyTokenReadyModule from "@handsonchain/jpy-stablecoin-contracts/ignition/modules/JpyTokenReady.js";

import local from "../../local.json" with { type: "json" };

LOCAL_BONDの末尾に、発行額と締め切りを足します。

  recordDates: [1783609200n, 1799506800n], // 2026-07-10、2027-01-10
  issueAmount: 30n,
  deadline: 1768316400n, // 2026-01-14
};

return { jpy, bond };の行を、次のコードに置き換えます。

  const settlement = m.contract("BondSettlement", [
    jpy,
    bond,
    issuer,
    m.getParameter("issueAmount", LOCAL_BOND.issueAmount),
    m.getParameter("deadline", LOCAL_BOND.deadline),
  ]);
  // 社債を発行できるのは決済のコントラクトだけにし、円を預かれるように円トークンの名簿に載せる
  m.call(bond, "grantRole", [keccak256(toHex("SETTLEMENT_ROLE")), settlement]);
  m.call(jpy, "setAllowed", [settlement, true], { id: "allow_settlement" });
  // 発行体は払込金を受け取り、利金を払うので、名簿に載せて利金の分の円を渡す。
  // 投資家には、申し込んだ後に売買でも買えるよう、1作目の100万円に200万円を足す
  const allowIssuer = m.call(jpy, "setAllowed", [issuer, true], { id: "allow_issuer" });
  m.call(jpy, "issue", [issuer, 1_000_000n * 10n ** 18n, keccak256(toHex("bond-issuer"))], { id: "issue_issuer", after: [allowIssuer] });
  local.accounts
    .filter((account) => account.role === "investor")
    .forEach((investor, index) => {
      // 1作目の手順が投資家を名簿に載せた後に渡す
      m.call(jpy, "issue", [investor.address, 2_000_000n * 10n ** 18n, keccak256(toHex(`bond-${investor.address}`))], {
        id: `issue_investor_${index}`,
        after: [JpyTokenReadyModule],
      });
    });
  return { jpy, bond, settlement };
});
コード 意味
m.contract("BondSettlement", [...]) 円トークンと社債と発行体に、発行額と締め切りを添えて決済のコントラクトをデプロイする
keccak256(toHex("SETTLEMENT_ROLE")) SolidityのSETTLEMENT_ROLEと同じ値を、TypeScriptで作る
m.call(bond, "grantRole", ...) 決済のコントラクトに、社債を発行する役割を渡す
{ id: "allow_settlement" } 同じ関数を2回以上呼ぶ時は、Ignitionの記録で見分ける名前を付ける
after: [allowIssuer] 発行体を名簿に載せた後に、発行体へ100万円を発行する。
名簿に載る前の発行は円トークンが拒む
after: [JpyTokenReadyModule] 1作目の手順が投資家を名簿に載せ終えた後に、投資家へ円を発行する
2_000_000n * 10n ** 18n 200万円を18桁の単位にした値。
1作目の手順の100万円と合わせて、投資家は300万円ずつ持つ

最後に、starter/contracts/test/deploy.test.tsで決済のコントラクトも受け取り、役割と名簿を確かめます。

    const { jpy, bond, settlement } = await ignition.deploy(DigitalBondModule);

社債が円トークンの名簿を読むことを確かめる行の後に、次の行を足します。

    // 決済のコントラクトだけが社債を発行できる
    assert.equal((await settlement.read.bond()).toLowerCase(), bond.address.toLowerCase());
    assert.equal(await bond.read.hasRole([await bond.read.SETTLEMENT_ROLE(), settlement.address]), true);
    // 決済のコントラクトが円を預かれるように、円トークンの名簿に載せてある
    assert.equal(await jpy.read.isAllowed([settlement.address]), true);
コード 意味
settlement.read.bond() 決済のコントラクトが、一緒にデプロイした社債を指しているかを読む
bond.read.hasRole([...]) 決済のコントラクトがSETTLEMENT_ROLEを持つかを読む
jpy.read.isAllowed([settlement.address]) 決済のコントラクトが円トークンの名簿に載っているかを読む

確かめる

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

forge test

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

[PASS] test_CloseExchangesWhenFilled()
[PASS] test_CloseRefundsWhenShort()
[PASS] test_RevertWhen_CloseBeforeDeadline()
Suite result: ok. 10 passed; 0 failed; 0 skipped

円と社債が1つの取引で動くことも確かめます。
_issueBondのvm.warp(DEADLINE + 1);の前に次の2行を足し、締めの前にcarolを凍結します。

        vm.prank(issuer);
        jpy.setFrozen(carol, true);

テストを実行すると、test_CloseExchangesWhenFilledがAccountFrozenで失敗します。

[FAIL: AccountFrozen(0xA4d4c1f8a763Ef6a0140D04291eCEef913Ffc272)] test_CloseExchangesWhenFilled()

社債トークンは凍結されたアカウントへの発行を拒むため、carolへのmintでcloseが拒まれます。
その前に済ませた発行体への円の移転と、aliceとbobへの発行も、取引ごと元に戻ります。
確かめたら、足した2行を消しておきます。

次に、Hardhatのテストでデプロイの手順を確かめます。
pnpm run buildは、次のレッスンの画面が読む決済のコントラクトのABIも書き出します。

pnpm run build
pnpm run test:hardhat

次の行が出れば、決済のコントラクトに役割と名簿の席を渡せています。

  DigitalBondModule
    ✔ ignition-deploys-bond-with-jpy

starter/appのpnpm devを起動し直すと、Ignitionが出すデプロイしたアドレスの一覧にDigitalBondModule#BondSettlement - 0x…の行が加わります。
デプロイした直後は、投資家A・B・Cが円を300万円ずつ持ち、発行体が100万円を持ちます。
次のレッスンで、申込と締めをブラウザから行う画面を作ります。