หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

FileFileGo Dentralized Storage & Data Sharing Network

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

FileFileGo เป็นโครงการชุมชนโอเพ่นซอร์สโดยไม่มีการควบคุมหรือความเป็นเจ้าของจากส่วนกลาง การกระจายเหรียญของมันได้รับการออกแบบให้มีความยุติธรรมโดยมีการปล่อย 40 FFG ต่อบล็อกที่ลดลงครึ่งหนึ่งทุก 24 เดือน โปรโตคอลจะเปิดตัวโดยไม่มี ICO/STO/IEO หรือ Pre-Mine อาศัยการพิสูจน์อัลกอริทึมฉันทามติผู้มีอำนาจซึ่งในที่สุดจะเปลี่ยนไปสู่การพิสูจน์สัดส่วนการลงทุนเพื่อให้ผู้มีส่วนได้ส่วนเสียเข้าร่วมได้มากขึ้น

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

นวัตกรรม: หลักฐานการถ่ายโอนด้วยการพิสูจน์ความรู้แบบศูนย์ (ป้องกัน ZK)

ปัญหา

ให้เราสมมติว่า node_1 จำเป็นต้องดาวน์โหลด data_x บางส่วนซึ่งเป็นเจ้าของโดย node_2 และชำระค่าธรรมเนียมที่กำหนดโดย node_2 จะเกิดอะไรขึ้นในกรณีของโหนดความผิดพลาดของไบแซนไทน์? เราจะตรวจสอบการถ่ายโอนข้อมูลที่ประสบความสำเร็จไปยังโหนดปลายทางได้อย่างไรและป้องกันกรณีที่เป็นอันตรายต่อไปนี้:

  1. node_1 เป็นโหนดที่ไม่ซื่อสัตย์ที่รายงาน data_x ไม่ถูกต้องเพื่อหลีกเลี่ยงการชำระค่าธรรมเนียม
  2. node_2 เป็นโหนดที่ไม่สุจริตที่ให้บริการ data_y ถึง node_1 และอ้างว่าเป็น data_x

สารละลาย

เครือข่ายสามารถต้านทานความผิดพลาดของ byzantine ได้หาก node_x สามารถออกอากาศ (peer-to-peer) ค่า x และตอบสนองต่อไปนี้:

  1. หาก node_x เป็นโหนดที่ซื่อสัตย์โหนดที่ซื่อสัตย์ทั้งหมดจะเห็นด้วยกับค่า x
  2. ไม่ว่าในกรณีใดโหนดที่ซื่อสัตย์ทั้งหมดเห็นด้วยกับค่าเดียวกัน y

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

              ┌───────────┐
     ┌────────►[verifiers]◄─────────┐
     │        └───────────┘         │
┌────┴───┐                     ┌────┴───┐
│        │                     │        │
│ node_1 ◄─────────────────────► node_2 │
│        │                     │        │
└────────┘                     ├────────┤
                               │ data_x │
                               └────────┘

อัลกอริทึม

อนุญาต $ x $ เป็นไฟล์อินพุตที่มีเนื้อหาแบ่งออกเป็น $ n = 1024 $ ส่วน

  1. หารเนื้อหาของไฟล์ $ x $ เข้าไปข้างใน $ n $ ส่วน: $ x = (x_1, x_2, ldots, x_n) $

  2. คำนวณแฮชต้นไม้ Merkle ของเซ็กเมนต์: ปล่อยให้ $ h (x_i) $ เป็นตัวแทนของแฮชของเซ็กเมนต์ $ x_i $ - สร้าง Merkle Tree โดย Hashing Segments ที่อยู่ติดกันในโครงสร้างต้นไม้ไบนารี:

    $ h (x_i) = text {hashfunction} (x_i) $ $ h (x_ {i, j}) = text {hashfunction} (h (x_i) | h (x_j)) $ ที่ไหน - หมายถึงการต่อกัน แฮชรากของต้นไม้ merkle คือ $ h _ { text {root}} = h (x_ {1,2}) $ แสดงเนื้อหาโดยรวม

  3. สลับเซ็กเมนต์: ปล่อยให้ $ pi $ เป็นการเปลี่ยนแปลงที่เป็นตัวแทนของการสับของเซ็กเมนต์ $ pi: {1, 2, ldots, n} rightarrow {1, 2, ldots, n} $ ส่วนที่สับเปลี่ยนคือ: $ x _ { pi (1)}, x _ { pi (2)}, ldots, x _ { pi (n)} $

  4. เข้ารหัส 1 เปอร์เซ็นต์ของส่วนที่สับเปลี่ยน: ปล่อยให้ $ m = lfloor 0.01 times n rfloor $ เป็นจำนวนกลุ่มที่จะเข้ารหัส อนุญาต $ e (x_i) $ แสดงถึงการเข้ารหัสของเซ็กเมนต์ $ x_i $ - ส่วนที่เข้ารหัสคือ: $ e (x _ { pi (1)}), e (x _ { pi (2)}), ldots, e (x _ { pi (m)}) $

กระบวนการตรวจสอบ

  1. การถอดรหัสส่วนที่เข้ารหัส: สำหรับแต่ละไฟล์ $ m $ ส่วนที่เข้ารหัสใช้ฟังก์ชันการถอดรหัส $ d (e (x _ { pi (i)})) $ เพื่อให้ได้รุ่นที่ถอดรหัสของเซ็กเมนต์ $ x _ { pi (i)} $ -

    $ x _ { pi (i)} '= d (e (x _ { pi (i)}) $

  2. การกู้คืนคำสั่งสับ: เนื่องจากกลุ่มถูกสับเปลี่ยนระหว่างกระบวนการเข้ารหัสพวกเขาจะต้องได้รับการฟื้นฟูตามลำดับเดิมโดยใช้การเปลี่ยนแปลงแบบผกผัน $ pi^{-1} $ -

    $ x '= (x _ { pi^{-1} (1)}', x _ { pi^{-1} (2)} ', ldots, x _ { pi^{-1} (m)}') $

  3. การคำนวณแฮชต้นไม้ Merkle: คำนวณใหม่ของ Merkle Tree Hash ของกลุ่มที่ถอดรหัสตามลำดับที่ได้รับการบูรณะ สร้างต้นแฮชคล้ายกับการก่อสร้างดั้งเดิม แต่ใช้ส่วนที่ถอดรหัส $ x '$ -

    $ h '(x_i') ​​= text {hashfunction} (x_i ') $ $ h '(x_ {i, j}') = text {hashfunction} (h '(x_i') ​​| h '(x_j')) $

  4. ในที่สุดแฮชรูท merkle ดั้งเดิมที่ได้รับมา $ h'_ text {root} $ ได้มาจากการแฮชลูกสองคนของแฮชราก $ h'_ text {root} = text {hashfunction} (h '(x_ {1,2}') | h '(x_ {3,4}')) $ -

  5. ฉันทามติจะเกิดขึ้นได้หากแฮชรูท merkle ที่ได้รับตรงกับแฮชรูท merkle ดั้งเดิม

การคำนวณแฮชรูท merkle

พิจารณาสถานการณ์ที่เกี่ยวข้องกับไฟล์ที่มีเนื้อหาที่ตามมา: 

 FileFileGo_Network

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

ภาพประกอบที่ตามมาแสดงให้เห็นถึงการรวมตัวกันของการจัดเรียงของไฟล์ที่ง่ายขึ้นในสื่อจัดเก็บข้อมูล แต่ละกล่องภายในภาพประกอบเป็นสัญลักษณ์ของข้อมูล 1 ไบต์ 

 ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ F │ i │ l │ e │ F │ i │ l │ e │ G │ o │ _ │ N │ e │ t │ w │ o │ r │ k │
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

ในการค้นหาแฮชรูท merkle ของไฟล์นี้เราจะแบ่งไฟล์ออกเป็นชิ้นส่วนที่เล็กลง ตัวอย่างเช่นลองแบ่งไฟล์ออกเป็นเก้าส่วนและแต่ละส่วนจะมีเพียงสองไบต์ 


    0       1       2       3       4       5      6       7        8
┌───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐
│ F   i │ l   e │ F   i │ l   e │ G   o │ _   N │ e   t │ w   o │ r   k │
└───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┘

ตอนนี้เราใช้แฮชของแต่ละเซ็กเมนต์: 

 segment 0: hash("Fi"), denoted by h0
segment 1: hash("le"), denoted by h1
segment 2: hash("Fi"), denoted by h2
segment 3: hash("le"), denoted by h3
segment 4: hash("Go"), denoted by h4
segment 5: hash("_N"), denoted by h5
segment 6: hash("et"), denoted by h6
segment 7: hash("wo"), denoted by h7
segment 8: hash("rk"), denoted by h8

จากนั้นเราคำนวณแฮชรูท merkle ของไฟล์โดยใช้อัลกอริทึม

นี่คือตัวอย่างของวิธีการทำงานของอัลกอริทึมนี้: 

            ┌───┬───┬───┬───┬───┬───┬───┬───┐
Data Blocks:│ a │ b │ c │ d │ e │ f │ g │ h │
            └───┴───┴───┴───┴───┴───┴───┴───┘
              0   1   2   3   4   5   6   7
              │   │   │   │   │   │   │   │
              └───┘   └───┘   └───┘   └───┘
               h01     h23     h45     h67
                │       │       │       │
                └───────┘       └───────┘
                h(h01+h23)     h(h45+h67)
                    │               │
                    │               │
                    └───────────────┘
         Merkle root:  h(h(h01+h23)+h(h45+h67))

ตอนนี้เรามีแฮชรูท merkle สำหรับไฟล์ซึ่งแสดงเป็น Mt (F) ซึ่งเป็นค่าแฮชอีกอย่างหนึ่ง

คำขอข้อมูล

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

random segments [ 1, 5, 2, 4, 7, 6, 3, 0, 8 ] ซึ่งแปลเป็นข้อตกลงต่อไปนี้: 


   1       5        2       4      7        6       3       0       8

┌───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐
│ l   e │ _   N │ F   i │ G   o │ w   o │ e   t │ l   e │ F   i │ r   k │
└───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┘

ต่อจากนั้นผู้ให้บริการจะสร้างคีย์สมมาตรและเวกเตอร์การเริ่มต้น (IV) เพื่อเข้ารหัสส่วนหนึ่งของกลุ่มเหล่านี้ ในภาพประกอบนี้เราจะเลือกที่จะเข้ารหัส 25% ของส่วนซึ่งเท่ากับ 2 ส่วน นอกจากนี้เราจะเข้ารหัสทุก ๆ 4 ส่วนซึ่งหมายความว่าเราจะเข้ารหัสเซ็กเมนต์ 0 และ 4: 

                       25% Segment Encryption = 2 segments

┌───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┐
│ l   e │ _   N │ F   i │ *   * │ w   o │ e   t │ l   e │ *   * │ r   k │
└───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┘

ตอนนี้ข้อมูลดังกล่าวจะถูกจัดเตรียมให้กับผู้ร้องขอข้อมูล ในขณะเดียวกันคีย์/IV ลำดับการสุ่มของเซ็กเมนต์และเนื้อหาของเซ็กเมนต์ 0 และ 4 จะถูกส่งไปยัง data verifier สิ่งสำคัญคือต้องเน้นว่าผู้ดาวน์โหลดมี Zero-Knowledge เกี่ยวกับลำดับของส่วนของไฟล์ภายในไฟล์และคีย์การเข้ารหัส/IV

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

เพื่อให้ข้อมูลเชิงลึกเพิ่มเติมพิจารณาว่าไฟล์ถูกแบ่งออกเป็นประมาณ 1024 ส่วน (หรือน้อยกว่าเล็กน้อย) ในสถานการณ์จริงและกลุ่มเหล่านี้จะถูกสุ่ม เพื่อให้ผู้โจมตีสร้างคำสั่งส่วนแรกขึ้นใหม่พวกเขาจะต้องดำเนินการ "การเปลี่ยนแปลงโดยไม่มีการทำซ้ำ" จำนวนวิธีทั้งหมดในการจัดเรียงกลุ่มไฟล์เหล่านี้ได้รับจาก N! (แฟคทอเรียล) ซึ่งมีจำนวน 1024! ในกรณีนี้ (https://coolconversion.com/math/factorial/what-is-the-factorial-of_1024_%3f)

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

ต่อไปนี้ผู้ดาวน์โหลดไฟล์จะต้องขอคีย์การเข้ารหัส/IV และลำดับสุ่มของกลุ่มไฟล์จาก data verifier ที่กำหนดภายในเครือข่าย

การตรวจสอบ

ตัวดาวน์โหลดข้อมูลส่งคำขอไปยังตัวตรวจสอบข้อมูลเพื่อค้นหาคีย์การเข้ารหัส/IV และกลุ่มสุ่ม คำขอนี้มาพร้อมกับส่วนแฮชของไฟล์ที่ดาวน์โหลดซึ่งนำเสนอดังนี้: 

 h1
h5
h2
h(enc(4))
h7
h6
h3
h(enc(0))
h8

data verifier ดำเนินการเข้ารหัสและแฮชสำหรับเซ็กเมนต์ 0 และ 4 ทำให้เกิดค่าแฮชต่อไปนี้: 

 h1
h5
h2
h4
h7
h6
h3
h0
h8

สุดท้าย data verifier จัดระเบียบส่วนใหม่ตามลำดับแบบสุ่มที่สร้างโดยไฟล์ Hoster ระหว่างการถ่ายโอนข้อมูลไปยังผู้ร้องขอ กระบวนการนี้ให้ผลตามลำดับเดิมของแฮชเซ็กเมนต์: 

 h0
h1
h2
h3
h4
h5
h6
h7
h8

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

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

ไหล

ในส่วนนี้วงจรชีวิตที่สมบูรณ์ของการตรวจสอบการถ่ายโอนข้อมูลจะแสดงให้เห็น

  1. การค้นพบข้อมูล: โปรโตคอลลวดจำนวนมากได้รับการพัฒนาเพื่ออำนวยความสะดวกในการสื่อสารระหว่างโหนดในเครือข่าย ในบรรดาโปรโตคอลเหล่านี้โปรโตคอลการสืบค้นข้อมูลมักใช้เป็นครั้งแรกโดยโหนด โปรโตคอลนี้ช่วยให้โหนดสามารถสอบถามรายละเอียดได้ตลอดช่องทางซุบซิบและดึงการตอบกลับผ่านการสื่อสารโดยตรง โดยพื้นฐานแล้วโหนดส่งคำขอสอบถามเกี่ยวกับโหนดใดโฮสต์ข้อมูลชิ้นใดชิ้นหนึ่ง 
             1. Data Query Request
                    ┌───────┐
    ┌───────────────►[nodes]├───────────────┐
    │               └───────┘               │
┌───┴────┐                             ┌────▼───┐
│        │                             │        │
│ node_1 │                             │ node_2 │
│        │                             │        │
└───▲────┘                             └───┬────┘
    │        2. Data Query Response        │
    └──────────────────────────────────────┘
  1. สัญญาอัจฉริยะ: Data Query Response มีข้อมูลทั้งหมดที่จำเป็นในการเตรียมธุรกรรมสัญญาอัจฉริยะ การทำธุรกรรมนี้จะถูกถ่ายทอดไปยังเครือข่ายซึ่งถูกเลือกโดยตัวตรวจสอบ 
 ┌──────────────────────────────────────┐
│              TRANSACTION             │
├──────────────────────────────────────┤
│  Data :                              │
│        - Data query response         │
│        - Remote node signature       │
│  Value:                              │
│        - Fees required by node       │
│                                      │
│  Fees :                              │
│        - Fees collected by verifier  │
│                                      │
│  To   :                              │
│        - Network verifier            │
└──────────────────────────────────────┘
  1. การตรวจสอบ: Verifier ( v1 ) สื่อสารกับโหนดที่เข้าร่วมและสร้างความท้าทายสำหรับโหนดที่โฮสต์ข้อมูล ( node_2 ) ความท้าทายประกอบด้วยขั้นตอนต่อไปนี้:
  • node_2 ควรสร้างแผนผัง Merkle ที่ตรงกับรูท Merkle ดั้งเดิมของ data_x ที่อัปโหลดตั้งแต่แรก
  • v1 ตัดสินใจ คำสั่งซื้อ และ จำนวนบล็อก/ช่วงข้อมูล ที่จะส่งไปยัง node_1 โดย node_2 เรายังไม่ต้องการเปิดเผยลำดับของบล็อกถึง node_1
  • v1 ขอให้ node_2 สำหรับช่วงข้อมูลคงที่ซึ่งจะถูกเข้ารหัสโดยใช้คีย์แบบสุ่ม k1 เป็น data_enc โดย v1 และส่งไปยัง node_1

ในขั้นตอนนี้ node_1 มี data_z และ data_enc บางส่วน แต่ขาดความรู้เกี่ยวกับวิธีการรวมไฟล์เหล่านั้นเพื่อให้ได้ไฟล์ต้นฉบับ Verifier, v1 สามารถตรวจสอบความสมบูรณ์ของข้อมูลที่ส่งไปยัง node_1 และหากพวกเขาตรงกับตัวตนของ Merkle Tree ดั้งเดิมคีย์ถอดรหัส K1 จะให้กับ node_1 นอกจากนี้คำสั่งบล็อกจะถูกส่งไปยัง node_1 ทำให้สามารถประกอบชิ้นส่วนทั้งหมดของชิ้นส่วนทั้งหมดเพื่อสร้างข้อมูลต้นฉบับ เมื่อกระบวนการนี้เสร็จสิ้น V1 จะปล่อยค่าธรรมเนียมเป็น node_2

การใช้อัลกอริทึมนี้ช่วยให้สามารถพิสูจน์การถ่ายโอนและหลักฐานการครอบครองข้อมูลได้พร้อมกัน

การติดตั้ง

ทำตามคำแนะนำเพื่อรวบรวมและติดตั้ง filefilego 

 https://filefilego.com/documentation/docs/installation.html#prerequisites

ส่วนประกอบ filefilego

คุณสมบัติ

FileFileGo เป็นเครือข่ายการกระจายอำนาจที่รวมความแข็งแกร่งของบล็อกเชน/cryptocurrency, DHT และเทคโนโลยีที่เป็นนวัตกรรมของ BitTorrent เพื่อสร้างโครงสร้างพื้นฐานที่ไม่สามารถใช้งานได้

  • แพลตฟอร์มนี้ใช้เทคโนโลยี blockchain สำหรับการจัดทำดัชนีและข้อมูลเมตาเครือข่ายอื่น ๆ และตรรกะเพื่อให้มั่นใจว่าระบบที่ปลอดภัยและมีประสิทธิภาพ
  • ทราฟฟิกที่เข้ารหัสจะปกป้องข้อมูลผู้ใช้จากการตรวจสอบการจราจรของบุคคลที่สามในขณะที่การออกแบบที่เน้นความเป็นส่วนตัวเป็นศูนย์กลางถ่ายทอดการรับส่งข้อมูลผ่านชุดของเพื่อนระดับกลาง
  • การออกแบบแบบเพียร์ทูเพียร์จำลองสถานะของเครือข่ายในแต่ละโหนดเต็มเพื่อเพิ่มความน่าเชื่อถือของข้อมูล
  • cryptocurrency ดั้งเดิมของเครือข่ายทำหน้าที่เป็น "เชื้อเพลิง" และรับประกันค่าธรรมเนียมการทำธุรกรรมที่ต่ำมากและมีเงื่อนไขเมื่อเทียบกับ Ethereum/Bitcoin
  • ด้วยขนาดบล็อกแบบไดนามิกและเวลาบล็อก 10 วินาทีไฟล์ FileFileGo ทำให้มั่นใจได้ว่าการทำธุรกรรมที่รวดเร็วและราบรื่น
  • FileFileGo ยังมีอินเทอร์เฟซ RPC ที่ช่วยให้นักพัฒนาสามารถสร้าง DAPPS บนเครือข่าย

อัลกอริทึมฉันทามติของ Blockchain

เพื่อให้ได้เวลาบล็อก 10 วินาที FileFileGo ต้องใช้อัลกอริทึมฉันทามติที่มีประสิทธิภาพในการประมวลผลธุรกรรมในปริมาณมากและอนุรักษ์กำลังการประมวลผล สำหรับขั้นตอนเริ่มต้นเราได้เลือกหลักฐานการมีอำนาจ (POA) เป็นอัลกอริทึมฉันทามติของเรา ในอนาคตกลไกการพิสูจน์สเตค (POS) จะแทนที่อัลกอริทึมปัจจุบัน

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

หลักฐานการมีอำนาจ / การตรวจสอบความถูกต้อง+อัลกอริทึม Verifier

ตัวตนของตัวตรวจสอบความถูกต้องจะถูกบันทึกไว้ใน blockchain และสามารถตรวจสอบได้โดยการตรวจสอบธุรกรรม Coinbase ของ Genesis Block โหนดที่เข้าร่วมสามารถตรวจสอบความถูกต้องของตัวตนเหล่านี้ได้อย่างง่ายดายโดยการตรวจสอบลายเซ็นของบล็อก

หลักฐานการถือหุ้น

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

blockchain และ metadata/การบัญชี

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

รายละเอียดทางเทคนิค

ในส่วนนี้เราจะให้ภาพรวมของข้อกำหนดทางเทคนิคและแนวคิดที่ใช้ใน FileFileGo

ช่อง

แชนเนลใน FileFileGo ช่วยให้ผู้ใช้สามารถจัดระเบียบและจัดกลุ่มข้อมูลเป็นถังหรือโฟลเดอร์ที่แตกต่างกัน ตัวอย่างเช่นเนื้อหาทั้งหมดใน Ubuntu.com สามารถวางไว้ในช่องที่ชื่อว่า "Ubuntu Official" ผู้ใช้ที่สร้างช่องจะได้รับสิทธิ์ทั้งหมดที่จำเป็นสำหรับการอัปเดตและการดำเนินการที่เกี่ยวข้องกับช่องอื่น ๆ

แชนเนลมีโครงสร้างในรูปแบบโหนดโซ่และสามารถระบุได้ว่าเป็นโหนดที่ไม่มี ParentHash

ช่องย่อย

แนวคิดของช่องทางย่อยคือการจัดหมวดหมู่ข้อมูลให้ดียิ่งขึ้น ตัวอย่างเช่นเอกสารรูปภาพหรือเพลง

รายการ & ไฟล์/ไดเรกทอรี

ใน FileFileGo Entry แสดงถึงโพสต์หรือชิ้นส่วนของข้อมูลที่มีข้อมูลเพิ่มเติมเกี่ยวกับรายการเองมากกว่าการจัดหมวดหมู่/การสั่งซื้อ File และ Directory สามารถวางลงใน Entry

เลเยอร์การจัดเก็บข้อมูล

Storage Engine เป็นชั้นจัดเก็บข้อมูลที่ติดตามข้อมูลไบนารีซึ่งใช้โดยพอยน์เตอร์แฮชภายในบล็อกเชนเพื่ออ้างถึงชิ้นส่วนของข้อมูล โครงสร้าง NodeItem มีฟิลด์ที่เรียกว่า FileHash ซึ่งหมายถึงแฮชไบนารีและอยู่ในรูปแบบของ "{HASH_ALGORITHM}:>{DATA_HASH}" เราต้องการรักษาข้อมูลเมตาของอัลกอริทึมการแฮชที่ใช้เพราะมันอาจจะมีประโยชน์ในอนาคต

ดัชนี/ค้นหาข้อความเต็มรูปแบบ

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

  1. จำเป็นหรือรวม ("FileFileGo Coin") ซึ่งหมายถึงทั้ง "FileFileGo" และ "Coin" เป็นสิ่งจำเป็นในผลการค้นหา
  2. ตัวเลือกหรือพิเศษ ("FileFileGo Currency") ซึ่งหมายความว่าหนึ่งในคำเหล่านั้นสามารถแยกออกจากผลการค้นหา

การพัฒนาภาษาคิวรีที่รองรับการสืบค้นที่ซับซ้อนเช่นนี้เป็นเครื่องมือที่ทรงพลังที่สามารถเพิ่มความแม่นยำของเครื่องมือค้นหาได้อย่างมีนัยสำคัญ

นอกจากนี้ยังเป็นไปได้ที่จะเปิดใช้งานฟังก์ชั่นการจัดทำดัชนีข้อความเต็มของโหนดโดยใช้ธง CLI- --search

เครื่องมือจัดเก็บข้อมูล

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

 ... --storage --storage_dir="/somewhere/to/store/data" --storage_token="somelongtokenhere" --storage_fees_byte="10000" ...

--storage_dir ควรเป็นไดเรกทอรีที่มีการอ่าน/เขียนที่เหมาะสม โปรดทราบว่าโหนดเต็มสามารถทำงานได้โดยไม่มีกลไกนี้ storage_token เป็นโทเค็นที่มอบสิทธิ์ผู้ดูแลระบบให้กับโทเค็นเพื่อให้สามารถสร้างโทเค็นอื่น ๆ โดยใช้ HTTP API สิ่งนี้มีประโยชน์เมื่อต้องการการเข้าถึงที่ถูกต้องโดยเว็บแอพหรือผู้ใช้ที่แตกต่างกันและ --storage_fees_byte="10000" คือค่าธรรมเนียมที่เรียกเก็บต่อข้อมูลไบต์

การกระจายเหรียญ

เหรียญ

หน่วย ค่า
ffgone 1
Kffg 1.000
MFFG 1.000.000
Gffg 1.000.000.000
microffg 1.000.000.000.000
miliffg 1.000.000.000.000.000
FFG (หน่วยเริ่มต้น) 1.000.000.000.000.000.000
zffg 1.000.000.000.000.000.000.000

ปริมาณทั้งหมด: 500 ล้าน FFG การตรวจสอบความถูกต้อง/รางวัลสเตค: 40 FFG ต่อบล็อก อัตราการลดลง: หารด้วย 2 ทุก 24 เดือน

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