คราวนี้เราจะนำ DA ของ Celestia ไปต่อยอดละ โดยจะนำไปพัฒนา dApp ง่ายที่พวกเราน่าจะคุ้นเคยกันอยู่ แล้วนั้นคือ TODO dApp นั้นเอง โดยข้อมูลทั้งหมดเราจะเก็บขึ้น on-chain ทั้งหมด พร้อมแล้วไปเริ่มกันเลย

เตรียมตัวกันก่อน

• Celestia light node (Testnet network) จากบทความก่อนหน้า ติดตั้งให้เรียบร้อย ทำหน้าที่เป็นเหมือน Database onchain เพื่อเก็บข้อมูลของ Todo แล้วเรายังสามารถเรียกข้อมูลกลับมาเมื่อไหร่ก็ได้ โดยที่ข้อมูลนั้นจะไม่เปลี่ยนไป หรือมีใครมาแก้ไขมันได้

• Go lang ติดตั้งให้เรียบร้อย เราจะใช้เป็น Logic ให้กับ Application เป็นเหมือนคนคอยจัดการข้อมูลก่อนส่งไปที่ Data Layer

เริ่มเขียนโค๊ดกัน

Initialize Golang module

go mod init todois-dapp

ติดตั้ง package

go get github.com/celestiaorg/celestia-openrpc@v0.5.0

สำหรับ packgage github.com/celestiaorg/celestia-openrpc จะมีการลง package ที่ทาง celestia เป็นคนทำขึ้นมา ดังนั้นเราจะต้องทำการ replace package เพื่อให้ Application ของเราสามารถทำงานได้ ซึ่งต้องไปแก้ไขในไฟล์ go.mod

replace (
 github.com/cosmos/cosmos-sdk => github.com/celestiaorg/cosmos-sdk v1.28.2-sdk-v0.46.16
 github.com/filecoin-project/dagstore => github.com/celestiaorg/dagstore v0.0.0-20230824094345-537c012aa403
 github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 github.com/ipfs/boxo => github.com/celestiaorg/boxo v0.29.0-fork
 github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
 github.com/tendermint/tendermint => github.com/celestiaorg/celestia-core v1.51.0-tm-v0.34.35
)

เสร็จจากตรงนี้ เราก็มีเตรียมตัวพร้อมที่จะไปเขียนในส่วนของ Logic ในการนำข้อมูลจาก TODO ขึ้น DA ของ Celestia Network

ส่งข้อมูลขึ้น DA ของ Celestia network

เริ่มจากเราต้องมี Light node ก่อน (ดูจากบทความที่แล้วได้นะ) เพื่อเป็นตัวกลางในการคุยกับ Celestia Data Availability แล้วเราจะได้ Light node endpoint มา

กำหนด Light node URL

url := "http://localhost:26658"

สร้าง Celestia client

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()

 // สร้าง Celestia Client
 c, err := client.NewClient(ctx, url, "")
 if err != nil {
  return err
 }
 defer c.Close()

กำหนด Namespace ให้กับข้อมูลของเรา

// กำหนด application namespace
namespace := "todoist"

// convert เป็น byte
namespaceBytes := []byte(namespace)

// convert ให้เป้น namespace id
 ns, err := share.NewBlobNamespaceV0([]byte(d.Namespace()))
 if err != nil {
  return err
 }

ทำการสร้างข้อมูล (เป็นตัวอย่างก่อนนะ)

 data := `[{ "title": "todo 1"}]`

// สร้าง blob จาก string โดยใช้เป็น v0
 b, err := blob.NewBlobV0(ns, data)
 if err != nil {
  return err
 }

เมื่อนำทุกอย่างมารวมร่างกัน

func SubmitData() uint64, error {
 url := "http://localhost:26658"
 token := ""

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()

 c, err := client.NewClient(ctx, url, token)
 if err != nil {
  return 0, err
 }
 defer c.Close()

 ns, err := share.NewBlobNamespaceV0([]byte(d.Namespace()))
 if err != nil {
  return 0, err
 }

 // Submit the data as a blob
 b, err := blob.NewBlobV0(ns, data)
 if err != nil {
  return 0, err
 }

 opts := &blob.SubmitOptions{}
 height, err := c.Blob.Submit(ctx, []*blob.Blob{b}, opts)
 if err != nil {
  return 0, err
 }

  // ส่ง height กลับไป เพื่อใช้ในการดึงข้อมูล
  // height = 10485
  return height, nil
}

จากตรงนี้เราก็จะได้ function ในการส่งข้อมูลขึ้นไปเก็บที่ Celestia network แล้ว

อ่านข้อมูลจาก DA

กำหนด Light node URL

url := "http://localhost:26658"

สร้าง Celestia Client เหมือนเดิม

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()

 c, err := client.NewClient(ctx, url, "")
 if err != nil {
  return "", err
 }
 defer c.Close()

กำหนด Namespace ที่เราจะใช้อ่านข้อมูลจาก Celestia network

// กำหนด application namespace
namespace := "todoist"
// convert เป็น byte
namespaceBytes := []byte(namespace)

// convert ให้เป้น namespace id
 ns, err := share.NewBlobNamespaceV0([]byte(d.Namespace()))
 if err != nil {
  return err
 }

เรียกข้อมูล โดยเราจะอ้างอิงจาก Height จากขั้นตอนแรก

height := 10485

 got, err := c.Blob.GetAll(ctx, height, []share.Namespace{ns})
 if err != nil {
  return "", err
 }

 if len(got) == 0 {
  return "", fmt.Errorf("no blobs found")
 }

 data := got[0].Data

นำทุกอย่างมารวมกันอีกครั้ง

func Get() (string, error) {
 url := "http://localhost:26658"
 token := ""

 // height จากการ submit data
 height := 10485

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
 defer cancel()

 c, err := client.NewClient(ctx, url, token)
 if err != nil {
  return "", err
 }
 defer c.Close()

 ns, err := share.NewBlobNamespaceV0([]byte(d.Namespace()))
 if err != nil {
  return "", err
 }

 got, err := c.Blob.GetAll(ctx, height, []share.Namespace{ns})
 if err != nil {
  return "", err
 }

 if len(got) == 0 {
  return "", fmt.Errorf("no blobs found")
 }

 return string(got[0].Data), nil
}

จากทั้งหมดนี้ เราจะได้ function ทั้งหมดละ ในการส่งข้อมูล เเละอ่านข้อมูลจาก DA ของ Celestia ขั้นตอนถัดไปเราจะสร้าง HTTP server (API) เพื่อเรียกใช้งาน function ดังกล่าว ลองเอาไปเล่นกันดูนะ เดียวรอบหน้าเราจะมาประกอบล่างกันต่อ

เจอกันครับ

by NUT | ContributionDAO

Celestia คือบล็อกเชนแบบ Modular ที่ทำหน้าที่เก็บและยืนยันความถูกต้องของข้อมูล (Data Availability) เพื่อให้บล็อกเชนอื่นหรือ Rollup สามารถโฟกัสที่การประมวลผลธุรกรรมได้โดยไม่ต้องสร้างระบบเก็บข้อมูลเอง

ถ้าอยากศึกษาข้อมูลเพิ่มเติม เราช่วยเปิดวาปให้ได้

• https://www.encodeclub.com/programmes/camp-mamo สมัครได้เลย เนื้อหาเเน่น

• https://x.com/CryptolyticLabs/status/1951231510406942730?t=2jX1MSXjpxvyPKqzgA-p2g&s=19 ข้อมูลเขิงลึก เอาแบบอ่านให้มึนกันไปข้างนึง

เอาละ มาดูกันว่าระบบ Data Availability (DA) ของ Celestia นั้น เราจะ ใช้งานจริง ได้อย่างไร — วันนี้เราจะลองมาส่ง ก้อนข้อมูล (Blob) ขึ้นไปเก็บไว้บนเครือข่าย Celestia ด้วยคำสั่ง CLI กันแบบ step-by-step

📦 Blob Data คืออะไร?

ใน Celestia คำว่า Blob ก็คือ ก้อนข้อมูล ที่เราต้องการส่งไปเก็บบน DA Layer

Blob อาจเป็นข้อมูลธุรกรรม, ข้อมูลจาก Rollup, หรือข้อมูลที่ต้องการให้ทุกคนในระบบสามารถเข้าถึงได้ โดยไม่จำเป็นต้องรู้เนื้อหาภายใน เพราะฉะนั้นมาเข้าเนื้อหาหลักกัน วันนี้เรามาเรียนรู้กันเเบบง่ายๆว่า เราจะส่ง ก้อนข้อมูล เหล่านั้นขึ้นไปเก็บยัง Celestia network ได้อย่างไร

ขั้นตอนทั้งหมด เราทำผ่าน ubuntu นะ ง่ายดี ถ้าใคร window, osx ก็ลองปรับกันดูนะ

1. ติดตั้ง Celestia binary

    # รันสคริปต์ติดตั้ง (จะ detect OS & architecture ให้)
    bash -c "$(curl -sL https://docs.celestia.org/celestia-node.sh)" -- -v v0.27.3-mocha
   

   หรือดูข้อมูลได้จากที่นี้นะ https://docs.celestia.org/how-to-guides/celestia-node?utm_source=chatgpt.com ซึ่งเราจะไปกันที่ Testnet กันก่อนนะ (Testnet ก็เหมือน Dev Env นั้นเอง) หลังติดตั้งแล้ว ให้ตรวจสอบข้อมูลว่าติดตั้งสำเร็จหรือไม่

    celestia version
    #ตัวอย่างผลลัพธ์ที่ได้
    Semantic version: 0.26.4
    Commit: 1b84e2b3f0df39a6f2197096fb2a58d9cd250687
    Build Date: 2025-10-06T12:07:26Z
    System version: arm64/darwin
    Golang version: go1.24.7
   

2. รัน light node

   Light Node คือ โหนดขนาดเล็ก ของ Celestia ที่สามารถ ตรวจสอบความถูกต้องของข้อมูล (Data Availability) ได้โดย ไม่ต้องโหลดบล็อกทั้งหมดเหมือน Full Node เพราะต้องโหลดข้อมูลขนาดใหญ่ ซึ่งจะทำให้เราสามารถ

   • ตรวจสอบว่า Blob ที่ถูกส่งขึ้นมานั้น มีอยู่จริง

   • ทดสอบการส่งข้อมูลผ่าน CLI ได้โดยไม่ต้องรัน full node

   • ใช้ในการเชื่อมต่อกับ DApp หรือ Rollup เพื่ออ่านข้อมูลได้

    #กำหนดค่าเริ่มต้นสำหรับ Testnet
    celestia light init --p2p.network mocha

มีข้อพึ่งระวังหน่อยในขั้นตอน init เราต้องเก็บข้อมูลชุดรหัสลับของกระเป๋าเราให้ดีๆนะ ซึ่งจะมีลักษณะข้อมูลเเบบนี้ พยายามเก็บอย่าให้หายเด็ดขาด เพราะถ้าหาย เราจะไม่สามารถเข้าถึงกระเป๋านี้ได้อีกต่อไป

    NAME: my_celes_key
    ADDRESS: celestia1cv5mxev9c90my8wu8cfvejyrgc36ul9t3qpuy8
    MNEMONIC (save this somewhere safe!!!):

สั่ง Start light node เพื่อทำการซิงค์ข้อมูล

    celestia light start --core.ip rpc-mocha.pops.one --core.port 9090 --p2p.network mocha

ใน Log เราจะเห็นหน้าตาประมาณนี้

    2025-10-08T14:02:25.459Z    INFO    header/store    store/store.go:614    new head    {"height": 7849464, "hash": "0097389D9D4B7D4B5E252D4ED5F4A7D56EEEEB3333A0F13211AE3E20C5ED99DA"}
    2025-10-08T14:02:25.546Z    INFO    das    das/worker.go:95    finished sampling headers    {"type": "catchup", "from": 7808648, "to": 7808747, "errors": 0, "# of headers skipped as outside of sampling window": 0, "finished (s)": 2.653042843}
    ...
    ...
    2025-10-08T14:13:07.960Z    INFO    header/store    store/store.go:614    new head    {"height": 7899622, "hash": "F5E27D74FD2FEDA93BA9AB87772EAEF951FE46C35F7D0E47E81F830CE9551F9E"}
    2025-10-08T14:13:08.432Z    INFO    das    das/worker.go:164    sampled header    {"type": "recent", "height": 7899622, "hash": "F5E27D74FD2FEDA93BA9AB87772EAEF951FE46C35F7D0E47E81F830CE9551F9E", "EDS square width": 4, "data root": "B65FAD9FD404E88ABE6886CC64929899C0FCA5449F83C942E6AC72788F54B8C3", "finished (s)": 0.472149806}

ซึ่งเราสามารถนำ height ไปเช็คได้ว่าเราทำซิงค์เสร็จสิ้นแล้วหรือยัง

• https://www.mintscan.io/celestia สำหรับ Mainnet

• https://www.mintscan.io/celestia-testnet สำหรับ Testnet

3. ส่งก้อนข้อมูลขึ้น Celestia network

   เมื่อทุกอย่างพร้อมแล้ว เราต้องมี TIA token ก่อนเพื่อเป็น gas (ค่าธรรมเนียมในการธุรกรรม) สามารถหาซื้อ TIA ได้จากกระดานเทรด หรือกรณี Testnet สามารถขอได้จาก Discord ของ Celestia ที่นี้ https://discord.gg/e3ZxQRv9

   โอเครเมื่อมีทุกอย่างพร้อมแล้วมาลุยเลย เราจะส่งก้อนข้อมูลผ่านคำสั่งอย่างง่ายตามตัวอย่างด้านล่าง

    celestia blob submit [namespace] [blobData]
   

   มาดูกันว่าแต่ละข้อมูลคืออะไรบ้าง

   • namesapce จะเป็นส่วนของการจัดกลุ่มของข้อมูล หรือการอ้างอิงข้อมูลนั้นเอง ซึ่งส่วนประกอบของ namesapce จะประกอบไปด้วย

     • version: 1 ไบต์ บอกรูปแบบของ namespace

     • id: ไบต์ยาว 28 ไบต์ ที่เป็นตัวระบุ namespace จริง

       ตัวอย่างเช่น

         00000000000000000000000000000000000042690c204d39600fddd3
       

       • ข้อมูลชุดแรก 000000000000000000000000000000000000 ซึ่งจะเป็น version อยู่ในรูปแบบของ Hex

       • ข้อมูลชุดที่สอง 42690c204d39600fddd3 จะเป็น id อยู่ในรูปแบบของ Hex

     • blobData คือกลุ่มข้อมูลที่จะส่งไปนั้นเอง

   • มาเริ่มส่งข้อมูลกัน

       celestia blob submit 0x63656c65737469617468 "Hello Celestia Thailand"
     

       {
         "result": {
           "height": 8345883,
           "commitments": [
             "0x3bb22be1da941acd080ebcaae66ecefe2369c6128410bd595baba362b9c2aff9"
           ]
         }
       }
     

เรียบร้อยข้อมูลของเราได้ถูกส่งไปยัง Celestia network แล้ว :)

4. เรียกดูข้อมูล

   หลังจากที่เราได้ทำการส่งข้อมูลไปที่ Celestia network แล้วเราก็สามารถเรียกดูข้อมูลเหล่านั้นได้ด้วยคำส่งด้านล่างนี้

    celestia blob get-all [height] [namespace]
   

   เพราะฉะนั้นจากข้อมูลก่อนหน้านี้คำสั่งที่เราจะเรียกดูข้อมูลจะเป็น

    celestia blob get-all 7912490 0x63656c65737469617468
   

   ผลลัพธ์ที่ได้จะเป็น

    {
      "result": [
        {
          "namespace": "0x63656c65737469617468",
          "data": "0xHello Celestia Thailand",
          "share_version": 0,
          "commitment": "0x3bb22be1da941acd080ebcaae66ecefe2369c6128410bd595baba362b9c2aff9",
          "index": 1
        }
      ]
    }
   

   เห็นไหมครับ ง่ายมาก 🎉 Blob ของเราถูกบันทึกไว้ใน Data Availability layer ของ Celestia แล้ว หมายความว่าข้อมูลนี้ เข้าถึงได้ตลอดเวลา และ ยืนยันความถูกต้องได้ หรือจะดูข้อมูลผ่าน explorer ก็ทำได้เช่นที่ https://mocha.celenium.io/tx/107bab7426bc49e8ca20782bd8c12b9c6639294cc3df9c9dd6f11d621cba6f31?tab=messages

วันนี้พอกันแค่นี้ก่อนนะ แค่อยากยกตัวอย่างเเบบง่ายๆทให้เห็นการใช้งาน รอบหน้าเราจะมาพัฒนา dApp ที่ทำการส่งข้อมูลไปเก็บบน Celestia กัน