⛳
Solidity基礎学習10日目(require, assert)

2025/09/02に公開
 Solidity基礎学習 - 例外処理とアサーションの実践的理解日付: 2025年8月31日

学習内容: Solidityの例外処理（require）とアサーション（assert）による安全なスマートコントラクトの実装について

 1. 例外処理の重要性
 017_ExceptionRequire.solの概要Solidityにおける適切な例外処理の実装方法について学習します。require文を使用することで、ユーザーに適切なフィードバックを提供し、安全なコントラクトの動作を保証します。

 重要なポイント
 コントラクトの基本構造contract SecureWalletSystem {
    mapping(address => uint) public userBalances;

    function depositFunds() public payable {
        userBalances[msg.sender] += msg.value;
    }

    function withdrawFunds(address payable _recipient, uint _amount) public {
        require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");
        userBalances[msg.sender] -= _amount;
        _recipient.transfer(_amount);
    }
}
コントラクトの特徴：

安全な出金処理: require文による残高チェック

ユーザーフィードバック: 明確なエラーメッセージの提供

トランザクション制御: 条件不満足時の適切な処理停止

ETH管理: 入金・出金の安全な処理

 2. 各機能の詳細分析
 2.1 入金機能（depositFunds）
 実装コードfunction depositFunds() public payable {
    userBalances[msg.sender] += msg.value;
}
機能の説明：

public payable: 外部からETHを受け取ることができる関数

残高更新: userBalances[msg.sender]に送金金額を加算

シンプルな処理: 入金時の特別な制限なし
使用例：
// 外部からETHを送金
contract.depositFunds{value: 1 ether}();

// 送金者のアドレスと送金額
// msg.sender: 送金者のアドレス
// msg.value: 送金されたETHの量（wei単位）

 2.2 出金機能（withdrawFunds）
 実装コードfunction withdrawFunds(address payable _recipient, uint _amount) public {
    require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");
    userBalances[msg.sender] -= _amount;
    _recipient.transfer(_amount);
}
機能の説明：

残高チェック: require文による出金額の検証

安全な出金: 残高不足時の処理停止

エラーメッセージ: ユーザーへの明確なフィードバック

ETH送金: 指定されたアドレスへの安全な送金
require文の動作：
require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");

条件がtrue: 処理を続行

条件がfalse: トランザクションをrevert、エラーメッセージを表示

 3. 例外処理の実装パターン
 3.1 従来のif文による実装の問題点
 問題のある実装function withdrawMoney(address payable _to, uint _amount) public {
    if(_amount <= userBalances[msg.sender]){
        userBalances[msg.sender] -= _amount;
        _to.transfer(_amount);
    }
    // 残高不足の場合、何も起こらない
}
問題点：

ユーザーフィードバックなし: 残高不足時に何が起こったか不明

トランザクション成功: 内部的には何も起こらないが、トランザクションは成功

デバッグ困難: 問題の原因を特定しにくい

ユーザー体験: 期待した動作と実際の動作の不一致

 3.2 require文による改善された実装
 改善された実装function withdrawFunds(address payable _recipient, uint _amount) public {
    require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");
    userBalances[msg.sender] -= _amount;
    _recipient.transfer(_amount);
}
改善点：

明確なエラーメッセージ: 問題の原因を明確に表示

トランザクション制御: 条件不満足時の適切な処理停止

デバッグ容易: エラーの原因が明確

ユーザー体験向上: 期待した動作と実際の動作の一致

 4. アサーション（assert）の活用
 018_Assert.solの概要Solidityのassert文を使用した、内部ロジックの整合性チェックについて学習します。型変換とオーバーフロー防止の実装パターンを理解します。

 重要なポイント
 コントラクトの基本構造contract TypeSafeWallet {
    mapping(address => uint8) public userBalances;

    function depositFunds() public payable {
        assert(msg.value == uint8(msg.value));
        userBalances[msg.sender] += uint8(msg.value);
    }

    function withdrawFunds(address payable _recipient, uint8 _amount) public {
        require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");
        userBalances[msg.sender] -= _amount;
        _recipient.transfer(_amount);
    }
}
コントラクトの特徴：

型安全性: uint8による範囲制限

オーバーフロー防止: assert文による型変換チェック

安全な入金: 256 wei以上の送金を防止

適切な例外処理: requireとassertの組み合わせ

 5. 各機能の詳細分析
 5.1 型安全な入金機能（depositFunds）
 実装コードfunction depositFunds() public payable {
    assert(msg.value == uint8(msg.value));
    userBalances[msg.sender] += uint8(msg.value);
}
機能の説明：

型変換チェック: assert文によるuint8範囲内の確認

オーバーフロー防止: 256 wei以上の送金を防止

型変換: uint8(msg.value)による範囲制限

安全な残高更新: 制限された範囲内での残高加算
assert文の動作：
assert(msg.value == uint8(msg.value));

条件がtrue: 処理を続行（0-255 weiの範囲）

条件がfalse: トランザクションをrevert（256+ weiの場合）

 5.2 型変換の詳細
 uint8の範囲制限// uint8の範囲: 0 ～ 255 (2^8 - 1)
uint8(100)   = 100   // 範囲内
uint8(200)   = 200   // 範囲内
uint8(255)   = 255   // 範囲内
uint8(256)   = 0     // オーバーフロー（256 % 256 = 0）
uint8(300)   = 44    // オーバーフロー（300 % 256 = 44）
uint8(400)   = 144   // オーバーフロー（400 % 256 = 144）
オーバーフローの例：
msg.value = 300 wei
uint8(msg.value) = 300 % 256 = 44 wei
assert(300 == 44);  // false → トランザクションrevert

 5.3 安全な出金機能（withdrawFunds）
 実装コードfunction withdrawFunds(address payable _recipient, uint8 _amount) public {
    require(_amount <= userBalances[msg.sender], "Insufficient balance, transaction aborted!");
    userBalances[msg.sender] -= _amount;
    _recipient.transfer(_amount);
}
機能の説明：

残高チェック: require文による出金額の検証

型制限: uint8型による出金額の範囲制限

安全な出金: 残高不足時の処理停止

ETH送金: 指定されたアドレスへの安全な送金

 6. requireとassertの使い分け
 6.1 require文の使用場面
 入力検証とユーザー制御可能な条件function withdrawFunds(address payable _recipient, uint _amount) public {
    // ユーザーが制御できる条件のチェック
    require(_amount > 0, "Amount must be greater than 0");
    require(_recipient != address(0), "Invalid recipient address");
    require(_amount <= userBalances[msg.sender], "Insufficient balance");
    
    // 処理の実行
    userBalances[msg.sender] -= _amount;
    _recipient.transfer(_amount);
}
require文の特徴：

用途: 外部入力やユーザー入力の検証

ガス: エラー時にガスを返還

エラーメッセージ: カスタムメッセージの設定可能

使用場面: ユーザーが制御できる条件のチェック

 6.2 assert文の使用場面
 内部ロジックと絶対に起こるはずがない条件function depositFunds() public payable {
    // 内部ロジックの整合性チェック
    assert(msg.value == uint8(msg.value));
    
    // 型変換後の値が正しいことを確認
    uint8 convertedValue = uint8(msg.value);
    assert(convertedValue <= 255);
    
    // 処理の実行
    userBalances[msg.sender] += convertedValue;
}
assert文の特徴：

用途: プログラムの内部ロジックエラーの検出

ガス: エラー時に全ガスを消費

エラーメッセージ: カスタムメッセージなし

使用場面: 絶対に起こるはずがない条件のチェック

 7. 実装のポイント
 7.1 セキュリティ設計
 基本的なセキュリティ考慮事項function secureWithdraw(address payable _recipient, uint _amount) public {
    // 入力値の検証
    require(_amount > 0, "Amount must be greater than 0");
    require(_recipient != address(0), "Invalid recipient address");
    require(_recipient != msg.sender, "Cannot withdraw to self");
    
    // ビジネスロジックの検証
    require(_amount <= userBalances[msg.sender], "Insufficient balance");
    require(userBalances[msg.sender] > 0, "No balance to withdraw");
    
    // 状態の更新
    userBalances[msg.sender] -= _amount;
    
    // 外部呼び出し（最後に実行）
    _recipient.transfer(_amount);
}
セキュリティの考慮点：

入力検証: 不正な値の検出と拒否

ビジネスロジック: ビジネスルールの適用

状態更新: 先に状態を更新してから外部呼び出し

エラーハンドリング: 適切なエラーメッセージの提供

 7.2 ガスコストの最適化
 効率的な実装// 読み取り専用関数はview修飾子を使用
function getBalance() public view returns(uint) {
    return userBalances[msg.sender];
}

// 状態変更は必要最小限に
function depositFunds() public payable {
    require(msg.value > 0, "Amount must be greater than 0");
    userBalances[msg.sender] += msg.value;
}
最適化のポイント：

view修飾子: 状態変更しない関数でのガス節約

効率的な状態更新: 必要最小限の処理のみ実行

適切な関数設計: 各機能を適切に分離

 8. 実用的な応用
 8.1 拡張可能な機能
 権限管理の追加contract SecureWalletWithAuth {
    mapping(address => bool) public authorizedUsers;
    address public owner;
    
    constructor() {
        owner = msg.sender;
        authorizedUsers[msg.sender] = true;
    }
    
    modifier onlyAuthorized() {
        require(authorizedUsers[msg.sender], "Not authorized");
        _;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }
    
    function withdrawFunds(address payable _recipient, uint _amount) public onlyAuthorized {
        require(_amount <= userBalances[msg.sender], "Insufficient balance");
        userBalances[msg.sender] -= _amount;
        _recipient.transfer(_amount);
    }
    
    function addAuthorizedUser(address _user) public onlyOwner {
        authorizedUsers[_user] = true;
    }
}
拡張機能：

権限管理: 承認されたユーザーのみが利用可能

所有者制御: 管理者によるユーザー管理

セキュリティ強化: 未承認ユーザーからの操作を拒否

 8.2 より柔軟な例外処理
 カスタムエラーの実装contract WalletWithCustomErrors {
    error InsufficientBalance(uint requested, uint available);
    error InvalidAmount(uint amount);
    error InvalidRecipient(address recipient);
    
    mapping(address => uint) public userBalances;
    
    function withdrawFunds(address payable _recipient, uint _amount) public {
        if (_amount == 0) revert InvalidAmount(_amount);
        if (_recipient == address(0)) revert InvalidRecipient(_recipient);
        if (_amount > userBalances[msg.sender]) {
            revert InsufficientBalance(_amount, userBalances[msg.sender]);
        }
        
        userBalances[msg.sender] -= _amount;
        _recipient.transfer(_amount);
    }
}
カスタムエラーの利点：

ガス効率: requireよりもガスコストが安い

詳細情報: エラーの詳細な情報を提供

デバッグ容易: 問題の原因を明確に特定

 8.3 型安全性の向上
 範囲制限付きの入金システムcontract TypeSafeWalletAdvanced {
    struct DepositLimit {
        uint8 minAmount;
        uint8 maxAmount;
        bool isActive;
    }
    
    mapping(address => uint8) public userBalances;
    DepositLimit public depositLimits;
    
    constructor() {
        depositLimits = DepositLimit(1, 100, true);
    }
    
    function depositFunds() public payable {
        require(depositLimits.isActive, "Deposits are currently disabled");
        require(msg.value >= depositLimits.minAmount, "Amount too small");
        require(msg.value <= depositLimits.maxAmount, "Amount too large");
        
        // 型変換の安全性チェック
        assert(msg.value == uint8(msg.value));
        
        userBalances[msg.sender] += uint8(msg.value);
    }
}
型安全性の特徴：

範囲制限: 最小・最大入金額の設定

動的制御: 入金機能の有効/無効切り替え

型変換チェック: オーバーフローの防止

 9. 学習の成果
 9.1 習得した概念
例外処理の重要性: 適切なエラーハンドリングの実装

require文の活用: ユーザー入力の検証とフィードバック

assert文の活用: 内部ロジックの整合性チェック

型安全性: オーバーフローとアンダーフローの防止

ユーザー体験: 明確なエラーメッセージの提供

セキュリティ: 安全なスマートコントラクトの設計

ガス最適化: 効率的な例外処理の実装

 9.2 実装スキル
適切な例外処理の実装能力

require文を使用した入力検証

assert文を使用した内部ロジックチェック

型安全性を考慮したコントラクト設計

セキュリティを考慮したETH操作

ユーザーフレンドリーなエラーハンドリング

 9.3 技術的な理解
require修飾子: 条件チェックとエラーメッセージの提供

assert修飾子: 内部ロジックの整合性チェック

型変換: uintからuint8への安全な変換

オーバーフロー: 型の範囲を超えた値の処理

ガス消費: 例外処理におけるガスコストの違い

トランザクション制御: 条件不満足時の適切な処理停止

 10. 今後の学習への応用
 10.1 発展的な機能
カスタムエラー: より詳細なエラー情報の提供

イベントログ: 重要な操作のログ記録と監視

権限管理: 管理者機能とユーザー権限の制御

手数料システム: 取引手数料の自動計算と徴収

 10.2 セキュリティの向上
リエントランシー攻撃: 再入攻撃への包括的な対策

オーバーフロー/アンダーフロー: 数値計算の安全性確保

アクセス制御: 適切な権限管理の実装

入力検証: 不正なパラメータの検出と拒否

 10.3 パフォーマンスの最適化
ガスコスト: 効率的な例外処理とエラーハンドリング

メモリ管理: 適切なデータ型とストレージ戦略

スケーラビリティ: 大量のトランザクションの効率的な処理

検索最適化: 高速なデータ検索とフィルタリング

 11. 実践的な応用例
 11.1 高度なウォレットシステムcontract AdvancedSecureWallet {
    struct Transaction {
        uint amount;
        uint timestamp;
        string description;
        TransactionStatus status;
    }
    
    enum TransactionStatus { Pending, Completed, Failed, Cancelled }
    
    struct UserProfile {
        uint totalBalance;
        uint transactionCount;
        mapping(uint => Transaction) transactions;
        bool isActive;
        uint dailyLimit;
        uint dailySpent;
        uint lastResetTime;
    }
    
    mapping(address => UserProfile) public users;
    
    function createTransaction(
        uint _amount,
        string memory _description
    ) public returns(uint) {
        require(users[msg.sender].isActive, "Account is not active");
        require(_amount > 0, "Amount must be greater than 0");
        require(_amount <= users[msg.sender].dailyLimit, "Exceeds daily limit");
        
        // 日次制限のチェック
        if (block.timestamp - users[msg.sender].lastResetTime >= 1 days) {
            users[msg.sender].dailySpent = 0;
            users[msg.sender].lastResetTime = block.timestamp;
        }
        
        require(users[msg.sender].dailySpent + _amount <= users[msg.sender].dailyLimit, "Exceeds daily limit");
        
        // トランザクションの作成
        uint transactionId = users[msg.sender].transactionCount;
        users[msg.sender].transactions[transactionId] = Transaction(
            _amount,
            block.timestamp,
            _description,
            TransactionStatus.Pending
        );
        
        users[msg.sender].transactionCount++;
        users[msg.sender].dailySpent += _amount;
        
        return transactionId;
    }
}

 11.2 取引制限システムcontract TransactionLimiter {
    struct LimitConfig {
        uint8 maxTransactionAmount;
        uint8 maxDailyTransactions;
        uint8 maxDailyVolume;
        bool isActive;
    }
    
    mapping(address => LimitConfig) public userLimits;
    mapping(address => uint8) public dailyTransactionCount;
    mapping(address => uint8) public dailyVolume;
    
    function setUserLimits(
        address _user,
        uint8 _maxAmount,
        uint8 _maxTransactions,
        uint8 _maxVolume
    ) public {
        userLimits[_user] = LimitConfig(_maxAmount, _maxTransactions, _maxVolume, true);
    }
    
    function checkTransactionAllowed(
        address _user,
        uint8 _amount
    ) public view returns(bool) {
        LimitConfig storage config = userLimits[_user];
        
        if (!config.isActive) return false;
        if (_amount > config.maxTransactionAmount) return false;
        if (dailyTransactionCount[_user] >= config.maxDailyTransactions) return false;
        if (dailyVolume[_user] + _amount > config.maxDailyVolume) return false;
        
        return true;
    }
}

 11.3 エラーログシステムcontract ErrorLogger {
    struct ErrorLog {
        address user;
        string errorMessage;
        uint timestamp;
        string functionName;
        bytes4 functionSelector;
    }
    
    ErrorLog[] public errorLogs;
    mapping(address => uint[]) public userErrorIndices;
    
    event ErrorLogged(
        address indexed user,
        string errorMessage,
        uint timestamp,
        string functionName
    );
    
    function logError(
        string memory _errorMessage,
        string memory _functionName
    ) public {
        uint logIndex = errorLogs.length;
        
        errorLogs.push(ErrorLog(
            msg.sender,
            _errorMessage,
            block.timestamp,
            _functionName,
            msg.sig
        ));
        
        userErrorIndices[msg.sender].push(logIndex);
        
        emit ErrorLogged(msg.sender, _errorMessage, block.timestamp, _functionName);
    }
    
    function getUserErrors(address _user) public view returns(ErrorLog[] memory) {
        uint[] storage indices = userErrorIndices[_user];
        ErrorLog[] memory userErrors = new ErrorLog[](indices.length);
        
        for (uint i = 0; i < indices.length; i++) {
            userErrors[i] = errorLogs[indices[i]];
        }
        
        return userErrors;
    }
}
参考:
Solidity公式ドキュメント
Ethereum開発者リソース
スマートコントラクトのセキュリティ
例外処理の詳細
require文の使用方法
assert文の使用方法
型変換の詳細
オーバーフローの防止
Discussion

DeIn
ブロックチェーンの素人が、東京大学ブロックチェーンイノベーション寄付講座をきっかけに、DeFi(分散型金融)の新規サービスを立ち上げるための記録。ビットコイン、イーサリウム、Solidity、Typescriptなどを学習しながら、サービスを作っていくので、学習したことを中心に記録していきます。
バッジを贈るとは
Solidity基礎学習 - 例外処理とアサーションの実践的理解