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

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

Ethereum กับต้นกำเนิดแนวคิด Smart Contract

ก่อนจะไปถึงรายละเอียดว่า Smart Contract คืออะไร การเข้าใจแนวคิดว่าทำไมถึงต้องมีสิ่งที่เรียกว่า Smart Contract ด้วยคงจะเป็นการเริ่มต้นที่ดีกว่า

ในอดีตยุคที่ Blockchain ถือกำเนิดนั้น โลกมี Application อยู่เพียงตัวเดียวที่ทำงานบน Blockchain และสิ่งนั้นมีชื่อว่า "Bitcoin"

ถึงวันนี้คำว่า Bitcoin จะดูหรูหราฟู่ฟ่าใครมีแล้วร่ำรวย แต่อย่างไรก็ตาม ถ้าให้พูดถึงฟังก์ชันของ Bitcoin แล้ว ถามว่ามันทำอะไรได้บ้าง ? นั่งคิด 3 วินาทีแล้วก็ตอบ ... "ก็โอนหากัน"

มันทำได้แค่นั้นจริง ๆ ... (ณ นาที้นั้นจนถึงนาทีนี้นะ อนาคตอีกเรื่อง)

เจ้าหนู Vitalik ผู้ซึ่งเป็นหนึ่งในทีม Bitcoin Magazine ที่มีชื่อเสียงมากในขณะนั้นก็รู้สึกว่า โอ้วจอร์จ นี่มันอะไรกัน มันช่างไร้สาระเสียชริง Blockchain มันมีประโยชน์มากกว่าแค่โอนหากันไปมานะ

โฉมหน้า Vitalik

Vitalik จึงเกิดแนวคิดว่า

คงจะดีถ้า Blockchain มีความสามารถในการรันโค้ด บันทึกข้อมูล รวมถึงบันทึกการเปลี่ยนแปลงของข้อมูลลงใน Blockchain ไว้ได้ด้วย

และสร้าง Blockchain ตัวแรกที่มาพร้อมความสามารถในการรันโค้ดขึ้นมานามว่า Ethereum ครับ

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

และโค้ดที่ว่านั้นไม่ได้คำสั่งเดียว แต่สามารถมีกี่คำสั่งก็ได้ อย่างเช่นด้านบนก็จะมี a, b, c ซึ่งจะถือว่าเป็นคำสั่งที่แยกกันไปครับ

ถ้าให้ดูดี ๆ จากด้านบนจะเห็นว่ามันก็เหมือนกระดาษที่เขียนสัญญาเอาไว้เป็นข้อ ๆ ให้เราเลือกใช้งานได้เลย โดยมีคุณสมบัติว่า

1) มันไม่สามารถเปลี่ยนแปลงได้

2) ทุกคนสามารถเข้าถึงและดูได้ว่าโค้ดเขียนไว้อย่างไร

3) สามารถสร้างลอจิคการทำงานได้ตามที่ต้องการ

4) สามารถบันทึกข้อมูลที่ต้องการลงใน Blockchain ได้

5) ข้อมูลที่ถูกบันทึกไว้จะอยู่ตลอดไป หากข้อมูลมีการเปลี่ยนแปลงก็สามารถตรวจสอบได้ เพราะข้อมูลไม่มีทางหายไป

ดู ๆ แล้ว มันก็คือสิ่งที่เราเรียกว่า "เอกสารสัญญา (Contract)" ดี ๆ นั่นเองครับ และพอมันอยู่ในรูปแบบที่เราเขียนโค้ดขึ้นมาได้และทำงานบน Blockchain ซึ่งเป็นรูปใหม่ของการทำระบบสัญญา เราเลยเรียกมันว่า

Smart Contract

นั่นเองครับ

หน้าตาของ Smart Contract

Smart Contract สามารถเขียนได้หลายภาษา โดยอิงตามว่า Blockchain ตัวนั้น ๆ สนับสนุนภาษาอะไรบ้าง อย่างของ Ethereum ก็จะใช้ภาษา Solidity เป็นหลักครับ หน้าตาจะคล้าย ๆ กับ Javascript เป็นภาษาง่าย ๆ เรียนรู้ไม่ยาก อันนี้เป็นตัวอย่างโค้ดจริงแบบเบสิคที่สุดครับ

pragma solidity ^0.4.0;

contract SimpleStorage {
    uint storedData;

    function set(uint x) public {
        storedData = x;
    }

    function get() public constant returns (uint) {
        return storedData;
    }
}

อย่างด้านบนจะเป็นเหมือนกระดาษสัญญาที่ทำอะไรไม่ได้เลยนอกจากเก็บบันทึกข้อมูลเอาไว้ได้ (ในที่นี้คือตัวแปรชื่อ storedData) และหากอยากจะเปลี่ยนก็สามารถเปลี่ยนค่าได้ด้วยการเรียกคำสั่ง set ครับ และถ้าอยากจะอ่านค่ากลับมาก็ใช้คำสั่ง get นั่นเอง ค่อนข้างตรงไปตรงมา ถ้าคุณเป็นโปรแกรมเมอร์ ถึงไม่เคยเขียนมาก่อนก็น่าจะอ่านโค้ดรู้เรื่องไม่ยากเนอะ แต่ถ้าไม่ใช่ก็ข้ามไปได้ ๆ

การ Deploy Smart Contract

แล้วโค้ดด้านบนนี้จะไปอยู่ไหนกัน ?

คำตอบคือ ก่อนที่คำสั่งเหล่านี้จะสามารถถูกเรียกใช้ได้ โค้ดเหล่านี้จะต้องถูก Deploy ขึ้นไปบน Blockchain ของ Ethereum เสียก่อนครับ

ก็ไม่มีอะไรมาก เพียงสร้าง Transaction พร้อมข้อมูลดังต่อไปนี้

1) บอกว่าเป็น Transaction ของการสร้าง Contract

2) ระบุ Ethereum Address เปล่า ๆ อันใหม่ไปหนึ่ง Address

3) แนบโค้ดที่ถูกคอมไพล์แล้วเป็น Bytecode ไป

เหล่า Miner ที่ได้รับ Transaction นี้ไปก็จะเอาโค้ดนี้บรรจุลงใน Ethereum Blockchain โดยมีตำแหน่งอ้างอิงเป็น Ethereum Address ที่ส่งไปนั่นเอง โดยเราจะเรียก Address นี้ว่า Contract Address ครับ (สมมติว่าเป็น 0x9ddA2a3d411e244fAdE52Fa2cdED30909827C5d1 ละกันนะ ซึ่งอันนี้ไม่ใช่ของจริง กดเข้าไปดูจะไม่เห็นอะไร แค่ขอเอามายกเป็นตัวอย่างให้เข้าใจง่าย)

คราวนี้ระบบก็จะรู้โดยถ้วนหน้ากันว่า Address นี้เป็นของ Contract ตัวที่เรา Deploy ไป หากต้องการอ้างอิงถึงคำสั่งต่าง ๆ ใน Contract นี้ เราก็จะอ้างอิงไปที่ Address นี้นั่นเองครับ

และนี่เป็นเหตุผลว่าทำไมโค้ด Smart Contract จึงไม่สามารถเปลี่ยนแปลงได้ มันถูกบรรจุลง Blockchain แล้วนั่นเอง

คำสั่งใน Smart Contract ถูกเรียกอย่างไร

น่าจะเดาได้ไม่ยาก ก็แค่สร้าง Transaction ตามรูปแบบนี้

1) ระบุ Contract Address ที่ Contract นั้น ๆ ถูก Deploy ไว้ใน Blockchain

2) ระบุว่าต้องการเรียกคำสั่งอะไร (ในรูปแบบ Hex Code)

3) หากมี Parameter ก็แนบต่อไปด้วย (ในรูปแบบ Hex Code เช่นกัน)

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

ใครเป็นคนรันโค้ด ?

ก็น่าจะเดาจากด้านบนได้อีกเช่นกัน ... Miner นั่นเอง พอ Miner ได้รับ Transaction มาและรับรู้ว่ามันเป็น Transaction ที่มีการเรียกไปที่คำสั่งใน Contract Address ใด ๆ นักขุดรายนั้น ๆ ก็จะดูดโค้ดจาก Blockchain ขึ้นมาและเอามารันใน Virtual Machine และบันทึกผลลัพธ์ลงไปใน Block ครับ

ด้วยเหตุผลตรงนี้ การรันโค้ดจึงไม่ได้ผูกไว้กับใครคนใดคนหนึ่งแต่ผลัดเปลี่ยนหมุนเวียนกันไปตามแต่ละ Block และเมื่อ Block นั้น ๆ ถูกกระจายไป คนอื่นใน Network ก็จะรันโค้ดซ้ำอีกรอบนึงก่อนเพื่อยืนยันว่าผลลัพธ์ตรงกันถึงจะยอมรับเข้ามาใน Blockchain

โดยรวมความปลอดภัยจึงสูง ไม่สามารถโจมตีกันได้ง่าย ๆ นั่นเองครับ

และถ้านึกภาพตามก็จะรู้ทันทีว่า โค้ดไม่ได้รันทันทีนะ แต่ต้องรอให้ Miner ยืนยันและบรรจุลงบล็อกก่อน ซึ่งระยะเวลาที่ใช้ก็ตามแล้วแต่ความเร็วของ Blockchain Network นั้น ๆ อย่าง Ethereum ก็เป็นนาที แต่บางเจ้า 2 วิก็รันเสร็จแล้วก็มี อันนี้ก็ถือเป็นข้อจำกัดนึงที่เอาไว้ในพิจารณาว่าเราจะทำระบบ Smart Contract บน Blockchain ตัวไหนด้วยครับ

เรื่องของข้อมูลที่ถูกเก็บไว้

หากย้อนไปดูข้อมูลที่ถูกเก็บไว้ storedData อาจจะมีอยู่สองคำถามคือ

1) ค่านี้จะอยู่คงถาวรไปเลยหรือไม่ หรือจะถูกรีเซตตาม Session ?

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

2) ข้อมูลถูกบันทึกไว้ที่ไหน ?

ก็ไม่ได้บันทึกไว้ที่ไหนไกล ก็อยู่ใน Blockchain โดยระบุตำแหน่งอ้างอิงเป็น Contract Address ที่ Contract นั้นถูก Deploy อยู่นั่นเองครับ

โดยรวมแล้วเหมือนกับว่ามันเป็นกระดาษสัญญาแผ่นหนึ่งเลยจริง ๆ และการเรียกคำสั่งต่าง ๆ ก็เหมือนการแก้ไขข้อมูลที่อยู่ในกระดาษแผ่นนั้นตามที่ระบุเอาไว้ หรือถ้ามองให้ Geek ไปหน่อย มันก็คือ Database ที่สามารถรันโค้ดลอจิคต่าง ๆ ได้นั่นเองครับ

อ่ะ ถ้ายกตัวอย่าง Contract ชื่อ SimpleStorage ด้านบน เริ่มต้นก็จะเหมือนกระดาษหน้าตาแบบนี้

และหากมีคนส่ง Transaction ยิงมาที่คำสั่ง set พร้อมโยนค่า 10 มา Contract นี้ก็จะเปลี่ยนเป็นแบบนี้

หากมีคนยิงมาอีกเป็นค่า 24 ก็จะเปลี่ยนไปอีก

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

เรารันบริการเต็มรูปแบบบน Smart Contract ได้มั้ย ?

คงเห็นภาพแล้วว่า Smart Contract มันก็เปรียบได้กับที่ที่เอาไว้เก็บข้อมูลแต่สามารถรันโค้ดเพื่อตัดสินใจว่าจะทำอะไรได้ ถ้าอย่างของ Ethereum นี่คือรันได้สมบูรณ์แบบตามที่เราต้องการเลย (เรียกว่า Turing Complete)

แต่ก็จะเห็นอีกว่าตัว Smart Contract นั้นไม่มี Element ไหนที่เอาต่อประสานงานกับผู้ใช้เลย อยากจะเรียกคำสั่งก็ต้องสร้าง Transaction ข้อมูลก็ถูกเก็บไว้ใน Blockchain อยากจะเข้าไปดูก็ต้องเข้าไปดูผ่าน Etherscan บลา ๆ ๆ

ดังนั้น Smart Contract จึงไม่สามารถทำงานอย่างสมบูรณ์แบบได้ด้วยตัวมันเองนะครับ ให้มองว่ามันเป็น Controller เอาไว้ควบคุมการเก็บข้อมูลลงใน Blockchain จะดีกว่า เป็นแค่ส่วนหนึ่งของ Tech Stack ไม่ใช่ Full Stack หากจะใช้งานมันก็ต้องเขียน Front End ขึ้นมาเพื่อติดต่อไปยัง Blockchain เพื่อเรียกคำสั่งและดึงข้อมูลมาใช้งานอีกทีครับ

น่าจะเห็นภาพเนอะ

เอาจริง ๆ Smart Contract อัปเดตโค้ดได้มั้ย ?

เราจะเห็นว่าพอ Deploy Contract ไปแล้วก็จะไม่สามารถแก้ไขโค้ดได้อีก Contract Address นั้นก็จะเป็นโค้ดนั้นตลอดไป แต่คำถามที่หลาย ๆ คนคงเกิดขึ้นในหัวตอนนี้คือ ... แล้วถ้าเขียน Smart Contract ผิดหละและต้องได้รับการแก้ไขหละ ?

ความจริงแล้วก็อัปเดตได้แหละครับ แต่เงื่อนไขคือ

1) Smart Contract จะต้องเขียนรองรับการอัปเดตไว้แต่แรก ไม่งั้นอาจมีเหนื่อย

2) Contract ตัวใหม่ไม่สามารถ Deploy ทับ Contract Address ตัวเก่าได้ ต้องใส่ Address ใหม่เท่านั้น แปลว่าข้อมูลทั้งหมดจะหายไป ก็ต้องเขียนโค้ดให้รองรับตรงนี้ด้วย (หลัก ๆ คือการแยกเก็บข้อมูลไว้ในอีก Address นึง ไม่ยากแต่ขอไม่ลงดีเทลตรงนี้ละกัน)

สรุปแล้วก็เปลี่ยนแปลงได้ แต่มันไม่เชิงเป็นการเปลี่ยนแปลงหรอก เป็นการสร้าง Contract ใหม่เลยมากกว่า ข้อดีก็มี เผื่อ Smart Contract มีบั๊กใหญ่ก็ต้องแก้ไขจริง ๆ แหละ ไม่งั้นอาจเสียหายหนัก แต่ข้อเสียก็มี ... ความโปร่งใสที่บอกว่าโค้ดไม่สามารถเปลี่ยนแปลงได้ก็จะหายไป ผู้ใช้บริการต้องเชื่อใจผู้ให้บริการมาก ๆ ไม่งั้นมีดราม่าครับ

Smart Contract หายไปได้มั้ย ?

คำถามถัดไป ... ถ้ามันอัปเดตได้ แล้วอย่างงี้เราสามารถทำลาย Smart Contract ทิ้งได้มั้ย ?

คำตอบคือได้ครับ เราสามารถเรียกคำสั่ง selfdestruct จากภายใน Contract เพื่อทำลาย Contract ทิ้งได้

ก็จะเห็นว่าถึงแม้โค้ดจะมีความโปร่งใส สามารถอ่านได้เลย แต่ความจริงรายละเอียดก็มีเยอะเหมือนกัน ต้องทำความเข้าใจพอสมควรครับ หาก Smart Contract เขียนมาไม่ดีมันก็เหมือนสัญญาที่เปิดมาเพื่อโกงในอนาคตได้เหมือนกัน ไม่ต่างจากสัญญาที่เป็นกระดาษที่ถูกเขียนมาด้วยถ้อยคำเลี่ยงบาลีและสามารถสร้างความเสียหายให้เราในภายหลังได้นั่นเอง

ตัวอย่างการใช้งาน Smart Contract ในโลกจริง

เอาหละ ถ้าเข้าใจ Fundamental ของ Smart Contract ตามที่เขียนไว้ด้านบนแล้วก็จะเห็นว่าประโยชน์ของ Smart Contract คือการเขียนโค้ดที่โปร่งใส ทุกคนสามารถตรวจสอบได้ เงื่อนไขในโค้ดเปลี่ยนแปลงไม่ได้ และก็สามารถบันทึกข้อมูลที่ทุกคนสามารถเข้ามาดูได้หมด

ดังนั้นมันจึงเหมาะกับงานหลาย ๆ งานที่มีเงื่อนไขชัดเจนและต้องการความโปร่งใสสูงครับ ตอนนี้ก็ถึงเวลายกตัวอย่างว่า Smart Contract ที่ใช้กันในโลกจริงมีบริการอะไรบ้าง จะได้เห็นภาพมากขึ้น

ระบบประกัน

ประกันที่มีเงื่อนไขที่ชัดเจน ก็โอนเงินแล้วรับสิทธิ์ประกันไปได้เลย ดังนั้นก็เลยสามารถเขียน Smart Contract ได้เลย ซึ่งทำได้หลายแบบ เช่น

แบบทำมือ - เราโอนเงินให้บริษัทประกันตามวิธีปกติ แล้วให้บริษัทประกันเขียนสิทธิ์ไว้ใน Contract เลยว่าเราได้รับสิทธิ์คุ้มครองจนถึงวันนั้นวันนี้ ... แต่วิธีนี้มันไม่เท่เอาซะเลย จะทำ Smart Contract ไว้ทำไมเนอะ ลองวิธีสอง

แบบอัตโนมัติ - ให้รับเงินโอนเป็น ETH ถ้ายอดเงินถึงตามที่ระบุไว้ใน Smart Contract ก็เขียนไว้ใน Contract Address นั้นเลยว่า คุณคนนี้ได้รับสิทธิ์คุ้มครองประกันถึงวันที่นี้ ๆ เวลานี้ ๆ หากเกิดเหตุให้ต้องเคลมประกันก็สามารถมาตรวจสอบบน Blockchain ได้เลย ไม่ต้องมางงกันภายหลัง

ส่วนประกันที่เงื่อนไขไม่ชัดเจนก็ ... ตัวใครตัวมัน

การซื้อสินค้าออนไลน์ทั้งระบบ

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

ทั้งโปรเซสนี้สามารถเขียน Smart Contract เพื่อเชื่อมโยงทุกฝ่ายเข้าด้วยการและสามารถตรวจสอบได้หมดว่าตอนนี้อยู่ขั้นตอนไหนแล้วและแต่ละขั้นตอนใช้เวลาเท่าไหร่ ไม่สามารถเปลี่ยนแปลงได้ ไม่สามารถโกหกกันได้

เกม

หนึ่งในเกมดังอย่าง Crytokitties ก็ใช้ Smart Contract ในการเก็บข้อมูลแมวไว้ใน Blockchain ระบบโดยรวมไม่มีอะไรมากเลย มันคือการเขียนโค้ดให้สามารถสร้างแมวขึ้นมาได้ ผสมพันธุ์ได้ ฯลฯ และก็มี Front End ที่เรียกคำสั่งเหล่านั้นอีกที

ความซับซ้อนของ Smart Contract อยู่ในระดับปานกลาง แต่ที่ต้องชมคือสามารถประยุกต์ใช้ Smart Contract ในแง่ที่คนคาดไม่ถึงกันมาก่อนได้ยอดเยี่ยมมาก จนทำให้เกิดเกมอื่นตามมาอีกเพียบ

การทำ ICO

อันนี้บูมมากในช่วงหลัง เขียน Smart Contract ให้รับเงินเป็น ETH แล้วส่ง Token กลับไปให้ผู้ซื้อด้วย Smart Contract หากขายหมดก็จะคืนเงินให้ผู้ส่งเงินมา รวมถึงหากมีเงื่อนไขเพิ่มเติมอีกเช่นว่า มี Token 33% ที่ล็อคไว้ให้เจ้าของแต่จะปลดล็อคในอีก 12 เดือนข้างหน้านะ ก็สามารถเขียนทั้งหมดลงใน Contract ได้เลย คราวนี้ทุกคนก็สบายใจได้ครับ
แล้วมันต่างอะไรกับการเขียนระบบด้วย Web Server แบบปัจจุบัน ?

จะเห็นว่า Smart Contract มันก็เป็นการรันโค้ดและบันทึกข้อมูลเก็บไว้เหมือนที่เราทำกันมาหลายสิบปีด้วย Web Server นั่นแหละ

ก็อาจจะเกิดคำถามว่า แล้วมันต่างกับการเขียน Web Server ขึ้นมาให้บริการหละ

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

ส่วนที่เหลือเอาจริง ๆ มันก็ไม่ต่างกันมาก ดีไม่ดีการทำด้วย Web Server ยังจะดีกว่าในหลาย ๆ กรณีด้วยซ้ำไป

เช่นถ้าถามว่าจะย้าย Netflix หรือ YouTube ไปบน Blockchain ได้มั้ย ? ... ได้ก็บร้าแล้ววว หรือเอาจริง ๆ อนาคตอาจจะทำได้ก็ได้ถ้า Sharding ฯลฯ มา แต่มันก็ยังไม่ Make Sense ที่จะทำอยู่ดี ถ้าจะทำก็ทำได้แค่เก็บข้อมูลเล็ก ๆ น้อย ๆ ของผู้ใช้ลงใน Blockchain ซึ่งไม่รู้จะทำไปทำไมให้วุ่นวาย

ก็เหมือนเทคโนโลยีทั้งหมดที่มีมาในโลกนี้ มันไม่มี Solution ที่ดีที่สุด มีแค่ Solution ที่ "เหมาะสมที่สุด" เท่านั้นเอง คราวนี้เวลาจะทำอะไรก็อย่าเอาแต่เห่อว่าต้องทำ Smart Contract มองหาข้อดีและความเหมาะสมด้วยว่าต้องทำมั้ย ทำแล้วได้ประโยชน์อะไร เทียบกับระบบอื่นเช่น Web Server อันไหนดีกว่ากัน ฯลฯ แล้วค่อยเลือกว่าจะใช้เทคโนโลยีไหนครับ

โครงสร้าง Smart Contract เปลี่ยนไปตามประเภท Blockchain

ที่เขียนในบล็อกนี้ส่วนใหญ่จะเน้นไปทางตัวอย่างของ Ethereum แต่ในโลกนี้มี Smart Contract Blockchain อยู่หลายสิบตัวมาก ดังนั้นจะให้ทุกตัวเหมือนกันก็คงไม่ใช่ บางตัวอาจจะมีรายละเอียดที่ต่างกันไปตั้งแต่ภาษาที่ใช้ยันวิธีเรียกใช้คำสั่งเลย แต่ในแง่ Fundamental ถ้าเข้าใจแนวคิด Smart Contract ของ Ethereum ก็จะต่อยอดไปยัง Blockchain ตัวอื่นไม่ยากครับ

สรุป

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

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

อย่างไรก็ตาม เป็นศาสตร์ที่ควรศึกษาไว้นะ หาเวลาว่าง ๆ มาลองฝึกเขียน Smart Contract เล่น เผื่อจะสามารถต่อยอดเอาไปทำอะไรในอนาคตได้ เทคโนโลยีมาแล้วก็ต้องตามให้ทันโนะ

ก็หวังว่าจะเห็นภาพกันนะ =)