งานในปีนี้เป็นครั้งแรกที่มุ่งเน้นไปที่ Mempool และ Transaction Relay โดยเฉพาะ ซึ่งเกี่ยวข้องโดยตรงกับการสร้าง Block Mempool ถูกมองว่าเป็นพื้นที่ส่วนรวม (commons) และเป็นตลาดประมูลที่เสรีและเปิดกว้างที่สุดแห่งหนึ่งของโลก ที่ซึ่งใครก็ตามที่เป็นเจ้าของ Bitcoin สามารถเสนอราคา (ค่าธรรมเนียม) และใครก็ตามที่ขุด Bitcoin ก็สามารถยอมรับราคานั้นและนำ Transaction เข้า Block ได้ แม้ว่ากระบวนการนี้จะมีความท้าทายและบางครั้งก็เป็นที่ถกเถียงกัน แต่ Bitcoin ยังคงทำงานเป็นระบบแบบอนาธิปไตย (anarchic system) ที่การพัฒนาเกิดขึ้นในลักษณะกระจายศูนย์

ประเด็นร้อน: OP_RETURN และการถกเถียงเรื่อง Data Carrier

หนึ่งในประเด็นหลักที่ถูกกล่าวถึงและมีการจัดดีเบตแบบ Oxford-style คือเรื่องขีดจำกัดของ Data Carrier ใน OP_RETURN โดยเฉพาะการถกเถียงเรื่องการปลดขีดจำกัดค่าเริ่มต้นใน Bitcoin Core การถกเถียงนี้สะท้อนให้เห็นถึงความตึงเครียดระหว่างกลุ่มที่เรียกว่า "Monetary Maximalists" ซึ่งต้องการให้ Bitcoin เป็นเงินที่ดีที่สุด กับกลุ่ม "Platform Maximalists" ที่ต้องการให้ Bitcoin สามารถทำสิ่งต่างๆ ที่ไม่เกี่ยวข้องกับเงินได้มากขึ้น เช่น การออก Token บน Bitcoin

ฝ่ายที่สนับสนุนการปลดขีดจำกัดแย้งว่ามันเป็นปัญหาทางเทคนิคที่ไม่มีวิธีที่มีหลักการในการป้องกันอย่างแท้จริงในระดับ Consensus การพยายามใช้ Filter ใน Mempool เพื่อป้องกันนั้นไม่สามารถทำได้อย่างสมบูรณ์ และผู้ใช้สามารถหาวิธีหลีกเลี่ยงได้ การปลดขีดจำกัดอาจช่วยลดการสร้าง UTXO ที่ใช้ไม่ได้ (unspendable UTXOs) ซึ่งเป็นสิ่งที่แย่กว่า OP_RETURN และจะช่วยประหยัดเวลาของนักพัฒนาจากการโต้เถียงในเรื่องเล็กๆ น้อยๆ

ขณะที่ฝ่ายคัดค้านการปลดขีดจำกัดยืนยันว่า Filter ใน Mempool ทำงานได้ผลในการยับยั้งการใช้ OP_RETURN สำหรับข้อมูลที่ไม่ใช่ทางการเงิน และการปลดขีดจำกัดจะเป็นการทำลาย Filter ที่มีอยู่ พวกเขาแย้งว่า Bitcoin ถูกออกแบบมาให้เป็นระบบการเงิน ไม่ใช่ฐานข้อมูลสำหรับเก็บข้อมูลตามอำเภอใจ การอนุญาตให้เก็บข้อมูลที่ไม่ใช่ทางการเงินจำนวนมากจะทำให้ Transaction ของผู้ใช้ทั่วไปมีค่าใช้จ่ายสูงขึ้น และเป็นการ "ขาย Bitcoin ให้กับผู้ที่เสนอราคาสูงสุด" ซึ่งอาจนำไปสู่การบ่อนทำลายโดยผู้ที่ควบคุมระบบการเงินแบบเก่า พวกเขายืนยันว่า Bitcoin ควรเน้นการเป็นเงิน และการเปลี่ยนแปลงที่ไม่จำเป็นซึ่งทำลาย Filter ที่ทำงานอยู่จะทำให้ความไว้วางใจใน Bitcoin Core ลดลง นอกจากนี้ยังมีการพูดถึงทางเลือกในการใช้ Filter ในระดับ Node เช่นที่ implement ใน Bitcoin Knots

ความรวมศูนย์ในการขุดและการกระจายศูนย์

ปัญหาความรวมศูนย์ใน Mining Pool เป็นอีกหัวข้อที่มีการหารืออย่างกว้างขวาง โดยเฉพาะเรื่องความหลากหลายของ Block Template เครื่องมืออย่าง stratum.work ถูกสร้างขึ้นมาเพื่อช่วยให้ผู้สังเกตการณ์สามารถเปรียบเทียบ Block Template จาก Pool ต่างๆ ได้ ข้อมูลแสดงให้เห็นว่า Antpool และ Pool ที่เป็น "เพื่อน" (Antpool and friends) รวมถึง Foundry มีส่วนแบ่ง Hash Rate รวมกันค่อนข้างสูง ซึ่งทำให้เกิดความกังวลเกี่ยวกับความรวมศูนย์ ปัญหาดังกล่าวถูกมองว่าเป็นปัญหาเชิงเศรษฐศาสตร์และแรงจูงใจ มากกว่าปัญหาทางเทคนิคล้วนๆ

ทางออกในการกระจายศูนย์การขุดและการสร้าง Block Template ถูกนำเสนอ โดยเฉพาะโปรโตคอล Datam ที่พัฒนาโดย Ocean Mining Datam ถูกออกแบบมาเพื่อการขุดแบบกระจายศูนย์โดยเฉพาะ โดย กำหนดให้ Miner ต้องรัน Node ของตัวเองเพื่อสร้าง Block Template ซึ่งแตกต่างจาก Stratum V2 ที่ยังคงมีการใช้งานแบบรวมศูนย์อยู่ Datam Gateway ทำหน้าที่เป็นตัวเชื่อมระหว่าง Miner กับ Pool โดยใช้ Stratum V1 แต่ Miner เป็นผู้สร้าง Block Template เอง โปรโตคอล Datam นั้นเรียบง่าย ใช้ภาษา C เพื่อให้มีขนาดเล็กและมีประสิทธิภาพสูง สามารถทำงานบน Raspberry Pi ได้ และมีการเข้ารหัสระหว่าง Pool กับ Gateway การสร้าง Datam ขึ้นมาใหม่จากศูนย์เป็นเพราะไม่มีโปรโตคอลหรือซอฟต์แวร์ Pool เดิมที่ตอบโจทย์การกระจายศูนย์ได้อย่างสมบูรณ์

การแก้ไข Bug ใน Consensus (Consensus Cleanup)

มีการนำเสนอ BIP 54 หรือ Great Consensus Cleanup ซึ่งเป็นข้อเสนอ Soft Fork เพื่อแก้ไข Bug เล็กน้อยในกฎ Consensus ของ Bitcoin จุดประสงค์ไม่ใช่การเปลี่ยนแปลงคุณค่าหลักของ Bitcoin แต่เป็นการแก้ไข Bug ที่สามารถทำได้ผ่าน Soft Fork Bug เหล่านี้รวมถึงปัญหาที่อาจนำไปสู่การมี Transaction ID (TXID) ของ Coinbase ซ้ำกันในอนาคตสำหรับ Block ที่เกิดขึ้นก่อน BIP 34 การแก้ไขใน BIP 54 เกี่ยวข้องกับการใช้ Time Locking และการกำหนดค่า End Sequence ใน Coinbase Transaction เพื่อป้องกันปัญหานี้ ข้อเสนอนี้ถูกพัฒนาขึ้นโดย Antoine Riard และมีการหารืออย่างละเอียด

ความปลอดภัยทางควอนตัมในอนาคต

ประเด็นเรื่องความปลอดภัยทางควอนตัมของ Bitcoin ก็ถูกหยิบยกขึ้นมาพูดคุย แม้จะดูเป็นปัญหาที่ไกลตัว แต่ก็เป็นสิ่งสำคัญที่จะต้องมีแผนรองรับ BIP 360 ถูกนำเสนอเป็นข้อเสนอ Soft Fork ทางเลือก (Opt-in soft fork) เพื่อเพิ่มความปลอดภัยทางควอนตัมให้กับ Bitcoin ปัญหาหลักคือผู้ใช้จะต้องเปิดเผย Public Key และ Signature เมื่อใช้จ่าย Transaction และคอมพิวเตอร์ควอนตัมอาจสามารถคำนวณ Private Key จาก Public Key ได้ BIP 360 เสนอให้เพิ่มข้อมูล Public Key และ Signature ที่ผ่านการป้องกันควอนตัมเข้าไปใน Transaction โดยรองรับ Taproot อย่างไรก็ตาม Multisig บางประเภท เช่น P2SH หรือ P2WSH อาจให้การป้องกันได้ดีกว่า เนื่องจากผู้โจมตีจะต้องหา Private Key หลายตัว ในขณะที่ Key Path Spend ของ Taproot อาจไม่ช่วยป้องกันปัญหานี้ BIP 360 ยังกำหนดให้มี Public Key ที่ป้องกันควอนตัมเพียงตัวเดียวเพื่อหลีกเลี่ยงความกำกวมของที่อยู่ Taproot

นวัตกรรมและกรณีใช้งานอื่นๆ

นอกจากนี้ยังมีการกล่าวถึงโครงการอื่นๆ ที่น่าสนใจ เช่น Maple AI ที่มุ่งมั่นสร้าง AI ที่ไม่ใช่แบบรวมศูนย์ และ Open Secret ซึ่งเป็น Framework สำหรับนักพัฒนาในการให้ผู้ใช้สามารถ Self-Custody ข้อมูลของตนเองได้ แนวคิดนี้คล้ายกับการ Self-Custody Bitcoin ใน Wallet โดยมองว่าการถือข้อมูลผู้ใช้เป็นภาระความเสี่ยงสำหรับนักพัฒนา

มีการพูดถึงแนวโน้มที่ผู้เล่นในระบบการเงินแบบเก่าอย่าง Visa และ Stripe กำลังพยายามเข้าสู่พื้นที่ Digital Currency โดยอาจใช้การ Tokenize Credit Card รวมถึงบทบาทที่อาจเกิดขึ้นของ AI Agents ซึ่งอาจเริ่มใช้ Bitcoin หรือ Lightning Network ในการชำระเงินในอนาคต มีการคาดการณ์ว่า AI Agents อาจทำธุรกรรมผ่าน Lightning Network ได้ในระดับที่สูงกว่าการใช้งานของมนุษย์อย่างรวดเร็ว โดยมีการพัฒนาโปรโตคอลอย่าง X402 และ Fusats เพื่อรองรับการชำระเงินสำหรับ Agents โดยเปิดโอกาสให้ Agents เลือกใช้สกุลเงินดิจิทัลที่ดีที่สุดในตลาดเสรี

สุดท้าย งาน Bitcoin++ เน้นย้ำถึงความสำคัญของการประชุมและการรวมตัวกันของนักพัฒนาเพื่อหารือ ประสานงาน และแบ่งปันไอเดีย โดยเฉพาะในประเด็นที่ต้องอาศัยความร่วมมือและการแก้ปัญหาที่ซับซ้อน

อะแฮ่ม ขอชี้แจงไว้ก่อนว่า ผมเขียนเพื่อให้ตัวเองอ่านเพื่อวันไหนจะกลับมาทำต่อจะได้พอจำได้ว่าตัวเองทำอะไรลงไปบ้าง เพราะงั้นบางส่วนในบทความนี้อาจจะไม่ละเอียด หากลองทำตามแล้วติดตรงไหนอยากสอบถาม ติดต่อมาได้ที่ Nostr Address: kritta@rightshift.to หรือลองค้นเพิ่มเติมใน link ท้ายบทความนะครับ

อย่างที่หลาย ๆ คนน่าจะทราบกันดีอยู่แล้วว่า Nostr เป็น open protocol ที่ใคร ๆ ก็สามารถเข้ามามีส่วนร่วมในการพัฒนาได้ ทำให้มีโปรเจคต่าง ๆ เกิดขึ้นมากมาย โดยบทความในชุดนี้ผมจะหยิบโปรเจคต่าง ๆ ที่น่าสนใจมามาลองเล่น และนำมาเล่าสู่กันฟัง หวังว่าผู้ที่หลงเข้ามาอ่านจะได้ประโยชน์จากสิ่งนี้นะครับ ;)

โดยในวันนี้โปรเจคที่ผมหยิบมาคือ NDK (Nostr development kit) ผมหาไม่เจอว่าใครเป็นคนเริ่มโปรเจค แต่คนที่ดูแล repo นี้หลัก ๆ คือคุณ yukibtc เริ่มต้นเหมือนจะเริ่มจาก RUST แต่ตอนนี้เหมือนจะแตกไป swift, java, python เอาจริง ๆ ผมไม่รู้หรอกว่าใครเป็นคนทำภาษาไหนเพราะ contributors เขาเยอะมาก แต่ก็นั่นแหละ ขอบคุณที่สร้างอะไรสนุก ๆ แบบนี้ออกมาให้ได้เล่นนะครับ

โดยอย่างแรกที่เราต้องเริ่มคือการสั่ง pip install ตัว nostr sdk เพื่อใช่งาน สำหรับคนที่ไม่มี python ในเครื่องก็ไปลง python ก่อนด้วยนะ หรือจะใช้ online ผ่าน google colab ลองเล่นดูก่อนก็ได้

pip install pip install nostr-sdk 

จากนั้นเราก็จะสามารถใช้งาน Nostr_sdk ได้แล้ว!!!
โดยการที่เราจะเข้ามาใช้งาน Nostr ได้นั้นเราจำเป็นต้องมี keys เพื่อเข้าสู่ระบบเสียก่อนงั้นเรามาเริ่มจากการสร้าง keys กันก่อน

from nostr_sdk import  Keys
#เพียงคำสั่งนี้คำสั่งเดียวก็ได้ keys แล้วงั้นเหรอ!!
keys = Keys.generate()
#แยก keys ออกเป็น secret key (sk) และ public key (pk) 
sk = keys.secret_key()
pk = keys.public_key()
#ไหน ๆ ขอดู keys หน่อยสิ้
print(f"public key: {pk.to_bech32()}")
print(f"Secret key: {sk.to_bech32()}")
#output:
#public key: npub1wkxaxzmmamc6h8n6ev7yq3y5qmqnyxmu0xmrllcepxup9tktuzrsu646r0
#Secret key: nsec160gefyqkderqlnr545ps4d5th6pex3ducqgcev69z0rstqakkv9scvat97

note ถ้าสร้าง keys เสร็จแล้วเอาไปเก็บไว้ในพวก dot env จะปลอดภัยและสะดวกในการใช้ต่อมากกว่า

แล้วหลังจากได้ keys มาแล้วเราจำเป็นต้องกำหนด signer, client และ relay ที่เราจะใช้ในการรับ event ของเรา

# กำหนด keys ที่เราพึ่งสร้างให้เป็นตัว sign event
signer = NostrSigner.keys(keys)
# นำเข้า key ที่มีอยู่แล้ว
# app_keys = Keys.parse("nsec......")
# signer = NostrSigner.keys(app_keys)
# หรือใช้ NIP46 signer
# uri = NostrConnectUri.parse("bunker://.. or nostrconnect://..")
# nip46 = Nip46Signer(uri, app_keys, timedelta(seconds=60), None)
# signer = NostrSigner.nip46(nip46)
# กำหนด client ให้ใช้ signer ตัวนี้ (feel like log in)
client = Client(signer)

# เพิ่ม relays ที่จะเก็บ event
client.add_relays(["wss://relay.damus.io", "wss://siamstr.com", "wss://siamstr.com","wss://relay.notoshi.win"])
client.connect()
#ตั้งชื่อให้ account เราสักหน่อยเพื่อเช็คด้วยว่า เราเชื่อมต่อ relay ต่าง ๆ ผ่านมั้ย
client.set_metadata(Metadata().set_name("Testing หลาม ๆ"))

หลังจากกำหนดทุกอย่างเรียบร้อยแล้ว เรามาลองสร้างโพสต์แรกกันเลยดีกว่า

#tag เพื่อเอาไว้เติมส่วนต่าง ๆ นอกจาก เนื้อหาของโน๊ต เช่นการ mention การใส่ hashtag
# p = mention
# t = hashtag
tag = Tag.parse(["p", "66df60562d939ada8612436489945a4ecf1d62346b3d9478dea8a338f3203c64"])
#ใส่เนื้อหาที่เราค้องการโพสต์
builder = EventBuilder.text_note("สวัสดีชาวทุ่ง ", [tag])
ส่ง event ไปให้ relay โลดดดด
client.send_event_builder(builder)

แล้วนอกจากโพสต์ตระกูล kind:1 แล้วเรายังโพสต์ kind อื่น ๆ ได้ด้วย

# ส่งจ้อความส่วนตัว
receiver_pk = PublicKey.from_bech32("npubคนรับ")
event = EventBuilder.encrypted_direct_msg(keys, receiver_pk, "ข้อความ", None).to_event(keys)
print(event.as_json())

# templateเปล่า
kind = Kind(เลข kind)
content = "..."
tags = []
builder = EventBuilder(kind, content, tags)


# POW
event = builder.to_pow_event(keys, 20)
print(f"POW event: {event.as_json()}")

ส่วนตัวผมมองว่าส่วนนี้แหละคือส่วนที่สนุกที่สุดของวันนี้ เพราะเป็นจุดที่เราสามารถนำมันออกไปต่อยอดได้มากที่สุด เช่นการเชื่อมต่อกับ service อื่น ๆ เช่น mempool.space เพื่อส่งค่าฟี bitcoin ให้เราผ่านแชท, ทำเกมง่าย ๆ เล่นกับเพื่อน ๆ หน้า timeline อย่าง cowdle หรือ หวย อย่างที่เห็นกันไปในช่วงก่อนหน้านี้ หรือใช้ทำงานกรรมกรแทนเรา เช่นการแจก badges ที่ทาง rightshift ได้ทำไปก่อนหน้า, bot relay notoshi, zapbot และอีกต่าง ๆ มากมาย

filter

ตัว filter เป็นคำสั่งที่ช่วยเรากรอง event ที่จะขอจาก relay ใช้เพื่อรับเฉพาะ event ที่เราต้องการเท่านั้น

f = (Filter()
     .pubkey(keys.public_key())
     .kinds([Kind(0), Kind.from_enum(KindEnum.TEXT_NOTE())])
     .custom_tag(SingleLetterTag.lowercase(Alphabet.J), ["test"])
     )
print(f.as_json())
# output: {"kinds":[0,1],"#j":["test"],"#p":["758dd30b7beef1ab9e7acb3c40449406c1321b7c79b63fff1909b812aecbe087"]}

f = f.kind(Kind(4)).custom_tag(SingleLetterTag.lowercase(Alphabet.J), ["append-new"])
print(f.as_json())
{"kinds":[0,1,4],"#j":["test","append-new"],"#p":["758dd30b7beef1ab9e7acb3c40449406c1321b7c79b63fff1909b812aecbe087"]}

#ตัวอย่างเช่นรับเฉพาะ event ของคนที่ใช้ notoshi relay
filter =Filter().kind(Kind(10002)).custom_tag(SingleLetterTag.lowercase(Alphabet.R), ["wss://relay.notoshi.win"])
events = client.get_events_of([filter], timedelta(seconds=30))

สองฟังก์ชันนี้เป็นตัวสำคัญในการทำบอทในส่วนต่อไปจะเป็นตัวเสริมต่าง ๆ ที่เพิ่มลูกเล่นให้บอทได้

Metadata

metadata มีไว้แก้ไขข้อมูลต่าง ๆ ในโปรไฟล์ของเรา

metadata = Metadata().set_name("username")\
        .set_display_name("My Username")\
        .set_about("Description")\
        .set_picture("https://example.com/avatar.png")\
        .set_banner("https://example.com/banner.png")\
        .set_nip05("username@example.com")\
        .set_lud16("username@example.com")
# name = ชื้อผู้ใช่
# display_name = ชื่อที่จะแสดงให้คนอื่นเห็น (ถ้าช่องนี้ว่างมักจะโชว์ชื่อที่ใว่ในช่อง name)
# about = bio
# picture = รูปโปรไฟล์
# banner = รูปปก
# nip05 = Nostr addr
# lud16 = Lightning addr

NWC

NWC หรือ Nostr wallet connection มีไว้ใช้ในการเชื่อมต่อกับกระเป๋า ln ของเราเพื่อคุมกระเป๋าของเราผ่าน Nostr

# นำ NWC uri มาวาง
uri = NostrWalletConnectUri.parse("nostr+walletconnect://..")

# สร้าง client ในรูปแบบที่เพิ่มการ zap
keys = Keys.generate()
signer = NostrSigner.keys(keys)
zapper = NostrZapper.nwc(uri)
client = ClientBuilder().signer(signer).zapper(zapper).build()

client.add_relay("wss://relay.damus.io")
client.connect()

pk = PublicKey.from_bech32(" npub คนรับ")
client.zap(ZapEntity.public_key(pk), 1000, None)

Bot template

from nostr_sdk import Client, NostrSigner, Keys, Event, UnsignedEvent, Filter, \
    HandleNotification, Timestamp, nip04_decrypt, UnwrappedGift, init_logger, LogLevel, Kind, KindEnum
import time

init_logger(LogLevel.DEBUG)

# sk = SecretKey.from_bech32("nsec1ufnus6pju578ste3v90xd5m2decpuzpql2295m3sknqcjzyys9ls0qlc85")
# keys = Keys(sk)
# OR
keys = Keys.parse("nsec1ufnus6pju578ste3v90xd5m2decpuzpql2295m3sknqcjzyys9ls0qlc85")

sk = keys.secret_key()
pk = keys.public_key()
print(f"Bot public key: {pk.to_bech32()}")

signer = NostrSigner.keys(keys)
client = Client(signer)

client.add_relay("wss://relay.damus.io")
client.add_relay("wss://nostr.mom")
client.add_relay("wss://nostr.oxtr.dev")
client.connect()

now = Timestamp.now()

nip04_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.ENCRYPTED_DIRECT_MESSAGE())).since(now)
nip59_filter = Filter().pubkey(pk).kind(Kind.from_enum(KindEnum.GIFT_WRAP())).since(
    Timestamp.from_secs(now.as_secs() - 60 * 60 * 24 * 7))  # NIP59 have a tweaked timestamp (in the past)
client.subscribe([nip04_filter, nip59_filter], None)


class NotificationHandler(HandleNotification):
    def handle(self, relay_url, subscription_id, event: Event):
        print(f"Received new event from {relay_url}: {event.as_json()}")
        if event.kind().match_enum(KindEnum.ENCRYPTED_DIRECT_MESSAGE()):
            print("Decrypting NIP04 event")
            try:
                msg = nip04_decrypt(sk, event.author(), event.content())
                print(f"Received new msg: {msg}")
                client.send_direct_msg(event.author(), f"Echo: {msg}", event.id())
            except Exception as e:
                print(f"Error during content NIP04 decryption: {e}")
        elif event.kind().match_enum(KindEnum.GIFT_WRAP()):
            print("Decrypting NIP59 event")
            try:
                # Extract rumor
                unwrapped_gift = UnwrappedGift.from_gift_wrap(keys, event)
                sender = unwrapped_gift.sender()
                rumor: UnsignedEvent = unwrapped_gift.rumor()

                # Check timestamp of rumor
                if rumor.created_at().as_secs() >= now.as_secs():
                    if rumor.kind().match_enum(KindEnum.SEALED_DIRECT()):
                        msg = rumor.content()
                        print(f"Received new msg [sealed]: {msg}")
                        client.send_sealed_msg(sender, f"Echo: {msg}", None)
                    else:
                        print(f"{rumor.as_json()}")
            except Exception as e:
                print(f"Error during content NIP59 decryption: {e}")

    def handle_msg(self, relay_url, msg):
        None


abortable = client.handle_notifications(NotificationHandler())
# Optionally, to abort handle notifications look, call abortable.abort()

while True:
    time.sleep(5.0)
    # abortable.abort()

ผมหวังว่าบทความนี้จะมีประโยชน์กับคนอ่าน และคาดหวังที่จะได้เห็น service ต่าง ๆ ที่สร้างสรรค์เกิดขึ้นหลังจากนี้
Link เพิ่มเติมที่สำหรับศึกษาต่อ

• https://github.com/rust-nostr/nostr/tree/master
• https://github.com/nostr-protocol/nips

ในบทความนี้เป็นการรีวิวการใช้ client ต่าง ๆ บน IOS ของผมและเพื่อน ๆ ที่ช่วยกันลองเล่นและทดสอบเพื่อหา client บน IOS ที่จะใช้ป้ายยาคนใหม่ ๆ ให้เขาไม่รู้สึกว่าการเข้ามาในทุ่งม่วงแห่งนี้เป็นเรื่องยาก เมื่อได้ทดลองแล้วเลยอยากมาแชร์ผลที่ได้กับทุก ๆ คนบน Nostr เพื่อเป็นแนวทางหรือเป็นส่วนประกอบการตัดสินใจในการเข้าไปลองเล่น client ใหม่ ๆ

ทั้งนี้ทั้งนั้น สิ่งที่ปรากฏภายในบทความนี้เป็นเพียงแค่ความคิดเห็นของผู้เขียนและแอพต่าง ๆ ที่ลอง
เป็นเวอร์ชันก่อนวันที่ 23/10/2023 หากโหลดมาใช้แล้วไม่เหมือนในรีวิวแปลว่าแอพมันอัปเดตไปแล้วนะครับ

Primal

Primal เป็นอีก client นึงที่มีฟังก์ชันต่าง ๆ ค่อนข้างครบครันและมี UX/UI ที่ดี สวยงามและปรับแต่งได้ในระดับหนึ่ง นอกจากนี้ยังสามารถ zap ผ่าน โน้ตต่าง ๆ ได้โดยตรงและนอกจากนี้ยังรองรับ one-click zap ผ่าน NWC ได้อีกด้วย ส่วนการดาวน์โหลดในปัจจุบันสามารถทำได้ดังนี้

Primal ในตอนนี้ทาง IOS สามารถดาวน์โหลดได้ผ่านทาง TestFlight เท่านั้น โดยสามารถเข้าไปรับ redeem code ได้ทางเว็บไซต์ของ primal จากนั้นให้ปุ่มดาวน์โหลดบน navbar แล้วเลือก IOS จากนั้นจะมีหน้าต่างโปรแกรม TestFlight ขึ้นมาให้เราดาวน์โหลด

• • หากไม่เคยใช้ TestFlight มาก่อน แนะนำว่าให้ทำการดาวน์โหลดและ login ให้เสร็จเรียบร้อยก่อนไปรับ redeem code บน primal
    ส่วนในแง่ของ ข้อดี – ข้อเสีย ที่ผมพอสรุปได้จากการใช้งานมีประมาณนี้ครับ

ข้อดี

• UI สวยงาม ตัวแอปลื่นไหลไม่สะดุดรองรับฟังก์ชันพื้นฐานครบ
• Zap ผ่านโน้ตได้ และรับรอง NWC เพื่อทำ one-click-zap ได้
• มีการแจ้งเตือนครบครันและปรับแต่งได้ตามความต้องการ
• สร้างฟีดของ # ต่าง ๆ ได้ (ตรงนี้จะแตกต่างจากการติดตาม # ของ client อื่น ๆ )
• UI ต่าง ๆ ของแอพเช่น ขนาดตัวอักษรสามารถปรับขนาดได้

ข้อเสีย

• จัดการรีเลย์ผ่านทางแอพไม่ได้ อาจต้องมี client อื่น ๆ บนเครื่องเพื่อทำการจัดการต่าง ๆ เกี่ยวกับรีเลย์
• การแจ้งเตือนในบางครั้งซ้ำซ้อนมีแจ้งเตือนเดิม ๆ เด้งหลาย ๆ ครั้ง
• การแสดงจำนวนเช่น ผู้ติดตาม, คนตอบกลับ, คนกดไลค์มากกว่าความเป็นจริง
• Upload วีดีโอตรง ๆ ไม่ได้ (เป็นลิ้งได้ครับ)
• เวลาเราโพสต์และติด tag event ของโพสต์เราจะไม่มี tag ในช่อง tag ทำให้คนที่ติดตาม tag บน client อื่น ๆ ไม่เห็นโพสต์เรา (ร้ายแรง)

ข้อสรุป

Primal เป็นอีก client นึงที่เหมาะสมกับการแนะนำมือใหม่มาก ๆ ครับเพราะถ้าสมัครบน primal มันจะเก็บ keys เข้าไปในมือถือเราไม่ต้องให้เรา copy ไปเก็บเองเหมือน client อื่น ๆ และนอกจากนี้ยังไม่ต้องให้มือใหม่ปวดหัวกับการจัดการรีเลย์ในช่วงแรกที่เล่นได้อีกด้วย

Freefrom

สำหรับทวิตเตอร์ เอ้ย freefrom เป็นอีก client ที่ใช้งานง่าย UI เป็นที่คุ้นเคย (ทวิต) แบบแทบจะเหมือนกันเลย และสามารถใช้งานฟังก์ชันต่าง ๆ ได้เหมือนกับโซเชี่ยลมีเดียโดยทั่วไปจุดเด่นที่ชอบในตัวของ freeform คือการที่เราสามารถส่ง contact card และ album ให้กันได้ด้วย ส่วนการดาวน์โหลดในปัจจุบันสามารถทำได้ดังนี้

ตอนนี้สามารถดาวน์โหลดได้ผ่านทาง App Store ได้ตรง ๆ เลยครับ รูปนกตัวอ้วนกว่านกฟ้านิดนึง

ข้อดี

• UI สวยงาม ใช้งานง่าย และหลาย ๆ คนน่าจะคุ้นเคยกับ UI รูปแบบนี้อยู่แล้ว
• ระบบ DM สวยและมีลูกเล่นเยอะเช่น การส่ง contact card, album
• Reaction ด้วย emoji ได้หลากหลายเป็นพื้นฐานอยู่แล้ว

ข้อเสีย

• ไม่สามารถ zap หรือทำอะไรเกี่ยวกับ Lightning ได้เลยบนแอพ
• ฟังก์ชันต่าง ๆ ที่เล่นได้ค่อนข้างน้อย ไม่รองรับ Follow # หรือการ Upload video ไม่ได้ (ต้องเป็นลิ้ง)

ข้อสรุป

Freeform เป็น client ที่เหมาะสมกับการแนะนำมือใหม่มาก ๆ โดยเฉพาะกลุ่มคนที่ไม่ได้เข้าใจ Bitcoin หรือ lightning เข้ามาเริ่มก่อนได้ง่าย ๆ และหากเขาสร้างคุณค่าในสังคมมากพอที่คนอยากจะ zap ให้เขา เดี๋ยวเขาก็หาทางใช้ client อื่น ๆ เพื่อมารับ zap เอง ;)

ทั้งนี้ที่บทความนี้เกิดขึ้นมาได้ต้องขอขอบคุณ Jakk Goodday ที่แนะนำ primal มา และขอบคุณ 🐰🤍 ที่ยอมกระโดดมาเล่น Nostr และ ยอมช่วยทดลองและมารีวิวช่วยกันเทสจนสามารถได้บทความนี้ขึ้นมา

Listr : ตัวช่วยในการจัดการหน้าฟีด

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

• เพียงแค่เราเข้าไปที่ Listr.lol

• กรอกข้อมูลลงในช่องต่าง ๆ และเพิ่ม account หรือ note ที่เราต้องการสร้าง list

• กด Publish new list

• จากนั้นเมื่อเราสามารถนำ address ที่ได้มาไปแชร์บน client ที่รองรับเพื่อส่งต่อให้คนอื่น ๆ ได้เลยครับ
  ตัวอย่าง:
  nostr:naddr1qqzx6at5v5q3wamnwvaz7tmjv4kxz7fwwd5kzmtnw3ezucm0d5qs6amnwvaz7tmwdaejumr0dspzqeklvptzmyu6m2rpysmy3x295nk0r43rg6eaj3uda29r8rejq0ryqvzqqqr4xqnfquht

list รวมเหล่า shitcoin หิวเงินที่มาหากินบนนี้ mute ไปได้เลยครับ

Badges.page : เหรียญตราสุดเท่บนโปรไฟล์

Badges เป็นอีกลูกเล่นหนึ่งของ nostr ที่ทำให้เราสามารถสร้างและส่ง badge ให้เพื่อน ๆ เพื่อเป็นสัญลักษณ์ หรือเพื่อความสวยงามของโปรไฟล์ จริง ๆ ที่ชอบเพราะมันเท่ดีเวลาเปิดหน้าโปรไฟล์

ส่วนวิธีการสร้าง badge สามารถทำได้ตามขั้นตอนต่อไปนี้เลยครับ

• เข้าเว็บ Badges.page และ login ให้เรียบร้อย
• จากนั้นคลิกคำว่า new บนหัวมุมขวาใกล้ ๆ โปรไฟล์

• และใส่ข้อมูลต่าง ๆ ที่เราต้องการลงไป จากนั้นกด save and Publish

• จากนั้นให้เราเข้าไปที่หน้าของ badge นั้น ๆ และใส่ nip-05 หรือ npub ของคนที่เราต้องการให้ badge ลงไป และกด Award badge ได้เลยครับ

• เมื่อเราทำการ award badge เรียบร้อยแล้ว ให้คนที่เราส่งให้เข้าไปรับที่ Badges.page โดยเข้าไปที่หน้าโปรไฟล์ เลือก awarded และกด accept

เพียงเท่านี้เมื่อเราเข้าไปท่องโลกของ nostr ผ่าน client ที่รองรับเราก็จะมี badge เท่ ๆ โชว์อยู่ที่หน้าโปรไฟล์แล้ว!

ZapGoals : เครื่องมือระดมทุนสุดเจ๋งบนNostr ! !

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

• เข้าไปที่เว็บ goals-silk.vercel.app
• จากนั้นเมื่อเรา login เรียบร้อยแล้ว กดที่ profile และกด new

• จากนั้นให้เราใส่ข้อมูลต่าง ๆ ที่เราต้องการให้แสดงลงไป
• และเราก็จะได้ goal ที่มีหน้าตาแบบนี้

แล้วเราสามารถเอา goal พวกนี้ไปทำอะไรได้บ้างละ ?

เราสามารถนำ link ของ goal ที่เราสร้างไปใส่ใน live stream บน zap.stream, บน long form content ผ่านทาง habla, ใน client ต่าง ๆ ที่รองรับ, หรือแม้แต่ใน badges ที่ได้กล่าวถึงข้างต้น

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

1. ให้ทำการดาวน์โหลดแอปพลิเคชั่น Nostore ผ่าน App store!
   
2. ให้ทำการเข้าไปในแอปในขั้นตอนนี้จะมีไกด์วิธีใช้งานในแต่ละ device แต่ถ้าไม่อยากอ่านก็ทำตามโน๊ตนี้ต่อก็ได้ครับ
   
3. ให้เราเข้าไปใน safari และ กดรูปจิ๊กซอที่แถบ URL และ เลือก Manage Extensions กดเปิด Nostore
   
4. จากนั้นให้เรากด NEW และ ใส่ข้อมูลต่าง ๆ ลงไป
   • profile name อันนี้แล้วแต่เราจะตั้งเลยครับจะมีประโยชน์ถ้าเราเล่นหลายแอค
   • relay อาจเพิ่มลำบากนิดนึงแต่แนะนำให้เพิ่มให้ครบตามที่เราใช้ใน platform ต่าง ๆ ครับ

หลังจากนั้นเมื่อเราเข้าเว็บต่าง ๆ ที่รองรับการเข้าสู่ระบบด้วย NIP-07 ตัว extension จะเด้งขึ้นมาให้เรากด allow ครับ(หน้าตามันจะหน้าเกลียดหน่อย ๆ นะครับ)
จากนั้นเมื่อเราก็สามารถเข้าเว็บอย่าง zap.stream , habla, yaki, listr หรือ web-base client ต่าง ๆ บน IOS device ของเราได้โดยไม่ต้องนำ nsec ของเราไปวางบนเว็บนั้น ๆ แล้ว

Log-structure File System (LFS)

เป็น File system รูปแบบหนึ่งที่จะทำการเก็บข้อมูลเป็น log และสามารถย้อนกลับได้ทุกการกระทำ นอกจากมีความถี่ในการสร้าง snapshot ที่สูงมาก จริง ๆ แล้วเหมาะกับงานประเภทที่ต้องการความต่อเนื่องหากดบัไปต้องกู้คืนได้มากที่สุดเท่าที่เป็นไปได้ แต่เพราะไอความสามารถตรงนั้นของมันนี่แหละ ที่ผมมองว่ามันน่าจะหยิบมาใช้กับการกู้คืน file หลังจากโดน ransomware ได้แน่ ๆ โดยในครั้งนี้ผมเลือกใช้เป็น NILFS2 เนื่องจากดูแล้วน่าจะเหลือตัวเดียวที่ยังพอมีการพัฒนาอยู่ 5555 รูปแบบการเก็บข้อมูลจะเหมือนกับภาพด้านล่างนี้

ตัวอย่าง:
เดิมที file A: "AAAAA" จากนั้นผมได้ทำการอัพเดตข้อมูลใน file A เป็น "BBBBB" ด้วยความสามารถของ LFS มันสามารถที่จะดึง file A เวอร์ชันที่เป็น "AAAAA" กลับมาได้

นี่เป็นปัจจัยสำคัญที่ทำให้ผมมองว่า LFS เหมาะสมที่จะมาเป็นระบบไฟล์ที่ใช้ในการสำรองข้อมูล แต่อยากที่ได้กล่าวไว้ข้างต้นว่าปัญหาของระบบไฟล์นี้คือมันใช้พื้นที่เก็บข้อมูลค่อนข้างสูง และมี write speed ที่ค่อนข้างช้า ถ้าเทียบกับระบบไฟล์อื่น ๆ ในกรณีที่ความเร็วของ SSD เท่ากัน เลยมองว่าถ้าจะใช้เป็นระบบหลักในการเก็บข้อมูลทุกอย่างคงจะไม่เหมาะ เลยนำไปสู่การทำระบบโดยใช้ระบบไฟล์สองแบบที่แตกต่างกัน

System Design

อย่างที่ได้พูดถึงข้อเสียของ NILFS2 ไปข้างต้น แปลว่าถ้าอยากจะให้คอมพิวเตอร์ทำงานได้อย่างมีประสิทธิภาพคงเดิมและสามารถป้องกัน ransomware ได้ด้วยก็จำเป็นต้องมีระบบไฟล์ที่ใช้กันทั่วไปอย่าง FAT32 หรือ ext4 และใช้ SSD อีกลูกหนึ่งที่ format เป็น NILFS2 และเขียนโปรแกรมให้คอยมอนิเตอร์ทุก ๆ กิจกรรมบน user space และทุกครั้งที่เกิดการเขียนไฟล์ขึ้นให้เขียนลงใน SSD ที่เป็น NILFS2 ด้วย ดังภาพที่แสดงด้านล่างนี้

แล้วทำไมไฟล์ในลูกที่เก็บสำรองข้อมูลถึงไม่เท่ากับจำนวนไฟล์ในที่เก็บข้อมูลหลักล่ะ ? เนื่องด้วยความเร็วในการเขียนที่ค่อนข้างแตกต่างกันของทั้งสอง ผมเลยมองว่าถ้าเราเก็บในรูปแบบบล๊อกจะทำให้เก็บข้อมูลได้ไวกว่า อย่างตัวอย่างในรูป สมมุติว่าไฟล์ A มีขนาดประมาณ 3 บล๊อกใน SSD ที่เป็น nilfs2 ก็จะมี 3 ไฟล์และต้องใช้ทั้งสามไฟล์เพื่อที่จะคืนค่าไฟล์ A กลับมา ถ้าอ่านมาถึงตรงนี้อาจจะเกิดข้อสงสัยว่า แล้วจะทำให้มันยุ่งยากทำไม คัดลอกไฟล์มาใส่ก็จบแล้วมั้ย ? ก็ใช่แหละและจริง ๆ ผมคิดว่าทำแบบนั้นก็เพียงพอ แต่ว่าอย่างที่บอกไปข้างต้น ผมอยากได้ระบบที่ป้องกันได้ 100% ผมเลยเลือกที่จะมอนิเตอร์ kernel เอาไว้และเมื่อมีการเขียนไฟล์เกิดขึ้นผมต้องการดึงข้อมูลมาจากตรงนั้นเลย ไม่อยากรอถูกเขียนลงในพื้นที่เก็บข้อมูลหลักก่อนแล้วค่อยคัดลอกมา จริง ๆ ก็ด้วยเหตุผลด้านประสิทธิภาพด้วย

แล้วจะมอนิเตอร์ kernel อย่างไร ??

ในครั้งนี้ผมเลือกที่จะใช้เป็น eBPF (extended Berkeley Packet Filter) จริงแล้วเจ้า eBPF เนี่ยใช้งานได้หลากหลายเลยแหละ เรียกได้ว่าประโยชน์รอบด้านสุด ๆ ตามรูปที่แนบด้านล่างเลย

แต่ในครั้งนี้เราจะยุ่งกับมันเพียงแค่การใช้งานเพื่อสอดส่อง kernel เท่านั้น

ภาพด้านบนนี้แสดงให้เห็นจุดที่เราสามารถใช้ eBPF ในการดึงข้อมูลได้ นั่นเลยเป็นเหตุผลหลักที่ผมเลือกใช้ โดยวางการทำงานทั้งหมดของการมอนิเตอร์ไว้ดังนี้

1. ใช้ eBPF เพื่อคอยเช็คว่ามีการเขียนเกิดขึ้นมั้ยโดยการอ่านค่า flag จาก NVMe ว่ามีค่าเป็นอะไรจากนั้นนำค่าที่ได้มา XOR ด้วย mask ถ้าค่าออกมาเป็น 1 แปลว่านั่นคือ write_operation (อาจแตกต่างกันแล้วแต่ version)
2. เมื่อเช็คค่าแล้วเป็น write_operation จากนั้นก็ให้ทำการอ่านเลข sector, และขนาดของข้อมูลที่ต้องการจะเขียน
3. จากนั้นเข้าไปอ่านต่อใน Bio ลงไปยัง Bio_vec และไป Bv_page ตามลำดับ เพื่ออ่านข้อมูลทั้งหมดที่มาจากคำสั่งในการเขียนครั้งนั้น ๆ
   
   *ภาพประกอบเพิ่มเติมเพื่อใครงงว่า Bio คืออะไรข้อมูลเวลาเราเขียนจะอยู่บน page
4. ส่งข้อมูลที่ได้ทั้งหมดออกมา

เพียงเท่านี้เราก็ทำการดึงข้อมูลทุกครั้งที่เราเขียนได้แล้ว และจะนำมันเข้าสู่ขั้นตอนต่อไปในการเก็บข้อมูลลง SSD

เก็บข้อมูลและส่งไป SSD ที่เป็น nilfs2

เมื่อได้ข้อมูลมาจากการทำงานที่ได้กล่าวไว้ข้างบนแล้ว ก็จะได้ชุดข้อมูลมาชุดหนึ่ง ส่งออกมันมาจาก ebpf(C program) มาสู่ Python ต่อโดยมีขั้นตอนดังนี้

1. นำเลข sector ที่ได้มาทำการคูณด้วยขนาดของ sector เพื่อให้เราได้ logical address มา จากนั้นให้นำ logical address หารด้วยขนาดของบล๊อกเพื่อให้ได้เลขบล๊อก
2. นำข้อมูลในแต่ละ sector มาเรียงลงในบล๊อกที่มันอยู่ละบันทึกลงไปใน SSD

ตัวอย่างเพื่อให้เห็นภาพมากขึ้น
สมมุติว่าข้อมูลที่ส่งกลับมาขนาด 4097 B และเริ่มเขียนที่ sector 0
(กำหนดให้ 1 sector มีขนาด 512B และ 1 Block มี 8 sector)

4097/512 = 8.xx ก็แปลว่าข้อมูลนี้ต้องเก็บใน 9 sector คือ sector 0 ถึง 8
และ 8 sector รวมเป็น 1 block แปลว่าข้อมูลใน sector 0-7จะอยู่ใน block 0 และ sector 8 จะอยู่ใน block 1 แปลว่าโปรแกรมของผมจะสร้างมาสองไฟล์คือ 0,1 จากนั้นจะทำการเติม 0 ท้ายไฟล์ 1 จนมีขนาด 4096 B เท่ากับขนาดของ block

สำหรับคนที่งงว่า sector บล๊อกคืออะไร

ให้ดูตรงรูปกลม ๆ ทางซ้ายมือจะเห็นได้ว่ามันเป็นหน่วยความจำในจานหมุน ซึ่ง sector คือหน่วยย่อยสุด และ sector รวม ๆ กันหลาย ๆ sector จะเป็น cluter บางที่ก็เรียก Tracks บางที่ก็ Block ซึ่งนี่แหละคือบล๊อกที่ผมหมายถึง

เพียงเท่านี้เราก็ได้ระบบที่สามารถป้องกัน ransomware ได้แล้ว เพราะเนื่องจากเมื่อเราโดน ransomware และไฟล์เราถูก encrypt เราก็เพียงใช้ความความสามารถของ SSD ลูกที่เป็น nilfs2 เพื่อนำไฟล์ดั้งเดิมก่อนจะถูก encrypt กับมาได้ดังรูปประกอบด้านล่างนี้

ส่งท้าย

จริง ๆ แล้วที่ผมเก็บเป็นไฟล์ block เพราะผมอยากให้ backup file สามารถเข้ากันได้กับทุกระบบไฟล์เพื่อให้สามารถใช้งานได้กับทุกระบบ ถึงจะยังทำไม่ได้ก็เหอะ 55555