pragma solidity >=0.4.22 <0.7.0;

/// @title 候補者名簿単位でコントラクトを作成する
contract Ballot {

    // 投票者の構造体
    struct Voter {
        uint weight; // 一票の重み。基本は1だが、委任を受けている場合は増加していく。
        bool voted;  // 投票が完了しているか
        address delegate; // 投票を委任しているか
        uint vote;   // 何番の提案に投票したか
    }

    // 投票を受ける提案の構造体
    struct Proposal {
        bytes32 name;   // 提案名
        uint voteCount; // 得票数。Voterのweightが加算されていく
    }

    // この投票の管理者
    address public chairperson;

    // 投票の権利が与えられたアドレスに対して、投票状況をマップで管理する
    mapping(address => Voter) public voters;

    // 提案一覧を配列で管理する
    Proposal[] public proposals;

    // 候補者名簿コントラクトを新規作成する
    // 引数はbytes32[]なので、Remixを仕様する際は、
    // ["0x01","0x02","0x03"]の様に引数を書く
    constructor(bytes32[] memory proposalNames) public {
        chairperson = msg.sender;
        // 管理者に投票権を追加する
        // 一票の価値は1が基本
        voters[chairperson].weight = 1;

        // それぞれの提案を初期化して、proposals配列に追加する
        for (uint i = 0; i < proposalNames.length; i++) {
            proposals.push(Proposal({
                name: proposalNames[i],
                voteCount: 0
            }));
        }
    }

    // アドレスに対して投票権を付与する
    // この関数は管理者のみ実行できる
    function giveRightToVote(address voter) public {
        // 実行者が管理者か確認する
        // requireが失敗した場合は、リバートされて前の状態に戻る
        require(
            msg.sender == chairperson,
            "Only chairperson can give right to vote."
        );
        // 投票済みの場合は無効
        require(
            !voters[voter].voted,
            "The voter already voted."
        );
        // weightは1以上でないと投票できない
        require(voters[voter].weight == 0);
        // 一票の価値を1に設定
        voters[voter].weight = 1;
    }

    // 投票権を委任する
    function delegate(address to) public {
        // 実行者の投票状況の参照を取得する
        Voter storage sender = voters[msg.sender];
        // すでに投票済みの場合は無効
        require(!sender.voted, "You already voted.");

        // 委任先が自分自身の場合は無効
        require(to != msg.sender, "Self-delegation is disallowed.");

        // toで指定された人がさらに委任している場合は、さらにデリゲーションを繰り返して行く。
        // 一般的にこういうループは、非常に長い処理になって多くのgasを消費する可能性があるため危険である。
        // 今回は委任を実行しないが、そうでないと長いループがコントラクトを完全にスタックさせてしまうかもしれない。
        // address(0)は'0x0000000000000000000000000000000000000000'が返る。
        // これは初期化されていないaddressの値
        while (voters[to].delegate != address(0)) {
            to = voters[to].delegate;

            // 無限ループ対策で、自分自身への委任が発生した場合は無効
            require(to != msg.sender, "Found loop in delegation.");
        }

        // senderには参照を受け取っているので `voters[msg.sender].voted`によって、voters中身が変更される
        sender.voted = true;
        sender.delegate = to;

        // 委任先の投票状況の参照を取得する
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {
            // もし委任先がすでに投票済みであれば、
            // 直接投票先にweightを加算する
            proposals[delegate_.vote].voteCount += sender.weight;
        } else {
            // 委任先がまだ投票していない場合は
            // 委任先の一票の重みに加算する
            delegate_.weight += sender.weight;
        }
    }

    // 投票する（委任された票を含めて）
    // proposalには配列のインデックスを受け取る
    function vote(uint proposal) public {
        // 実行者の投票状況を取得する
        Voter storage sender = voters[msg.sender];

        // weightが0であれば、投票権がないので無効
        require(sender.weight != 0, "Has no right to vote");
        // votedがfalseでなければ、投票済みなので無効
        require(!sender.voted, "Already voted.");

        sender.voted = true;
        sender.vote = proposal;

        // もしproposalが配列の範囲外の場合は、
        // コントラクトが失敗し、全ての変更がリバートされる
        proposals[proposal].voteCount += sender.weight;
    }

    /// @dev 勝った提案を取得する
    function winningProposal() public view returns (uint winningProposal_)
    {
        // 勝者の得票数
        uint winningVoteCount = 0;

        // 提案全てを確認する
        for (uint p = 0; p < proposals.length; p++) {
            if (proposals[p].voteCount > winningVoteCount) {
                winningVoteCount = proposals[p].voteCount;
                // この値がリターンされる
                winningProposal_ = p;
            }
        }
    }

    // 勝った提案の名前を返却する
    function winnerName() public view
            returns (bytes32 winnerName_)
    {
        winnerName_ = proposals[winningProposal()].name;
    }
}

pragma solidity >=0.4.22 <0.7.0;

contract SimpleAuction {

    // 受益者
    address payable public beneficiary;
    // 終了までの秒数
    uint public auctionEndTime;

    // オークションの現在の状態
    address public highestBidder;
    uint public highestBid;

    // 過去の入札金額を引き出す
    mapping(address => uint) pendingReturns;

    // オークションが終了したらtrueをセットする
    // 最初はfalseに初期化されている
    bool ended;

    // オークションの進行状況をDappsが把握するためのイベント
    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    // 以下は所謂ナットスペックと呼ばれ、
    // スラッシュ３つで認識される。
    // これは、ユーザがトランザクションの確認を求められた時に表示される。

    /// `_biddingTime`秒で受益者のアドレス`_beneficiary`に利益が発生する
    constructor(
        uint _biddingTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        // nowで現在時刻のunixタイムスタンプが取得できる
        auctionEndTime = now + _biddingTime;
    }

    /// このトランザクションで送金された金額を使用して、入札をする。
    /// この金額はオークションで落札できなかった時だけ返金される。
    function bid() public payable {
        // 引数は必要ない。全ての情報はトランザクションの一部である。
        // payableのキーワードはファンクションがetherを受け取ることができるようにするために必要である。

        // 入札期間が終了している場合はリバートする。
        require(
            now <= auctionEndTime,
            "Auction already ended."
        );

        // 入札金額が現在価格以下だった場合は返金する。
        require(
            msg.value > highestBid,
            "There already is a higher bid."
        );

        if (highestBid != 0) {
            // シンプルに `highestBidder.send(highestBid)`で返金するのはセキュリティーリスクがある。
            // なぜなら、信頼できないコントラクトが実行している可能性がある。
            // 受取人自身に引き出してもらうのが常により安全である。
            // （そのためここで送金処理は行わない）
            pendingReturns[highestBidder] += highestBid;
        }
        // 最高額入札者と入札額を更新
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
    }

    /// 高値が更新された入札の引き出しを行う
    function withdraw() public returns (bool) {
        uint amount = pendingReturns[msg.sender];
        if (amount > 0) {

            // `send`が終了する前に、レシービングコールからこの関数を再度実行できるので、
            // 先にここを0にしておくことは重要である。
            pendingReturns[msg.sender] = 0;

            if (!msg.sender.send(amount)) {
                // 単に残高をリセットするだけなので、ここでthrowする必要はない。
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

    /// オークション終了時に、最高金額の入札額を受益者に送信する。
    function auctionEnd() public {
        // 外部のコントラクトと相互作用を持つ（可能性がある）関数の構築する場合は下記のガイドラインに従う
        // 1. 条件を確認する
        // 2. アクションを実行して、状態を変更する。
        // 3. 他のコントラクトとインタラクションする
        // これらの段階が混ざってしまうと、他のコントラクトが正しいコントラクトをコールバックできてしまい、
        // 状態を変更したり、アクション(etherの払い出し)を複数回実行できる。
        // もし関数が内部呼び出しを通じて間接的にでも外部のコントラクトとの相互作用を持つ可能性があるのであれば、
        // 外部のコントラクトとの相互作用を考慮する必要がある。

        // 1. 条件
        // オークションの入札期間が終了していること
        require(now >= auctionEndTime, "Auction not yet ended.");
        // オークションがすでに終了していないこと
        require(!ended, "auctionEnd has already been called.");

        // 2. 効果
        ended = true;
        emit AuctionEnded(highestBidder, highestBid);

        // 3. 相互作用
        beneficiary.transfer(highestBid);
    }
}

pragma solidity >0.4.23 <0.7.0;

contract BlindAuction {
    struct Bid {
        bytes32 blindedBid; // <- 入札はハッシュ化されている
        uint deposit;       // <- 入札金額より十分大きなデポジットを入れて置く
    }

    // 受益者
    address payable public beneficiary;
    // 入札終了までの時間
    uint public biddingEnd;
    // 開封終了までの時間
    uint public revealEnd;
    //　オークションが終了しているか
    bool public ended;

    // ブラインドな入札を管理、一人複数回ブラインド入札ができる
    mapping(address => Bid[]) public bids;

    // 最高額入札者
    address public highestBidder;
    uint public highestBid;

    // 最高値が更新された以前の入札の引き出しを許可する
    mapping(address => uint) pendingReturns;

    event AuctionEnded(address winner, uint highestBid);

    /// Modifierは関数の入力をvalidateする便利な方法である。
    /// `onlyBefore` は下記の `bid` 関数 に適用される。
    /// Modifierをつけた関数の内容はmodifierの内容の、 `_` の部分を元の関数の内容で置き換えた物になる。
    modifier onlyBefore(uint _time) { require(now < _time); _; }
    modifier onlyAfter(uint _time) { require(now > _time); _; }

    constructor(
        uint _biddingTime,
        uint _revealTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        biddingEnd = now + _biddingTime;
        revealEnd = biddingEnd + _revealTime;
    }

    /// blinded bid を以下の様に置く。
    /// `_blindedBid` = keccak256(abi.encodePacked(value, fake, secret))。
    /// デポジットしたetherは開封期間に正しく開封された場合のみ返金される。
    /// 入札と共に送金されたetherが入札金額以上で'fake'でない時、入札は有効になる。
    /// 'fake'をtrueにして不正確な値を送金することは本当の入札を隠す方法だが、
    /// 十分なデポジットが必要(出ないと牽制の意味がない)。
    /// 同じアドレスは、複数の入札が可能
    function bid(bytes32 _blindedBid)
        public
        payable
        onlyBefore(biddingEnd)
    {
        bids[msg.sender].push(Bid({
            blindedBid: _blindedBid,
            deposit: msg.value
        }));
    }

    /// blinded bidsを開封する。
    /// 最終的にもっとも高額な入札以外の入札の全てを返金する。
    function reveal(
        uint[] memory _values,
        bool[] memory _fake,
        bytes32[] memory _secret
    ) public onlyAfter(biddingEnd) onlyBefore(revealEnd) {
        uint length = bids[msg.sender].length;
        require(_values.length == length);
        require(_fake.length == length);
        require(_secret.length == length);

        uint refund; // 返金する額
        for (uint i = 0; i < length; i++) {
            Bid storage bidToCheck = bids[msg.sender][i];
            (uint value, bool fake, bytes32 secret) =
                    (_values[i], _fake[i], _secret[i]);
            if (bidToCheck.blindedBid != keccak256(abi.encodePacked(value, fake, secret))) {
                // 入札開封できていない、デポジットを返金しない。
                continue;
            }
            refund += bidToCheck.deposit;

            // 正しい入札だったか？
            if (!fake && bidToCheck.deposit >= value) {
                // 入札が可能か？
                if (placeBid(msg.sender, value))
                    // 入札ができた場合、返金額から入札金額を引いた値を返却する
                    refund -= value;
            }
            // 再度同じデポジットから引き出すことができない様にする
            bidToCheck.blindedBid = bytes32(0);
        }
        // 本当はpull型の実装に変えた方がいい部分
        msg.sender.transfer(refund);
    }

    // これは内部関数で、このコントラクトの内部（もしくは継承したコントラクト）からしか呼ばれない
    function placeBid(address bidder, uint value) internal
            returns (bool success)
    {
        if (value <= highestBid) {
            return false;
        }
        if (highestBidder != address(0)) {
            // 事前に最高額入札者を返金マップに登録
            pendingReturns[highestBidder] += highestBid;
        }
        highestBid = value;
        highestBidder = bidder;
        return true;
    }

    /// 競り負けた入札を引き出す
    function withdraw() public {
        uint amount = pendingReturns[msg.sender];
        if (amount > 0) {
            // 必ず先に状態を変更して置く
            pendingReturns[msg.sender] = 0;

            msg.sender.transfer(amount);
        }
    }

    /// オークションを終了し、最高入札額を受益者に送信する
    function auctionEnd() public onlyAfter(revealEnd)
    {
        require(!ended);
        emit AuctionEnded(highestBidder, highestBid);
        ended = true;
        beneficiary.transfer(highestBid);
    }
}

pragma solidity >=0.4.22 <0.7.0;

contract Purchase {
    uint public value; // 商品の金額の2倍
    address payable public seller;
    address payable public buyer;
    // 現在の状態
    enum State { Created, Locked, Inactive }
    State public state;

    // `msg.value` が偶数であることを確認する. (商品価格の2倍を送金しておく)
    // 奇数の場合除算で切り捨てられるので、かけ算を使って、それが奇数でないことを確認する。
    constructor() public payable {
        seller = msg.sender;
        value = msg.value / 2;
        require((2 * value) == msg.value, "Value has to be even.");
    }

    modifier condition(bool _condition) {
        require(_condition);
        _;
    }

    // 購入者だけに実行を許可する
    modifier onlyBuyer() {
        require(
            msg.sender == buyer,
            "Only buyer can call this."
        );
        _;
    }

    // 販売者だけに実行を許可する
    modifier onlySeller() {
        require(
            msg.sender == seller,
            "Only seller can call this."
        );
        _;
    }

    // 現在の状態で実行に制限をつける
    modifier inState(State _state) {
        require(
            state == _state,
            "Invalid state."
        );
        _;
    }

    event Aborted();           // 中止
    event PurchaseConfirmed(); // 購入を確認
    event ItemReceived();      // 商品を受け取った

    /// 販売を中断して、etherの返却を要求する
    /// コントラクトがロックされる前に、販売者だけが呼び出せる　
    function abort() public onlySeller inState(State.Created)
    {
        emit Aborted();
        // ステートを変更
        state = State.Inactive;
        // 販売者にコントラクトの残高を返金する
        seller.transfer(address(this).balance);
    }

    /// 購入者によって、購入を確認する
    /// トランザクションは`2 * 商品価格` 分の Ether を含む必要がある。
    /// (商品価格の2倍を送金して置く)
    /// このetherは商品を受とった購入者がconfirmReceivedを呼ぶまでロックされる。
    function confirmPurchase() public payable
        inState(State.Created)
        condition(msg.value == (2 * value))
    {
        emit PurchaseConfirmed();
        buyer = msg.sender;
        state = State.Locked;
    }

    /// 購入者が商品を受け取ったことを確認する
    /// これでロックされたetherが解放される
    function confirmReceived()
        public
        onlyBuyer
        inState(State.Locked)
    {
        emit ItemReceived();
        // 必ず状態を先に変更して置く
        state = State.Inactive;

        // 引き出すパターンで実装するべき。(push型は推奨されない)
        buyer.transfer(value);                  // 商品金額の1倍を購入者へ返金
        seller.transfer(address(this).balance); // 商品金額の3倍を販売者へ返金
    }
}

// version 0.x.x
var hash = web3.sha3("message to sign");
web3.personal.sign(hash, web3.eth.defaultAccount, function () { console.log("Signed"); });

// version 1.x.x
var hash = web3.utils.sha3("message to sign");
web3.eth.personal.sign(hash, web3.eth.defaultAccount, function () { console.log("Signed"); });

// recipient: 受取人のアドレス。
// amount:    送金額[wei]
// nonce:     繰り返し攻撃を防ぐためのユニークな数
// contractAddress:  cross-contract replay attacks を防ぐためのコントラクトアドレス
function signPayment(recipient, amount, nonce, contractAddress, callback) {
  var hash = "0x" + abi.soliditySHA3(
    ["address", "uint256", "uint256", "address"],
    [recipient, amount, nonce, contractAddress]
  ).toString("hex");

  web3.personal.sign(hash, web3.eth.defaultAccount, callback);
}
// web3の0系で記述

pragma solidity >=0.4.24 <0.7.0;

contract ReceiverPays {
    address owner = msg.sender;

    // 使用済みの nonce を格納する
    mapping(uint256 => bool) usedNonces;

    // 残高確認用
    function getBalance() public view returns (uint) {
        return address(this).balance;
    }

    constructor() public payable {}

    // 支払い要求
    function claimPayment(uint256 amount, uint256 nonce, bytes memory signature) public {
        // nonce が使用済でないことを確認する
        require(!usedNonces[nonce]);
        usedNonces[nonce] = true;

        // クライアントで署名されたメッセージを再生成する
        bytes32 message = prefixed(keccak256(abi.encodePacked(msg.sender, amount, nonce, this)));

        require(recoverSigner(message, signature) == owner);

        msg.sender.transfer(amount);
    }

    /// コントラクトを破棄して返金する
    function kill() public {
        require(msg.sender == owner);
        selfdestruct(msg.sender);
    }

    /// 署名関数
    // バイト文字列を r s v に分割する
    function splitSignature(bytes memory sig)
        internal
        pure
        returns (uint8 v, bytes32 r, bytes32 s)
    {
        require(sig.length == 65);

        assembly {
            // length prefix の後の32bytes
            r := mload(add(sig, 32))
            // 次の32bytes
            s := mload(add(sig, 64))
            // 次の32bytes
            v := byte(0, mload(add(sig, 96)))
        }

        return (v, r, s);
    }

    // メッセージを復元する
    function recoverSigner(bytes32 message, bytes memory sig)
        internal
        pure
        returns (address)
    {
        (uint8 v, bytes32 r, bytes32 s) = splitSignature(sig);

        return ecrecover(message, v, r, s);
    }

    /// eth_signの処理を再現するために prefixed hashを生成する
    function prefixed(bytes32 hash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

var abi = require('ethereumjs-abi');

function signPayment(recipient, amount, nonce, contractAddress, callback) {
  var hash = "0x" + abi.soliditySHA3(
    ["address", "uint256", "uint256", "address"],
    [recipient, amount, nonce, contractAddress]
  ).toString("hex");

  web3.personal.sign(hash, web3.eth.defaultAccount, callback);
}

const callback = (error, message) => {
  global.message = message;
  console.log(global.message);
};

signPayment(
  '0x902a72a16ac342d29ee7737216767515784ad5bc',
  web3.toWei(1, 'ether'),
  1,
  '0x77fb65ac5bde1c6b9b37d52692ddf4f99913bd3d',
  callback
);

const abi = require('ethereumjs-abi');

function constructPaymentMessage(contractAddress, amount) {
  return abi.soliditySHA3( ["address", "uint256"], [contractAddress, amount]);
}

function signMessage(message, callback) {
  web3.personal.sign( "0x" + message.toString("hex"), web3.eth.defaultAccount, callback);
}

function signPayment(contractAddress, amount, callback) {
  const message = constructPaymentMessage(contractAddress, amount);
  signMessage(message, callback);
}

pragma solidity >=0.4.24 <0.7.0;

contract SimplePaymentChannel {
    address payable public sender;      // 送信者
    address payable public recipient;   // 受取人
    uint256 public expiration;          // 受取期限

    // コントラクトのデプロイ時に、デポジットし、受取人と期間を登録する
    constructor (address payable _recipient, uint256 duration)
        public
        payable
    {
        sender = msg.sender;
        recipient = _recipient;
        expiration = now + duration;
    }

    // 署名が正しいか確認する
    function isValidSignature(uint256 amount, bytes memory signature)
        internal
        view
        returns (bool)
    {
        bytes32 message = prefixed(keccak256(abi.encodePacked(this, amount)));

        // メッセージの署名者が、コントラクトの生成者と一致するかを確認する
        return recoverSigner(message, signature) == sender;
    }

    /// 受取人は送信者から提供されたメッセージでコントラクトをクローズできる。
    /// メッセージに記載されている金額は受取人に送金され、残りは送信者に返金される
    function close(uint256 amount, bytes memory signature) public {
        // 受取人だけ実行できる
        require(msg.sender == recipient);
        // メッセージが正しい事を確認する
        require(isValidSignature(amount, signature));

        recipient.transfer(amount);

        // 残ったデポジットは送金者に返金する
        selfdestruct(sender);
    }

    /// 送信者は受け取り期限をいつでも伸ばすことができる
    function extend(uint256 newExpiration) public {
        require(msg.sender == sender);
        require(newExpiration > expiration);

        expiration = newExpiration;
    }

    /// 受取人がクローズしないうちに支払い期限になった場合、全額を送信者に返金する
    function claimTimeout() public {
        require(now >= expiration);
        selfdestruct(sender);
    }

    /// 以下は前章と同じ

    function splitSignature(bytes memory sig)
        internal
        pure
        returns (uint8 v, bytes32 r, bytes32 s)
    {
        require(sig.length == 65);

        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))
            v := byte(0, mload(add(sig, 96)))
        }

        return (v, r, s);
    }

    function recoverSigner(bytes32 message, bytes memory sig)
        internal
        pure
        returns (address)
    {
        (uint8 v, bytes32 r, bytes32 s) = splitSignature(sig);

        return ecrecover(message, v, r, s);
    }

    function prefixed(bytes32 hash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

function prefixed(hash) {
  return abi.soliditySHA3(
    ["string", "bytes32"],
    ["\x19Ethereum Signed Message:\n32", hash]
  );
}

function recoverSigner(message, signature) {
  var split = util.fromRpcSig(signature);
  var publicKey = util.ecrecover(message, split.v, split.r, split.s);
  var signer = util.pubToAddress(publicKey).toString("hex");
  return signer;
}

function isValidSignature(contractAddress, amount, signature, expectedSigner) {
  var message = prefixed(constructPaymentMessage(contractAddress, amount));
  var signer = recoverSigner(message, signature);
  return signer.toLowerCase() == util.stripHexPrefix(expectedSigner).toLowerCase();
}