บทความนี้ผมตั้งใจที่จะเขียนมาได้สักพักแล้ว แต่เนื่องด้วยการทำงานใน KULAP ที่เข้มข้นทำให้ยังไม่มีเวลาลงมือเขียนสักที แต่เนื่องจาก 2 วันที่ผ่านมีมีปรากฎการณ์ครั้งสำคัญเกิดขึ้นกับ Uniswap เลยถือโอกาสเขียนบทความนี้ตามที่ได้ตั้งใจไว้สักที (พอมีอะไรมา trigger งานมันก็จะเสร็จนั้นแหละ 555)

ขายของ: สนใจเขียนโปรแกรมภาษา Solidity สามารถติดตาม Course ของทาง KULAP Skill ได้ที่นี้ครับ https://www.kulapskill.com/

Uniswap คืออะไร

Uniswap เป็นหนึ่งในโปรเจคชื่อดังในโลก DeFi (Decentralized Finance) Uniswap คือระบบการซื้อขายแลกเปลี่ยนสินทรัพย์ดิจิทัลแบบไร้ศูนย์กลาง ไร้คนควบคุม ไร้องค์กรควบคุม ทุกคนสามารถแลกเปลี่ยนจากสกุลหนึ่งไปอีกสกุลหนึ่งได้เสรี ทุกคนสามารถนำสินทรัพย์ดิจิทัลใหม่เข้ามา List ในระบบได้อย่างเสรี ทุกคนสามารถเป็นผู้ให้สภาพคล่อง (Liquidity provider) ได้อย่างเสรี และระบบสามารถปันผลได้อัตโนมัติ ทั้งหมดที่ว่ามานี้ไม่มีคนจัดการเลยทั้งระบบ แต่เป็น “Source code” หรือ DApp ที่ทำงานบนระบบ Blockchain แบบไร้ศูนย์กลางอีกที

Uniswap เป็นระบบ Decentralized Exchange (DEX) ประเภท Instance exchange กล่าวคือ เป็นระบบซื้อขายเหรียญดิจิทัลแบบทันที คล้ายกับเวลาเราซื้อขายทองคำ ที่จะมีราคารับซื้อ / ขาย ให้ตลอดเวลา โดยผู้ใช้งานจำเป็นต้องมีกระเป๋าเงินดิจิทัล (Crypto wallet) เช่น Metamask / Ledger / Trezor เพื่อใช้ในการส่งคำสั่งซื้อขาย โดยคำสั่งซื้อขายจะประมวลผลโดยตรงไปที่ Smart contract (App) ที่ทำงานอยู่บน Blockchain โดย “ไม่ผ่านตัวกลาง” ตรงนี้เราเทียบเคียงว่า Smart contract คล้ายแอพช้อปปิ้งออนไลน์ และ Blockchain คล้าย App Store / Play store ก็ได้

DeFi คือระบบการเงินบนโลกเสรี ที่ทำงานด้วยหุ่นยนต์ (Automation) ทั้งระบบ ให้นึกภาพเหมือนโรงงานผลิตรถยนต์ที่เต็มไปด้วยหุนยนต์ แล้วตัดภาพมาธนาคารที่ไม่มีคนทั้งในสาขาธนาคาร และสำนักงานใหญ่

Blockchain คือระบบฐานข้อมูลแบบไร้ศูนย์กลาง ที่สามารถเก็บข้อมูลทางการเงินได้ทั้งระบบ ทั้งบัญชีผู้ใช้ รายการธุรกรรม และฟังก์ชั่นการใช้งาน (Application) โดยคอมพิวเตอร์ทั่วโลกช่วยกันประมวลผล ยืนยันความถูกต้อง และเก็บบันทึกข้อมูลที่ตรงกันเสมอ (Public Blockchain ปัจจุบันยังไม่ 100% finality แต่ได้ที่ 99.99% ถ้ารอระยะ confirm เพียงพอ)

Liquidity Provider

ด้วยความที่ Uniswap เป็น Instance exchange ทำให้ระบบต้องมี Maker หรือผู้เสนอราคาซื้อ / ขาย ตลอดเวลา จึงได้มีระบบ “Liquidity provider (LP)” เข้ามา ซึ่งมันคือกองทุน (Reserve) ที่มี Smart contract เป็นตัวจัดการ ทำหน้าที่ถือเหรียญของผู้ลงทุนเอาไว้ เช่น เหรียญ ETH-UNI (ถือเป็นคู่) ถ้าหาก user ต้องการแลกจาก ETH -> UNI ระบบก็จะเก็บ ETH ของ user เพิ่มเข้าไปใน Reserve และนำเหรียญ UNI ออกจาก Reserve ส่งไปให้ user

ด้วยหลักการง่าย ๆ นี้ ทำให้สามารถเขียนเป็นสมการคณิตศาสตร์ x * y = kเพื่อใช้ในการควบคุมราคาด้วย Smart contract ที่เขียนด้วยภาษาคอมพิวเตอร์สุดพิเศษชื่อ Solidity นั้นเอง

ใคร ๆ ก็สามารถเป็น Liquidity provider ด้วยการเชื่อมกระเป๋าเงินดิจิทัล และนำเงินทั้งสองฝั่ง เช่น ETH-UNI ในมูลค่าที่เท่ากัน (ณ เวลานั้น) ฝากเข้าไปใน Reserve และผู้ฝากจะได้เหรียญ LP กลับมา เปรียบเสมือนตัวแทนหน่วยลงทุน ที่สามารถนำมา claim เงินคืนได้ทุกเมื่อ และเต็มจำนวน เพราะระบบไม่ได้นำเงินดิจิทัลเราไปลงทุนที่ไหนต่อนั้นเอง

จากภาพจะเห็นว่าตอนแรกใน Reserve มี ETH-UNI อยู่ก่อนแล้วที่ 15 / 1,000 พอ User ต้องการลงทุนใน Reserve นี้ด้วย เราก็จำเป็นต้องลงในอัตราส่วนเดียวกัน นั้นก็คือ 15 : 1,000 จากในภาพ User จึงเพิ่มเข้าไป 10: 666.66 นั้นเอง และ User ก็จะได้รับเหรียญ LP กลับมา คิดเป็นหุ้นส่วนที่ 40% ของจำนวนเหรียญ LP ทั้งหมดของ Reserve นี้

การถอนเงินออกจาก Reserve ระบบจะทำการคำนวณยอดเงินใน Pool ณ ตอนถอนที่เป็นส่วนของเรา ซึ่งจะรวมค่าธรรมเนียมการซื้อขายที่เราได้ส่วนแบ่งเอาไว้ให้แล้ว ทำให้ ณ ตอนถอนเราจะได้เงินต้น + กำไรออกมาด้วย (แต่ก็สามารถขาดทุนได้ หากราคาเหรียญลง ณ ตอนถอน)

สมการ x * y = k

สมการนี้ถูกนำเสนอโดยนาย Vitalik Buterin และ Hayden Adams (Uniswap) นำมาพัฒนาจริงโดยสมการคณิตศาสตร์นี้มีหลักการออกแบบโดยคำนึงถึง ผู้ลงทุน ‘’Liquidity provider” เป็นสำคัญ และการันตีว่า ผู้ลงทุนจะไม่เสียหายในทุกกรณี กล่าวคือหากระบบมีการขึ้นลงของราคาเหรียญ และสุดท้ายกลับมา ณ จุดราคาเดิม ระบบจะไม่มีทางสูญเสียเงินต้นเด็ดขาด จะมีแต่ได้ค่าธรรมเนียมการเทรดส่วนเพิ่มเข้ามา

อย่างไรก็ตาม Liquidity provider จะมีความเสี่ยงเรื่อง Impermanent loss หากราคาขึ้นลงมากเกินไป

ประวัติ Hayden Adams น่าสนใจมากครับ ถ้ามีโอกาสผมอาจได้เขียนถึงในบทความอื่น

การซื้อขายทำให้ราคาเปลี่ยนอัตโนมัติ

ตามภาพที่ 2) จะเห็นว่า User ต้องการแลกเปลี่ยน Token A ไปเป็น Token B และหลังจากแลกเปลี่ยนแล้ว สมการ x * y = k ก็จะทำการคำนวนราคาใหม่ถัดไปทันที ทำให้ราคาเหรียญ B แพงขึ้นเมื่อเทียบกับ A (เป็นไปตามหลัก Supply and Demand) เพราะ Token A เพิ่มขึ้น และ Token B ลดลงใน Reserve นั้นเอง

ตัวสมการ x * y = k จากภาพ 2) เราจะแทนสมการนี้ด้วย “จำนวน Token A *จำนวน Token B = k” และพอมีการเทรดเกิดขึ้น ระบบจะคำนวณราคาซื้อขายอัตโนมัติ โดยที่ค่า k หลังจากซื้อขายต้องมากกว่าเดิม 0.3% เสมอ (รายได้ของ LP) ซึ่งจากข้อมูลนี้ ทำให้ราคาขึ้นกับปริมาณที่ต้องการขายด้วย ยิ่งขายเยอะ เรทจะยิ่งแย่นั้นเอง

Reserve ยิ่งใหญ่ ราคายิ่งดี

ด้วยสมการ x * y = k นี้เอง ทำให้เราสามารถ Proof ทางคณิตศาสตร์ได้ว่า ยอดฝากใน Reserve ยิ่งใหญ่เท่าไหร่ ราคา ณ ตอนซื้อขายก็จะยิ่งดีเท่านั้น เพราะเป็นการลด ช่วงราคา (Price Spread) ลงนั้นเอง

หากใครสนใจเพิ่มเติม แนะนำให้อ่าน White paper ตาม ref ด้านล่างได้เลยครับ

ระบบ Smart contract

Smart contract ถือเป็นหัวใจสำคัญของระบบ DeFi เพราะเปิดโอกาสให้ทุกคนสามารถอ่าน Source code ของระบบได้อย่างเปิดเผย และตรวจสอบธุรกรรมทั้งหมด ที่ทุกคนกระทำกับระบบได้ ทำให้มีความโปร่งใส (Transparency) ตรวจสอบได้ และที่สำคัญคือไม่ต้องใช้คนประมวลผลเลย ทำให้ต้นทุนระบบลดไปได้อย่างมหาศาลทั้งในแง่ Fix cost และ Operation cost (เข้าใกล้ศูนย์) และในอีกทางหนึ่ง ต้นทุนธุรกรรม user เป็นคนจ่ายเอง ตามหลักการออกแบบ Public Blockchain ในปัจจุบัน

ด้วยต้นทุนธุรกรรมมีวิธีการคำนวณที่ผิดแปลกไปจากธุรกิจเดิม ๆ ที่ผู้ประกอบการเป็นคนจ่ายต้นทุน และหาวิธีสร้างรายได้จากการเก็บเงินจาก user โดยตรง หรือคู่ค้า ไปเป็น user เป็นคนออกค่าใช้จ่ายเอง และจ่ายเป็นรายธุรกรรม ทำให้ระบบนี้ถูกเรียกว่า Decentralized Finance ที่ผู้ใช้ไม่ต้องกังวลว่าผู้ให้บริการจะปิดระบบเมื่อไหร่ เพราะหาก user มีเงินจ่ายค่าธรรมเนียม ก็สามารถทำธุรกรรมได้ตลอดเวลาที่ต้องการ หรือสรุปได้ว่าหากตัว Smart contract ไม่มีคำสั่งปิดการใช้งาน ระบบนี้ก็ไม่มีใครสั่งปิดได้ แม้กระทั้งผู้สร้างเองก็ทำไม่ได้

การ Listing

ตัวระบบ Uniswap ได้สร้างปรากฎการณ์ใหม่ ที่ไม่เคยมีใครทำได้มาก่อน (ในระดับ mass ขนาดนี้) ก็คืออนุญาตให้ใครก็ได้สามารถ List เหรียญอะไรก็ได้ ได้อย่างอิสระเสรี โดยหากเป็นการ List ครั้งแรก จะนับเป็นการเปิด Pool ใหม่ด้วยราคาที่เรากำหนด และหลังจากนั้นหากใครต้องการลง Pool นี้ด้วยก็สามารถทำได้ตามที่อธิบายไปข้างต้น โดยมีข้อสังเกตคือ หากคนที่เปิด Pool คนแรกกำหนดราคาไม่เป็นไปตามตลาด ก็จะมี Arbitragers มาทำการ ซื้อ / ขาย จนราคาเท่ากับตลาดนั้นเอง (Arbitrager ได้กำไรจากส่วนต่างราคาไป)

แม้ว่าการ List จะทำได้อิสระในระดับ Smart contract แต่ในการขึ้นหน้าเว็บ app.uniswap.org ต้องขอความเห็นชอบจาก Community ก่อนเสมอ เพื่อป้องกันการ List เหรียญ Scam เข้ามาในระบบนั้นเอง

แต่หากผู้ใช้เป็น Smart Contract developer / DApp อื่นที่ต้องการใช้งานระบบ Uniswap จะไม่เจอข้อจำกัดด้านความเห็นชอบจาก Community นี้ สามารถ List และใช้งานได้เลยทันที (เช่น Lending / Margin trading)

การใช้งานจาก User

สำหรับผู้ใช้ที่ต้องการซื้อขาย และแลกเปลี่ยนถือว่ามีขั้นตอนที่ง่ายมาก ๆ เพียงแค่ผู้ใช้มีกระเป๋าเงินดิจิทัล เช่น Metamask / Ledger / Trezor และมีเงินดิจิทัลที่ต้องการขายรอไว้ก่อนแล้ว ก็เปิดเว็บ app.uniswap.org และเลือกเหรียญที่ต้องการซื้อได้เลย ตรงนี้สมการ x * y = k จะทำการคำนวนราคาให้อัตโนมัติในทุกครั้งที่มีการซื้อขาย (ยิ่งขายมาก ราคาจะยิ่งแย่ ลองสังเกตุดูกันได้ครับ) และระบบจะหักค่าธรรมเนียม 0.3% ให้กับ LP ครับ

Revenue Sharing

จากตรงนี้เราจะเห็นว่าระบบ Uniswap จะประกอบไปด้วย Stakeholder 2 ส่วนคือ

1. Liquidity provider (LP)
2. Trader

โดยในส่วนของ LP นั้นจะได้ 0.3% ของปริมาณการซื้อขายทุกครั้ง ทำให้คนเริ่มนิยมนำเหรียญดิจิทัลของตัวเอง มาวางลงใน Pool เพื่อรับรายได้ส่วนนี้นั้นเอง สำหรับผลตอบแทนสามารถดูได้ที่ Uniswap.info ครับ

ตรงส่วน Revenue sharing นี้เองที่ผมมองว่าเป็นจุดเปลี่ยนสำคัญของระบบการเงินในโลกยุคใหม่ เพราะแต่เดิมรายได้ส่วนของผู้ให้บริการ คนทั่วไปไม่สามารถเข้าไปมีส่วนแบ่งได้เลย สามารถทำได้จากการถือหุ้นของกิจการเท่านั้น ซึ่งก็เข้าถึงได้ในวงจำกัด (ง่ายสุดก็คือบริษัทมหาชนในตลาดหลักทรัพย์) แต่ระบบ LP นี้ ทำให้บุคคล หรือองค์กรทั่วไป สามารถมีส่วนแบ่งได้อย่างเสรี และลงในจำนวนเท่าไหร่ก็ได้ และด้วยตัว Uniswap แบ่งออกเป็นหลาย Pool (เช่น USDC-USDT, ETH-MKR, ETH-UNI) ทำให้เราสามารถเลือกลงตามใจชอบใน Pool ที่เรารับความเสี่ยงได้

ค่าธรรมเนียม (Fee)

ค่าธรรมเนียมเป็นสิ่งที่ไม่พูดถึงไม่ได้เลย เพราะเป็นต้นทุนที่ user ทุกคนต้องจ่าย ในทุกธุรกรรม โดยค่า fee นี้จะแบ่งออกเป็น 2 ส่วน ดังนี้

1) ค่าธรรมเนียมการเทรด ตรงนี้ง่าย ๆ ตรง ๆ ก็คือ 0.3% ของมูลค่าการซื้อขาย ในระบบ app.uniswap.org ราคาที่แสดงเป็นราคาที่รวมค่าธรรมเนียมตรงนี้ให้แล้ว

2) ค่าธรรมเนียม Blockchain อันนี้เป็นค่าธรรมเนียมที่ไม่ตายตัว และเป็นไปตามสภาพตลาด ตามความหนาแน่นของธุรกรรมที่รอการ confirm ณ ขณะนั้น หากมีปริมาณมากก็จะแพงมากเช่นกัน ตรงนี้ตัวกระเป๋าเงินดิจิทัลของเราจะคำนวนให้อัตโนมัติก่อน confirm ทุกครั้ง

ค่าธรรมเนียมในข้อสองต้องใส่ใจมาก ๆ เพราะบางช่วงเวลาส่วนนี้แพงมาก ๆ จนทำให้อาจไม่คุ้มที่จะทำธุรกรรมเลยด้วยซ้ำ เช่น 100–1,000 บาทต่อธุรกรรม แต่ข้อสังเกตุคือ ค่าธรรมเนียมในส่วนนี้ไม่ว่าจะทำธุรกรรมมูลค่ามากหรือน้อย ค่าธรรมเนียมก็จะเท่ากัน ทำให้ผู้ที่ซื้อขายปริมาณมากก็จะคุ้มมาก ๆ นั้นเอง

Impermanent loss

หากใครที่ต้องการฝากเงินใน LP เพื่อรับรายได้ ประเด็น Impermanent loss ถือว่าสำคัญ และไม่รู้ไม่ได้เลยครับ เพราะหากไม่คำนวณความเสี่ยงตรงนี้เข้าไปด้วย อาจทำให้ขาดทุน หรือขาดทุนกำไรโดยไม่รู้ตัวครับ

Impermanent loss จะเกิดขึ้นเมื่อมีการเปลี่ยนแปลงราคา จะทำให้เราขาดทุนเมื่อเทียบกับการถือเอาไว้เฉย ๆ เช่น ถ้าผมฝาก ETH-USDT มูลค่ารวม $1,000 (500+500) เข้าไปใน Reserve แล้วปรากฎว่าราคาสูง ETH ขึ้น 500% แทนที่มูลค่าใน Reserve จะเป็น $3,000 (2,500+500) แต่จะได้ $2,250 แทน ได้ต่ำกว่าถือไว้เฉย ๆ 25% (เป็นตัวเลขตัวอย่างของจริงจะต่างจากนี้) โดยสมการ Impermanent loss คือ

impermanent_loss = 2 * sqrt(price_ratio) / (1+price_ratio) – 1

แต่ถ้าหากราคากลับมา ณ จุดเดิม คือ 100% (ไม่เพิ่มไม่ลด) มูลค่าของเราใน Reserve จะกลับมาจุดเดิมที่ $1,000

ตาราง Impermanent loss

“a 1.25x price change results in a 0.6% loss relative to HODL”

“a 1.50x price change results in a 2.0% loss relative to HODL”

“a 1.75x price change results in a 3.8% loss relative to HODL”

“a 2x price change results in a 5.7% loss relative to HODL”

“a 3x price change results in a 13.4% loss relative to HODL”

“a 4x price change results in a 20.0% loss relative to HODL”

“a 5x price change results in a 25.5% loss relative to HODL”

UNI Token

UNI Token หรือเหรียญของ Uniswap เป็นเหรียญที่มีจุดหมายในการ “แสดงสิทธิ” ในการบริหารจัดการ กำหนดความเป็นไป กำหนดค่า Parmeters ต่าง ๆ ในระบบ กำหนดการแจกจ่ายปันผล กำหนดการนำเงินกองทุนไปใช้ ซึ่งทุกกระบวนการที่กล่าวมานั้น กระทำผ่าน On-chain governance (ระบบการ vote ผ่าน Smart contract) ที่มีความโปร่งใส ตรวจสอบได้ โดย 1 เหรียญมีค่าเท่ากับ 1 เสียง

การดำเนินการใด ๆ ที่มีการเปลี่ยนแปลงระบบ จะกระทำผ่าน Smart contract อีกชุด ที่ถูกนำเสนอเข้ามาพร้อมกับ Proposal เพื่อให้ทุกคนได้โหวตกัน และเมื่อผ่านการโหวต (Win) ระบบจะ Execute คำสั่ง Smart contract นั้น ๆ ทำให้การันตีได้ว่า ผลลัพธ์ในเชิงปฏิบัติจะเป็นไปตามการโหวตจริง ๆ

วิธีการได้รับเหรียญ UNI Token (ที่ไม่ใช่การซื้อ)

1) Airdrop

ในขั้นแรกตอน UNI Token เปิดตัว มีการแจกเหรียญ (Airdrop) ให้กับคนที่เคยใช้ระบบอย่างน้อย 1 ธุรกรรม เช่นการเทรด และคนที่ให้สภาพคล่อง (LP) โดยในส่วนคนที่เคยใช้ระบบ จะได้ 400 UNI ทุก address ส่วนคนที่ให้สภาพคล่องจะเป็นไปตามการคำนวน “มูลค่า * ระยะเวลาที่ฝาก”

ข้อนี้ได้เฉพาะคนที่ทำตามเงื่อนไขก่อน September 1, 2020, at 12:00 am UTC. เท่านั้น

2) Farming

อีกวิธีคือการนำเหรียญ LP ไป Stake (ล็อคไว้ในระบบ) เพื่อรับเหรียญ UNI ตามปริมาณที่เราฝากไว้ โดยจะแจกจ่ายเป็นราย 15 วินาที (1 block) โดยผู้ใช้สามารถ ฝาก / ถอน ได้ตลอดเวลา วิธีนี้เรียกกันทั่วไปว่าการ Farming

คู่เหรียญที่เข้าร่วมการ Farming ปัจจุบันดังภาพนี้ครับ

UNI Token Detail

• Total Supply: 1,000,000,000 UNI
• Price: ~$5.5 (ราคา ณ 21 กันยายน 2020)
• Inflation: 2% ต่อปี
• Governance: 1 เสียง 1 โหวต

Architecture

Smart contract ของ Uniswap หลัก ๆ จะมี 3 Components ประกอบด้วย Factory, Pair (Reserve) และ Router

1. Pair

ทำ 3 ฟังก์ชั่นหลักของระบบ ก็คือ Trade, Deposit และ Withdraw กับตัว Reserve และเป็น Smart contract ที่ทำหน้าที่ถือสินทรัยพ์ดิจิทัลแทนทุกคน และออกเหรียญ​ LP แทนหน่วยลงทุนให้กับทุกคน

2. Factory

เป็น Component หลัก ที่ทำหน้าที่ “โรงงานผลิต” ตัว Reserve หรือคู่ Pair อีกที โดยระบบมีการกำหนด Blueprint (bytecode) สำหรับใช้ในการสร้าง Pair เอาไว้แล้ว ทำให้มั่นใจได้ว่าทุก Reserve มีการทำงานเหมือนกันทุกอย่าง

3. Router

ทำหน้าที่ “อำนวยความสะดวก” ให้กับ Reserve อีกที เพราะด้วยการออกแบบ Source code ของระบบ Reserve ที่เน้นความเรียบง่าย เพื่อลดความเสี่ยงที่จะเกิดช่องโหว่ในระบบ ทำให้ตัว Reserve ขาดฟังก์ชั่นงานสำคัญเช่น Price discovery ตรงนี้ Router จะทำตรงนี้ให้

และที่สำคัญ หาก User ต้องการแลกเปลี่ยน แต่ไม่มีในคู่เหรียญ (Reserve) ไหนเลย เช่นดังภาพที่ 8) User ต้องการแลก DAI -> MKR สิ่งที่ Router ทำให้คือแลก DAI -> ETH ก่อน หลังจากนั้นนำ ETH -> MKR อีกที ซึ่งทั้งสองคำสั่งนี้ทำเสร็จภายใน 1 transaction บน Blockchain

Factory และ Pair นับเป็น Core components เนื่องจากเกี่ยวกับระบบงานสำคัญเช่น ซื้อ / ขาย และ ถือสินทรัพย์ดิจิทัล ส่วน Router ถือเป็น Optional มีไว้เพื่ออำนวยความสะดวกให้กับ User ที่มาเรียกใช้

จนถึงปัจจุบัน Router มีการออกมา 2 version แล้ว และอนาคตก็จะมีการอัพเดตได้เรื่อย ๆ ส่วน Factory และ Pair หากมีการออก version ใหม่ ผู้ใช้มีสิทธิเลือกจะใช้ระบบเดิมต่อไปก็ได้ (คือย้ายหรือไม่ย้าย user เป็นคนเลือก)

IPFS

ด้วยความที่ Uniswap เป็นระบบที่ขับเคลื่อนส่วนงานสำคัญทั้งระบบด้วย Smart contract แต่ก็ยังมีส่วนหนึ่งมีความ Centralized (รวมศูนย์) อยู่ นั้นก็คือเว็บไซต์ https://app.uniswap.org/ ถึงแม้ว่าตัวเว็บไซต์จะไม่สามารถจัดการเงินของ User ได้โดยตรง แต่ก็สามารถถูกโจมตีหรือ Censor ระบบได้

ทำให้ Uniswap ได้เอาระบบเว็บไซต์ อัพโหลดเอาไว้ในระบบ IPFS ที่เป็น Distributed File Storage Systems ที่มีการออกแบบระบบตรวจสอบความถูกต้องของเนื้อหา และตัวเว็บไซต์กระจายตัวอยู่ตาม Nodes ต่าง ๆ ทั่วโลก ทำให้เพิ่มขีดความสามารถด้าน Avaibility และ Censorship resistance ไปในตัว ใครสนใจก็เข้าใช้งานได้ที่ https://uniswap.eth.link/ ครับ

ในอนาคต Browser จะเริ่มรองรับ ipfs:// ทำให้ลดการรวมศูนย์ของ TLD Manager (ระบบจัดการ Domain) ลงไปอีก และเพิ่มการตรวจสอบที่เข้นข้นกว่า https://

Smart contract audit

มีการ Audit ตัว Smart contracts ของระบบ ที่เขียนด้วยภาษา Solidity ด้วย Engineer จำนวน 6 คน จากทีม klab (ไม่ใช่ KULAP นะครับ lol) สามารถดู Audit report ได้ทีนี้ครับ https://uniswap.org/audit.html#orgbd4e765

ส่วนตัวผมได้อ่าน Source code ทุกบรรทัด เทียบระหว่าง version 1 ที่เขียนด้วยภาษา Vyper กับ version 2 (ปัจจุบัน) ที่เขียนด้วยภาษา Solidity ผมค่อนข้างชอบความ Lean ใน Style การเขียน และสัมผัสได้ถึงความใส่ใจในความปลอดภัย ที่มีมากขึ้นใน version 2 อย่างชัดเจนครับ

Regulation

ปัจจุบันยังไม่มีการกำกับดูแลจากหน่วยงานใด ๆ ณ จุดนี้หากใครใช้งานก็ให้พึงระวังว่าจะไม่ได้รับความช่วยเหลือใด ๆ จากหน่วยงาน

ในมุมมองส่วนตัว คิดว่า Regulator ทั่วโลกเริ่มให้ความสนใจตัว Uniswap หรือโปรเจคที่ใกล้เคียงกันมากขึ้น เนื่องด้วยปริมาณสินทรัพย์ และปริมาณการซื้อขาย ที่สูงขึ้นอย่างก้าวกระโดด และด้วยอัตราเร่งนี้เอง ทำให้เงินทุน หรือ Productivity จะเริ่ม Adopt การใช้งานมากขึ้นเรื่อย ๆ และปัจจุบันก็ได้พิสูจน์แล้วว่า สามารถเป็นจุดซื้อขายแลกเปลี่ยนได้จริง (สำหรับ Volume ที่สูงจนคุ้มค่า Fee)

Risk ความเสี่ยง และการบริหารความเสี่ยง

ความเสี่ยงในการใช้งานระบบ Uniswap ถ้าให้พูดเทียบกับระบบอื่น ๆ ในโลก DeFi ผมก็จะบอกว่าปลอดภัยมาก แต่หากเทียบกับระบบการเงินเดิม (tradiational finance) ก็ถือว่ามีความเสี่ยงกว่ามาก อาทิเช่น ไม่มีใครกำกับดูแลตลาด (ไม่มี regulator) ไม่มีการประกันความเสี่ยง ไม่มีการดำรงกองทุน รวมไปถึงอัตราผันผวนที่สูงมากในหลายสินทรัพย์ดิจิทัล และที่สำคัญ User จำเป็นต้องบริหารจัดการ Crypto Wallet ด้วยตัวเอง

หากเรารับความเสี่ยงตามที่บอกข้างต้นได้แล้ว อีกจุดที่ควรระวังก็คือตัวเหรียญที่เราถือ และเอามาลงใน Reserve นั้น ๆ ว่าเหรียญมีความน่าเชื่อถือแค่ไหน เพราะทุกเหรียญก็ล้วนสร้างด้วย Smart contract กันหมด หากมีความเสี่ยงเรื่อง Technical หรือ Business ก็จะกระทบมูลค่ามหาศาลได้ครับ

อีก 1 ความเสี่ยงที่ไม่พูดถึงไม่ได้ ก็คือตัว Uniswap เอง ว่าหากวันนึงมี Attacker สามารถหาช่องโหว่ของระบบ Smart contract ได้ ก็อาจโจมตีระบบจน LP สูญเสียเงินต้นได้

Crypto wallet ที่แนะนำ

หากต้องการแค่ทดสอบ ผมมองว่า Metamask ทั้งบนคอม และมือถือ ก็เพียงพอ แต่หากต้องการลงทุนจริงจัง (แนะนำให้เป็น % ที่น้อย หรือเป็นเงินเย็นนะครับ) ต้องใช้ Hardware wallet เท่านั้น ไม่งั้นวันนึงอาจตื่นมาแล้วเงินหายได้ครับ

ที่ผมเน้นว่าเงินเยอะให้ใช้ Hardware wallet เท่านั้น เพราะความเสี่ยงในตัว Software wallet มีสูงมาก มีหลายจุดที่ป้องกันยาก และที่สำคัญตัว Hardware wallet ก็ราคาไม่แพงมากนัก เช่น Trezor, Ledger ราคาไม่ถึง 5,000 บาท

มูลค่าตลาด

ณ กันยายน 2020 มูลค่าสินทรัพย์ที่ Lock เอาไว้ในระบบ (LP) $2.15 พันล้านดอลล่าร์ หรือราว 6 หมื่นกว่าล้านบาท มีปริมาณการซื้อขายต่อวันมากกว่า $300 ล้านดอลล่าร์ หรือราว 9 พันล้านบาท

Liquidity: $2,150,000,000

Trading volume per day : $300,000,000

Reserve: 10,042 คู่เหรียญ

การเติบโตค่อนข้างหวือหวา ทั้งในแง่ Liquidity และ Trading volume เป็นสิ่งที่ทุกคนต้องจับตากันต่อไป หากยังรักษาการเติบโตเช่นนี้เอาไว้ได้ อนาคตตลาดการเงินโดยภาพรวมคงเริ่มมีการเปลี่ยนแปลงในระยะเวลาอันใกล้

ref: https://uniswap.info/home

ทิศทางในอนาคต

ในอนาคตอันใกล้ เราจะเริ่มเห็น Productivity อื่น ๆ เริ่มนำ Uniswap protocol ไปใช้ ถ้าพูดให้เห็นภาพง่าย ๆ ก็มองว่า Uniswap คือ ตลาดหลักทรัพย์ดิจิทัล ที่ใครต้องการระบบนี้ไป Plug & Play ก็ทำได้เลย เช่นระบบ Ecommerce ที่ให้ลูกค้าชำระด้วยเหรียญอะไรก็ได้ ระบบ E-Salary ที่ให้ลูกจ้างต่างประเทศเลือกรับเป็นสกุลตัวเอง (ระบบแปลงเรทอัตโนมัติ ณ วันจ่าย) ระบบ Real Estate ที่ให้ผู้ซื้อ / เช่า วางเงินประกัน และชำระด้วยสกุลที่ต้องการ ในขณะที่ผู้ลงทุนอสังหาริมทรัพย์ ก็รับเป็นเงินที่ตัวเองเลือกได้

สรุป

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

สำหรับ Innovator นับเป็นจังหวะดี ที่จะเริ่มศึกษา ทั้งความเป็นไปได้ในแง่ Technology และในมุม Business เพื่อสร้างความได้เปรียบในการแข่งขัน ในยุคใหม่ที่กำลังมา ที่ผมเองก็ตื่นเต้นกับมันมาก ๆ ครับ

เกี่ยวกับผู้เขียน

ผมโต๊ด นัฐพล นิมากุล เป็น CTO ของ KULAP.io ที่ให้บริการซื้อขายแลกเปลี่ยนสินทรัพย์ดิจิทัลน้องใหม่ ที่ได้ใบอนุญาติจาก ก.ล.ต. ผ่านความเห็นชอบจากกระทรวงการคลัง ปัจจุบันผมเป็น Researcher ที่ศึกษา Blockchain ทั้ง Bitcoin, Ethereum, Libra และอื่น ๆ แบบ Full time หากใครสนใจด้านนี้ ทักมาคุยกับผมได้ครับ ถ้าเรื่อง Blockchain นี้คุยได้ทั้งวัน ^_^

https://www.facebook.com/totiz

KULAP Skill

สนใจศึกษาการทำงานของระบบ Ethereum Blockchain หลักการทำงานของ Smart Contract และการเขียนโปรแกรมภาษา Solidity สามารถติดตาม Course ของทาง KULAP Skill ได้ที่นี้ครับ https://www.kulapskill.com/

ref: https://uniswap.org/docs/v2/core-concepts/pools/

ref2: https://m.youtube.com/watch?v=b2qRD1cm57s

ref3: https://uniswap.org/whitepaper.pdf

ref4: https://uniswap.org/blog/uni/

ref5: https://tokenlists.org/

ref6: https://uniswap.org/docs/v2/advanced-topics/understanding-returns

Uniswap ปฐมบทโลกเสรีการเงินที่ทุกคนต้องจับตา was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

* เปลี่ยนกระบวนการสร้าง Block จากเดิมที่ใช้คอมพิวเตอร์สมรรถนะสูง ไปเป็นการวางหลักทรัพย์ และกำหนดบทลงโทษหากก่อกวนระบบ ด้วยการยึดทรัพย์ที่วางไว้

วันนี้ผมจะพาทุกท่านมาดูมุมมองของการพัฒนาครั้งนี้ไปด้วยกัน เนื่องจากหนทางยังอีกยาวไกล (ปัจจุบันยังอยู่ในเฟส 0 จาก 4 เฟส 😂) โดยนาย Vitalik ได้พูดถึงปรัชญา “หลักการยืนยันความถูกต้องของ Blockchain” ไว้อย่างน่าสนใจ

ทำไมเราถึงต้องรัน Full Node?

การทำงานของ Blockchain สาธารณะ (Bitcoin, Ethereum) จะอาศัย Node (~คอมพิวเตอร์) ทำงานกันเป็นเครือข่าย พูดคุยกันแบบ Peer-to-peer ทำให้มีอิสระในการทำงาน และไม่มีคน กลุ่มคน หรือองค์กรใด ๆ สามารถควบคุมได้ แต่เพื่อให้ทุกคนมีข้อมูลตรงกัน จึงมีการกำหนดหลักการสร้างชุดข้อมูลใหม่ (Block) และให้ทุก Node ในเครือข่ายช่วยกันตรวจสอบความถูกต้อง

Node ที่ทำหน้าที่สร้าง Block เราจะเรียกว่า Miner / Validator ส่วน Node ที่ทำหน้าที่ตรวจสอบ เราจะเรียกว่า Full Node

จากภาพ 1) เราจะเห็นว่ามี Miner / Validator พยายามสร้าง Block ที่ไม่ถูกต้อง (เช่นแอบโอนเงินชาวบ้านให้ตัวเอง) พอ Block สีแดงนี้ถูกส่งมาให้ Full Node ที่กระจายอยู่ทั่วโลกทำการตรวจสอบ Full Node ก็จะทำการปฏิเสธ Block นี้ ทำให้ Blockchain จะวิ่งต่อในสายล่าง (สีเขียว) ที่เป็นสายที่มีแต่ข้อมูลที่ถูกต้องเท่านั้น

แต่กลับกัน หากทุกคนพร้อมใจกันไม่ตั้ง Full Node ของตัวเอง แต่เชื่อถือ Miner / Valiator เลย Blockchain จะวิ่งต่อในสายบน (สีแดง) ส่งผลให้ทุกคนใน Blockchain ตกอยู่ในความเสี่ยงทันที

สรุปได้ว่า หากไม่มี Full Node หรือมีไม่เพียงพอ การโจมตีระบบโดย Miner / Validator จะสำเร็จได้โดยง่าย แต่หากมี Full Node เพียงพอ ต่อให้มีการสร้าง Block สีแดงสำเร็จ เครือข่ายก็จะไม่นับรวมเข้ามาในสาย Blockchain อยู่ดี

ทำไมระบบ Proof-of-Stake ถึงน่าสนใจกว่า Proof-of-Work

ในระบบ PoW คนสร้าง Block จะเรียกว่า Miner ที่ต้องอาศัยเครื่องขุด และได้รับผลตอบแทนเป็นเหรียญดิจิทัล

ในระบบ PoS คนสร้าง Block จะเรียกว่า Validator ที่ต้องวางหลักทรัพย์เป็นเหรียญดิจิทัล และได้รับผลตอบแทนเป็นเหรียญดิจิทัล แต่หากกระทำผิดจะถูกยึดทรัพย์

เปรีบเทียบกระบวนการลงโทษ

ในการสร้าง Block ของระบบ PoW หาก Miner พยายามสร้าง Block ที่ผิด จะแค่ถูกปฏิเสธจากเครือข่าย* ส่วนระบบ PoS หาก Block ถูกระบุว่าผิด Validators ที่ลงความเห็นต่อ Block นั้น จะถูกยึดทรัพย์ (ทั้งหมดหรือบางส่วน)

Miner ในระบบ PoW ต้นทุนหลัก ๆ คือค่าไฟ และค่าเสื่อมของเครื่องขุด

จากข้อมูลนี้ หากบทลงโทษของ PoS ถูกกำหนดเอาไว้อย่างเหมาะสม จะทำให้ต้นทุนในการโจมตีระบบ PoS สูงกว่า PoW เป็นอย่างมาก และถึงแม้สามารถสร้าง Block ที่ผิดได้สำเร็จแล้ว การที่ Full Node ทั่วโลกจะยอมรับ ก็จะยิ่งยากขึ้นไปอีก

Sharding และ Validation

Sharding คือหนึ่งในจุดขายของ Ethereum 2.0 ที่จะแตก Blockchain ออกเป็นหลายสาย (มองเป็นถนนที่มี 100 เส้นขนานกันไป) ทำงานไม่ขึ้นต่อกัน (แต่คุยไปมาหากันได้) ถ้าเรากำหนดให้ทุก Full Node ต้องตรวจสอบทุกธุรกรรมของทุกสาย (Validation) การทำงานคงไร้ประสิทธิภาพ และไม่ตอบโจทย์การแตกเป็นหลายสายตั้งแต่แรก ดังนั้นการออกแบบที่เหมาะสมควรจะเป็น “ตรวจสอบเท่าที่จำเป็น” แทน

ตรวจสอบเท่าที่จำเป็น ถือเป็นพัฒนาการที่สำคัญในระบบ Blockchain เพราะแต่เดิมการจะเป็น Full Node ได้ ต้องตรวจสอบทุกธุรกรรมเท่านั้น แต่ Ethereum 2.0 มองต่างออกไป ว่าเราสามารถทำระบบ False Alarm ที่มีแนวคิดว่า แต่ละ shard มี Full Node ที่ตรวจสอบทุกธุรกรรมของสายตัวเอง แล้วส่งสัญญาณ False Alarm ออกมาหากเจอธุรกรรมที่ไม่ถูกต้อง พอ Node ไหนที่ได้รับสัญญาณนี้ ก็จะทำการขอ Fraud Proof ไปที่เครือข่าย และทำการ re-validate (ตรวจสอบอีกครั้ง) ว่าผิดจริง แล้วจึงส่ง False Alarm ออกไปเป็นทอด ๆ จนทุก Node ในเครือข่ายได้รับสัญญาณนี้จนครบ

False Alarm นี้ทำให้ลดภาระการตรวจสอบทุกธุรกรรม (Computing power) ลงไปได้มาก จนสามารถรัน Full Node บนเครื่องโน๊ตบุ๊คก็ยังได้

Light clients

Light client คือโปรแกรม Blockchain ที่ขนาดเบา และสามารถรันอยู่บนอุปกรณ์ขนาดเล็กได้

สิ่งที่เป็นความฝันของผู้พัฒนา Blockchain สาธารณะเสมอมา แต่ยังไม่เกิดขึ้นจริงในปัจจุบันก็คือ การให้มือถือ / ตู้เย็น / แอร์ / และทุกอุปกรณ์ IoT (Internet of things) สามารถรัน Blockchain ได้โดยปลอดภัย จากแต่เดิม Light client ได้ข้อมูลจาก Full Nodes ที่ตัวเองเชื่อมต่ออยู่เท่านั้น* เป็น Light client จะ subscribe (รับข้อมูล) fraud proof package ด้วยอีกทางหนึ่ง (คล้าย ๆ ระบบ push notification เวลา facebook มีข้อความใหม่) ทำให้ระบบมีความแข็งแกร่ง และสามารถใช้งานได้จริง

* Light client สามารถโดนโจมตีได้โดยง่ายจาก Miner / Validator หากปราศจาก Fraud proofs

สรุป Ethereum 2.0

Ethereum 2.0 นอกจากเปลี่ยนระบบ Consensus จาก PoW ไปเป็น PoS แล้ว ยังมีการเร่งประสิทธิภาพด้วยระบบ Sharding ที่แตก Blockchain ออกเป็นหลายสาย และสร้างระบบ False Alarm / Fraud Proof ขึ้นมาเพื่อให้ Full Node สามารถรันบนคอมพิวเตอร์ส่วนบุคคลได้ เพิ่มความแข็งแกร่งของระบบไปอีกระดับ เพราะใคร ๆ ก็รัน Full Node ได้ ผสมกับ Light client ที่เอา Blockchain ไปรันบนอุปกรณ์ขนาดเล็กเช่นมือถือได้อย่างมั่นใจ ทำให้เราสามารถสรุปได้ว่า Ethereum 2.0 ถือเป็นเป้าหมายสำคัญของการยกระดับ Blockchain สาธารณะ ให้ดียิ่งขึ้น จนเข้าใกล้ Mass Adoption (การมี Blockchain อยู่ในชีวิตประจำวัน) ในเร็ววัน

Ref:
A Philosophy of Blockchain Validation (Vitalik Buterin) https://vitalik.ca/general/2020/08/17/philosophy.html

ปรัชญาการออกแบบ Ethereum 2.0 ด้วยระบบ Validation was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

จากเหตุการณ์โจมตี bZx ทั้งสองครั้งติด ๆ กัน ในไม่กี่วันที่ผ่านมา มูลค่าความเสียหายราว 28 ล้านบาท (ประมาณการ) ถือเป็นการโจมตี DeFi ครั้งใหญ่ครั้งแรก และใช้ DeFi หลายโปรโตคอลรวมกัน (DeFi composability) ในการโจมตีทั้งสองครั้ง

หมายเหตุ: สำหรับโปรโตคอลอื่นนอกเหนือจาก bZx เป็นการทำกำไรจาก ระบบการเงินปกติ แต่ส่วนของ bZx เกิดจาก Bug ใน Smart Contract

ref: https://thedefiant.substack.com/p/arbs-exploit-defi-to-make-900k-in

หากคนสนใจในรายละเอียดเชิงลึก ลองศึกษาจาก ref ด้านบน หรือค้นหา “bzx attack” ได้ครับ มีบทความวิเคราะห์ไว้หลากหลายทีเดียว

การตื่นตัวในการมาของ Flash Loan

Flash loan เป็นอีกหนึ่ง DeFi (Decentralized Finance) โปรโตคอล ที่พึงมีการพูดถึงกันไม่นาน ผู้เล่นในปัจจุบันมี dYdX, Aave และ bZx โดยการเข้าใจหลักการทำงานของโปรโตคอลนี้เป็นสิ่งสำคัญที่ผู้ออกแบบ DeFi ทุกคนควรศึกษา เพื่อที่จะได้เตรียมพร้อมรับมือกับเหตุการณ์ที่ไม่คาดฝันเช่นนี้

Flash Loan คืออะไร?

Flash loan คือโปรโตคอลการกู้ยืมแบบไม่ต้องค้ำประกัน (unsecured loan) โดยสามารถกู้เหรียญจำนวนเท่าใดก็ได้ (ตามที่ Pool มี) โดยมีเงื่อนไขเดียว คือต้องคืนเงินกู้เต็มจำนวนภายในเสี้ยววินาที!!! ฟังไม่ผิดครับ ต้องคืนเงินกู้ ณ เวลาเดียวกับตอนที่ยืมเลย

หรือถ้าอธิบายในภาษาเทคนิคคือ ต้องคืนภายใน Transaction เดียวกัน ดังนั้นคนธรรมดาทำไม่ได้แน่นอน (ยกเว้นคุณเป็น The Flash!) ต้องทำผ่าน Smart Contract เท่านั้น เพราะด้วยคุณสมบัติของ Smart Contract ที่ทำงานได้หลายคำสั่งใน Transaction เดียว ทำให้ Flash Loan ถือกำเนิดขึ้นมาได้ โดยผู้ปล่อยกู้จะเช็คว่าก่อนจบ Transaction ได้เงินกู้คืนมาครบหรือไม่ ถ้าไม่จะทำการยกเลิก (Revert) ทั้ง Transaction

หมายเหตุ: ผู้กู้ก็เป็น Smart Contract เช่นกัน และตอนคืนต้องคืนพร้อมดอกเบี้ย (ถ้ามี)

Flash Loan ทำอะไรได้บ้าง

1. ใช้เพื่อทำ Arbitrage หรือทำกำไรจากราคาที่ต่างกันสองตลาด เช่นกู้ DAI ไปซื้อ ETH จาก Kyber ในราคาที่ถูกกว่า แล้วนำไปขายที่ Uniswap ในราคาที่แพงกว่า
2. Collateral swap หรือ กู้เพื่อไปคืนเงินกู้ แล้วเอา Asset ที่ค้ำไว้ถอนออกมา แล้วเอาไปค้ำเพื่อกู้ต่อในอีกระบบนึง (Interest Rate Swap)
3. Liquidation กู้เพื่อไปคืนเงินกู้ (เหมือนข้อ 2) แล้วเอา Asset ที่ค้ำไว้ไปขายในตลาด แล้วเอาส่วนนึงไปคืนเงินกู้ ส่วนมากวิธีนี้ใช้เพื่อป้องกันไม่ให้ถูก liquidate ที่จะเสียค่า penalty ที่สูง

ref: https://medium.com/aave/flash-loans-one-month-in-73bde954a239

เอา Flash Loan มาสร้างให้ระบบการเงินผิดปกติ

ตรงนี้ผมจะอธิบายคร่าว ๆ นะครับ ไม่ลงรายละเอียดมาก

ทั้ง 2 เคสที่โจมตี bZx คือ ผู้โจมตีเขียน Smart Contract เพื่อกู้เงินจาก Flash loan แล้วเอาไปทำ Arbitrage ในระบบ แต่แทนที่จะเป็นการทำ Arbitrage ธรรมดา กลับใช้เงินส่วนนึงที่กู้ ไปทำการปั่นราคา (Price Manipulation) ส่งผลให้ WBTC ราคาเกินจริงไปมาก ทำให้ได้กำไรจากการทำ Arbitrage โดยแทบไม่ต้องลงทุนอะไรเลย (เสียค่า gas ให้ Ethereum เล็กน้อย)

Maker Dao ตั้งการ์ดรับมือ ป้องกันไว้ดีกว่าแก้

เนื่องด้วยโปรโตคอล MakerDAO อาศัยเหรียญ MKR แทนเสียงโหวตเพื่อปรับค่า Parameters ต่าง ๆ ของระบบ ที่เรียกว่า Executive Vote โดยอำนาจของเหรียญนี้มีมาก (ถึงขนาดโหวตให้เสกเหรียญ MKR เพิ่มขึ้นมาก็ได้) ทำให้มีการกังวลว่าหลังจากเหตุการณ์ bZx เกิดขึ้นแล้ว อาจมีคนพยายามทำ Proposal ประสงค์ร้าย แล้วกู้ MKR จาก Flash loan มาโหวตให้ผ่านได้

วิธีการป้องกันก็เรียบง่ายมากครับทาง Maker ได้มีการร้องขอผ่าน Community ให้รวมเสียงของทั้ง Community มาไว้ที่ Hat ซึ่งเป็น Proposal ตั้งรับ โดยเสียง ณ ตอนนี้รวมกันได้ 150,000 เสียงแล้ว คิดเป็น 76% ของผู้มีสิทธิออกเสียงในปัจจุบัน หรือคิดเป็น 15% ของเหรียญที่มีอยู่ทั้งระบบ

โดยการทำแบบนี้ทำให้หากต้องการจะโจมตี ต้องมีเสียงมากกว่า 150,000 เสียงถึงจะชนะ ซึ่ง Flash loan pool ที่ผมเช็ค มีแค่ 890 เหรียญเท่านั้นเอง

หมายเหตุ: Hat คือ Proposal ตัวล่าสุดที่ได้รับการ Activated อยู่

MakerDAO Next Step

วันนี้ MakerDAO จะทำการเปิดโหวต Proposal เพื่อ Implement ระบบที่เรียกว่า GSM (Governance Security Module) ใช้ในการหน่วงเวลา Proposal ที่ชนะแล้ว ไม่ให้ทำการ Active ได้ทันที เช่น หน่วงเวลาเอาไว้ 24 ชั่วโมง เพียงเท่านี้ Flash loan ก็ทำอะไรไม่ได้แล้ว

สรุป สิ่งที่เราได้จากเหตุการณ์นี้

DeFi เป็น Ecosystem ที่ใหม่มาก และมีแนวโน้มว่าจะมีอัตราการเติบโตที่สูง (สูงกว่าที่ใครหลาย ๆ คนคิดไว้) การมี DeFi Protocol ที่มากขึ้นในอนาคต ก็อาจก่อให้เกิดความเสี่ยงที่มากขึ้นตาม โดยเฉพาะอย่างยิ่งการมี Bug ใน Smart Contract เมื่อเกิดความเสียหายแล้วก็ยากที่จะเอาเงินคืนกลับมาได้

สำหรับนักพัฒนา เราต้องตระหนักถึงเรื่องนี้ และเตรียมรับมือกับเหตุการณ์เหล่านี้ให้ได้ ขอให้ศึกษาระบบ DeFi แต่ละเจ้าให้ดี ทั้งหลักการทำงาน ทีมงาน และความปลอดภัยที่ระบบออกแบบไว้ อีกทั้งไม่ควรลงทุนในจำนวนที่มาก (ตามความเสี่ยงที่รับได้)

ต่อไปนี้ใครทำระบบอาจต้องคำนึงถึง Flash Loan ด้วยว่าระบบเราจะถูกโจมตีด้วยวิธีนี้หรือไม่ อย่าง MakerDAO ก็รีบหาทางป้องกันทันที เพราะถ้าหากวันหนึ่งใน Pool มีเหรียญ MKR มากพอแล้วถูกยืมมา Vote ตัว Proposal ที่ประสงค์ร้ายก็จะเกิดความเสียหายได้

ขอบคุณพี่ฮ้อ TonHorที่ช่วยตรวจบทความ

Maker DAO (DAI) เตรียมอัพเดตระบบ ป้องกันการโจมตีจาก Flash Loan was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

ต่อเนื่องจากงาน Libra Developer Bangkok ที่จัดกันไปเมื่ออาทิตย์ที่ผ่านมา ได้เสียงตอบรับจากนักพัฒนาชาวไทยอย่างล้นหลาม ชนิดที่ว่าเกินความคาดหมายไปเยอะมาก ตั้งแต่บัตรหมดภายใน 1 วินาที!!! ใช่ครับ ผมยังตกใจเลย แบบถาม “พี่ฮ้อ ระบบัตรเรามีปัญหาหรือเปล่า” ก็ได้รับคำตอบว่า “หมดแล้ว มันหมดภายใน 1 วินาที” O_O และมียอดชมผ่าน Live และดูย้อนหลังกว่า 20,000 views

อีก 1 ไฮไลท์ในงานก็คือ การเปิดตัว LibraCoffee.io ซึ่งเป็นระบบ Libra Merchant แรกของโลก ที่พยายามแสดงให้เห็นถึง Use case เวลาใน Libra มาใช้จริงในการซื้อกาแฟ ว่ามีประสบการณ์ใช้งานอย่างไร โดยผู้ที่ได้เข้าร่วม ก็ได้ใช้ Libra Wallet POC ในการจ่ายค่ากาแฟ โดยมีให้เลือก 4 เมนูด้วยกัน และชำระเงินด้วยเหรียญ Libra Coins จบภายใน 3 วินาที!

การใช้งาน LibraCoffee.io

• ร้านค้าเปิด LibraCoffee.io ด้วย Web browser เช่น Safari หรือ Chrome บน iPad, Notebook หรือ PC จากนั้นให้ผู้ใช้ จิ้มไปที่เมนูที่ แล้วกด “PAY”

• ระบบทำการสร้าง QR Payment สำหรับใช้งานครั้งเดียว ที่ระบุค่า 3 อย่างใน QR นี้คือ 1) address ของร้านค้า 2) จำนวนยอดที่ต้องชำระ 3) ชื่อร้านค้า

• ผู้ใช้เปิด Libra Wallet POC กด “Send/Pay” แล้ว Scan QR โค้ดที่หน้าจอ

• ผู้ใช้ยืนยันการชำระเงิน

• ร้านค้าได้รับเงิน และแสดง E-Receipt ที่หน้าผู้ใช้ทันที

เทคนิคการทำงานเบื้องหลัง

ตัว LibraCoffee.io ถูกพัฒนาในรูปแบบ Open Source แบบ MIT License อยู่ที่นี้ครับ https://github.com/kulapio/libra-merchant โดยสร้างขึ้นด้วย Vuejs และใช้ Libra Service APIs (ในส่วนนี้ ผมเขียนอธิบายไว้ใน blog นี้) ในการสร้าง Address เพื่อรับเงิน และเช็คยอดเงิน

Step 1 ผู้ใช้กดจ่ายเงิน

ทันทีที่ผู้ใช้กดจ่ายเงิน ระบบจะทำการเรียก Creat Wallet API เพื่อให้ได้ Address ใหม่มา และยอดเงินเป็น 0

Request
Method: POST
URL: https://libraservice2.kulap.io/createWallet

curl --location --request POST "https://libraservice2.kulap.io/createWallet" \
  --header "Content-Type: application/json" \
  --data "{
    \"minting\": false
}"

Response

{
  "address": "e79fa865dd12d554312..",
  "balance":"0"
}

เราจะได้ Address เพื่อใช้ในการชำระเงินครั้งเดียวมา (ผู้ใช้คนละคน และชำระเงินคนละครั้ง ก็จะเป็น Address ต่างกันไปทุกครั้ง)

Step 2 ระบบทำการเช็คว่ามีเงินโอนเข้าหรือยัง

ตัวระบบ Libra Merchant จะทำการเรียก Get Balance API เพื่อทำการเช็คทุก 2 วินาที ว่ามีเงินโอนเข้ามาหรือยัง และเกินยอดที่กำหนดไว้หรือไม่

Request
Method: POST
URL: https://libraservice2.kulap.io/createWallet

curl --location --request POST "https://libraservice2.kulap.io/getBalance" \
  --header "Content-Type: application/json" \
  --data "{
	\"address\": \"e79fa865dd12d554312...\"
}"

Response

{
  "address": "e79fa865dd12d554312..",
  "balance":"14.5"
}

หากยอดที่ชำระเข้ามาถึงแล้ว ก็แสดงหน้า Thank you พร้อมแสดงยอดที่ได้รับ

Step 3 ฝั่งผู้ใช้ชำระเงินแล้ว

พอผู้ใช้ได้ชำระเงินเสร็จแล้ว ก็จะแสดงหน้า E-Receipt เพื่อแสดงเลขอ้างอิง โดยจะใช้ Unique Address ของผู้รับ 6 ตัวอักษรแรก เป็น Reference id ครับ

สรุปปิดท้าย

จะเห็นได้ว่า Flow การทำงานเรียบง่ายมาก แทบไม่มีอะไรซับซ้อน แต่กลับสร้างผลตอบรับที่ดีจากผู้ใช้ เพราะทำให้ผู้ใช้สามารถทดลองจ่ายเงินซื้อกาแฟ (แบบจำลอง) และได้ประสบการณ์ผู้ใช้จริง หากมีการนำไปต่อยอดจนใช้งานจริงได้ เราอาจได้เห็นการท่องเที่ยวไทยที่มีเม็ดเงินมหาศาลอยู่แล้ว ลูกค้าต่างชาติสามารถซื้อกาแฟ เข้าร้านสะดวกซื้อ หรือจับจ่ายในห้าง ได้ด้วย Libra Wallet ได้เลย โดยไม่ต้องยุ่งยากในการแปลงเงินไปมา ทำให้เพิ่มยอดขายให้กับร้าน เพื่อเป็นอีก 1 ทางเลือกในการจับจ่ายได้ครับ

ใน Step ถัดไป ผมจะพัฒนาตัว Libra Merchant ให้ร้านค้าสามารถเก็บเงินได้จริง ๆ ใน Wallet ของร้านเอง แทนที่จะใช้ Create Wallet API ที่สร้างจากฝั่ง Client เพื่อความปลอดภัยในการใช้งาน และยังคงประสบการณ์การใช้งาน ให้ง่ายหมือนเดิม ครับผม

หากใครสนใจอยากศึกษาและพัฒนา Libra Blockchain มากกว่านี้ทางเราจัดคอร์สเรียน Libra Blockchain แบบเต็มวันที่มีเนื้อหาครบถ้วนก็ลองไปดูรายละเอียดกันได้ครับ Build DApps on Libra Blockchain

หากใครชอบบทความ ฝากกดติดตาม Kulap Official กันได้นะครับ ทีมงาน Kulap เราเป็นทีมที่สนใจศึกษาด้าน Blockchain โดยเฉพาะ และกำลังทำ Decentralized Exchange (Dex) กันอยู่ครับ

☕ Libracoffee.io ระบบสั่งซื้อกาแฟด้วยเหรียญ Libra เป็น Use case แรกของโลก was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

สวัสดีครับทุกท่าน จบไปแล้วกันง่าย Libra Developer Bangkok ที่จัดโดย เหล่านักพัฒนาจากคนไทย รวมไปถึงเหล่า contributes ให้กับโปรเจค Open Source Libra หลายตัว ที่ค่อนข้าง active กันมาก เดือนเดียวมีโปรเจคที่ทีมผมทำกันทั้ง contributes / watch เพียบเลย ซึ่งผมเองก็มีโอกาสได้พูดในหัวข้อ “The First Libra Wallet: how to build your own wallet”

โอเคมาเข้าประเด็นกันเลย ทางทีมงาน kulap.io เราได้มีโอกาสทำ Libra Wallet POC https://dev.kulap.io/libra/ ไปตั้งแต่วันแรก ๆ ที่ Libra เปิดตัวออกมา แต่ ณ ตอนนั้นทุกอย่างยัง early มาก เราเลยใช้วิธี hack ๆ กัน โดยการรัน express.js ตัวหนึ่งมารับ api create / query balance / transfer แล้วเบื้องหลังไปเรียก docker มาทำงานอีกที ใครสนใจลองอ่านบทความ The First Libra Wallet POC นี้ได้ครับ

ซึ่งได้รับความสนใจเยอะมาก จนตอนนี้มีผู้ใช้งานมากกว่า 17,000 คน และมีธุรกรรมมากว่า 140,000 ธุรกรรมที่เกิดขึ้นในระบบ Libra Blockchain

แต่ระบบนี้ก็มีความปลอดภัยที่ต่ำ เนื่องจากมีการสร้าง secret key (mnemonic phrase / private key) ที่เป็นกุญแจลับในการเข้าถึงบัญชี Libra จาก server แล้วส่งให้ผู้ใช้ แล้วพอผู้ใช้จะโอนเงิน ก็ต้องส่ง secret key ไปที่ server อีก ตรงนี้หาก server โดนโจมตี หรือโดนดักฟัง เงินในบัญชีก็จะมีความเสี่ยงทันที

Introduce npm i kulap-libra 🔱

พอมีผู้ใช้สูงขึ้น เราก็เลยคิดว่าถึงเวลาอัพเกรดให้เข้าใกล้ Production grade ด้วยการทำให้มันเป็น Crypto Wallet จริง ๆ เลยด้วยการใช้ kulap-libra npm package ในการ create / transfer จาก Browser และ nodejs ได้โดยไม่ต้องพึง Server อีกต่อไป (ตัว Kulap Libra Wallet อัพเกรดมาใช้ตัวนี้เรียบร้อย)

ก็เลยอยากจะพาเพื่อน ๆ มาลองเขียน Wallet ใช้เองกันดู โดยจะเริมตั้งแต่ต้นเลย ใครอยากดูแบบ VDO เพื่อทำตามก็ได้นะครับ อันนี้เลย

Step 1) npm i kulap-libra

mkdir myfirstwallet
cd myfirstwallet

npm init -y
npm install kulap-libra

Step 2) สร้างบัญชี Libra

สร้างไฟล์ index.js จากนั้นเขียนคำสั่งสร้าง Wallet โดยใช้ new LibraWallet()

บรรทัดที่ 2 ทำการโหลด kulap-libra javascript library

บรรทัดที่ 5 เป็นจังหวะการสร้างรหัสลับด้วย Crypto Random เพื่อหาเลขสุ่ม และสร้างออกมาเป็น mnemonic phrase (ชุดคำ 24 คำ ที่เป็นความลับ) ขั้นตอนนี้ยังไม่มีการติดต่อกับ Blockchain แต่อย่างใด ทำให้ไม่มี Internet ก็สร้างได้

บรรทัดที่ 6 เป็นการสร้างบัญชีจาก mnemonic phrase ที่อยู่ใน wallet object โดย account ที่ได้จะประกอบไปด้วย Address, Public key และ Secret key (private key)

ลองรันด้วยคำสั่ง

node index.js

จะได้คำตอบประมาณนี้

{ 
    address:  '2ebdbe44a375c668d3d83d51adbb4fc118ec3754e6cdb5cae3612d933c7d7b5f',
    mnemonic: 'small bring zero feed found angle impose symptom scatter file category fee gentle orient fork gorilla robot van regret luxury almost garage wine illness' 
}

หรือถ้าใครรันไม่ได้ ให้แก้ package.json ตรง scripts ตามนี้

"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node index.js"
},

แล้วลอง

npm run start

เย้!! เราสร้าง Libra Wallet เป็นของตัวเองได้ง่าย ๆ แล้ว หากเรารันอีกครั้งก็จะได้ Wallet ใหม่ทุกครั้ง ถ้าอยากใช้ Wallet เดิมต้อง load menmonic phrase เข้าไป ใครสนใจศึกษาเพิ่มเติมได้ที่นี้ครับ https://github.com/kulapio/libra-core

Step 3) รับเหรียญฟรี 1,000 เหรียญจาก Libra Testnet Faucet

ก่อนอื่นต้องลง bignumber.js เพราะต้องใช้ในการแปลง Micro LIB <-> LIB

npm install bignumber.js

- แก้ไฟล์ index.js ตามนี้ เพิ่มส่วน mint เข้าไป

บรรทัดที่ 16 เป็นการสร้าง client เชื่อมไปยัง Libra Testnet

บรรทัดที่ 17 จะเห็นว่ามีการ * 10⁶ เพราะว่าเหรียญ Libra Coins หรือ LIB จะมีทศนิยมทั้งหมด 6 หลัก ถ้าเราสั่งเสกเหรียญ 12 เหรียญ ต้องระบุเป็น 12000000

จะได้คำตอบประมาณนี้

...
mintingResult 188168

** ตัวเลข 188168 เป็นตัวเลข Transaction ID ของคนเสกเหรียญ ไม่ใช่ยอดเงินนะ

ทีนี้เราก็เอา address ของเราไปเช็คยอดเงินที่ https://libexplorer.com/ ด้วยการใส่ address ไปในช่อง search

อูฮูยย เราได้เงินแล้ว!! 👼 ง่ายจัง เป็น Dev นี้ดีจริง ๆ ทีนี้เราก็เอาเงินตรงนี้ไปซื้อบ้าน ซื้อรถ กันเถอะ…. เดี่ยว ๆ ตื่น ๆ อันนี้เงิน Testnet ครับ ไม่มีมูลค่าอะไร เพราะเสกให้กันฟรี ๆ ต้องรอ Mainnet อันนั้นแหละเงินจริง (แล้วก็ต้องใช้เงินเราไปซื้อเช่นกัน)

Step 4) เพิ่มโค้ดเช็คยอดเงิน Balance

ดูผ่าน Libra Explorer มันก็ง่ายดี แต่ไม่ geek เราสาย Dev ต้องอ่านด้วยโค้ดสิ งั้นมาเพิ่มโค้ดกัน

บรรทัดที่ 25 ทำการเช็คสถานะล่าสุดของบัญชี address ที่เรากำหนด (เบื้องหลังจะทำการ Update to latest ledger) เราจะได้หลายค่ากลับมา เช่น balance, sequence number, sent/receive events count

บรรทัดที่ 28, 31 ทำการแปลงไปมาระหว่างหน่วย LIB <-> Micro LIB

run แล้วจะได้คำตอบแบบนี้

...
balanceResult 1000

Step 5) สั่งโอนเงิน

การโอนเงินบนโลก Blockchain เราจะใช้ Private key เซ็นคำสั่งโอนเงิน (transaction script) บน client แล้วค่อยส่งผ่านไปยัง Admission Control ผ่าน LibraClient ดังนี้

ผมปรับ บรรทัดที่ 7 ให้โหลดค่าจาก mnemonic phrase ที่เราได้จากจากขั้นตอนก่อนหน้า เราจะได้เข้าถึงบัญชีเดิมทุกครั้งไม่ต้องสร้างใหม่

บรรทัดที่ 11 เพิ่มให้ return account object ออกมาด้วย

บรรทัดที่ 38 เป็น function โอนเงิน โดย ณ บรรทัดที่ 40 ด้านใน lib kulap-libra จะทำการลงลายเซ็นดิจิตอลด้วย private key ของเรา และทำการส่งไปยัง ac.testnet.libra.org (Admission Control ของ Libra Testnet) ให้

บรรทัดที่ 58 ทำการเรียกใช้คำสั่งโอนเงิน โดยระบุ address ผู้รับ ตรงนี้อาจใช้ https://dev.kulap.io/libra/ เพื่อเป็น wallet ผู้รับ กด Receive แล้ว copy address มาใช้ได้ (พอโอนเสร็จ กด refresh เพื่อเช็คยอดเงินเข้า)

ผลลัพธ์

...
balance Before 927.999976
transferResult 0
balance After 915.999976

เย้!! 😄 เราโอนเงินสำเร็จแล้ว และยอดเงินก็ได้ลดแล้ว ทีนี้ก็อย่าลืมลองเช็คที่ผู้รับกันด้วยนะครับ

สรุปส่งท้าย

เราจะเห็นได้ว่าในโลก Blockchain ในทีนี้คือ Libra Blockchain สามารถที่จะเขียนโปรเจคสั่งงาน เพื่อทำระบบ Crypto Wallet ได้ด้วยตัวเอง และเป็น Protocol กลางที่ทุก ๆ โปรแกรมของทุก ๆ คนสามารถที่จะติดต่อสื่อสารกันได้ กล่าวคือ ผมอาจสร้าง Wallet ของตัวเองชื่อว่า Kulap Wallet แล้วเพื่อนผมสร้างชื่อ TonHor Wallet ทั้ง 2 ผู้ให้บริการนี้ไม่เคยคุยกันมาก่อน แต่ก็สามารถส่งเงินหากันได้ เพราะเราใช้ Protocol ในการสื่อสารที่เหมือนกันนั้นเอง

หากใครสนใจที่จะสร้าง Wallet ต่อยอดจาก kulap-libra javascript ตัวนี้ ก็อย่าลืมแบ่งปั่นให้เพื่อน ๆ ใน Libra and Move Developers Thailand ได้ลองเล่นก้นด้วยนะคร้บ และหากให้อยากต่อยอดมากกว่านี้ทางเราจัดคอร์สเรียน Libra Blockchain แบบเต็มวันที่มีเนื้อหาครบถ้วนก็ลองไปดูรายละเอียดกันได้ครับ Build DApps on Libra Blockchain

หากใครชอบบทความ ฝากกดติดตาม Kulap Official กันได้นะครับ ทีมงาน Kulap เราเป็นทีมที่สนใจศึกษาด้าน Blockchain โดยเฉพาะ และกำลังทำ Decentralized Exchange (Dex) กันอยู่ครับ

หมายเหตุ: ขอบคุณพี่ฮ้อ TonHor ที่ช่วยตรวจบทความให้

พัฒนา Libra Wallet ใช้เอง กันง่าย ๆ ด้วย libra-core.js ที่ทำงานได้ทั้งบน Browser และ Nodejs — Part1 was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

(28/06/2019) Now, we have users more than 3,000 with more than 21,000 transactions using our wallet.

It’s been almost a week since Facebook announced Libra Blockchain which has Libra Coin run on it. Libra Coin is a Stable coin backed by a basket of fiat currencies. Libra Coin itself is created by Move language that Facebook announced alongside with its blockchain.

Libra is an open source project so we can look inside, play around with it or create a custom module (by Move language). So for Developers it just easy to get started with Libra-CLI to create an account, mint some coins and send it to your friends (of course Developers).

Just try this one, https://developers.libra.org/docs/my-first-transaction

And Thai version here.

What about normal users? who might interest Libra right now? do they have a chance to get some Libra coins? of course not because we no have a user interface for now (Yeah it just getting started 🎉).

Introduce Libra Wallet POC

You can try the first Libra wallet here => https://dev.kulap.io/libra/

At Kulap.io as we’re smart contract developers for Ethereum that building Dex (Decentralized Exchange). we see a lot of opportunities here, and we think mass users should have a chance to try it out so we create Libra Wallet POC that easy to use on hands of all users.

Libra Wallet POC is a web wallet that allows users to create their wallets (with 100 Libra Coins) as just open a web page, and send it to their friends with QR Code!

Quick walkthrough

1. Open this page https://dev.kulap.io/libra/

It will be creating your wallet with 100 Libra coins on it.

If don’t get 100 coins to please clear browser local storage and try again.

2. Send to your friends (or other browsers)

Select “Send” to scan QR or use “Manual” to provide target address yourself (you can use an account on Libra-CLI here), then “Confirm”.

3. Done

Then, you should see now your wallet remain balance’s 90 Libra coins.

And the destination address received 10 Libra coins.

Libra wallet APIs

Right now Libra project hasn’t officially announced any APIs that we can use with frontend so we decide to make our own APIs that routing any requests to Libra-CLI and return the result from it.

1. Creating a wallet

[POST] https://libraservice3.kulap.io/createWallet

Request Params:
// not thing or {}

Return:

You will get the mnemonic phrase (secret) and public address.

Will call Libra-CLI as following below.

1. account create

2. account mint 0 100

3. query balance 0

4. account write (to get your mnemonic phrase)

curl --location --request POST "https://libraservice3.kulap.io/createWallet" \
  --header "Content-Type: application/json" \
  --data "{}"

2. Transfer

[POST] https://libraservice3.kulap.io/transfer

Request:

Return:

Will call Libra-CLI as following below.

1. account recover

2. transferb 0 31c70925…14144b 11 (suffix ‘b’ is for waiting transaction to be committed to the blockchain)

curl --location --request POST "https://libraservice3.kulap.io/transfer" \
  --header "Content-Type: application/json" \
  --data "{
	\"fromAddress\": \"91f63f777d8fc5294a4a19a4631a1af4a7e3ae4829cf6b021275773b25782dc7\",
	\"mnemonic\": \"burger trust skirt hotel duck recipe vivid token south hero illness memory entry way property caution auto cram quality aisle choose erosion crane army;1\",
	\"toAddress\": \"31c7092554bb804a4e25bd24399859428404c28cbc3b44dea5dc2a9f2314144b\",
	\"amount\": \"11\"
}"

3. Get balance

[POST] https://libraservice3.kulap.io/getBalance

Request:

Return:

Will call Libra-CLI as following below.

1. query balance 08c7bdf6…0e18c3

curl --location --request POST "https://libraservice3.kulap.io/getBalance" \
  --header "Content-Type: application/json" \
  --data "{
	\"address\": \"91f63f777d8fc5294a4a19a4631a1af4a7e3ae4829cf6b021275773b25782dc7\"
}"

Postman

https://documenter.getpostman.com/view/1671913/S1a32SZ5?version=latest

Libra Wallet Service Architect

To build that APIs we need shell interactive that can send requests to Libra-cli so we use Node.js with child_process and rauschma/stringio libs to run a Libra-cli container every time when the user makes a request (stateless).

For example, createAccount() function will spawn a process of libra-cli container and pipe writableSteam and readableSteam to createAccountWriteToWritable and createAccountReadable accordingly to simulate shell command inout / output.

Inside “createAccountWriteToWritable”, will call each libra-cli commands step by step and use sleep() between each step to make sure that command from previous step has done.

Finally createAccountReadable we use to parse command output, record it to states, then return output to API caller (output return in createAccount() scope).

You can see all complete code here https://github.com/kulapio/libra-service.

The Frontend project

We use Vue.js and Axios for API calling so nothing fancy here if you interesting please have a look at https://github.com/kulapio/libra-wallet-poc.

Mnemonic phrase is saved on local storage, so you can just open another browser to have two wallets.

Conclusion

This POC Libra wallet focusses on users to show how it works by allowing them to play it on their smartphone, laptop or desktop. This’s not safe wallet so please don’t use this technique to your production wallet because sending mnemonic phrase around is not secure at all.

To building a production-grade wallet we should generate mnemonic phrase on the client and never sent it to anyone when the user needs to make a transaction wallet itself need to implement private key singing mechanism and use signed transaction to board cast to the network. Might implementing mnemonic phrase encryption with password as well.

Thank you

Thank you very much for your time reading. If you like this article feel free to share this article with your friends or someone who might be interested ^_^.

Thanks to Bitcoin-Addict Thailand for mentioning this Wallet as The first Libra Wallet in the world ^^.

Any questions please feel free to comments.

Feedback

After we launched our application until now (23 June) We have active users that create a wallet in our app > 1,000+ wallets. With 5,000+ transactions.

Welcome to contributing

Github

API Service: https://github.com/kulapio/libra-service

Frontend: https://github.com/kulapio/libra-wallet-poc

Ref

https://developers.libra.org/docs/my-first-transaction

The First Libra Wallet POC— Building your own Wallet and APIs was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

Libra เป็นสกุลเงินดิจิตอลแบบ Open source ที่ให้คนทั้งโลกใช้รับส่งเงินกันได้อิสระ และสามารถใช้ชำระค่าสินค้า และบริการได้ ใช้ Blockchain เป็นเทคโนโลยีเบื้องหลังในการจัดการ ตั้งแต่การสร้างบัญชี ฝากเงิน โอนเงิน ชำระเงิน และ Business logic (ใช่แล้วครับ มันคือธนาคารโดย facebook)

ตัวเหรียญจะถูกค้ำด้วยสกุลเงินต่าง ๆ ทั่วโลก ในการผลิต เช่น ผมส่งเงิน $100 เข้าไปยัง Libra Association ผมก็จะได้เหรียญ Libra กลับมาในมูลค่าเท่ากัน ในทางกลับกันหากผมส่งเหรียญ Libra กลับเข้า Libra Association (หน่วยงานที่รับแลก) ก็จะได้ $100 กลับคืนมา ทั้งนี้เหรียญ Libra จะมี rate ค่าเงินเป็นของตัวเอง (ใครสนใจอ่านต่อใน white paper ด้านล่างได้)

เตรียมเครื่องให้พร้อม

• ใช้งานได้บน Linux (Red Hat or Debian-based) หรือ macOS system เท่านั้น
• หากเป็น Mac ให้ลง Homebrew ให้เรียบร้อย
• Windows ไม่เขียนไว้ว่ารองรับ (T_T) ใครใช้ Windows ก็อ่านบทความนี้ไปพลาง ๆ ก่อน

มาลองเล่น Libra CLI กัน

1. เริ่มด้วยดาวน์โหลดโปรเจคจาก Github

git clone https://github.com/libra/libra.git

2. ติดตั้ง Libra Core

cd libra 
./scripts/dev_setup.sh

การติดตั้ง Libra Core จะดาวน์โหลดและติดตั้ง software ที่เราต้องใช้ เช่น rustup (ตัวติดตั้งภาษา Rust) protoc (protocol buffers) และก็ Go lang

ใครติดขั้นตอนนี้ ให้ลองดูที่ Troubleshooting

3. ติดตั้ง Libra CLI และเชื่อมต่อสู่ Libra Testnet

./scripts/cli/start_cli_testnet.sh

ขั้นตอนนี้ค่อนข้างนาน แนะนำให้ไปอาบน้ำ กินข้าวรอได้เลย ฮ่า ๆ

ตัวคำสั่งนี้จะ build และ run ตัว cargo และเชื่อมต่อไปยัง Validator node บน Libra Testnet

หากสำเร็จจะขึ้นแบบนี้

เย้ ๆๆๆ เราเชื่อมต่อกับ Blockchain ได้แล้ว ที่นี้ก็มาต่อด้วยการสร้าง Account และรับเหรียญ Libra ฟรีเป็นครั้งแรก (อันนี้ Testnet นะ ท่องไว้ ๆ)

ใครติดขั้นตอนนี้ ให้ดูที่ Troubleshooting.

4. สร้าง Account

libra% account create

>> Creating/retrieving next account from wallet
Created/retrieved account #0 address 0fd8527664496198346580b316ef68b9eb636f8f5a3c25322008e0a4e10c0326

• การสร้าง Account จะถือเป็นการสร้าง Key-pair บนเครื่องเรา ยังไม่บันทึกลงบน Blockchain

5. เสกเหรียญ

เนื่องด้วยเป็น Testnet เราเลยสร้างเหรียญเองได้ ด้วยคำสั่ง mint

libra% account mint 0 99

>> Minting coins
Mint request submitted

• 0 หมายถึง Account #0 ซึ่งตรงนี้จะใส่ full address จากด้านบนก็ได้

6. เช็คยอดเงิน

libra% query balance 0

Balance is: 99

7. สร้าง Account ที่ 2

libra% account create

>> Creating/retrieving next account from wallet

Created/retrieved account #1 address 6f0643a3a16ca18215bc8146d3d28c2f86101a4573181d175444e1b5ffdf881d

8. โอนเงินระหว่าง Accounts

libra% transfer 0 1 10

>> Transferring

Transaction submitted to validator

To query for transaction status, run: query txn_acc_seq 0 0 <fetch_events=true|false>

สั่งโอน account #0 -> account #1 จำนวน 10 เหรียญ เช่นกัน ตรงนี้จะแทน 0 1 ด้วย address แบบเต็มก็ได้

9. เช็คยอดใน Account ที่ 2

libra% query balance 1

Balance is: 10

10. ดู Transaction ที่โอนไปแล้ว

libra% query txn_acc_seq 0 0 true

0 แรกคือ account #0, 0 ที่สองคือ transaction sequence เช่นถ้าทำธุรกรรมครั้งถัดไป ค่านี้จะเป็น 1 2 3 4 ไปเรือยๆ

ก็เป็นอันจบเท่านี้ กับการเล่น Libra CLI จากที่เห็นการใช้งานค่อนข้างง่าย หากใครต้องการเล่นอะไรเพิ่มเติม ก็พิพม์ help ลงไป หรืออ่านต่อใน Libra Developer

Programmable money

สิ่งที่ไม่พูดถึงไม่ได้คือ ตัว Libra ถือเป็น Programmable money ประเภทหนึ่ง กล่าวคือ เราสามารถเขียนโปรแกรมควบคุมการไหลของเงินได้ เช่น ทำสัญญาเงินกู้ ระบบอนุพันธ์ หรือระบบ Exchange โดยเราจะเขียนด้วย Smart contract (ภาษา move) และรันบน Blockchain โดยตรง

ภาษา Move

เป็นภาษาที่ถูกออกแบบมาให้รันบน Libra โดยเฉพาะ โดยตัว bytecode จะ deploy ลง Libra Blockchain และรันโดย Move VM เพื่อทำ Business logic ตามที่เราต้องการ เช่น การสร้างสกุลเงิน (resource type) ที่เราสามารถกำหนดเงื่อนไขการผลิต และทำลาย ได้ตามต้องการ ทั้งหมดควบคุมด้วยภาษา Move โดยเหรียญ Libra เองก็สร้างด้วยวิธีนี้

ภาษา Move เทียบเท่า Solidity และ Move VM ก็เทียบเท่า EVM บน Ethereum

ลองดูตัวอย่างกันสักหน่อย

1. ตัวอย่าง Peer-to-Peer Payment

2. ตัวอย่าง Deposit

3. ตัวอย่าง Withdraw

ปิดท้าย

เราจะเห็นได้ว่า Libra ใช้งานค่อนข้างง่าย แถมมีภาษา Move รองรับการควบคุมเงินเพื่อตอบโจทย์ Fintech สำหรับองค์กรต่าง ๆ หรือบุคคลทั่วไป ที่ต้องการความง่ายในการรับส่งเงิน สำหรับชาว Dev ก็ขอให้จับตาดูตัวนี้ไว้ให้ดี ตามข่าวคาดว่าจะเปิดตัวในปี 2020 ถ้าใครจับกระแสดี ๆ เขียนโปรแกรมรองรับ อาจรวยได้นะครับ ฮ่า ๆ

หากใครชอบบทความ ฝากกดติดตาม Kulap Official กันได้นะครับ ทีมงาน Kulap เราเป็นทีมที่สนใจศึกษาด้าน Blockchain โดยเฉพาะ และกำลังทำ Decentralized Exchange (Dex) กันอยู่ครับ

Ref1: Libra White Paper https://developers.libra.org/docs/assets/papers/the-libra-blockchain.pdf?fbclid=IwAR0mj3f4ZmodUOP5GZzRXFgccyGrGIzCWpFopcYZDgCXOkYBTiCTR04wTLw

Ref2: Move White Paper https://developers.libra.org/docs/assets/papers/libra-move-a-language-with-programmable-resources.pdf

Ref3: My First Transaction https://developers.libra.org/docs/my-first-transaction

Libra มาลองเล่นสกุลเงินดิจิตอลใหม่ โอนเงินทั่วโลกภายในวินาที ค่าธรรมเนียมต่ำ โดย facebook was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

อาทิตย์นี้ทีม Kulap เราได้มีโอกาสเข้าร่วมงาน #SurgeBangkok เป็นงาน Hackathon จัดขึ้นโดย Unicef ในธีมงาน Financial Inclusion ซึ่งมุ่งหวังให้ผู้เข้าร่วมได้คิดไอเดียในการช่วยเหลือสังคม ด้วยการนำเทคโนโลยี Blockchain มาใช้ให้เกิดประโยชน์ในงานครั้งนี้

รูปแบบงานจะเป็นวันศุกร์จัด Workshop ที่สอนการใช้ Blockchain ในรูปแบบต่าง ๆ และวันเสาร์กับวันอาทิตย์เป็นเวลาให้แต่ละทีมมาแข่ง Hackahton กันโดยทีมเรามีด้วยกันทั้งหมด 5 คน ได้แก่ Nattapon Nimakul, Phuwanai Thummavet, Pongsatorn Nitithammawoot, Sarun Saengsomboon และ TonHor

ก่อนอื่นขอเล่าถึงบรรยากาศงานกันสักหน่อยครับ

Workshop ของ OmiseGO เล่าถึง Plasma ที่พึ่งขึ้น Testnet ทั้งสองตัว Ari (อารีย์) และ Samrong (สำโรง) ซึ่งในเวอร์ชั่น Samrong มีการเพิ่มส่วน Meta-data เข้าไปตอนทำธุรกรรมช่วยให้ DApps สามารถใส่ข้อมูลลงไปในธุรกรรมได้ และ EIP-712 ที่เปิดให้ Wallet เซ็นต์ชื่อธุรกรรมได้

ในส่วน Workshop ของ MakerDao ที่ทำเหรียญ Dai รอบนี้มาสอน Dai.js เพื่อใช้ในการสร้างเหรียญ Dai โดยใช้ Eth มาค้ำมูลค่าไว้ ตัว Dai.js จะส่งคำสั่งตรงเข้า Smart Contract ซึ่งเป็นส่วนที่ใช้ในโปรเจคของทีม Kulap เราด้วยในงานนี้

ในส่วน Workshop ของ Status ได้แจก Keycard ที่ใช้เก็บเหรียญคริปโต และจัดการ Private key ได้ในตัว ร่วมถึงรองรับ NFC ในการสั่งงาน

โอเค มาพูดถึงตัวระบบ Katinrun Fundraising Platform กัน

• ตัวระบบเข้ามาหน้าแรกก็จะเจอ รายการรับบริจาคต่างๆ ที่ Active อยู่ รอให้ผู้ใจดีมาบริจาค

• หากเราสนใจโครงการไหนเช่น โครงการก้าวคนละก้าวของพี่ตูนที่โด่งดังไปทั่วโลก หากเราอยู่อีกมุมโลกและอยากบริจาคด้วย ก็สามารถกด Donate now ได้ทันที

• ผู้บริจาคสามารถเลือกเหรียญที่ระบบรองรับได้ ซึ่งรองรับทั้งหมด 6 สกุลด้วยกัน

• หลังจากเลือกเหรียญที่เราต้องการบริจาค และระบุจำนวนเงินแล้ว ระบบจะคำนวณเป็นหน่วย Dai (เทียบเท่า USD) พร้อมแปลงให้อัตโนมัติผ่านระบบ DEX (Decentralized Exchange)

• สุดท้ายผู้บริจาคทำการยืนยันที่ตัว Crypto wallet ของตัวเอง เช่น Metamask, Coinbase wallet หรือ Trust wallet เพื่อบริจาคเข้าสู่โครงการนั้น ๆ โดยตรงผ่านระบบ Smart Contract ทำให้มั่นใจได้ว่าไม่มีใครเข้าถึงเงินบริจาค นอกจากผู้รับที่ระบุไว้ในโครงการเท่านั้น

รูปแบบการทำงานในเชิงเทคนิค

ตัวระบบจะแบ่งส่วนการทำงานหลัก ๆ เป็นทั้งหมด 3 ส่วนด้วยกัน

1. Frontend ส่วนนี้เขียนด้วย Vue.js ทำหน้าที่แสดงรายการโครงการที่รอรับการบริจาค และมีส่วน web3.js ที่ใช้ติดต่อ Smart contract เพื่อทำการบริจาคโดยตรงจาก Crypto wallet
2. Dex ระบบตัวนี้เป็นแก่นกลางสำคัญที่ทำให้ Platform นี้ทรงพลังมากขึ้น เนื่องด้วยโครงการต่าง ๆ ใน Platform นี้มีเป้าหมายการระดมทุนเป็นหน่วยดอลล่าร์เหรียญ Dai (=$1) แต่เพื่ออำนวยความสะดวกให้กับผู้สนับสนุนโครงการ เราได้รองรับ 6 สกุลเหรียญหลักบน Ethereum ประกอบไปด้วย Dai, Omg, Knc, Snt, Mesg และ Mkr โดยทุกเหรียญจะถูกส่งไปยัง Dex (Decentralized Exchange) เพื่อทำการแปลงเป็น Dai ณ ราคาปัจจุบัน แล้วจึงส่งไปบริจาคยังโครงการ โดยทั้งหมดนี้ทำจบภายใน 1 ธุรกรรมบน Blockchain ครับ (เรียกว่าเทคนิค Atomic)
3. Smart Contract ตัวนี้เป็นหัวใจของระบบ ทำหน้าที่จัดการ Logic ต่าง ๆ ในการทำโครงการรับบริจาค เช่น สร้างโครงการใหม่ กำหนดเป้าหมายโครงการ (จำนวนเหรียญ Dai ที่ต้องการ) บันทึกการบริจาคของทุกคน ส่งเงินให้ผู้รับบริจาคเมื่อโครงการระดมทุนสำเร็จ และทำการคืนเงินทันทีให้กับทุกคนเมื่อการบริจาคไม่ถึงเป้าหมาย ตรงนี้เขียนด้วย Smart Contract ในภาษา Solidity ทั้งหมดครับ

รางวัลที่เราได้รับ

ในงานนี้เราได้ 2 รางวัลด้วยกัน คือ

1. รางวัลจากโจทย์การนำระบบ MakerDAO ไปใช้ในประเทศเศรษฐกิจเกิดใหม่ ที่ผู้คนจำนวนมากยังเข้าถึงระบบทางการเงินได้ยาก ซึ่งในตัวโปรเจคเราใช้เหรียญ Dai (สร้างโดยระบบ MakerDAO) เป็นสื่อกลางสำคัญในการระดมทุนให้โครงการ

2. รางวัลจากการนำระบบ Embark ซึ่งเป็นระบบจัดการตัว Smart Contract ที่ช่วยตั้งแต่ขึ้นโปรเจค ทำ automated testing ร่วมไปถึงมีระบบ Dashboard ที่ช่วย Debug ตัว Smart Contract ได้โดยตรงจากเว็บเลย ส่วนตัวผมค่อนข้างชอบตัว Embark นี้หลังจากได้ลองใช้ในงานนี้เป็นครั้งแรก ให้ความรู้สึกเหมือนมี Truffle + Remix ในตัวเดียวกัน

ขอบคุณผู้จัดงาน และทีมทุกคนครับ

Github: https://github.com/kulapio/surge-hack-fundraising-platform

Demo: https://katinrunfoundation.github.io/

ลาไปกับรูปบรรยากาศของงาน 📷

ภาพทั้งหมดสามารถเข้าไปดูได้ที่อัลบั้มเลยจ้า

โปรเจคระดมทุน Katinrun Fundraising Platform เพื่อสังคมที่ดีขึ้น was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

Our team at Kulap won the first runner-up in the 1st RSK Hackathon in Bangkok which was held at the Knowledge Exchange Center. Most of the teams participated in the event came from abroad countries. There were only two teams from Thailand, one is ours.

Understanding Stable Coin

USDT is one of the well-known stable coin. The way it works is that they claim that every USDT have the real USD (or related with) backed in their bank account (i.e., fiat money). With the USDT, however, it is hard to prove and verify that the rate ratio is always 1:1.

Recently, the project called MakerDAO has come. They aim to create the pure USD stable coin on a smart contract called DAI with the so-called Crypto-Asset-Backed mechanism. The project is just 1 year old but gain popularity among decentralized exchanges as the main token.

The DAI system provides more transparency as everyone can look up at Ethereum Blockchain to see all activities such as issuing, repaying, list of all contracts, collateral ratio and etc.

What is RTHB — ThaiBahtCoin?

We believe that the crypto-asset-backed stable coin is the future. If we organize it in the right way, it will unlock much more financial services and bring trust to the crypto ecosystem, resulting in the mass adoption.

Introduce RTHB, is a proof of concept for securely issuing Thai Baht Stable Coin which is backed by Bitcoin (BTC). Anyone can issue RTHB by lock up their BTC. In this case we use RBTC (Native BTC on RSK Blockchain Network) to back RTHB with the ratio 1.5:1.

We believe that BTC has potential to be the new gold standard, and RTHB that backed by BTC could be a strong stable coin.

How RTHB Works?

1. Alice sends 1 RBTC at a rate 1,500 THB/BTC to RTHB Smart Contract (calling issue()).
2. Alice receives 1,000 RTHB back (at 1.5:1 ratio).

Now Alice can freely transfer any amount of RTHBs to anyone. This’s the real usage of this protocol.

3. Alice decides to return 1,000 RTHB to get her own RBTC back (calling claim()).

4. Fortunately the rate is still the same as when the RBTC was deposited, so the RTHB Smart Contract would return 1 RBTC back to Alice.

More scenarios are available here: https://github.com/kulapio/RTHB-ThaiBahtCoin#example-scenarios-of-rthb

RTHB Use Case

To prove the concept of RTHB adoptions, we developed the IoT-featured device called Candoreum which is a candy machine connected to RSK blockchain network to accept the proposed RTHB.

That is, users can buy some candy from the machine by simply scanning QR-Code to sending 10 RTHB to Candoreum address and wait for seconds to get their candy.

There’re many more use cases, for example, buy a cup of coffee at coffee shop, buy movie ticket, loan, and so on.

Conclusion

RTHB (Thai Baht Stable Coin) is just one use case of smart contracts on the blockchain. There are also many awesome projects out there. We hope this project would inspire you to create some exciting projects to bring the world to the Decentralized era.

Team

Tot — https://www.facebook.com/totiz

Q — https://www.facebook.com/Qsinseongyag

Bright — https://www.facebook.com/br1gh7n4ry

Open Source

kulapio/RTHB-ThaiBahtCoin

Follow Us

https://www.facebook.com/KULAP.io/

https://medium.com/kulapofficial

KULAP The best rate protocal

RTHB — Thai Baht Stable Coin in the 1st RSK Hackathon in Bangkok was originally published in KULAPofficial on Medium, where people are continuing the conversation by highlighting and responding to this story.

Lazy เป็นอีกหนึ่งตัวช่วยสำคัญในภาษา Swift ที่ทำให้การเขียน App ง่ายขึ้น ลดการใช้หน่วยความจำและทำงานได้เร็วขึ้นอีกด้วย

ทำความรู้จัก Lazy ในภาษา Swift กัน

Lazy พูดกันง่ายๆ คือการชะลอการทำงาน หรือการคำนวณบางอย่างออกไป ช่วยลดการหน่วงของแอพ (กระตุก) รวมทั้งการจัดการ Code ก็ง่ายขึ้นด้วย

โดย Lazy ใน Swift แบ่งออกเป็น 2 ส่วนใหญ่ๆ ดังนี้

1. Lazy Var

ตัวแปรแบบ Lazy จะพบได้บ่อยสุด ทั้งในตัวแปรระดับออปเจค ตัวแปรระดับคลาส ตัวแปรระบบ รวมทั้งยังใช้ในสตรัคได้อีกด้วย

lazy var ในคลาส หรือสตรัค

บรรทัด 15: คำนวณหาระยะทางโดยใช้ lazy โดยจะคำนวณในบรรทัด 22 ครั้งเดียว ส่วนบรรทัด 23 จะเรียกค่าที่คำนวณไว้แล้วแทน

ข้อดีของ Lazy var แบบนี้คือ จะไม่มีคำนวณระยะทางเลยหากไม่มีการเรียกใช้ และหากมีการขอข้อมูลระยะทางหลายครั้ง ก็จะคำนวณแค่ครั้งเดียวเท่านั้น

ข้อควรรู้ในการใช้ lazy

• ใช้กับคลาสต้องใส่ [unowned self] in ภายใน { … } ทุกครั้งหากมีการเรียกตัวแปรภายใน เพื่อป้องกัน Reference Cycle
• เหมาะที่จะใช้กับคลาสลูกของ UIViewController เพราะจะทำให้ตัวแปรต่างๆ ไม่ถูก Load ขณะ Init ส่งผลให้ ViewDidLoad ถูกเรียกได้เร็วขึ้น
• สามารถเรียกเมธอดต่างๆ ภายใน { … }() ได้
• สำหรับสตรัค ตัวแปรที่สร้างจากสตรัคต้องใช้ var เท่านั้น เช่น var line = Line(…) เพราะว่าค่าใน lazy เริ่มแรกจะไม่มีค่า จะมีก็ต่อเมื่อเรียกครั้งแรก ถือว่าเป็นการ mutating (อัพเดตค่าตัวแปร)

static let, varในคลาส สตรัค หรือระดับ App

บรรทัด 2: สร้างตัวแปร Global ภายในคลาส AppController ในกรณีนี้ไม่จำเป็นต้องใส่ lazy ลงไป ทุกตัวแปรที่ประกาศด้วย static จะเป็น lazy อัตโนมัติ

บรรทัด 5: คล้ายตัวอย่างก่อนหน้า โดยกรณีจะเป็นการสร้าง Array แบบ lazy

ประกาศตัวแปรระบบ สังเกตุว่าไม่ต้องระบุ static แล้ว เพราะหากประกาศในสโคปนอกคลาส หรือสตรัค ทุกอย่างจะถือเป็น lazy หมดโดยอัตโนมัติ

2. Collection Lazy

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

.lazy สามารถเรียกใช้ได้ทั้ง Array และ Diciontary โดยจะเรียกใช้ร่วมกับ map, flatMap, filter, forEach หรืออื่นๆ

ตัวอย่าง

บรรทัด 3–5: ถ้าไม่มี .lazy จะทำให้คำนวณเลขยกกำลังทั้ง Array ก่อนค่อยส่งไปแสดงผล
บรรทัด 3–5: พอใส่ .lazy โค้ดส่วน pow(x, 2) จะดีเลย์ออกไปคำนวณตอนแสดงผล ทำให้ลดการใช้หน่วยความจำเก็บผลลัพธ์ค่ายกกำลังทั้ง Array ลงไปได้

บรรทัด 7–12: เหมือนกับด้านบน ต่างกันที่ใช้ for .. in แทน forEach { .. }
บรรทัด 16: ผสมการใช้ map และ filter เพื่อหาเส้นรอบวง > 40
* บรรทัด 17: ลองเอา Array (…) ออก แล้วสังเกตผลลัพธ์ดูครับ
บรรทัด 20: ตัวอย่างการใช้ maxElement เพื่อหาค่าสูงสุดแบบ lazy

จากตัวอย่างจะเห็นว่า เราสามรถใช้ lazy ได้ในหลายสถาณการณ์ และไม่ได้เพิ่มบรรทัดของโค้ดเลย เพียงแค่เติม .lazy ลงไป และจะเห็นผลชัดเจนหาก Array หรือ Dictionary เราใหญ่มากๆ ก็ยิ่งลดการพีคของหน่วยความจำจน App ปิดตัวไปได้

จะมีบางสถาณการณ์ที่ลดการใช้ CPU ลงได้อย่างมาก เช่น

บรรทัด 5–19: สร้าง Array (count: 50,000) เก็บค่า JSON-Style
บรรทัด 24–28: กด hitMap(..) จะทำการหาชื่อ “Cat” แบบไม่ใช่ Lazy ใช้เวลาเฉลี่ย 0.129
บรรทัด 32–36: กด hitLazyMap(..) จะทำการหาชื่อ “Cat” แบบ Lazy ใช้เวลาเฉลี่ย 0.000168

จากข้อมูลทดสอบนี้ ปรากฎว่าแบบ lazy สามารถหาข้อมูลโดยใช้ indexOf(..) เร็วกว่าถึง ~700 เท่าเลยทีเดียว

Tips
ตัวที่ทำให้ช้าคือ .map{ $0[“name”] as! string } เพราะต้องแปลงข้อมูลปริมาณมากก่อนนำไปใช้ ให้ลองนึกถึงในการใช้งานจริง เราอาจต้องแปลงข้อมูลที่รับมาจาก Api ก่อนนำไปใช้ ซึ่ง .lazy ในตัวอย่างนี้ จะช่วยให้ไม่ต้องแปลงทั้งหมดก็หาผลลัพธ์ได้

วัดการใช้งาน CPU โดยใช้ Time Profile

วัดการใช้งาน Ram โดยใช้ Allocations (Allocation Density)

• เนื่องจากดาต้าเซตใหญ่ ถ้าเขียนแบบปกติจะเห็นช่วง spike ของหน่วยความจำ ส่วนแบบ lazy ไม่เห็นการพีคของหน่วยความจำเลย

สรุป

การใช้ lazy ช่วยให้โค้ดเรารันได้เร็วขึ้น และลดการพีคของหน่วยความจำลงได้ หากคนที่ใช้ map, flatMap, forEeah, filter, … เป็นประจำอยู่แล้ว ไม่ต้องปรับโครงสร้างโค้ดใดๆ ก็สามารถใช้ lazy ได้เลย แต่ถ้าใครยังไม่แม่น syntax หรือยัง ใช้ for .. in .. ในการแปลงค่า หรือหาผลลัพธ์ ลองศึกษาแนวทางนี้ดูครับ จะทำให้โค้ดสั้นลง และเร็วขึ้นอีกด้วย

Swift Lazy was originally published in Swifty Coffee on Medium, where people are continuing the conversation by highlighting and responding to this story.