มาเขียนระบบเลือกตั้ง 0.4 ในไทย ให้ทันสมัยด้วย Blockchain (Ethereum) แบบง่ายๆ กันเถอะ

หมายเหตุบทความเก่า (เผยแพร่ครั้งแรก 31 มีนาคม 2018): บทความนี้เก็บแนวคิด ข้อกล่าวอ้าง และตัวอย่างตามต้นฉบับเพื่อการอ่านเชิงประวัติศาสตร์ ไม่ใช่คำแนะนำด้านความปลอดภัย การเงิน หรือแบบระบบเลือกตั้งสำหรับใช้งานจริงในปัจจุบัน ไม่ได้ปรับ API หรือทดสอบโค้ดระหว่างการย้ายครั้งนี้

หมายเหตุการเติมโค้ด: clipping ไม่ได้เก็บโค้ดฝังทั้งสี่ส่วนไว้ จึงนำโค้ดจาก Gist ของผู้เขียนมาใส่ตามที่ผู้เขียนอนุญาต โดยคงโค้ด Solidity ^0.4.18 ตาม revision ที่ลิงก์ใต้แต่ละหัวข้อ ไม่ได้ยืนยันว่าเป็น revision เดียวกับ embed บน Medium เดิม และไม่ได้แก้หรือรันทดสอบโค้ด

Photo by Heather Mount on Unsplash

“บทความนี้ไม่มีพิษมีภัยต่อความมั่นคงของประเทศแม้แต่น้อย”

จั่วหัวแบบเพลย์เซฟ แล้วก็ขอกราบ สวัสดีมิตรรักแฟนเพลงทุกท่าน ตอนที่กำลังพิมพ์อยู่นี้รู้เลยว่าตัวเองห่างหายไปจากการเขียนบทความนานมาก คือนานจริงจัง ทั้งๆที่ในดราฟก็มีหลายเรื่องที่เขียนไว้ เหมือนมันเขียนแล้วก็หมดแรงไปเฉยๆ ไม่ได้รดน้ำแล้วก็ปล่อยมันเฉาตายไปในที่สุด 😢

เอาหละเกริ่นเยอะเดี๋ยวจะไม่ค่อยสนุก อาจเพราะชื่อหัวข้อฟังดูล่อตีนไปหน่อยแต่เชื่อผมเถอะ… มันจะ(ไม่)เป็นแบบนั้นจริงๆ สัญญา 😆

อะไร? ทำไม? ยังไง?

อะไร?

แล้วอะไรคือ Blockchain?

ด้วยสาระที่มีเปี่ยมล้น แนะนำให้อ่านบล็อกพี่หนูเนยอันนี้ Blockchain คืออะไร? อธิบายแบบละเอียด แต่เข้าใจง่าย(มั้ง) พี่เค้าเขียนไว้โคตรดี แต่ผมแนะนำว่าให้อ่านทีหลังจากที่อ่านบล็อกนี้ก็ได้ เดี๋ยวจะหมดแรงไม่อยากอ่านของผมซะก่อน ฮ่าๆๆ

เลยสรุปให้สั้นๆเหลือ 1 บรรทัดว่า

Blockchain คือ รูปแบบเทคโนโลยีการเก็บข้อมูล ที่มีความปลอดภัยสูงมาก น่าเชื่อถือและไม่ต้องมีคนกลาง!

อธิบายในนึงบรรทัดอาจไม่เข้าใจ สรุปแนะนำให้กลับไปอ่านลิ้งพี่หนูเนยข้างบนอีกทีละกันครับ 🙇

แล้วอะไรคือ การเลือกตั้งของประเทศไทย?

อันนี้ยิ่งยากกว่าข้างบน หลายๆคนคงลืมไปเหมือนกันว่าครั้งสุดท้ายที่ไปหย่อนบัตรคือตอนไหน แต่การเลือกตั้งของไทยในนิยามบน wiki ก็จะเป็นตามนี้

การเลือกตั้งของประเทศไทย เป็นกระบวนการตามรัฐธรรมนูญแห่งราชอาณาจักรไทย เพื่อให้ได้มาซึ่งบุคคลเข้าไปทำหน้าที่ในการปกครองประเทศไทย อาทิ สมาชิกสภาผู้แทนราษฎรไทย, วุฒิสภาไทย, ผู้ว่าราชการกรุงเทพมหานคร, ผู้ว่าเมืองพัทยา และผู้บริหารท้องถิ่นอื่น ๆ ด้วยการให้ประชาชนออกเสียงเลือกบุคคลที่เห็นสมควร

ง่ายๆก็คือ การที่เราใช้ สิทธิของเรา เลือกคนที่เราไว้วางใจ มาไว้คอยบริหารประเทศ มาช่วยทำให้ประเทศชาติพัฒนา

ทำไม?

ทำไมถึงอยากเอาเทคโนโลยี Blockchain มาทำระบบการเลือกตั้งให้กับประเทศไทยเพราะว่าวันก่อนผมไปอ่านเจอบทความนึงที่ได้พูดเรื่องของการนำระบบอิเล็กทรอนิกซ์มาใช้ในการเลือกตั้ง ซึ่งหลักๆแต่ก่อนเราก็ใช้กันแต่แบบศูนย์รวมปกติก็คือ Centralized ง่ายๆประชาชนก็ต้องออกจากบ้านมาที่หน่วยเลือกตั้ง ที่เปิดบ้างไม่เปิดบ้าง(โดนม๊อบปิดในบางประเทศ) ดีหน่อยก็ลงคะแนนออนไลน์ได้ แต่ด้วยที่ว่าปัญหามันอาจต้องใช้งบประมาณเยอะ ต้องมีหน่วยงาน ต้องมีคณะกรรมการการจัดการเลือกตั้งสารพัด โกงนับคะแนนนู่นนี่อีกล้านแปด จึงมีบางประเทศที่ได้เริ่มคิดแผนพัฒนาให้มีการเลือกตั้งแบบใหม่คือแบบกระจายศูนย์ (Decentralized) ซึ่งระบบการเลือกตั้งแบบนี้จะถูกพัฒนาบนเครื่องข่าย Blockchain ซึ่งจะช่วยให้เกิดการเลือกตั้งที่โกงยาก(แทบจะเป็นไปไม่ได้) โปร่งใสขึ้นและป้องกันทุจริตได้ เพราะบน Blockchain ทุกคนจะเห็นรูปแบบข้อมูลที่ตรงกัน แฟร์ๆ เห็นกันชัดๆ ไม่ต้องไปเสียเวลาเปิดหีบเอาใบลงคะแนนมานับกันให้ยุ่งยากอีกด้วย

ยังไง?

มองกลับมาที่ประเทศไทยของเรา ถ้าเราอยากทำระบบเลือกตั้งแบบ Decentralize ขึ้นมาเนี่ยจะทำยังไงได้บ้าง? ถ้าทำขึ้นมาเองเล่นๆ มันจะเป็นแบบไหนดีหนอ

ผมเลยตัดสินใจมาขอลองกับ Ethereum ว่าถ้าเราเอาความสามารถของมันมาใช้ โดยการเขียน Smart contracts ที่เอาไว้ใช้สำหรับเลือกตั้งบ้านเรา น่าจะพอตอบโจทย์ได้ดีเลยทีเชียวเดียว

เพราะด้วยที่ Ethereum นั้นเป็น Decentralize platform ที่จะช่วยป้องกันการโกงหรือการเข้ามาแทรกแซงจากบุคคลที่ 3 ซึ่งเราสามารถเขียนคุณสมบัติหรือรูปแบบการเลือกตั้งของเราได้ด้วย Smart contracts หรือที่เรียกกันว่า “สัญญาอัจฉริยะ” ซึ่งมันจะสามารถทำงานได้ด้วยตัวมันเองและโปร่งใส เพราะใครๆก็สามารถตรวจสอบ Smart contracts นี้ได้ ความสามารถของมันถ้าจะให้อธิบายง่ายๆ คือมันเหมือนชุดคำสั่งที่ถ้าเราทำตามเงื่อนไขอะไรบางใหญ่ เห้ย บางอย่างที่มันมีให้ มันจะทำตามเงื่อนไขที่ชุดคำสั่งนั้นได้สร้างไว้ต่อ เช่น เราเขียนชุดคำสั่งง่ายๆ อาจจะชื่อว่า canIBorrowYourWatch ซึ่งในชุดคำสั่งนี้เราได้เขียนข้อกำหนดคร่าวๆขึ้นมาว่า

function canIBorrowYourWatch(address _watchOwner) public {
    // 1 
    require(isOwnerFriend(msg.sender));
    
    // 2
    Watch _watch = expensiveWatchOf[_watchOwner];
    
    // 3
    watchInCollection[msg.sender].push(_watch);
}

1. คนที่จะขอยืมนาฬิกาต้องเป็นเพื่อนกับเจ้าของนาฬิกานะ ไม่ใช่นี่ห้ามยืม
2. ถ้าเป็นเพื่อนกันก็จะยืมได้ ระบบก็จะเอานาฬิกาจากเจ้าของมาให้คนขอยืม
3. คนขอยืมก็จะมีนาฬิกาเพิ่มในคอลเลคชั่น
4. จบข่าว

เราจะเห็นได้ว่า ชุดคำสั่งใน Smart contracts จะทำงานอย่างตรงไปตรงมา ตามที่เราได้กำหนดไว้เท่านั้น ดังนั้นการเขียน Smart contracts จึงต้องเขียนอย่างรอบคอบมากๆ เพื่อป้องกันข้อผิดพลาดหรือช่องโหว่ที่อาจจะเกิดขึ้นได้ เพราะเมื่อเรา Deploy Smart contracts ของเราขึ้นไปบน Ethereum Blockchain แล้วเราจะทำการแก้ไขมันไม่ได้อีก (ตรงนี้จริงๆมีวิธีการเขียนให้ Smart contracts ของเรากลายเป็นแบบ Upgradable ได้ เอาไว้ว่างๆ จะมาลองเขียนให้ดูครับ) 😉

ระบบเลือกตั้งแบบง่ายๆ ที่เราอยากได้น่าจะมีอะไรบ้าง?

มีปืน 🔫 แฮ่! อะล้อเล่นนน

1. ประธานคณะกรรมการการเลือกตั้ง
2. ผู้สมัครรับเลือกตั้ง
3. ประชาชนที่ลงคะแนนได้อย่างเรา
4. นโยบายจากผู้สมัคร
5. ระบบนับคะแนนหาผู้ชนะการเลือกตั้ง

เอาคร่าวๆ เท่านี้ก่อน … 5 อันด้านบนน่าจะเพียงพอที่จะสร้างระบบการลงคะแนนเลือกตั้งได้ รูปแบบคร่าวๆคงประมาณ ประธานคณะกรรมการการเลือกตั้งเลือกวันเริ่มต้นและสิ้นสุดการเลือกตั้ง คนที่อยากเป็นผู้แทนก็เข้ามาสมัคร อาจจะมีค่าสมัครหรือไม่มีก็ได้ พอสมัครแล้ว สิ่งที่ต้องทำคือผู้แทนก็ต้องมีนโยบายเพื่อเอาไว้ให้ประชาชนเข้ามาดูเพื่อตัดสินใจว่านโยบายผู้สมัครนั้นดีพอที่เขาจะเลือกหรือไม่ ถ้าประชาชนโอเค ก็สามารถลงคะแนนให้กับผู้สมัครนั้นผ่านระบบลงคะแนนได้ทันที ซึ่งระบบก็สามารถตรวจสอบได้ตลอดเวลาว่า ณ ปัจจุบันคะแนนใครมาเป็นอันดับหนึ่ง ซึ่งก็คือผู้ที่จะเป็นผู้นำประเทศคนต่อไป

เอาแบบง่ายๆไม่ซับซ้อนมาก คือ 1 ผู้สมัครต่อ 1 Proposal ไปเลย ยังไม่ต้องถึงขั้นมีพรรค ประชาชนสามาร ถเลือกลงคะแนนให้กับ Proposal ที่ชอบมากที่สุด หนึ่งคนจะมีหนึ่งเสียง คือลงคะแนนไปได้เพียงครั้ง เดียว ถ้าลงคะแนนไปแล้วก็จะลงไม่ได้อีก ส่วน Proposal ของผู้สมัครคนไหนได้คะแนนเสียงจากประชาชนเยอะที่สุด ผู้สมัครคนนั้นก็ได้เป็นนายกเลย โดยคนแต่งตั้งก็จะเป็นประธานหรืออะไรก็ว่าไป 👨

Photo by Helloquence on Unsplash

มาเริ่มสร้าง Smart contracts ระบบเลือกตั้งของเรากัน

จากข้อมูลด้านบน เราก็จะอาจทำ contract สนุกๆมาได้สัก 3, 4 อัน ประมาณนี้

1. Thailand: ตัวหลักของระบบการแต่งตั้งตำแหน่งต่างๆ ทั้งประธานการเลือกตั้ง, นายกรัฐมนตรี และ… ตำแหน่งอื่นๆ พร้อมทั้งเก็บ address ของบุคคลนั้นไว้อีกด้วย
2. ThailandBollot: ตัวหลักของระบบการลงคะแนน ระบบตั้งช่วงเวลาการลงคะแนน, การนับผลโหวต, ข้อมูล Proposal
3. Proposal: ทดลองแยกออกมาเป็นอีกอันเผื่อไว้ในอนาคตถ้าเราอยากอัพเดทมันได้ เช่น เพิ่มข้อมูลหรือฟังก์ชันอื่นๆ
4. ThailandMilitaryPower (อันนี้จำลองเฉยๆนะ ว่ามันทำได้)

สัญญาอัจฉริยะหรือ Smart contracts แต่ละ contract ที่เราได้สร้างขึ้นมาจะมีหน้าที่และข้อมูลที่จัดเก็บแตกต่างกัน มาดูทีละอันดีกว่า ว่าถ้าเขียนออกมาจะได้ประมาณไหน

Contract: Thailand 🇹🇭

ที่มา: Thailand.sol — Gist ของผู้เขียน

pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/math/SafeMath.sol";

contract Thailand {
    using SafeMath for uint256;
    
    address public owner;
    address public primeMinister;
    address public commanderInChief;
    address public chairperson;    
    mapping (address => bool) public prisoners;
    
    // Modifier
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    
    function Thailand() public {
        owner = msg.sender;
    }
    
    function nominatePrimeMinister(address _someOneElse) public onlyOwner {
        primeMinister = _someOneElse;
    }
    
    function nominateCommanderInChief(address _militaryMan) public onlyOwner {
        commanderInChief = _militaryMan;
    }
    
    function nominateChairperson(address _lazyBoy) public onlyOwner {
        chairperson = _lazyBoy;
    }
}

Contract: ThailandBollot ✍️

ที่มา: ThailandBollot.sol — Gist ของผู้เขียน

pragma solidity ^0.4.18;

import './ThailandMilitaryPower.sol';
import './Proposal.sol';

contract ThailandBollot is ThailandMilitaryPower {
    struct Voter {
        // This property should be hide :P
        // uint8 voteToProposal;
        bool voted;
    }

    // Fee for who want to be candidate
    uint256 public politicalFee;
    
    // Candidates
    Proposal[] public proposals;
    mapping (address => bool) public candidates;
    address[] public candidateList;
   
    // Voters
    address[] public voterList;
    mapping (address => Voter) public addressOfVoter;
    mapping (address => uint256) public voteCountOfProposal;
    
    // Election Time
    uint256 public startTime;
    uint256 public endTime;
    
    // Modifier
    modifier duringVoteTime() {
        require(now >= startTime && now <= endTime);
        _;
    }
    
    modifier onlyChairperson() {
        require(msg.sender == chairperson);
        _;
    }
    
    modifier onlyCandidate() {
        require(candidates[msg.sender]);
        _;
    }
    
    // 1514764800, 1546214400
    function ThailandBollot(uint256 _startTime, uint256 _endTime) public {
        startTime = _startTime;
        endTime = _endTime;
        politicalFee = 0.44 ether;
    }
    
    function updatePoliticalFee(uint256 _fee) public onlyChairperson {
        politicalFee = _fee;
    }
    
    function wantToBeCandidate() public payable {
        require(msg.value >= politicalFee);
        candidates[msg.sender] = true;
        candidateList.push(msg.sender);
    }
    
    function createProposal(string _manifesto) public onlyCandidate {
        proposals.push(new Proposal(msg.sender, _manifesto));
    }
    
    function vote(address _toProposal) public duringVoteTime {
        Voter storage voter = addressOfVoter[msg.sender];
        require(!voter.voted);
        require(_toProposal != address(0));
        
        voterList.push(msg.sender);
        voter.voted = true;
        voteCountOfProposal[_toProposal] = voteCountOfProposal[_toProposal].add(1);
    }
    
    function winningProposal() public view returns (address _winningProposal) {
        uint256 _winningVoteCount = 0;
        for (uint8 prop = 0; prop < proposals.length; prop++) {
            if (voteCountOfProposal[proposals[prop]] > _winningVoteCount) {
                _winningVoteCount = voteCountOfProposal[proposals[prop]];
                _winningProposal = proposals[prop];
            }
        }
        
        return _winningProposal;
    }
}

Contract: Proposal 📄

ที่มา: Proposal.sol — Gist ของผู้เขียน

pragma solidity ^0.4.18;

contract Proposal {
    address public creator; // Candidate
    string public manifesto;
    
    modifier onlyCreator {
        require(msg.sender == creator);
        _;
    }
    
    function Proposal(address _creator, string _manifesto) public {
        creator = _creator;
        manifesto = _manifesto;
    }
    
    function editProposal(string _manifesto) public onlyCreator {
        manifesto = _manifesto;
    }
}

Contract: ThailandMilitaryPower 🔫

ที่มา: ThailandMilitaryPower.sol — Gist ของผู้เขียน

pragma solidity ^0.4.18;

import './Thailand.sol';

contract ThailandMilitaryPower is Thailand {
    uint256 public curfewStartTime;
    uint256 public curfewEndTime;
    
    // Modifier
    modifier whoHasATank() {
        require(msg.sender == commanderInChief);
        _;
    }
 
    function declareCoup() public whoHasATank {
        _transformToPrimeMinister(commanderInChief);
        address _goverment = this;
        commanderInChief.transfer(_goverment.balance);
        // In the real world case, it should be call selfdestruct :p
        // suicide(commanderInChief);
    }
    
    function imposeCurfew(uint256 _startTime, uint256 _endTime) public whoHasATank {
        curfewStartTime = _startTime;
        curfewEndTime = _endTime;
    }
    
    function arrest(address _victim) public whoHasATank {
        prisoners[_victim] = true;
    }
    
    function _transformToPrimeMinister(address _theChoosenOne) internal {
        primeMinister = _theChoosenOne;
    }
}

จาก Smart contracts ทั้งหมดด้านบน จะเห็นได้ว่าในส่วนการทำงานของแต่ละฟังก์ชันนั้น ล้วนแล้วมีหน้าที่แตกต่างกัน แต่สามารถใช้งานได้อย่างสัมพันธ์กัน เริ่มด้วย

1. Contract ถูกสร้างขึ้นด้วยบุคคลสำคัญที่มีพาวเวอร์พอที่จะดูแลระบบนี้ได้ เค้าเองจะมีพลังแต่งตั้ง ตำแหน่งสำคัญๆในนี้ด้วย ไม่ว่าจะเป็น แต่งตั้งนายก แต่งตั้งประธานกรรมการการเลือกตั้ง จนไปถึง ผบ.ทบ. 🎖
2. หลังจากที่เขาแต่งตั้งประธานกรรมการการเลือกตั้งแล้ว หน้าที่ของประธานก็ต้องจัดวันเวลาสำหรับเลือกตั้งขึ้นมา
3. เมื่อกรรมการประกาศเสร็จ เราอาจกำหนดให้สักสัปดาห์แรกของการเลือกตั้งเป็นการเปิดรับสมัครผู้รับการเลือกตั้ง หรือคนที่อยากเข้ามาเป็นนายก
4. ผู้สมัครทุกคนจะต้องสร้าง Proposal ของตัวเอง เพื่อแสดงถึงวิสัยทัศน์ต่างๆ
5. หลังจากเรียบร้อย ประชาชนก็สามารถมาลงคะแนนเสียงให้กับ Proposal ที่ตัวเองชอบที่สุด ซึ่ง Proposal นั้นก็จะสื่อถึงผู้สมัครรับเลือกตั้งไปในตัวด้วย
6. ทุกคนจะสามารถลงคะแนนเสียงได้เพียงครั้งเดียวและจะแก้ไขไม่ได้ด้วย
7. ระบบทำการนับคะแนนแบบอัตโนมัติ ทุกคนสามารถเข้ามาดูได้ตลอดเวลาว่า Proposal ไหนคะแนนมากที่สุดในขณะนั้น
8. หมดเวลาการลงคะแนน เราก็จะได้ Proposal ที่ได้คะแนนมากที่สุดพร้อมทั้งผู้สมัครรับเลือกที่กลายเป็นนายกคนต่อไป
9. บุคคลสำคัญแต่งตั้งนายกคนใหม่
10. Happy ending 💃

เราจะได้รูปแบบการเลือกตั้งคร่าวๆ ที่มีการเก็บข้อมูลที่ปลอดภัยและตรวจสอบได้ ด้วยความสามารถของการเก็บข้อมูลบน Blockchain

ด้วยความขยันที่จำกัด ผมเองเลือกที่จะไม่อธิบายเป็นรายบรรทัดหรือบาง Contract เพราะคิดว่าท่านผู้อ่านที่กดเข้ามานั้น คงเข้าใจมันได้ไม่ยากอย่างแน่นอนครับ ตรงนี้ผมกล้าเอาหัวเพื่อนเป็นประกันเลย 😆

สำหรับนักพัฒนาที่อยากทดลองเล่นง่ายๆ ให้ทดลองนำโค้ดแต่ละส่วนมาประกอบกัน และรันตัว ThailandBallot contract ซึ่งสามารถที่จะเลือกใช้ Remix IDE ก็ได้ หรือจะเลือก pull code จาก ThailandZeroPointFour บน github แล้วรันผ่าน Truffle ก็สะดวกเช่นกันครับ ตรงนี้ผมไม่ได้ deploy ขึ้น test net หรือ main net ไว้ให้ลองเล่นอันนี้ต้องขออภัยด้วยจริงๆ

หรือถ้าสนใจอยากร่วมแจมหรือเปิด pr มาก็ขอให้คิดถึงครอบครัวกับพ่อแม่ไว้ให้มากๆ เพราะโปรเจคนี้ผมทำเอาสนุกจริงๆ คือมีไฟแล้วก็ใส่เลย คิดแล้วก็ทำๆๆเลยไม่กี่ ชม. ซึ่งจะเอาไปใช้งาน(จริงๆจังๆ)คงไม่ได้ บางฟังก์ชัน บางตัวแปร บางเงื่อนไขอาจยังเขียนไม่ครบ ขาดตกบกพร่องอีกเพียบครับผม 😅

Photo by Buatoom on Streetwill

สุดท้าย 🙇

ผมได้แต่หวังว่าวันนึงข้างหน้าประเทศเราจะพัฒนาขึ้นกว่าเดิม โปร่งใสและสะอาดขึ้นกว่าเดิมด้วยเทคโนโลยีที่มีอยู่บนโลก ผมเชื่อมั่นมาตลอดว่านักพัฒนาไทยทำได้แน่นอน ประเทศเรามีคนที่เก่งและทรงพลังกว่าผมมากมาย ที่พร้อมจะขับเคลื่อนและนำเทคโนโลยีดีๆเหล่านี้มาช่วยอัพเกรดคุณภาพของประเทศเราได้ในวันข้างหน้า

ประเทศไทย ใครก็รักครับ สู้ๆครับ ✌️ ❤️ 🇹🇭

Make Thailand great again 🤣