ชื่อเรื่องเดิม: "The Billion User Social Graph》

ชื่อเรื่องเดิม: "

ผู้เขียน: จอน สโตกส์

การรวบรวมต้นฉบับ: Dan, W 3. Hitchhiker

ด้วยการเข้าครอบครอง Twitter ล่าสุดของ Elon Musk ทำให้มีการพูดคุยกันมากมายเกี่ยวกับการย้ายจากโซเชียลเน็ตเวิร์กขนาดใหญ่ไปสู่ทางเลือกที่เป็นอิสระหรือเปิดกว้าง แต่สำหรับใครก็ตามที่เพิ่งเริ่มเพ้อฝันเกี่ยวกับการเข้าร่วมชุมชนที่เฟื่องฟูของผู้ที่เคยใช้ Twitter มาก่อน เร็วๆ นี้ จะเป็นปัญหาที่ฝ่ายขวาต้องเผชิญตั้งแต่การกวาดล้างโซเชียลมีเดียข้ามแพลตฟอร์มหลัง J6: การล็อคออนไลน์เป็นเรื่องจริงคุณสามารถทำการวิเคราะห์เชิงทฤษฎีและเชิงกลยุทธ์ของปัญหาการประสานงาน ลำดับความชอบ การส่งสัญญาณ และแนวคิดแบบทฤษฎีเกมอื่นๆ - ฉันไม่ปฏิเสธว่าสิ่งเหล่านี้เป็นวิธีที่มีประโยชน์ในการทำความเข้าใจปัญหา - แต่เข้าใจถึงอิทธิพลอันทรงพลังของ Twitter และ Facebook ต่อหลายร้อยรายการ พวกเราหลายล้านคน สิ่งที่คุณต้องรู้จริงๆคือ。

ฮิวริสติกอย่างง่าย

กฎของเมตคาล์ฟระบุว่ามูลค่าของเครือข่ายโทรคมนาคมเป็นสัดส่วนกับกำลังสองของจำนวนผู้ใช้ที่เชื่อมต่อของระบบ (n 2 ) เดิมทีกฎของเมตคาล์ฟถูกกำหนดขึ้นในรูปแบบนี้โดยจอร์จ กิลเดอร์ในปี 1993 และให้เครดิตกับงานอีเทอร์เน็ตของโรเบิร์ต เมตคาล์ฟ ประมาณปี 1980 เดิมทีกฎของเมตคาล์ฟไม่ได้แสดงอยู่ในหน่วยของผู้ใช้ แต่อยู่ในหน่วยของ "อุปกรณ์สื่อสารที่เข้ากันได้" (เช่น เครื่องโทรสาร โทรศัพท์) กฎหมายนี้มีผลใช้บังคับกับผู้ใช้และเครือข่ายในภายหลังด้วยโลกาภิวัตน์ของอินเทอร์เน็ต เนื่องจากเดิมมีจุดมุ่งหมายเพื่ออธิบายการเชื่อมต่ออีเทอร์เน็ต

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

น่าแปลกที่ web3 แก้ปัญหานี้ได้ หรืออย่างน้อยก็สามารถแก้ปัญหานี้ได้หากเราใช้สัญญาอัจฉริยะง่ายๆ ที่เปลี่ยนบล็อคเชนจากตารางผู้ใช้ขนาดยักษ์ให้กลายเป็นกราฟโซเชียลขนาดยักษ์

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

อย่างที่ฉันเขียนไว้ในตารางผู้ใช้พันล้าน:
บล็อกเชนสาธารณะนั้นเทียบเท่ากับตารางผู้ใช้ขนาดใหญ่เพียงตารางเดียวสำหรับอินเทอร์เน็ตทั้งหมด ซึ่งจะมีการสร้างแอปพลิเคชั่นแบบกระจายคลื่นลูกต่อไป
แทนที่ด้วยเครือข่ายการกระจายอำนาจของคลังข้อมูลผู้ใช้ที่เชื่อมต่อด้วย API ซึ่งเป็นที่เก็บข้อมูลผู้ใช้แบบกระจายอำนาจเพียงแห่งเดียวที่เข้าถึงได้ผ่านโปรโตคอลแบบเปิดและเครือข่ายโหนดจัดเก็บข้อมูลแบบกระจายอำนาจ ด้วยเหตุนี้ บล็อกเชนที่ดูแลข้อมูลประจำตัวจึงแสดงถึงการกระจายอำนาจของชั้นการดำเนินการจัดเก็บข้อมูล และการรวมศูนย์อีกครั้งของชั้นการเข้าถึงที่จัดเก็บข้อมูล
ลองนึกภาพว่า LinkedIn, Reddit และ Github ต่างย้ายตารางผู้ใช้ของตน (และข้อมูลที่เป็นกรรมสิทธิ์ของพวกเขาจำนวนมาก เช่น การรับรอง คะแนน และประวัติกิจกรรม) ไปยัง BitClout นี่คือสิ่งที่เกิดขึ้นทันที: ผู้ใช้ Github ทุกคนยังเป็นผู้ใช้ Reddit ผู้ใช้ LinkedIn และผู้ใช้ BitClout ในทำนองเดียวกัน ผู้ใช้ Reddit ทุกคนยังเป็นผู้ใช้ Github ผู้ใช้ LinkedIn และผู้ใช้ BitClout ฉันสามารถพูดต่อไปเรื่อย ๆ แต่คุณจะได้ประเด็น

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

(ตอนนี้ห่วงโซ่ในโครงการนั้นเรียกว่า DeSo) เป็นตัวอย่างที่สำคัญของบล็อกเชนที่สามารถรองรับกรณีการใช้งานนี้ได้ แต่เท่าที่ฉันตื่นเต้นเกี่ยวกับสิ่งทั้งหมดของ DeSo มันไม่ได้ยอดเยี่ยมขนาดนั้น

นี่ไม่ใช่สถานที่สำหรับชันสูตรพลิกศพของ Bitclout/DeSo แต่เป็นการเหมาะสมที่จะระบุแง่มุมของบล็อกเชนนี้ที่มีความสำคัญต่อการอภิปรายในขณะนี้ Bitclout มุ่งมั่นที่จะทำให้เครือข่ายโซเชียลทั้งหมดอยู่บนเครือข่าย โดยแต่ละโพสต์จะถูกเขียนบนเครือข่ายเป็นวัตถุที่สามารถสร้างรายได้ (ผ่าน Bitclout Diamonds) เป็นเรื่องที่ฉลาด แต่บล็อกเชนใด ๆ ที่พยายามโฮสต์เนื้อหาจริงจะเห็นความต้องการข้อมูลเพิ่มขึ้นเป็นเส้นตรงตามจำนวนผู้ใช้และการเชื่อมต่อ

ทีมงาน Bitclout คุ้นเคยกับปัญหาการเติบโตของข้อมูลที่ไร้ขอบเขตนี้เป็นอย่างดี และได้ใช้ความพยายามด้านวิศวกรรมอย่างแท้จริงเพื่อพยายามแก้ไขปัญหาดังกล่าว แต่เมื่อมองย้อนกลับไป ฉันคิดว่าพวกเขาพยายามทำหลายอย่างพร้อมกันมากเกินไป พวกเขาควรมุ่งเน้นไปที่ปัญหาการพกพาของกราฟทางสังคมเท่านั้น

• users

• user_follows_user

• posts

• user_likes_post

ตามที่อธิบายไว้ในเงื่อนไขของฐานข้อมูลจากโพสต์ก่อนหน้าของฉัน Bitclout พยายามวางตารางต่อไปนี้ทั้งหมดบนเครือข่าย (รวมถึงบางตารางที่เฉพาะเจาะจงของ Bitclout):

สองตารางสุดท้ายมักจะมีการระเบิดของข้อมูล ซึ่งจะกลายเป็นเรื่องยากที่จะดำเนินการในกรณีที่ผู้ใช้เติบโตอย่างรวดเร็ว

ดังนั้นฉันคิดว่าแนวทางที่ดีกว่าคือการใช้ blockchain ที่มีอยู่ ซึ่งโดยพื้นฐานแล้วเป็นตารางแรกอยู่แล้ว (เช่น ผู้ใช้) และเพิ่มตารางรวม user_follow_user ลงไป (เรายังสามารถขยายการรวมสำหรับความสัมพันธ์ประเภทอื่นๆ เช่น user_mutes_user ได้ แต่ตอนนี้เราจะทำให้มันง่ายไว้ก่อน)

ตารางการเชื่อมต่อระหว่างผู้ใช้กับผู้ใช้นี้จะเพิ่มขึ้นตามจำนวนผู้ใช้เป็นเส้นตรง แต่ในอัตราที่ช้าลง และที่สำคัญกว่านั้น เพื่อแสดงถึงจำนวนข้อมูลเพิ่มเติมที่ต้องการ (= พื้นที่บล็อกพิเศษที่ใช้จำนวน) จะ ต่ำกว่าตารางโพสต์มาก

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

กราฟโซเชียลบนเครือข่ายอาจมีลักษณะอย่างไร

ลองนึกภาพกราฟ Twitter ทั้งหมดของฉันถูกรวมเข้ากับเครือข่าย – รวมถึงบัญชีจริงและความสัมพันธ์ของผู้ติดตาม ในการดูโพสต์ Twitter ในกราฟนี้ (และการถูกใจที่เกี่ยวข้อง การรีทวีต แทร็กรีทวีต ฯลฯ) ฉันต้องเชื่อมต่อกับ Twitter.com ด้วยกระเป๋าเงินของฉัน แต่สมมติว่าฉันต้องการข้ามไปที่ Tribe.com หรือ gab.com หรือแพลตฟอร์มโซเชียลอื่นๆ ที่มีแนวโน้มพิเศษและนโยบายการกลั่นกรองของตัวเอง ถ้าพวกเขาสามารถอ่านกราฟโซเชียลของฉันจากบล็อกเชนได้ ฉันก็สามารถเชื่อมต่อกระเป๋าเงินของฉันที่นั่นและ ดูการเชื่อมต่อเดียวกันและดูโพสต์ใด ๆ ที่พวกเขามีในเว็บไซต์อื่นนี้Tribelนี่อาจฟังดูไม่น่าดึงดูดนัก แต่ลองพิจารณาความจริงที่ว่าถ้าฉันเป็นเช่นนั้นGabติดตามคนใหม่บน Twitter ดังนั้นตอนนี้ฉันยังใช้ Twitter และ

ติดตามบุคคลนี้บน Facebook – และทุกแพลตฟอร์มโซเชียลอื่น ๆ ที่ใช้กราฟผู้ใช้และความสัมพันธ์บนเครือข่ายเดียวกัน การเลิกติดตามและการบล็อกทำงานในลักษณะเดียวกัน – ทำเพียงครั้งเดียวในที่เดียว และการเปลี่ยนแปลงในกราฟของคุณจะมีผลทันทีในทุกที่

ตอนนี้ พวกคุณที่ต้องการใช้ประโยชน์จากสิ่งนี้ในขณะที่อ่านได้ตระหนักแล้วว่าในโลกเช่นโลกข้างต้น สิ่งที่จะเกิดขึ้นอย่างหลีกเลี่ยงไม่ได้ก็คือ จะมีใครบางคนสร้าง catch-all client ที่จะช่วยให้คุณเข้าถึงข้อมูลจากสิ่งใดสิ่งหนึ่งหรือทั้งหมด ของเครือข่ายเหล่านี้ผ่านอินเทอร์เฟซเดียว อ่าน และเผยแพร่ข้อมูลใน ถ้าอย่างนั้นก็ไม่มีประโยชน์ที่จะแยกบริการ พวกเขาทั้งหมดจะเลิกกิจการ...หรือจะเป็นเช่นนั้น?

ตัวอย่างสิ่งที่จะเกิดขึ้น: หมายเลขโทรศัพท์ + รายชื่อผู้ติดต่อ + แอพส่งข้อความ

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

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

ด้วยเหตุนี้ คุณจึงสามารถเลือกแลกเปลี่ยนข้อความด้วยหมายเลขโทรศัพท์เดียวกันผ่าน Signal, Telegram, WhatsApp, iMessage หรือ SMS แบบเดิมได้ ทั้งหมดขึ้นอยู่กับโปรโตคอลการส่งข้อความที่คุณและคนอื่นๆ ในเครือข่ายต้องการใช้นอกจากนี้ยังมีวัฏจักรชั่วนิรันดร์ ซึ่งก็คือการกระจายอำนาจและการรวมศูนย์กลางอีกครั้งของแอปพลิเคชันการรับส่งข้อความ ซึ่งเริ่มต้นจากยุค ICQ และยังคงเกิดขึ้นในยุค WhatsApp/Signal/Telegram/Facebook/อื่นๆ คุณสามารถหาจำนวนเท่าใดก็ได้ทั้งหมดในอย่างเดียว

ไคลเอนต์การส่งข้อความที่รองรับแพลตฟอร์มเหล่านี้จำนวนมากในหน้าต่างเดียว

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

เกี่ยวกับความสามารถในการประกอบและความสัมพันธ์ทางสังคม

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

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

พิจารณา Facebook "เพื่อน" - นี่เป็นประเภทของการเชื่อมต่อของมันเอง แต่ก็หมายถึง "การติดตาม" ด้วย เพราะเมื่อคุณเพิ่มใครสักคนเป็นเพื่อน คุณจะติดตามพวกเขาโดยอัตโนมัติ ใน Twitter "บล็อก" หมายถึง "ปิดเสียง" เพราะเมื่อคุณบล็อกใครบางคน เท่ากับคุณปิดเสียงเขาในขณะเดียวกันก็ป้องกันไม่ให้พวกเขาเห็นโพสต์ของคุณด้วย

• สำหรับข้อเสนอกราฟทางสังคมสองข้อของฉันเอง ด้านล่างนี้ ฉันอยากจะแนะนำชุดความสัมพันธ์ของกราฟทางสังคมดังต่อไปนี้ สะอาดกว่าและเรียบเรียงได้:

• ติดตาม: คุณสามารถอ่านโพสต์จากคนที่คุณติดตาม

• ปิดเสียง: คุณไม่สามารถอ่านโพสต์จากคนที่คุณปิดเสียงได้

บล็อก: คนที่คุณบล็อกไม่สามารถอ่านโพสต์ของคุณได้

ภายใต้โครงร่างนี้ บล็อกคือ "ปิดเสียง" บวกด้วย "บล็อก" ดังนั้นจึงประกอบด้วยการดำเนินการสองรายการในที่อยู่เป้าหมายเดียวกัน (เช่น ถ้าฉันต้องการบล็อกที่น่ารำคาญ Hater.eth ฉันจะปิดที่อยู่นี้ จากนั้น ปิดกั้น)

ถ้าฉันต้องการเห็นโพสต์ของใครซักคนแต่ไม่อยากให้เขาเห็นโพสต์ของฉัน ฉันติดตามเขาและบล็อกได้ หรือฉันติดตามและปิดเสียงได้หากต้องการอ่านต่อโดยไปที่เนื้อหาหรือเปิดเสียงเป็นระยะๆ

ฉันพยายามอธิบายความสัมพันธ์ด้วยวิธีนี้ เพราะจะทำให้ง่ายต่อการให้เหตุผลเกี่ยวกับสัญญาและความสัมพันธ์ในบทต่อๆ ไป

ภูมิหลังบางประการของข้อเสนอสองข้อของฉัน

• ในส่วนที่เหลือของเอกสารนี้ ฉันได้เสนอข้อเสนอสองข้อสำหรับการแบ่งชั้นของกราฟทางสังคมลงในตารางผู้ใช้หนึ่งพันล้านคน

• กราฟแบบแรกคือ On-Chain Graph (OCG) เปิดกว้างและเรียบง่ายกว่า แต่ก็มีราคาแพงกว่าในแง่ของค่าธรรมเนียม ดังนั้นบางคนจะชอบและบางคนก็ไม่ชอบ

• กราฟแบบที่สอง (CLG) ซับซ้อนกว่าแต่ถูกกว่า และให้การควบคุมและความเป็นส่วนตัวมากกว่า ดังนั้นฉันคาดว่าคนส่วนใหญ่จะชอบกราฟนี้มากกว่า อย่างไรก็ตาม แพลตฟอร์มต่างๆ สามารถรองรับทั้งสองแนวทางพร้อมกันได้

• เพื่อให้เข้าใจข้อเสนอทั้งสองอย่างแท้จริง คุณต้องมีความคุ้นเคยเบื้องต้นเกี่ยวกับแนวคิดต่อไปนี้:

• บริการชื่อโดเมน Ethereum

• สัญญาที่ชาญฉลาด

สัญญาที่ชาญฉลาด

การรู้ Solidity เล็กน้อย (ภาษาโปรแกรมสัญญาอัจฉริยะของ Ethereum) ก็จะช่วยได้เช่นกัน หากคุณยังคลุมเครือในข้อใดข้อหนึ่งหรือทั้งหมดข้างต้น ฉันได้พยายามเขียนสิ่งนี้ในลักษณะที่คุณน่าจะยังเข้าใจพื้นฐานได้ENSสำหรับข้อเสนอทั้งสอง ฉันคิดว่าเราใช้

ตัวอย่างบันทึก ENS ในกรณีนี้คือชื่อ ENS ของฉันเอง

curl https://jonstokes.com/jons-profile.json

-H "Accept: application/json"

{

"name": "jonstokes.(eth|com)",

"bio": "Writer. Coder. Doomer Techno-Optimist. Cryptography Brother.",

"website": "https://jonstokes.com/",

"location": "Austin, TX"

}

ฉันต้องการเสนอบันทึก ENS เพิ่มเติมสำหรับ URI ข้อมูลผู้ใช้โซเชียล เพื่อให้คุณสามารถอัปเดตข้อมูลโซเชียลของคุณโดยไม่ต้องเปลืองแรง ระเบียน profileURI ที่เสนอจะเชื่อมโยงกับออบเจกต์ JSON ที่ซ่อนอยู่ในแพลตฟอร์มของบุคคลที่สาม ซึ่งมีลักษณะดังนี้:

เนื้อหาบางอย่างในโปรไฟล์ JSON ซ้ำซ้อนกับฟิลด์ ENS ที่มีอยู่ แต่ไม่เป็นไร จุดประสงค์ของการดำเนินการนี้คือเพื่อให้แพลตฟอร์มโซเชียลแสดงบางสิ่งและอนุญาตให้ผู้ใช้ทำการเปลี่ยนแปลงโปรไฟล์โซเชียลโดยไม่ต้องเสียเงินเพื่ออัปเดตบันทึก ENS

ข้อเสนอที่ 1: กราฟบนเครือข่าย

• แนวคิดของ On-Chain Graph ใช้ NTFT เพื่อแสดงถึงความสัมพันธ์สามประการข้างต้น สำหรับสัญญาโซเชียลสามรายการต่อไปนี้ กระเป๋าเงินใบเดียวกันที่มี ENS NFT ควรเป็นเจ้าของสัญญาเหล่านี้ด้วย และบันทึกที่อยู่ ENS สามรายการที่เกี่ยวข้องควรชี้ไปที่สัญญาเหล่านี้:

• ผู้ติดตาม OCG: เมื่อคุณฝาก NTFT จากสัญญาผู้ติดตาม OCG ของฉันลงในกระเป๋าเงินของคุณ คุณก็ติดตามฉัน พวกเราทุกคนสามารถทำลาย NFT นี้และทำให้คุณเลิกติดตามฉันได้

• การบล็อก OCG: ฉันบล็อกคุณเมื่อฉันปล่อย NTFT จากสัญญา OCG Ghosted ลงในกระเป๋าเงินของคุณ มีเพียงฉันเท่านั้นที่สามารถทำลาย NTFT นี้เพื่อบรรเทาคุณได้

OCG Mute: เมื่อฉันออกอากาศ NTFT จากสัญญา OCG Mute ไปยังกระเป๋าเงินของคุณ ฉันได้ปิดเสียงคุณแล้ว มีเพียงฉันเท่านั้นที่สามารถทำลาย NTFT นี้เพื่อเปิดเสียงคุณได้

ความหมายของทั้งสามกรณีโดยพื้นฐานแล้ว: "เทียบกับฉัน เจ้าของสัญญา คุณคือ X" โดยที่ "X" คือผู้ติดตาม การบล็อก และใบ้

// SPDX-License-Identifier: MIT

pragma solidity ^ 0.8.4;

import "@openzeppelin/contracts/token/ERC 721/ERC 721.sol";

import "@openzeppelin/contracts/token/ERC 721/extensions/ERC 721 Enumerable.sol";

import "@openzeppelin/contracts/security/Pausable.sol";

import "@openzeppelin/contracts/access/Ownable.sol";

import "@openzeppelin/contracts/token/ERC 721/extensions/ERC 721 Burnable.sol";

import "@openzeppelin/contracts/utils/Counters.sol";

contract OCGFollower is ERC 721, ERC 721 Enumerable, Pausable, Ownable, ERC 721 Burnable {

using Counters for Counters.Counter;

Counters.Counter private _tokenIdCounter;

constructor() ERC 721("OCGFollower", "OCGF") {}

function _baseURI() internal pure override returns (string memory) {

return "https://jonstokes.com/ocg/follower";

}

function relationship() public {

return "ocg follower";

}

function pause() public onlyOwner {

_pause();

}

function unpause() public onlyOwner {

_unpause();

}

function safeMint(address to) public {

//Prevent anyone but the owner from minting

//a token to an address they don't own.

require(isOwner(_msgSender()) || (_msgSender() == to), "Unable to mint to this address");

uint 256 tokenId = _tokenIdCounter.current();

_tokenIdCounter.increment();

_safeMint(to, tokenId);

}

function _beforeTokenTransfer(address from, address to, uint 256) pure override internal {

//Disable token transfers.

require(from == address( 0) || to == address( 0), "Cannot be transferred.");

}

// The following functions are overrides required by Solidity.

function supportsInterface(bytes 4 interfaceId)

public

view

override(ERC 721, ERC 721 Enumerable)

returns (bool)

{

return super.supportsInterface(interfaceId);

}

}

นี่คือตัวอย่างสัญญาผู้ติดตาม:

หากคุณคุ้นเคยกับ Solidity คุณสามารถดูได้ว่าสัญญาที่เรียบง่าย (และยังไม่ได้ทดลอง!) นี้กำลังพยายามทำอะไร

• ส่วนขยายแรก:

• มีการรวมส่วนขยาย ERC 721 Enumerable เพื่อให้ผู้ถือโทเค็นสามารถแสดงรายการโดยไคลเอนต์โซเชียลเน็ตเวิร์กโดยไม่ต้องสแกนห่วงโซ่ทั้งหมด

• ฉันใช้ Pausable เพราะคุณควรหยุดการสร้างเหรียญชั่วคราวเพื่อล็อกบัญชีของคุณเป็นระยะเวลาหนึ่ง เช่น หยุดรับผู้ติดตามใหม่

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

• ERC 721 Burnable มาถึงแล้ว เนื่องจากคุณต้องสามารถเบิร์นโทเค็นเพื่อลบความสัมพันธ์ที่ติดตามได้ ฟังก์ชันเบิร์นมาตรฐาน () ที่รวมอยู่ในนี้มีสิทธิ์ที่เราต้องการ เช่น เฉพาะเจ้าของหรือเจ้าของโทเค็นเท่านั้นที่สามารถเบิร์นโทเค็นได้

ฉันได้รวม Counters เพื่อให้ tokenID เพิ่มขึ้นโดยอัตโนมัติ ซึ่งสะดวก

• ตอนนี้แก้ไขผลลัพธ์ของตัวช่วยสร้าง OpenZeppelin:

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

• _beforeTokenTransfer() ถูกเขียนใหม่เพื่อให้ปิดใช้งานความสามารถในการโอนโทเค็นโดยพื้นฐานแล้ว สร้างโทเค็นที่มีจิตวิญญาณที่เรียบง่าย

ฟังก์ชัน relationship() เป็นวิธีอำนวยความสะดวกที่ช่วยให้มั่นใจว่ามีวิธีง่ายๆ ในการสอบถามสัญญาและยืนยันว่า NFT แสดงถึงความสัมพันธ์ใด ฉันไม่ใช่แฟนของการรวมสิ่งนี้ แต่ดูเหมือนว่ามีประโยชน์

• ทุกอย่างง่ายมาก สำหรับรูปแบบที่ปิดบังของ OCG และรูปแบบที่ปิดเสียงของ OCG คุณต้องทำการเปลี่ยนแปลงเล็กน้อยดังต่อไปนี้:

• เปลี่ยนชื่อสัญญาและสัญลักษณ์

• เปลี่ยนค่าส่งคืนของ relationship() และ baseURI() เพื่อสะท้อนความสัมพันธ์ที่คุณเป็นตัวแทน (เช่น "ปิดเสียง" หรือ "โกสต์")

เปลี่ยนทั้งฟังก์ชัน safeMint() และ burn() เป็นฟังก์ชัน onlyOwner เพื่อให้เฉพาะเจ้าของสัญญาเท่านั้นที่สามารถเรียกใช้ฟังก์ชันทั้งสองนี้ได้

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

เพิ่มความสนใจจ่าย

uint 256 public mintRate = 0.01 ether;

function setMintRate(uint 256 mintRate_) public onlyOwner {

mintRate = mintRate_;

}

function safeMint(address to) public payable {

// Require pay-to-follow

require(msg.value >= mintRate, "Not enough ether to mint");

//Prevent anyone but the owner from minting

//a token to an address they don't own.

require(isOwner(_msgSender()) || (_msgSender() == to), "Unable to mint to this address");

uint 256 tokenId = _tokenIdCounter.current();

_tokenIdCounter.increment();

_safeMint(to, tokenId);

}

คุณสามารถเพิ่มเจ้าหนี้ใน safeMint จากนั้นใช้ setMintRate เพื่อกำหนดราคาที่ผู้คนต้องจ่ายให้คุณสำหรับสิ่งต่อไปนี้ ดังนั้นสิ่งนี้:

ฉันแน่ใจว่าฉันสามารถคิดถึงการปรับแต่งและฟีเจอร์อื่นๆ อีกมากมายเพื่อเพิ่มในคำแนะนำนี้ได้ แต่ทางที่ดีควรเริ่มจากสิ่งที่เรียบง่ายและเข้าใจได้ง่าย

ข้อเสนอที่ 2: กราฟการเชื่อมต่อโซ่

• สัญญา OCG ที่อธิบายไว้ข้างต้นนั้นเรียบง่ายพอ แต่โครงการมีนิสัยแปลก ๆ ที่อาจทำให้คนจำนวนมากแตกแยก:

• ทุกอย่างเป็นแบบสาธารณะ บนเครือข่าย รวมถึงการบล็อกและการปิดเสียง คุณไม่สามารถทำเช่นนี้เพื่อล็อคบัญชีได้ แต่วิธีแก้ปัญหาที่เป็นไปได้คือการใช้บัญชีอื่น

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

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

เนื่องจากไม่ใช่ทุกคนที่จะชอบคุณสมบัติเหล่านี้ของข้อเสนอนี้ ฉันจึงขอเสนอชุดสัญญาทางสังคมทางเลือกที่ให้ผู้ใช้และแพลตฟอร์มสามารถควบคุมได้ละเอียดมากขึ้นว่าใครจะเห็นข้อมูลใดบ้าง และมีค่าใช้จ่ายน้อยกว่าในการใช้

• แนวคิดพื้นฐานของ Chain Link Graph (CLG): เราไม่แสดงความสัมพันธ์ทางสังคม (ติดตาม บล็อก ปิดเสียง) บนเชนโดยตรงผ่าน NFT แต่เก็บความสัมพันธ์เหล่านี้ไว้นอกเชน และใช้โทเค็นบนเชนเพื่อค้นหาและ เข้าถึงความสัมพันธ์เหล่านี้

• การค้นพบ: สัญญามีฟังก์ชัน listURI() ที่ส่งคืนรายการ JSON ของลิงก์ไปยังชื่อ ENS ที่คุณต้องการประกาศความสัมพันธ์ทางสังคม (เช่น ฉันติดตามพวกเขา ฉันปิดเสียง หรือบล็อกพวกเขา)

การเข้าถึง: หากลิงก์ที่ส่งกลับโดย listURI() ถูกควบคุมด้วยโทเค็น โทเค็นของสัญญาจะมอบสิทธิ์การอ่านลิงก์ที่พบในข้อมูลเมตาแก่เจ้าของ

จากนั้นความสัมพันธ์ทางสังคมไม่ได้อยู่บนห่วงโซ่โดยตรง แต่เชื่อมโยงกับห่วงโซ่ผ่านชุดของสัญญาและ URL

• เช่นเดียวกับ OCG ความสัมพันธ์ทางสังคมทั้งสามประเภทถูกควบคุมโดยสัญญาอัจฉริยะ แต่ CLG มีความหมายที่แตกต่างกัน:

• ติดตาม: ประกอบด้วยรายการ JSON ของลิงก์ไปยังชื่อของ ENS ที่คุณกำลังติดตาม และโทเค็นที่ออกโดยให้สิทธิ์การเข้าถึงแบบอ่านไปยังรายการเฝ้าดูนั้น

• ปิดเสียง: ประกอบด้วยรายชื่อ JSON ที่เชื่อมโยงกับ ENS ที่คุณกำลังปิดเสียง โทเค็นที่ออกโดยมันให้สิทธิ์การเข้าถึงแบบอ่านไปยังรายการที่ปิดเสียงนั้น

บล็อก: ประกอบด้วยรายการ JSON ที่เชื่อมโยงกับชื่อ ENS ที่คุณกำลังบล็อก โทเค็นที่ออกโดยมันให้สิทธิ์การอ่านรายการบล็อก

ดังนั้น ความหมายของโทเค็น CLG คือ: "นี่คือการเข้าถึงเพื่ออ่านรายการบัญชี X ของฉัน" โดยที่ "X" คือ "ติดตาม", "ปิดเสียง" หรือ "บล็อก"

คุณคิดว่าข้อเสนอของฉันในส่วนนี้เป็นค่าประมาณของหมายเลขโทรศัพท์ + สมุดที่อยู่ที่ฉันอธิบายไว้สำหรับแอปพลิเคชันการส่งข้อความ หมายเลขโทรศัพท์ของคุณเป็น (เสมือน) สาธารณะ และเมื่อคุณเชื่อมต่อแอปส่งข้อความใหม่เข้ากับหมายเลขดังกล่าว คุณสามารถให้สิทธิ์หรือปฏิเสธการเข้าถึงแอปนั้นเพื่ออ่านรายชื่อผู้ติดต่อของคุณได้

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

(การเข้าถึงเพื่อเขียนรายการที่ประกอบกันเป็นกราฟทางสังคมของคุณอาจถูกควบคุมโดย ENS NFT ปกติของคุณ - หากคุณมีชื่อ ENS ของคุณในกระเป๋าเงินของคุณ คุณสามารถเขียน/อัปเดต/ลบรายการได้ ทางเลือกหนึ่งที่เป็นไปได้คือมีรายการที่สี่ สัญญาทางสังคมที่ให้สิทธิ์ในการเขียนรายชื่อผู้ถือ NTFT ดังนั้นคุณจึงสามารถว่าจ้างบุคคลภายนอกในการจัดการรายชื่อได้)

• การโฮสต์รายการเหล่านี้นอกเชน ในขณะที่ชี้ไปที่รายการจากออนเชนมีประโยชน์หลายประการ:

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

• การอัปเดตรายการนอกเครือข่ายไม่มีค่าใช้จ่าย

• วิธีการนี้ช่วยให้สามารถสร้างตลาดของบริการโฮสติ้งกราฟโซเชียลที่ทำงานร่วมกันได้กับผู้ให้บริการโซเชียล

ทุกคนหรือบริการสามารถค้นพบรายชื่อของคุณได้อย่างง่ายดาย

การควบคุมการเข้าถึงโทเค็นและการเข้าถึงการอ่าน

นวัตกรรมที่สำคัญในการปฏิบัติตามสัญญา CLG คือการควบคุมการเข้าถึงโทเค็น แนวคิดเบื้องหลังการควบคุมการเข้าถึงโทเค็นคือ คุณไม่สามารถเข้าถึงข้อมูลเฉพาะบนโฮสต์ได้ เว้นแต่คุณจะเชื่อมต่อกับโฮสต์ด้วยกระเป๋าเงินที่มีโทเค็นการเข้าถึงเฉพาะ

ตัวอย่างเช่น คุณสามารถมีโทเค็นควบคุมการเข้าถึงเนื้อหาบน IPFS เพื่อให้เฉพาะผู้อ่านที่เชื่อมต่อกับจุดสิ้นสุดด้วย NFT เฉพาะในกระเป๋าเงินของพวกเขาเท่านั้นที่สามารถดูไฟล์เฉพาะได้

CLG ใช้โทเค็นเกตเพื่อเพิ่มทางอ้อมให้กับสัญญาโซเชียลของเรา ดังนั้นแทนที่จะแสดงความสัมพันธ์ประเภทใดประเภทหนึ่ง เช่น ติดตาม ปิดเสียง หรือบล็อก NFT โซเชียลจะแสดงถึงการเข้าถึงแบบอ่านไปยังส่วนของกราฟโซเชียลของคุณ

เห็นได้ชัดว่าเพื่อให้เกณฑ์โทเค็นทำงานได้ แพลตฟอร์มจะต้องปฏิบัติตาม หากแพลตฟอร์มไม่ปฏิบัติตามการควบคุมการเข้าถึงโทเค็น คุณจะถ่ายโอนรายการความสัมพันธ์ของคุณไปยังแพลตฟอร์มอื่น และเปลี่ยนสัญญาของคุณ ออก NFT ใหม่หากจำเป็น

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

แม่แบบสัญญา: CLG ติดตาม

// SPDX-License-Identifier: MIT

pragma solidity ^ 0.8.4;

import "@openzeppelin/contracts/token/ERC 721/ERC 721.sol";

import "@openzeppelin/contracts/security/Pausable.sol";

import "@openzeppelin/contracts/access/Ownable.sol";

import "@openzeppelin/contracts/token/ERC 721/extensions/ERC 721 Burnable.sol";

import "@openzeppelin/contracts/utils/Counters.sol";

contract CLGFollows is ERC 721, Pausable, Ownable, ERC 721 Burnable {

using Counters for Counters.Counter;

Counters.Counter private _tokenIdCounter;

constructor() ERC 721("CLGFollows", "CLGF") {}

function _baseURI() internal pure override returns (string memory) {

return "https://jonstokes.com/clgfollows/";

}

function listURI() public {

return "https://jonstokes.com/clgfollows/list";

}

function relationship() public {

return "clg follows";

}

function pause() public onlyOwner {

_pause();

}

function unpause() public onlyOwner {

_unpause();

}

function safeMint(address to) public onlyOwner {

uint 256 tokenId = _tokenIdCounter.current();

_tokenIdCounter.increment();

_safeMint(to, tokenId);

}

function _beforeTokenTransfer(address from, address to, uint 256) pure override internal {

//Disable token transfers.

require(from == address( 0) || to == address( 0), "Cannot be transferred.");

}

}

สัญญาด้านล่างจะเป็นสัญญามาตรฐาน ERC 721 NTFT ซึ่งใกล้เคียงกับสัญญา OCG ด้านบนมาก:

ส่วนขยายทั้งหมดเหมือนกันกับ OCG ยกเว้นว่าฉันไม่ได้รวม ERC 721 Enumerable เนื่องจากไม่ชัดเจนว่ามีใครต้องการให้โทเค็น CLG Follows ของพวกเขาระบุ (รวมทั้งเพิ่มต้นทุนก๊าซของการสร้างเหรียญ)

• สำหรับฟังก์ชัน ฉันได้แก้ไขเอาต์พุตของตัวช่วยสร้าง OpenZeppelin ดังต่อไปนี้:

• ความสัมพันธ์ (): เช่นเดียวกับ OLG จะส่งคืนประเภทของสัญญาทางสังคม อีกครั้ง นี่อาจไม่จำเป็นสำหรับสัญญา Solidity และฉันไม่เคยเห็นมันทำเสร็จ แต่ถึงกระนั้น ฉันรู้สึกว่าฉันต้องการให้สัญญารายงานประเภทของมันด้วยตัวเอง ฉันไม่รู้ - โปรดอย่าสนใจหากสิ่งนี้ทำให้คุณขุ่นเคือง

listURI() ส่งคืนลิงก์ไปยังวัตถุ JSON ที่เป็นรายชื่อ ENS ที่คุณกำลังติดตาม (หรือปิดเสียงหรือบล็อก ขึ้นอยู่กับประเภทสัญญา) เราต้องการให้ URI นี้ถูกทำเครื่องหมายเป็นส่วนตัว แต่ไม่จำเป็น

ส่วนใหญ่คุณจะใช้ CLG ติดตาม NTFT และโพสต์ไปยังที่อยู่ของแพลตฟอร์มโซเชียล ด้วยวิธีนี้ แพลตฟอร์มสามารถอ่านรายการเฝ้าดูของคุณและแสดงโพสต์ที่ถูกต้อง

แต่คุณยังสามารถส่ง NTFT เหล่านี้ไปยังผู้ติดตามเพื่อให้ผู้ติดตามของคุณสามารถค้นพบผู้ติดตามคนอื่นๆ ได้ คุณสามารถทำได้โดยการส่งไปยังผู้ติดตามหรือโดยการเลิกแบนเหรียญ เพื่อให้ทุกคนสามารถสร้างเหรียญได้

สัญญาอื่นๆ ทั้งหมดทำงานเหมือนกับข้างต้น แต่มีชื่อและสัญลักษณ์ต่างกัน และส่งกลับค่าที่แตกต่างจากrelation() และ listURI()

ตัวแปรที่เป็นไปได้

หากคุณกังวลว่ารายการของคุณรั่วไหลจากบริการต่างๆ การเปลี่ยน listURI() เป็นสิ่งที่คล้ายกับ tokenURI(uint 256 tokenId) ค่อนข้างตรงไปตรงมา กล่าวคือ ลายเซ็นคือ listURI(uint 256 tokenId) ซึ่งจะเชื่อม tokenID กับส่วนท้ายของ a URI พื้นฐานเพื่อให้ผู้ถือโทเค็นแต่ละรายได้รับ URL รายการของตัวเอง คุณลักษณะนี้ เมื่อรวมกับตรรกะบางอย่างบนโฮสต์รายการ ช่วยให้คุณสามารถแยกรายการในลักษณะที่ผู้ถือโทเค็นที่แตกต่างกันได้รับกราฟย่อยที่แตกต่างกันของกราฟหลัก ด้วยวิธีนี้ หากแพลตฟอร์มเป็นเจ้าของ เฉพาะส่วนนั้นของกราฟของฉันเท่านั้นที่ถูกบุกรุก

คุณอาจต้องการอัปเดต URL ที่ส่งคืนโดย tokenURI() และ/หรือ listURI() ซึ่งในกรณีนี้ คุณจะต้องจัดเก็บ URL เหล่านี้ในตัวแปร เริ่มต้น URL ใน Constructor และให้เฉพาะฟังก์ชัน Setter ของเจ้าของสำหรับการอัปเดต . สิ่งนี้จะเพิ่มต้นทุนการผลิตเหรียญของคุณ แต่ถ้าคุณจะให้บริการแก่พวกเขาเท่านั้น ไม่ใช่รายบุคคล สิ่งนี้อาจไม่สำคัญ

ให้บริการ

ให้บริการ

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

ประเภทบริการที่ชัดเจนที่สุดคือการโฮสต์สิ่งที่ส่งคืนโดยหนึ่งในฟังก์ชัน URI เช่น ข้อมูลโปรไฟล์ ข้อมูลเมตา NTFT และรายการ JSON ของการควบคุมโทเค็น (ในกรณีของ CLG)

สุดท้ายนี้ อาจมีบริการของบุคคลที่สามเพื่อตรวจสอบบัญชีให้เหมาะกับความต้องการของผู้ใช้และองค์กร

สรุป

สรุป

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

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

ลิงค์ต้นฉบับ