• https://onthemove.contributiondao.com/sui-stack-messaging-sdk-introduction (EP 1)

• https://onthemove.contributiondao.com/sui-stack-messaging-sdk-ep-2-first-step-encrypted-chat-cli (EP 2)

สิ่งที่เราจะต้องเตรียมคือ

• Wallet สำหรับ AI

• AI API KEY ขึ้นกับถนัดนะ ใครอยากใช้ตัวไหนก็ตามสบายเลย

ซึ่งก่อนหน้านี้เราสร้าง CLI chatroom ที่ส่งข้อความ encrypted ได้แล้วใช่ไหม วันนี้จะมาเพิ่มสิ่งที่ทำให้มันเจ๋งขึ้นอีกขั้น โดยจะทำให้ AI Bot ที่คอยตอบแชทอัตโนมัติ ทุกข้อความที่ bot ส่งก็ encrypted on-chain เหมือนกัน.. หลักการมันไม่มีอะไร แค่มี AI เป็น interface แค่นั้นเอง มาเริ่มกันเลย

1. AI Wrapper

เราเลือกใช้ Groq API นะ ไปสร้าง API Key กันได้เลย ฟรี โดยเราจะเริ่มจากสร้าง ตัวกลางระหว่าง bot กับ Groq API ก่อน

import Groq from "groq-sdk";
import { config } from "../config.js";

const groq = new Groq({ apiKey: config.groqApiKey });

const SYSTEM_PROMPT = `You are a helpful AI assistant in a Web3 chatroom
built on Sui blockchain. Knowledge: Sui, Move, DeFi, Walrus, Seal.

CRITICAL: Messages on-chain cap at 512 bytes.
Thai = 3 bytes/char → keep Thai replies under ~150 chars.
English → under ~400 chars. Be concise, 1-3 sentences max.
Respond in the same language the user writes in.`;

export async function getAIResponse(
  userMessage: string,
  conversationHistory: { role: "user" | "assistant"; content: string }[] = []
): Promise<string> {
  try {
    const messages = [
      { role: "system" as const, content: SYSTEM_PROMPT },
      ...conversationHistory.slice(-10), 
      { role: "user" as const, content: userMessage },
    ];

    const response = await groq.chat.completions.create({
      model: config.groqModel,
      max_tokens: 150,
      messages,
    });

    return response.choices[0]?.message?.content || "🤖 (no response)";
  } catch (err: any) {
    console.error("Groq API error:", err.message);
    return "🤖 Sorry, I'm having trouble connecting right now.";
  }
}

มีจุดที่ต้องเข้าใจหลักๆ คือ

• SYSTEM_PROMPT บอก AI ว่ามันคือใคร ตอบเรื่องอะไรได้บ้าง และที่สำคัญคือต้องตอบสั้นๆ เพราะ channel contract จำกัด message ไว้ที่ 512 bytes ภาษาไทย 1 ตัวอักษร = 3 bytes (UTF-8) ดังนั้นถ้าตอบยาวเกินจะส่งขึ้น chain ไม่ได้เลย error ตลอด อันนี้เเหละที่นั่ง debug อยู่นาน :'(

• conversationHistory เราส่ง 10 ข้อความล่าสุดเข้าไปด้วย ทำให้ bot จำบริบทการสนทนาได้ ไม่ใช่ตอบแบบลืมหมดทุกครั้ง

• max_tokens: 150 จำกัดความยาว reply ของ AI ไว้อีกชั้นหนึ่งจะได้ไม่หลุด

ส่วนใครถนัดตัวไหนก็ลองกับตัวนั้นได้เลย ส่วนนี้ไม่มีอะไรเเค่เขียนติดต่อกับ AI

2. Bot Main Loop

ส่วนหลักของ EP คือBot ทำงานเป็น long-running process มาดู flow ทั้งหมดตั้งแต่เริ่มต้นจนตอบข้อความ

สร้างไฟล์ bot.ts

import chalk from "chalk";
import { createBotClient } from "../client.js";
import { config } from "../config.js";
import { getAIResponse } from "./ai.js";
import { getEncryptionKey } from "../encryption.js";

const conversationHistory: Record<string, { role: "user" | "assistant"; content: string }[]> = {};
const pollingStates: Record<string, {
  lastMessageCount: bigint;
  lastCursor: bigint | null;
  channelId: string;
}> = {};
const encryptionKeyCache: Record<string, Awaited<ReturnType<typeof getEncryptionKey>>> = {};

เริ่มจาก state ที่เก็บใน memory ทั้งหมด ซึ่งจะมี conversationHistory สำหรับให้ AI จำบริบทได้, pollingStates สำหรับจำว่า poll ถึงข้อความไหนแล้ว, encryptionKeyCache สำหรับ cache key ไม่ต้อง fetch ทุกรอบ

ฟังก์ชัน pollAndReply ใช้เพื่อ รับข้อความ → ถาม AI → ตอบกลับ

นี่คือหัวใจจริงๆ ของ bot ทำงาน 3 ขั้นตอนคือ ดึงข้อความใหม่ → ส่งให้ Groq ตอบ → ส่ง reply กลับเข้า channel

async function pollAndReply(channelId: string, memberCapId: string) {
  const { client, messagingClient, keypair } = createBotClient();
  const botAddress = keypair.toSuiAddress();

  if (!encryptionKeyCache[channelId]) {
    encryptionKeyCache[channelId] = await getEncryptionKey(messagingClient, channelId, botAddress);
  }
  const encryptedKey = encryptionKeyCache[channelId];

  if (!pollingStates[channelId]) {
    const channels = await messagingClient.getChannelObjectsByChannelIds({
      channelIds: [channelId],
      userAddress: botAddress,
    });
    pollingStates[channelId] = {
      lastMessageCount: BigInt(channels[0].messages_count),
      lastCursor: null,
      channelId,
    };
    console.log(chalk.gray(`  Initialized polling for ${channelId.slice(0, 12)}...`));
    return;
  }

  const pollingState = pollingStates[channelId];
  const newMsgs = await messagingClient.getLatestMessages({
    channelId,
    userAddress: botAddress,
    pollingState,
  });

  if (newMsgs.messages.length === 0) return;

  for (const msg of newMsgs.messages) {
    if (msg.sender === botAddress) continue;

    console.log(chalk.cyan(`  📨 \({msg.sender.slice(0, 8)}...: \){msg.text}`));

    if (!conversationHistory[channelId]) conversationHistory[channelId] = [];

    const rawReply = await getAIResponse(msg.text, conversationHistory[channelId]);
    const aiReply = truncateToBytes(rawReply, 480);
    try {
      const { digest } = await messagingClient.executeSendMessageTransaction({
        signer: keypair,
        channelId,
        memberCapId,
        message: aiReply,
        encryptedKey,
      });
      await client.waitForTransaction({ digest });

      console.log(chalk.green(`  🤖 Bot: ${aiReply.slice(0, 80)}...`));
      console.log(chalk.gray(`     🔗 ${config.suiscanTxUrl(digest)}`));

      conversationHistory[channelId].push(
        { role: "user", content: msg.text },
        { role: "assistant", content: aiReply },
      );

      if (conversationHistory[channelId].length > 20) {
        conversationHistory[channelId] = conversationHistory[channelId].slice(-20);
      }
    } catch (err: any) {
      console.log(chalk.red(`  ❌ Failed to reply: ${err.message}`));
      delete encryptionKeyCache[channelId];
    }
  }
  pollingState.lastMessageCount += BigInt(newMsgs.messages.length);
}

เล่า flow ตามตัวอย่างด้านบนอีกรอบนึงคือ

1. ครั้งแรก bot จะดูว่า channel มีข้อความกี่ข้อความแล้ว แล้วจำตัวเลขนี้ไว้ ข้อความก่อนหน้านี้จะถูกข้ามทั้งหมด

2. ครั้งถัดไป bot ถาม SDK ว่ามีข้อความใหม่กว่าตัวเลขที่จำไว้ไหม ถ้ามีก็ดึงมา

3. กรองข้อความ ข้ามข้อความที่ bot ส่งเอง ไม่งั่นได้ติดในลูปแน่

4. ส่งให้ AI เรียก getAIResponse() พร้อม conversation history

5. ตัดความยาว truncateToBytes() ตัดไม่ให้เกิน 480 bytes ซึ่งจะเป็นส่วนช่วยป้องกัน error นั้นเอง

6. ส่งกลับ executeSendMessageTransaction() encrypt + store on-chain

7. รอ finality waitForTransaction() รอให้ transaction เสร็จก่อน poll รอบถัดไป

8. จำบริบท เก็บ history ไว้ให้ AI ตอบครั้งหน้าได้ต่อเนื่อง

ฟังก์ชัน truncateToBytes — ตัดข้อความให้พอดี 512 bytes

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

const MAX_MESSAGE_BYTES = 480;

function truncateToBytes(text: string, maxBytes: number): string {
  const bytes = new TextEncoder().encode(text);
  if (bytes.length <= maxBytes) return text;
  let cut = maxBytes - 3;
  while (cut > 0 && (bytes[cut] & 0xc0) === 0x80) cut--;
  return new TextDecoder().decode(bytes.slice(0, cut)) + "...";
}

ส่วนนี้เรากำหนดไว้ 480 เพราะถ้า 512 พอดีมันจะมีพวก overhead ข้อมูลอื่นๆด้วยทำให้เกินตลอด

ฟังก์ชัน main เพื่อเริ่มต้นการทำงาน

async function main() {
  const { messagingClient, keypair } = createBotClient();
  const botAddress = keypair.toSuiAddress();

  console.log(chalk.blue("🤖 Sui Chat AI Bot Starting..."));
  console.log(chalk.blue("   Bot wallet:"), botAddress);

  const result = await messagingClient.getChannelMemberships({ address: botAddress });
  const memberships = new Map<string, string>(
    result.memberships.map((m) => [m.channel_id, m.member_cap_id]),
  );

  if (memberships.size === 0) {
    console.log(chalk.yellow("  Bot is not a member of any channels."));
    console.log(chalk.white(`  Invite first: npm run dev -- invite <channelId> ${botAddress}`));
    process.exit(0);
  }

  console.log(chalk.green(`  Monitoring ${memberships.size} channel(s)`));

  let polling = false;
  const poll = async () => {
    if (polling) return;
    polling = true;
    try {
      for (const [channelId, memberCapId] of memberships) {
        await pollAndReply(channelId, memberCapId);
      }
    } finally {
      polling = false;
    }
  };

  await poll();
  setInterval(poll, config.botPollIntervalMs);
  console.log(chalk.green("  ✅ Bot is running. Press Ctrl+C to stop.\n"));
}

main().catch((err) => {
  console.error(chalk.red("Bot crashed:"), err);
  process.exit(1);
});

ตรง polling flag สำคัญ — ถ้ารอบก่อนยังทำไม่เสร็จ (เช่น Groq ตอบช้า หรือ Sui ยัง finalize ไม่เสร็จ) รอบถัดไปจะถูกข้ามไปเลย ป้องกัน object-lock error

3. Demo

วิธีการทดสอบนั้นไม่ยากถ้าใครลองเล่น EP.2 ก็ให้เราสร้างห้องขึ้นมาก่อนแล้วทำการ invite bot เข้าห้องที่เราสร้างนั้นเอง

# Create room
npm run dev -- create-room

# Invite bot to join 
npm run dev -- invite <channelId> 0xBOT_ADDRESS

# Room own join the chat room
npm run dev -- chat <channelId>

หลังจากนั้นเปิดอีก terminal นึงขึ้นมาเพื่อรันบอท

npm run bot

เรียบร้อยจ้าเสร็จละ ซึ่งแต่ละข้อความอาจจะต้องรอประมาณ 5-10 วินาที bot จะตอบกลับมาอัตโนมัติ ทุกข้อความ encrypted on-chain ทั้งหมด ลองไปดู transaction บน https://suiscan.xyz/ ได้เลยนะ

ใครขี้เกียจก็ไปตามได้ที่นี้เลย เอา source code ทั้งหมดไว้ละ https://github.com/Contribution-DAO/ON-THE-MOVE-Workshop/tree/main/sui-messaging-sdk

แล้วเจอกันในบทความหน้านะ แอบกระซิบว่าเร็วๆนี้ในไทยจะมีงานที่โพกัสเกี่ยวกับ SUI Developer ด้วยน๊าา ชาร์ตเเบตรอได้เลยจ้า

• https://onthemove.contributiondao.com/sui-stack-messaging-sdk-introduction

ถึงเวลาละ เราจะลงมือสร้าง CLI Chatroom ซึ่งจะให้ AI ค่อยโต้ตอบกับเราเเทนตามวิถีคนเป็น introvert (ทำเป็น CLI เพราะตัวฉันไม่ถนัดงาน frontend เลยจ้า) ที่ข้อความทุกอย่างถูก encrypted ด้วย Seal แล้วเก็บบน Sui blockchain โดยจะทำเป็น CLI app ง่ายๆ ที่มีคำสั่งแบบนี้

• create-room — สร้างห้องแชท encrypted

• list-rooms — ดูห้องที่เราอยู่

• chat — เข้าห้องแชท อ่าน + ส่งข้อความ real-time

• invite — เชิญคนเข้าห้อง

• members — ดูสมาชิก

1. Create project

ตาม step ครับเริ่มจากสร้าง project กันก่อน

mkdir sui-chat-cli && cd sui-chat-cli
npm init -y
npm i @mysten/messaging @mysten/seal @mysten/sui \
     chalk commander dotenv groq-sdk
npm i -D typescript tsx @types/node

อย่าลืมเพิ่ม "type": "module" ใน package.json ด้วยนะ แล้วก็เพิ่ม scripts ไว้ใช้สะดวกๆ

{
  "type": "module",
  "scripts": {
    "dev": "tsx src/index.ts",
    "bot": "tsx src/bot/bot.ts"
  }
}

จากนั้นสร้าง .env โดย private key สามารถไป export จาก Slush wallet ได้นะ และเราแนะนำให้แยกกระเป๋าที่ใช้ทดสอบกับกระเป๋าส่วนตัว จะได้ไม่พลาด ซึ่งครั้งใช้บน Testnet เท่านั้น เพราะยังไม่มี Mainnet ให้ใช้งาน

SUI_PRIVATE_KEY=suiprivkeyxxxxx
BOT_PRIVATE_KEY=suiprivkeyxxxxx

GROQ_API_KEY=gsk_xxxxx
GROQ_MODEL=llama-3.3-70b-versatile

NETWORK=testnet
BOT_POLL_INTERVAL_MS=5000

2. Config

import "dotenv/config";
import {
  TESTNET_MESSAGING_PACKAGE_CONFIG,
  MAINNET_MESSAGING_PACKAGE_CONFIG,
} from "@mysten/messaging";

const network = (process.env.NETWORK ?? "testnet") as "testnet" | "mainnet";

export const config = {
  suiPrivateKey: process.env.SUI_PRIVATE_KEY!,
  botPrivateKey: process.env.BOT_PRIVATE_KEY || process.env.SUI_PRIVATE_KEY!,
  network,
  groqApiKey: process.env.GROQ_API_KEY!,
  groqModel: process.env.GROQ_MODEL || "llama-3.3-70b-versatile",
  botPollIntervalMs: parseInt(process.env.BOT_POLL_INTERVAL_MS || "5000"),

  messagingPackageId:
    network === "mainnet"
      ? MAINNET_MESSAGING_PACKAGE_CONFIG.packageId
      : TESTNET_MESSAGING_PACKAGE_CONFIG.packageId,

  get fullnodeUrl(): string {
    return this.network === "mainnet"
      ? "https://fullnode.mainnet.sui.io:443"
      : "https://fullnode.testnet.sui.io:443";
  },

  suiscanTxUrl(digest: string): string {
    return `https://suiscan.xyz/\({this.network}/tx/\){digest}`;
  },

  sealServers: [
    {
      objectId: "0x73d05d62c18d9374e3ea529e8e0ed6161da1a141a94d3f76ae3fe4e99356db75",
      weight: 1,
    },
    {
      objectId: "0xf5d14a81a982144ae441cd7d64b09027f116a468bd36e7eca494f750591623c8",
      weight: 1,
    },
  ],

  walrus: {
    aggregator: "https://aggregator.walrus-testnet.walrus.space",
    publisher: "https://publisher.walrus-testnet.walrus.space",
    epochs: 1,
  },
};

ตรง messagingPackageId นี่สำคัญ เพราะถ้า SDK upgrade version ค่านี้อาจเปลี่ยน การดึงจาก SDK โดยตรงทำให้ไม่ต้องมานั่ง update เอง ปัจจุบันมันมีแค่ Testnet นะ ซึ่งมันก็คือ packageId สำหรับส่วนของ messaging นั้นเเหละ ส่วนอื่นๆก็น่าจะเคยเห็นกันมาบ้างแล้วจากบทความก่อนๆ

3. Messaging Client (สำคัญ)

export function createMessagingClient(keypair: Ed25519Keypair) {
  const client = new SuiClient({
    url: config.fullnodeUrl,
    network: config.network,
    mvr: {
      overrides: {
        packages: {
          "@local-pkg/sui-stack-messaging": config.messagingPackageId,
        },
      },
    },
  })
    .$extend(SealClient.asClientExtension({
      serverConfigs: config.sealServers,
    }))
    .$extend(messaging({
      walrusStorageConfig: { /* Walrus endpoints */ },
      sessionKeyConfig: {
        address: keypair.toSuiAddress(),
        ttlMin: 30,
        signer: keypair,
      },
    }));

  return { client, messagingClient: client.messaging, keypair };
}
export function createUserClient() {
  const keypair = createKeypair(config.suiPrivateKey);
  return createMessagingClient(keypair);
}

มีจุดสำคัญที่เราอาจจะพึ่งเคยเห็นกันก็คือ เราจะใส่ mvr.overrides.packages ไม่งั้นจะเจอ error MVR Api URL is not set ตรงนี้เสียเวลาไป debug อยู่พอสมควร กับอีกส่วนนึงคือ walrus config ที่ต้องใส่ด้วยเพราะตัว SDK มันบังคับถึงจะยังไม่ได้ใช้ก็ตาม

MVR คือ Move Registry นะ ไว้ค่อยลงลึกกันอีกทีนึงแต่ฝั่ง npm อาจจะคุ้นๆกันอยู่ละ

4. Encryption Key

ก่อนจะส่งหรืออ่านข้อความได้ เราต้องมี encryption key ของ channel นั้น ซึ่ง SDK มี method ให้ดึงออกมาจาก channel object บน chain

export async function getEncryptionKey(
  messagingClient: any,
  channelId: string,
  userAddress: string,
) {
  const channels = await messagingClient.getChannelObjectsByChannelIds({
    channelIds: [channelId],
    userAddress,
  });

  const ch = channels[0];
  return {
    $kind: "Encrypted" as const,
    encryptedBytes: new Uint8Array(ch.encryption_key_history.latest),
    version: ch.encryption_key_history.latest_version,
  };
}

สิ่งที่ควรรู้คือ encryption key จะ rotate ทุกครั้งที่เชิญสมาชิกใหม่เข้า channel ดังนั้นถ้าเราเชิญใครเข้ามาใหม่ key เก่าจะใช้ไม่ได้ ต้อง fetch ใหม่ ส่วนนี้เราสร้างแยกออกมาจะได้เรียกใช้งานได้สะดวก

5. Create Room — สร้างห้องแชท

คำสั่งแรกที่เราต้องทำ คือสร้าง encrypted channel

export async function createRoom(memberAddresses: string[]) {
  const { messagingClient, keypair } = createUserClient();

  const { channelId, creatorCapId } =
    await messagingClient.executeCreateChannelTransaction({
      signer: keypair,
      initialMembers: memberAddresses,
    });

  const memberCap = await messagingClient.getUserMemberCap(
    keypair.toSuiAddress(), channelId
  );

  console.log("✅ Channel ID:", channelId);
}

executeCreateChannelTransaction ทำ 2 อย่างในครั้งเดียว — สร้าง channel + attach encryption key หลังสร้างเสร็จเราจะได้ channelId ที่ต้องเก็บไว้แชร์กับคนอื่น

ส่วน getUserMemberCap คือไปดึง MemberCap ของเรา ซึ่งเป็น object บน chain ที่ prove ว่าเราเป็นสมาชิกห้องนี้ ต้องมี MemberCap ถึงจะส่งข้อความได้

6. List Rooms & Members

ดู channels ที่เราเข้าร่วมอยู่ ก็แค่เรียก getChannelMemberships

const result = await messagingClient.getChannelMemberships({
  address: myAddress,
});

ส่วนดูสมาชิกของ channel ก็ใช้ getChannelMembers

const result = await messagingClient.getChannelMembers(channelId);

อันนี้จะทำหรือไม่ทำก็ได้ เพราะง่ายมาก SDK จัดการทุกอย่างให้แล้ว

7. Invite (เอาไว้ดึงคนเข้าห้อง)

const { digest, addedMembers } =
  await messagingClient.executeAddMembersTransaction({
    signer: keypair,
    channelId,
    memberCapId: memberCap.id.id,
    newMemberAddresses,
  });

⚠️ มีแค่ creator (คนที่สร้างห้อง) เท่านั้นที่เชิญคนเข้าได้นะ ถ้าคนอื่นลอง invite จะ error และอย่าลืมว่าเมื่อเชิญสมาชิกใหม่ encryption key จะ rotate — ต้อง fetch key ใหม่ก่อนส่งข้อความ

8. Interactive Chat

มาถึงส่วนสำคัญละ ส่วนนี้จะเป็น interface เอาไว้เราเข้าห้อง chat ผ่าน CLI ซึ่งจะทำให้เราสามารถ ส่ง และอ่านข้อความได้ โดยจะแบ่งเป็น 3 ส่วนหลักๆคือ

ส่วนที่ 1 — ดึง MemberCap, encryption key, และแสดงข้อความเก่า 10 ข้อความย้อนหลัง

const { messagingClient, keypair } = createUserClient();
const myAddress = keypair.toSuiAddress();
const memberCap = await messagingClient.getUserMemberCap(myAddress, channelId);
const encryptedKey = await getEncryptionKey(messagingClient, channelId, myAddress);

const { messages } = await messagingClient.getChannelMessages({
  channelId,
  userAddress: myAddress,
  limit: 10,
  direction: "backward",
});

ส่วนที่ 2: Polling — เช็คข้อความใหม่ทุก 3 วินาที

SDK ไม่มี WebSocket ดังนั้นเราต้อง poll เอง หลักการคือเราจะจำ lastMessageCount ไว้ แล้วถาม SDK ว่ามีข้อความใหม่กว่านี้ไหม ตอนนี้เลยทำเป็น interval ง่ายๆ

const [channel] = await client.getChannelObjectsByChannelIds({
  channelIds: [channelId], userAddress: myAddress,
});
const pollingState = {
  lastMessageCount: BigInt(channel.messages_count),
  lastCursor: null as bigint | null,
  channelId,
};

setInterval(async () => {
  const { messages } = await client.getLatestMessages({
    channelId, userAddress: myAddress, pollingState,
  });
  for (const msg of messages) {
    if (msg.sender !== myAddress) printMessage(msg);
  }
  pollingState.lastMessageCount += BigInt(messages.length);
}, 3000);

ส่วนที่ 3: Input Loop — ใช้ในการส่งข้อความ

const rl = createInterface({ input: process.stdin, output: process.stdout });

rl.on("line", async (line) => {
  if (text === "/quit") { process.exit(0); }

const { digest } = await messagingClient.executeSendMessageTransaction({
    signer: keypair,
    channelId,
    memberCapId: memberCap.id.id,
    message: text,
    encryptedKey,
  });
});

โดยส่วนนี้เราจะอ่านข้อความจาก cli ซึ่งทุกข้อความที่ส่ง จะถูก encrypt ด้วย Seal → store เป็น object บน Sui → ได้ transaction digest กลับมา ลองไปดูที่ https://suiscan.xyz/ ได้เลย (อย่าลืมเปลี่ยนเป็น Testnet)

9. CLI Entry Point

สุดท้ายละทำการรวมทุก command ด้วย Commander

program.command("create-room")
  .argument("[members...]", "Sui addresses to invite")
  .action(async (members) => { await createRoom(members || []); });

program.command("list-rooms").action(listRooms);

program.command("chat")
  .argument("<channelId>", "Channel ID")
  .action(interactiveChat);

program.command("invite")
  .argument("<channelId>", "Channel ID")
  .argument("<addresses...>", "Sui addresses to invite")
  .action(inviteMember);

program.command("members")
  .argument("<channelId>", "Channel ID")
  .action(listMembers);

9. Testing

เมื่อประกอบร่างทุกอย่างแล้ว ลองรันทดสอบกันดูนะ

# Help command
npm run dev -- --help

# Create room
npm run dev -- create-room

# Create room and invite
npm run dev -- create-room 0xALICE_ADDRESS

# List all rooms
npm run dev -- list-rooms

# Join chat room 
npm run dev -- chat <channelId>

# List all members
npm run dev -- members <channelId>

# Invite bot to chat room
npm run dev -- invite <channelId> <BOT_ADDRESS>

เรียบร้อยเราได้ตัว client แล้วเเต่.... ยังไม่จบนะ มาได้เกินครึ่งทางละ ไว้ต่อ EP หน้า ซึ่งเป็น EP สุดท้ายละ ตัว EP หน้าเราจะมาต่อกับ AI โดยให้ AI ตอบโต้กับคนในห้อง ซึ่งเราเลือกใช้ Groq AI มันมี Free API key อยู่ด้วย หรือใครจะใช้ตัวอื่นๆก็เตรียมๆไว้ได้เลย เพราะส่วนนี้เเค่เป็นการเขียน API เชื่อมต่อกับ AI เท่านั้น

เจอกันจ้า

ตอนนี้ SDK ยังอยู่ในสถานะ Alpha และรองรับเฉพาะ Testnet เท่านั้นนะ ยังไม่พร้อมใช้ production นะ

Sui Stack Messaging SDK คืออะไร?

พูดง่ายๆ มันคือชุดเครื่องมือที่ให้ developer สามารถฝัง encrypted messaging เข้าไปใน Web 3.0 application ได้เลย โดยไม่ต้องสร้าง backend เอง ข้อความทุกอย่างจะถูกเข้ารหัสแบบ end-to-end ผูกกับ wallet address และ recoverable ข้ามอุปกรณ์ได้

. .

ที่น่าสนใจคือ SDK ถูกออกแบบให้ทำงานร่วมกับ 3 layers ของ Sui Stack ดังนี้

1) Sui Blockchain — Identity & State

ทุกช่องทาง, ข้อความ, และการเป็นสมาชิกถูกจัดเก็บเป็นวัตถุบน Sui blockchain โดยใช้สัญญาอัจฉริยะ Move ในการจัดการ สิ่งที่น่าสนใจคือ SDK ใช้การควบคุมการเข้าถึงแบบอิงตามความสามารถ

• CreatorCap — ผู้สร้างช่องทางจะได้รับวัตถุนี้ ใช้สำหรับเพิ่ม/ลบสมาชิก มีเพียงหนึ่งคนต่อช่องทาง

• MemberCap — สมาชิกทุกคนจะได้รับวัตถุนี้ ใช้เป็นหลักฐานการเป็นสมาชิกสำหรับการส่งข้อความ

ถ้าใครเขียน Move มาบ้างจะคุ้นเคยกับ pattern นี้ดี เพราะมัน object-centric เหมือนทุกอย่างบน Sui เลย

2) Walrus — Decentralized Attachment Storage

ไฟล์แนบทั้งหมด (รูป, เอกสาร ฯลฯ) จะถูก encrypt ด้วย Seal ก่อน แล้ว upload ไปเก็บบน Walrus ครับ ส่วน metadata กับ reference จะถูกบันทึกบน Sui เพื่อให้ verifiable ได้ การเข้าถึงไฟล์ใช้ผ่าน aggregator/publisher endpoints ของ Walrus

3) Seal — Encryption & Access Control

Seal ทำหน้าที่เป็น key management layer เลย เมื่อสร้าง channel จะมีการ generate symmetric key ขึ้นมา แล้ว encrypt ด้วย Seal ก่อนผูกกับ channel object บน Sui

ที่ทำให้มันต่างจาก encryption ทั่วไปคือ programmable access policies สามารถกำหนดเงื่อนไขการเข้าถึงผ่าน smart contract ได้เลย เช่น ต้องถือ token จำนวนหนึ่ง หรือเป็นสมาชิก DAO ถึงจะอ่านข้อความได้ ตามที่เราเคยเขียนไปเเล้วนั้นเองในบทความก่อนหน้านี้

การทำงานของ Encryption

มาดูทบทวนกันว่า Seal ทำงานยังไงกับ SDK ตัวนี้ ขั้นตอนคร่าวๆ คือ

1. สร้าง Channel → SDK สร้าง channel object บน Sui พร้อม MemberCaps ให้สมาชิก

2. Generate Encryption Key → Seal generate symmetric key แล้ว encrypt ไว้

3. Attach Key กับ Channel → key ถูกผูกกับ channel object บน chain

4. ส่งข้อความ → ข้อความถูก encrypt ด้วย key แล้ว store เป็น object บน Sui

5. อ่านข้อความ → SDK fetch message objects แล้ว decrypt ด้วย Session Key

Session Key คืออะไร? ก็คือ key ที่มีอายุจำกัด (TTL) เพื่อไม่ต้อง sign transaction ทุกครั้งที่ decrypt ข้อความ sign ครั้งเดียวสร้าง session แล้วใช้ต่อเนื่องได้เลย เมื่อหมดอายุ SDK จะ refresh ให้อัตโนมัติ

เปรียบเทียบกับ XMTP และ Push Protocol (คู่แข่ง)

จุดแข็งที่สุดของ Sui Messaging SDK คือ on-chain composability นะ messages เป็น Sui objects ที่ smart contracts สามารถ interact ได้โดยตรง ซึ่ง XMTP หรือ Push ทำไม่ได้ในระดับเดียวกัน แต่ข้อแลกเปลี่ยนคือต้องผูกกับ Sui ecosystem

สรุปข้อจำกัดที่ควรรู้

• ไม่มี Anonymous Messaging — ทุกข้อความต้องมา verified Sui identity ไม่สามารถส่งแบบ anonymous ได้

• ไม่มี Forward Secrecy — ถ้า key ถูก compromise ข้อความในอดีตก็อาจถูก decrypt ได้

• Polling-based — ยังไม่มี WebSocket ต้องใช้ getLatestMessages() แบบ polling

• Testnet Only — ยังไม่พร้อม Mainnet อาจมี breaking changes ไว้ว่ากันทีเมื่อถึงตอนนั้น

เป็นไงบ้างเห็นภาพรวมกันแล้วใช่ไหม สรุปง่ายๆ Sui Stack Messaging SDK มันทำให้ messaging กลายเป็น programmable primitive ของ Web 3.0 application บน Sui ได้ ไม่ใช่แค่ chat library ธรรมดา แต่เป็น infrastructure ที่ smart contracts สามารถ trigger ได้เลย

เดียว EP หน้าจะมาลงมือเขียนโค้ดกันจริงๆ ตั้งแต่ setup project, สร้าง channel, ส่งข้อความ, อ่านข้อความ แบบ step-by-step เลยนะ รอบนี้ไม่ให้รอนานละ ดองไว้นานเกินต้องขอโทษด้วยนะครับ

• https://onthemove.contributiondao.com/deepbook-ep1

• https://onthemove.contributiondao.com/deepbook-ep2

ก่อนหน้านี้เราได้เรียนรู้วิธีการ Create balance manager, Deposit, Check balance และ Withdraw ไปแล้วใช่ไหม มาวันนี้ได้เวลาละกับการวาง Order ซึ่งง่ายมากเมื่อทำผ่าน SDK พร้อมละเริ่มกันเลย

1. Create limit order

   เริ่มจากเตรียมข้อมูลต่างๆก่อน ซึ่งก็เหมือนครั้งที่แล้วเลย

    import "dotenv/config";
    import { deepbook, type BalanceManager } from "@mysten/deepbook-v3";
    import { SuiGrpcClient } from "@mysten/sui/grpc";
    import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
    import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
    import { Transaction } from "@mysten/sui/transactions";
   
    const env = (process.env.NETWORK ?? "testnet") as "testnet" | "mainnet";
    const { scheme, secretKey } = decodeSuiPrivateKey(process.env.SUI_PRIVATE_KEY!);
    if (scheme !== "ED25519") throw new Error(`Unsupported scheme: ${scheme}`);
    const keypair = Ed25519Keypair.fromSecretKey(secretKey);
    const address = keypair.toSuiAddress();
   
    const BALANCE_MANAGER_KEY = "BM1";
    const BALANCE_MANAGER_ID = "0x09921a24e9fe239b194a109ed8b8812f86fefc3389f851c4d06f7e55bef79a9f";
    const balanceManagers: { [k: string]: BalanceManager } = {
      [BALANCE_MANAGER_KEY]: { address: BALANCE_MANAGER_ID },
    };
    const client = new SuiGrpcClient({
      network: env,
      baseUrl: env === "mainnet" ? "https://fullnode.mainnet.sui.io:443" : "https://fullnode.testnet.sui.io:443",
    }).$extend(
      deepbook({
        address,
        balanceManagers,
      }),
    );
    const POOL_KEY = "SUI_DBUSDC";
   

   ทำการตรวจสอบ Bid และ Ask order ว่ามีการวางคำสั่งซื้อขายที่ราคาเท่าไหร่

    //Query Bid, Ask order
    const bids = await client.deepbook.getLevel2Range(POOL_KEY, 0.9, 0.91, true);
    const asks = await client.deepbook.getLevel2Range(POOL_KEY, 0.91, 0.95, false);
   
    console.log("=== BIDS Order ===");
    console.dir(bids, { depth: null });
   
    console.log("=== ASKS Order ===");
    console.dir(asks, { depth: null });
   

   ซึ่งเราจะเรียกผ่าน getLevel2Range นั้นเอง ซึ่งสิ่งที่เราต้องใช้เพื่อเรียกดูข้อมูลคือ Pool ที่เราต้องการเรียกดูข้อมูล เเละช่วงของราคาซึ่งจะเป็น ช่วงที่ต่ำสุดเเละสูงที่สุด รวมถึง Boolean ซึ่งจะบ่งบอกว่าจะดึงข้อมูลฝั่งไหนระหว่าง Bid หรือ Ask เมื่อเราทราบช่วงราคาเเล้ว หรือจะไม่ต้องสนใจก็ได้เผื่อใครอยากวางช้อนซื้อลึกๆ หรือขายสูง ก็ปล่อยผ่านไปเลย

   ขั้นตอนต่อเราก็ต้องสร้างคำสั่งขาย SUI ของเรา ด้วยวิธีการตามด้านล่างนี้

    //Check SUI Balance
    const suiInManager = await client.deepbook.checkManagerBalance(BALANCE_MANAGER_KEY, "SUI");
    console.log("SUI in manager =", suiInManager);
   
    const tx = new Transaction();
   
    const expireTimestamp = Date.now() + 60 * 60 * 1000; //1 HR
    //Verify check if an order can be placed
    const checkCanPlaceOrder = await client.deepbook.canPlaceLimitOrder({
      poolKey: "SUI_DBUSDC",
      balanceManagerKey: "BM1",
      price: 1,
      quantity: 1.0,
      isBid: false, // false = sell
      payWithDeep: false, //Pay 
      expireTimestamp,
    });
    console.log("canPlaceLimitOrder = ", checkCanPlaceOrder);
   
    tx.add(
      client.deepbook.deepBook.placeLimitOrder({
        poolKey: "SUI_DBUSDC",
        balanceManagerKey: "BM1",
        clientOrderId: `${Date.now()}`,
        price: 1,
        quantity: 5.0,
        isBid: false,
        payWithDeep: false,
      }),
    );
   
    const res = await client.core.signAndExecuteTransaction({
      transaction: tx,
      signer: keypair,
      include: { effects: true, objectTypes: true },
    });
   
    //Get account information
    let acct = await client.deepbook.account(POOL_KEY, BALANCE_MANAGER_KEY);
    console.log("=== ACCOUNT (available/locked) ===");
    console.dir(acct);
   

   จากตัวอย่างนี้เราจะเริ่มจากตรวจก่อนว่าเราสามารถวาง Order ได้ไหม เช่นถ้าเรามี SUI ไม่พอใน Balance Manager ก็จะไม่สามารถวาง Order ได้นั้นเอง เเละขั้นตอนสุดท้ายเราจะเรียกดูของมูลของเราขึ้นมา ซึ่งนึงที่จะได้คือ Order ID นั้นเอง โดย Order ID ห้ามซ้ำนะ เราเลยใช้ timestamp เลย ส่วน payWithDeep คือใช้ DEEP Token จ่ายเป็นค่าธรรมเนียมซึ่งเราไม่มีเลยใช้ SUI จ่ายแทน

   ง่ายไหม เราวาง Order ได้เรียบร้อยแล้วก็รอให้ Order ของเราถูก Match ก็เรียบร้อย

2. Cancel order

   การยกเลิก Order นั้นสามารถทำผ่าน SDK ได้เลยครับ มีตั้งแต่คำสั่งยกเลิกทีละ Order หรือยกเลิกทั้งหมดก็ได้ วิธีการก็มีดังนี้

    const cancelTx = new Transaction();
    cancelTx.add(client.deepbook.deepBook.cancelAllOrders(POOL_KEY, BALANCE_MANAGER_KEY));
   
    const resCancelOrder = await client.core.signAndExecuteTransaction({
      transaction: cancelTx,
      signer: keypair,
      include: { effects: true, objectTypes: true },
    });
   

   ถ้าหากเราต้องการยกเลิกทีละ Order ก็เปลี่ยนไปใช้งานฟังก์ชั่น cancelOrder หรือ cancelOrders นะ โดยเราสามารถนำ Order ID จากขั้นตอนที่แล้วมาใช้ได้เลย หลังจากนั้นลองเรียก deepbook.account ดูนะว่า Order ของเราได้ถูกยกเลิกไปหรือไม่

3. Market order

   มีวาง Limit ไปแล้วก็ขาดเรื่องการวางเเบบ Market order ไม่ได้ ซึ่งเราได้อธิบายไปตั้งแต่ EP แรกเเล้วว่าขั้นตอนการทำงานของ Market order เป็นยังไง ลองดูนะ วิธิการก็ง่ายอีกเช่นกัน

    tx.add(
      client.deepbook.deepBook.placeMarketOrder({
        poolKey: POOL_KEY,
        balanceManagerKey: BALANCE_MANAGER_KEY,
        clientOrderId: `${Date.now()}`,
        quantity:1,
        isBid: false,
        payWithDeep: false,
      }),
    );
   

   ในกรณีตัวอย่างข้างต้นคือขาย SUI แบบ Market order เป็นจำนวน 1 SUI

4. Swap token

   ส่วนนี้จะต่างจากการวาง Order นะ ซึ่งจำได้ไหมจาก EP ที่เเล้วเราต้องเริ่มจาก Deposit เงินที่ต้องการเทรดลงไปใน Balance manager จึงจะสามารถทำการสร้าง Order ได้ แต่กรณีของ Swap นั้นจะเเตกต่างกัน เพราะมีให้เลือกว่าจะใช้หรือไม่ใช้ ถ้าไม่ใช้ก็จะเป็นการ Swap โดยดูจาก token ที่อยู่ใน Wallet เราได้เลย ถ้าใครเคยใช้งานพวก Uniswap ก็น่าจะคุ้นเคยดี โดย DeepBook ได้คำสั่งสำหรับการ Swap ทั้งหมดดังนี้

   • swapExactBaseForQuote ระบุจำนวน Base token ที่ต้องการขาย แล้วระบบจะคำนวณให้ว่าได้ Quote เท่าไหร่

   • swapExactQuoteForBase ระบุจำนวน Quote token ที่ต้องการใช้ซื้อ แล้วระบบจะคำนวณว่าได้ Base เท่าไหร่

   • swapExactQuantity ใช้สำหรับ swap จำนวนที่กำหนด (exact quantity) ได้ทั้งสองทิศทาง

   • swapExactBaseForQuoteWithManager, swapExactQuoteForBaseWithManager, swapExactQuantityWithManager เหมือน ข้างบนแต่ใช้จาก Balance Manager

ซึ่งแน่นอนเราจะไม่ใช้จาก Balance Manager มาดูวิธีกันเลย

    const swapTx = new Transaction();

    const [baseOut, quoteOut, deepOut] = client.deepbook.deepBook.swapExactBaseForQuote({
        poolKey: "SUI_DBUSDC",
        amount: 1,       
        deepAmount: 1,  
        minOut: 0.5   
    })(swapTx);
    swapTx.transferObjects([baseOut, quoteOut, deepOut], keypair.toSuiAddress());

    const swapRes = await client.core.signAndExecuteTransaction({
        transaction: swapTx,
        signer: keypair,
        include: { effects: true, events: true, objectTypes: true },
    });
    console.log("=== SWAP RESULT ===");
    console.dir(swapRes, { depth: null });

จากตัวอย่างก็คือเราจะ SWAP 1 SUI ไปเป็น DBUSDC นั้นเอง แต่จะมีปัญหา เพราะว่า…เราไม่มี DEEP Token ใช้ไหม วิธีการก็ไม่ยากลองเอาทั้งหมดที่เรียนรู้มาลองดูนะ ไบ้ให้ว่าก็ทำลองทำพวก Market order แล้วถอนออกมายังกระเป๋าของเราเอง เราก็จะได้ DEEP Token สำหรับจ่ายค่าธรรมเนียมแล้ว

เป็นไงหวังว่าจะเห็นภาพรวมทั้งหมดนะ สมัยนี้อะไรๆก็ Build ง่ายยย เพราะเครื่องมือไม้เครื่องมือพร้อมไปหมดละ เเละถ้าใครคันมือลองไปลองไปประลองฝีมือได้ที่นี้ https://x.com/SuiNetwork/status/2021269860211400801 นะกับโครงการ DeFi Moonshoot ซึ่งมี incentive ให้สูงถึง $500k ด้วยกัน

เอาละไว้เจอกันในบทความหน้า เอาเรื่องอะไรดี เเล้วก็อย่าลืมมาเรียนกันนะกับ กับโครงการ ON THE MOVE: Getting Started with Move on Sui

สมัครเลยที่นี้จ้า https://luma.com/j743avm7

มากินหมูสะเต๊ะกัน

เจอกันนะ

• https://onthemove.contributiondao.com/deepbook-ep1

พร้อมแล้วก็มาเริ่มกันเลย

1. Create project and setup configuration

    mkdir deepbook-basic && cd deepbook-basic
    npm init -y
    npm i @mysten/sui @mysten/deepbook-v3 dotenv
    npm i -D typescript tsx @types/node
   

   สร้าง .env โดย private key สามารถไป export จาก Slush wallet ได้นะครับ และเราแนะนำให้เเยกกระเป๋าที่ใช้ทดสอบกับกระเป๋าส่วนตัวนะ จะได้ไม่พลาด

    SUI_PRIVATE_KEY=suiprivkeyxxxxx
    NETWORK=testnet
   

   เราจะทดสอบกันที่ Testnet อย่าลืมไปขอ Faucet SUI testnet token ด้วยนะ เพราะนอกจากจะต้องใช้เพื่อจ่ายค่าทำธุรกรรมแล้ว เราจะต้องใช้เพื่อฝากเข้าไปยัง BalanceManager ด้วย

2. Create Balance Manager

    import "dotenv/config";
    import { deepbook, type DeepBookClient } from "@mysten/deepbook-v3";
    import { SuiGrpcClient } from "@mysten/sui/grpc";
    import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
    import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
    import { Transaction } from "@mysten/sui/transactions";
   
    const env = (process.env.NETWORK ?? "testnet") as "testnet" | "mainnet";
    const { scheme, secretKey } = decodeSuiPrivateKey(process.env.SUI_PRIVATE_KEY!);
    if (scheme !== "ED25519") throw new Error(`Unsupported scheme: ${scheme}`);
    const keypair = Ed25519Keypair.fromSecretKey(secretKey);
    const client = new SuiGrpcClient({
      network: env,
      baseUrl: env === "mainnet" ? "https://fullnode.mainnet.sui.io:443" : "https://fullnode.testnet.sui.io:443",
    }).$extend(
      deepbook({
        address: keypair.toSuiAddress(),
      }),
    );
   
    const tx = new Transaction();
    tx.add(client.deepbook.balanceManager.createAndShareBalanceManager());
   
    const result = await client.core.signAndExecuteTransaction({
      transaction: tx,
      signer: keypair,
      include: { effects: true, objectTypes: true },
    });
   
    console.dir(result, { depth: null });
   

   ขั้นตอนนี้เราจะได้ BalanceManager objectId สำคัญให้เก็บเอาไว้นะครับ โดยการสร้าง Balance Manager จะมีทั้งหมด 3 ประเภทด้วยกันคือ

   • createAndShareBalanceManager สร้าง + เเชร์ ในขั้นตอนเดียว เอาไว้ใช้งานทั่วไป

   • createBalanceManagerWithOwner สร้างแบบ Private เอาไว้ควบคุมหรือเตรียม object ก่อนจะเเชร์ภายหลัง

   • shareBalanceManager เอาไว้เเชร์จากขั้นตอน createBalanceManagerWithOwner นั้นเอง

และตัวอย่างของเราจะได้เป็นเเบบนี้

    '0x09921a24e9fe239b194a109ed8b8812f86fefc3389f851c4d06f7e55bef79a9f': '0xfb28c4cbc6865bd1c897d26aecbe1f8792d1509a20ffec692c800660cbec6982::balance_manager::BalanceManager'

3. Deposit SUI into Balance Manager

   หลังจากที่เราสร้าง Balance Manager เรียบร้อยแล้ว เราก็จะต้องทำการฝาก SUI testnet token เข้าไปยัง Balance MAnager ของเรา จริงๆมีหลายเหรียญให้ใช้ทดสอบ เช่น DEEP, WAL เพียงแต่มันจะวุ่นวายหน่อย เพราะหา testnet token ลำบากเลยใช้ SUI testnet token ไปเลย ง่ายดี

    import "dotenv/config";
    import { deepbook, type BalanceManager } from "@mysten/deepbook-v3";
    import { SuiGrpcClient } from "@mysten/sui/grpc";
    import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
    import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
    import { Transaction } from "@mysten/sui/transactions";
   
    const env = (process.env.NETWORK ?? "testnet") as "testnet" | "mainnet";
    const { scheme, secretKey } = decodeSuiPrivateKey(process.env.SUI_PRIVATE_KEY!);
    if (scheme !== "ED25519") throw new Error(`Unsupported scheme: ${scheme}`);
    const keypair = Ed25519Keypair.fromSecretKey(secretKey);
   
    const BALANCE_MANAGER_KEY = "BM1";
    const BALANCE_MANAGER_ID = "0x09921a24e9fe239b194a109ed8b8812f86fefc3389f851c4d06f7e55bef79a9f";
   
    const balanceManagers: { [k: string]: BalanceManager } = { [BALANCE_MANAGER_KEY]: { address: BALANCE_MANAGER_ID } };
   
    const client = new SuiGrpcClient({
      network: env,
      baseUrl: env === "mainnet" ? "https://fullnode.mainnet.sui.io:443" : "https://fullnode.testnet.sui.io:443",
    }).$extend(
      deepbook({
        address: keypair.toSuiAddress(),
        balanceManagers,
      }),
    );
    const tx = new Transaction();
    tx.add(client.deepbook.balanceManager.depositIntoManager(BALANCE_MANAGER_KEY, "SUI", 0.5));
   
    const res = await client.core.signAndExecuteTransaction({
      transaction: tx,
      signer: keypair,
      include: { effects: true, objectTypes: true },
    });
   
    console.dir(res, { depth: null });
   

   สังเกตุไหมว่า BALANCE_MANAGER_ID คือค่าที่เราได้จาก step 2 นั้นเองส่วน BALANCE_MANAGER_KEY คือ ชื่อที่เราสามรถอะไรก็ได้ ไว้สำหรับ อ้างอิงไปยัง BalanceManager object ไหนบน chain เเละในขั้นตอนนี้เราจะฝาก 0.5 SUI testnet token นะครับ ขั้นตอนนี้เมื่อสำเร็จเราจะได้ digest ของ transaction ซึ่งสามารถนำไปเปิดดูผ่าน https://suiscan.xyz/ ได้นะ แต่อย่าลืมเปลี่ยจาก Mainnet เป็น Testnet ด้วยนะ

4. Read pool balance and Withdraw

   เมื่อเราทำการฝากเงินเข้าไปแล้ว เราก็จะมาทดสอบ อ่านข้อมูลกันสักหน่อย ว่าตัวเลขถูกต้องใหม และทำการถอนเงินออกมาด้วยเลย

    import "dotenv/config";
    import { deepbook, type BalanceManager } from "@mysten/deepbook-v3";
    import { SuiGrpcClient } from "@mysten/sui/grpc";
    import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
    import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
    import { Transaction } from "@mysten/sui/transactions";
   
    const env = (process.env.NETWORK ?? "testnet") as "testnet" | "mainnet";
    const { scheme, secretKey } = decodeSuiPrivateKey(process.env.SUI_PRIVATE_KEY!);
    if (scheme !== "ED25519") throw new Error(`Unsupported scheme: ${scheme}`);
    const keypair = Ed25519Keypair.fromSecretKey(secretKey);
    const address = keypair.toSuiAddress();
   
    const BALANCE_MANAGER_KEY = "BM1";
    const BALANCE_MANAGER_ID = "0x09921a24e9fe239b194a109ed8b8812f86fefc3389f851c4d06f7e55bef79a9f";
   
    const balanceManagers: { [k: string]: BalanceManager } = { [BALANCE_MANAGER_KEY]: { address: BALANCE_MANAGER_ID } };
   
    const client = new SuiGrpcClient({
      network: env,
      baseUrl: env === "mainnet" ? "https://fullnode.mainnet.sui.io:443" : "https://fullnode.testnet.sui.io:443",
    }).$extend(
      deepbook({
        address,
        balanceManagers,
      }),
    );
   
    const suiBalance = await client.deepbook.checkManagerBalance(BALANCE_MANAGER_KEY, "SUI");
    console.log("SUI in manager =", suiBalance);
   
    const tx = new Transaction();
    client.deepbook.balanceManager.withdrawAllFromManager(BALANCE_MANAGER_KEY, "SUI", address)(tx);
   
    const res = await client.core.signAndExecuteTransaction({
      transaction: tx,
      signer: keypair,
      include: { effects: true, objectTypes: true },
    });
   
    console.dir(res, { depth: null });
   

   ซึ่งผลลัพธ์ที่ได้นั้น เราจะเห็นว่ามีอยู่ 0.5 SUI testnet token และเมื่อเราสั่งถอน เเละลองทดสอบรันอีกรอบจะเหลือ 0 SUI testnet token ซึ่งถ้ามี 0 token เราจะไม่สามารถวางคำสั่งเพื่อขาย SUI ได้นะ เพราะเราไม่มีเงินเพียงพอที่จะทำขายนั้นเอง ตามที่เคยอธิบายไปแล้วในบล็อคก่อนหน้า (Funding account = 0)

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

และก่อนจะจบบทความ ขอประชาสัมพันธ์หน่อย ON THE MOVE จะมี MOVE Workshop เร็วๆนี้ที่ CONTRIBUTIONDAO Office นะครับ ใครอยากลองมานั่งเขียนโค๊ดร่วมกันมากันได้น๊าา มีของกินตลอดทั้งวัน :P

• https://luma.com/j743avm7

แล้วเจอกันนะครับ :)

เกริ่นไว้แค่นั้นพอเเหละ เดียวจะยาวที่พูดถึงเรื่องนี้ เพราะสัญญาเอาไว้ว่าจะเขียนบล็อคเกี่ยวกับ DeFi บน SUI network ซึ่งถ้าพูดถึงเรื่องนี้ ก็จะไม่พูดถึง DeepBook ไม่ได้ โดยที่

DeepBook คือระบบซื้อขายแบบ Decentralized Central Limit Order Book (CLOB) บน SUI Network ที่ออกเเบบมาเพื่อการทำงานที่มีประสิทธิภาพสูง มีความเร็วนั้นเอง เพราะอาศัยการประมวลผลเเบบคู่ขนาดของ SUI ในการทำงาน ควบคู่ไปกับข้อดีในเรื่องค่าธรรมเนียมที่ต่ำ ซึ่งตัว DeepBook นั้นเป็นชุดพัฒนา ไม่ได้มี Interface ให้เราใช้งานนะ แต่จะมีพวกโครงสร้างพื้นฐานต่างๆให้เราสามารถนำไปใช้งานต่อยอดได้

CLOB คือระบบจับคู่คำสั่งซื้อขายที่ใช้กันอย่างแพร่หลายในตลาดซื้อขายแบบดั้งเดิมและศูนย์ซื้อขายคริปโตทั่วๆไป (เช่นตลาดหุ้นหรือ CEX) โดยผู้ใช้งานสามารถกำหนด ราคาที่ต้องการซื้อหรือขายล่วงหน้า ได้ผ่านคำสั่งที่เรียกว่า Limit Order ระบบจะนำคำสั่งซื้อ (Bid) และคำสั่งขาย (Ask) ใครเคยเทรดหุ้นมาบ้างก็พอจะเห็นภาพเน้อ เช่น เราต้องการซื้อหุ้น A ที่ราคา 20 บาท เราก็ส่งคำสั่งซื้อเข้าไปในระบบนั้นเอง

การทำงานเเละโครงสร้างพื้นฐานของ DeepBook

DeepBook ถูกออกเเบบให้มีการทำงาน 3 องค์ประกอบดังต่อไปนี้

1. Pool

   แทน ตลาดซื้อขายนั้นเอง เช่น SUI/USDC นั้นคือตลาดซื้อขายเเลกเปลี่ยน Token SUI กับ Stable token USDC โดยเป็น shared object ที่ผู้ใช้งานและแอปพลิเคชันต่าง ๆ สามารถเรียกใช้งานร่วมกันได้ ภายใน Pool จะรวมทุกสิ่งที่จำเป็นต่อการทำงานของ orderbook ไว้ในที่เดียว โดย Pool ถูกออกแบบให้แบ่งหน้าที่ภายในออกเป็นส่วนย่อย ได้แก่

   • Book: ทำหน้าที่เก็บและจัดการ orderbook ทั้งฝั่ง bid (ราคาเสนอซื้อ) และ ask (ราคาเสนอขาย) รวมถึงการจับคู่คำสั่งซื้อขาย

   • State: จัดการสถานะของตลาด เช่น ค่าธรรมเนียม, ประวัติการซื้อขาย และกฎต่าง ๆ ของพูล

   • Vault: ดูแลการ settle และการเคลื่อนย้ายสินทรัพย์จริงหลังจากคำสั่งถูกจับคู่สำเร็จแล้ว

เมื่อมีการวางคำสั่งซื้อขายหรือทำการแลกเปลี่ยน ระบบจะประมวลผลทั้งหมดภายใน Pool แบบ atomic transaction เดียว ทำให้มั่นใจได้ว่าการจับคู่คำสั่งและการเคลื่อนย้ายสินทรัพย์จะสอดคล้องกันเสมอ

2. PoolRegistry

   ทำหน้าที่เป็น registry กลางของระบบ DeepBookV3 โดยมีบทบาทสำคัญคือ

   • เก็บรายการ Pool ทั้งหมดที่มีอยู่ในระบบ

   • เป็นจุดอ้างอิงสำหรับแอปพลิเคชันหรือ SDK ในการค้นหา pool ที่ต้องการใช้งาน

   • ควบคุมการสร้าง Pool ใหม่ เพื่อให้โครงสร้างของตลาดเป็นไปตามกฎของโปรโตคอล

ด้วยการมี PoolRegistry ทำให้ DeepBookV3 สามารถขยายไปสู่หลายตลาดได้อย่างเป็นระบบ และลดความซับซ้อนในการ integrate สำหรับ dApp, wallet หรือ DEX ต่าง ๆ ที่ต้องการเข้าถึงสภาพคล่องจากหลายคู่เทรดได้

3. BalanceManager

   เป็นองค์ประกอบสำคัญที่เชื่อมระหว่างผู้ใช้งานกับ Pool โดยทำหน้าที่เป็นบัญชีสำหรับการเทรดบน DeepBook แยกออกจากกระเป๋าปกติของผู้ใช้งาน ซึ่งต้องบอกก่อนว่าใน การเทรดทุกครั้งต้องผ่าน BalanceManager ซึ่งเป็น shared object ที่เก็บยอดเงินและใช้เป็นแหล่งเงินต้นในการวาง orders หรือ swap ในแต่ละ pool (ยกเว้นบางกรณีของ swap) และเมื่อคำสั่งถูก match แล้วระบบจะโอนเงินเข้าออก BalanceManager แทนที่จะเทรดโดยตรงกับกระเป๋าของผู้ใช้งาน

   บทบาทหลักของ BalanceManager ที่สำคัญๆ คือ

   • เก็บยอดคงเหลือของสินทรัพย์ที่ผู้ใช้งานนำมาใช้สำหรับการเทรด

   • ใช้เป็นแหล่งเงินในการวางคำสั่งซื้อขาย (limit order / market order)

   • รับผลลัพธ์จากการจับคู่คำสั่ง เช่น เหรียญที่ได้จากการเทรด หรือยอดที่เหลือหลังจาก Partial fill

การออกแบบให้ผู้ใช้งานต้องฝากสินทรัพย์เข้า BalanceManager ก่อนเทรด ช่วยให้ระบบสามารถจัดการคำสั่งซื้อขายได้อย่างมีประสิทธิภาพ ลดความซับซ้อนของ state และรองรับการทำงานแบบขนานของ Sui ได้ดียิ่งขึ้น

มาดูตัวอย่างการทำงานกัน

อิงจากรูปนี้นะ

1. เราทำการฝากเงินเข้าไปที่ Balance Manager เพื่อทำการส่งคำสั่งซื้อหรือขายนั้นเอง เช่น เราบอกว่าจะขาย SUI token ก็จะเป็นการฝาก SUI เข้าไปที่ Balance Manager เป็นขั้นตอนแรก ถ้าเรายกเลิกคำสั่งซื้อเงินก็จะถูกถอนกลับมาที่กระเป๋าของเราทันที

2. Swap Exact/External Contract ตรงส่วนนี้จะทำให้ DEX, Router, Aggregator ต่างๆ สามารถทำการเเลกเปลี่ยนเหรียญได้ ถ้าจะให้เขาใจง่ายๆก็เหมือน Market order ละมั่ง อารมณ์แบบอยากซื้อราคาที่ตลาดตอนนี้เลย ถ้าสมมุติว่า SUI มีมูลค่า 10 บาทต่อ tokens เเล้วเรามีอยู่ 100 บาท เราไม่อยากรอให้ราคาลงมาที่ 9 บาท เราก็จะทำการ Swap Exact โดยเเค่บอกว่า เรามีเงินอยู่ 100 บาทนะ เอาไปแลก SUI ให้หน่อย ซึ่งเราอาจจะได้ SUI กลับมาไม่ถึง 10 tokens ก็เป็นได้ ไม่งงใช่ไหม

3. DeepBook V3 Contract ส่วนนี้จะเป็นหัวใจหลัก หน้าที่มันก็จะมีจำพวก

   • รับคำสั่งจากมาจาก ผู้ใช้งาน หรือ DEX ต่างๆ

   • จัดการ logic ของ orderbook / matching / settlement

   • ประสานงานกับ Pool และ Balance Manager

ทั้งหมดคือข้อมูลคร่าวๆนะ ตามไปอ่านต่อกันได้ที่ https://docs.sui.io/standards/deepbook ซึ่ง บทความถัดไปเราจะไม่เกริ่นอะไรกันละ เราจะมาเริ่มลงมือเขียนโค๊ดกัน เริ่มกันตั้งแต่ สร้าง Balance Manager การวางคำสั่งซื้อ คำสั่งขาย การอ่านค่า order book เป็นต้น ซึ่งไม่รู้จะจบในกี่ตอน ยังไงก็ฝากติดตามกันด้วยน๊า อ่อลืมบอกไปตอนนี้ DeepBook มีการเก็บคะเเนนการใช้งานด้วยนะ ซึ่งในโลกของ Web 3.0 คะแนน ย่อม หมายถึง เงินฟรี ที่อาจจะเเยกในอนาคน :P

ZKLogin บน Sui คือกลไกการล็อกอินที่ผสาน Zero-Knowledge Proof เข้ากับ OAuth (เช่น Google หรือ X) เพื่อให้ผู้ใช้เข้าใช้งาน Web 3.0 ได้โดยไม่ต้องสร้างหรือเก็บ Private key เอง ระบบจะพิสูจน์ตัวตนว่า ผู้ใช้ล็อกอินถูกต้อง โดยไม่เปิดเผยข้อมูลส่วนบุคคลบนบล็อกเชน และสร้างบัญชีที่ผูกกับ session ผลลัพธ์คือประสบการณ์ใช้งานที่ใกล้เคียง Web 2.0 แต่ยังคงคุณสมบัติด้านความเป็นส่วนตัวและความปลอดภัยแบบ Web 3.0 ลดปัญหาสำหรับผู้ใช้งานมือใหม่ และช่วยให้นักพัฒนาสร้าง dApp ที่ onboard คนได้ง่ายขึ้นเป็นอย่างมาก

เรามาดูวิธีการตัวอย่างการ Implement ZK Login กันดีกว่า

สิ่งต้องเตรียม

• Node.js (เวอร์ชัน 18 ขึ้นไปแนะนำ)

• Sui TypeScript SDK: @mysten/sui

• Google Cloud Project: เพื่อเอา Client ID (เพราะเราจะจำลองการ Login ด้วย Google account)

มาเริ่มกัน

1. ติดตั้ง SDK

    npm install @mysten/sui jwt-decode
   

2. เตรียม Google OAuth (Client ID)

   เริ่มจากเราต้องไปที่ Google Cloud Console แล้วทำตามขั้นตอนดังนี้

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

     

   • ไปที่ APIs & Services > Credentials (https://console.cloud.google.com/apis/credentials)

   • สร้าง OAuth client ID กรอกข้อมูลต่างตามตัวอย่างรูปข้างล่าง และตั้งค่า Authorized redirect URIs ให้ตรงกับหน้าเว็บของเรา (เช่น http://localhost:5173)

     

   • Copy Client ID เก็บไว้นะ เราต้องนำไปใช้งานต่อ

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

   ซึ่งการทำ ZK Login จะมี Flow หลักๆ ดังนี้

   • สร้างกุญแจชั่วคราว (Ephemeral Key)

   • สร้าง Nonce และส่ง User ไปล็อกอิน Google

   • รับ JWT Token จาก Google

   • สร้าง ZK Proof และส่ง Transaction

• เริ่มจาก สร้าง Ephemeral Key และ URL สำหรับ Login

  อันดับแรก เราต้องสร้างกุญแจชั่วคราวก่อน เพื่อใช้เซ็นธุรกรรมแทน User ใน Session ที่ผู้ใช้งานได้เข้าสู่ระบบ

    import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
    import { generateNonce, generateRandomness } from '@mysten/sui/zklogin';
  
    // 1. สร้างกุญแจชั่วคราว (Ephemeral Key)
    const ephemeralKeyPair = new Ed25519Keypair();
  
    // 2. กำหนดค่าพื้นฐาน
    const maxEpoch = 100; // กำหนดอายุการใช้งานของ Key (เช็ค epoch ปัจจุบันจาก RPC ได้)
    const randomness = generateRandomness(); // ค่าสุ่มเพื่อความปลอดภัย
  
    // 3. สร้าง Nonce
    // Nonce นี้จะผูก Public Key ชั่วคราวของเราเข้ากับ Login Session ของ Google
    const nonce = generateNonce(
        ephemeralKeyPair.getPublicKey(), 
        maxEpoch, 
        randomness
    );
  
    // 4. สร้าง URL เพื่อส่ง User ไปหน้า Login Google
    const REDIRECT_URI = 'http://localhost:5173'; // URL หน้าเว็บของคุณ
    const CLIENT_ID = 'YOUR_GOOGLE_CLIENT_ID'; // ใส่ Client ID ที่ได้จาก Google
  
    const params = new URLSearchParams({
        client_id: CLIENT_ID,
        response_type: 'id_token',
        redirect_uri: REDIRECT_URI,
        scope: 'openid email', // ขอสิทธิ์ดู email
        nonce: nonce, // สำคัญมาก! ต้องส่ง nonce ไปด้วย
    });
  
    const loginURL = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
  
    console.log('Login Link:', loginURL);
    // ในเว็บจริง: window.location.href = loginURL;
  

• รับ JWT และสร้าง Sui Address (หลัง User ล็อกอินเสร็จ)

  จากขั้นตอนแรกเราจะได้ Login Link ให้นำ URL ดังกล่าวไปเปิดผ่าน browser นะ และเมื่อผู้ใช้งานล็อกอินสำเร็จ Google จะ redirect กลับมาพร้อม id_token (JWT) ใน URL นั้นเอง และเมื่อเราได้ SUI address มาเเล้วอย่าลืมไปขอ Devent token นะ

    import { jwtToAddress } from '@mysten/sui/zklogin';
    import { jwtDecode } from 'jwt-decode';
  
    // สมมติว่าดึง id_token มาจาก URL แล้ว
    const idToken = '...JWT_TOKEN_FROM_GOOGLE_URL...'; 
  
    // ถอดรหัส JWT เพื่อดูข้อมูล (ไม่จำเป็นต้องใช้ private key)
    const decodedJwt = jwtDecode(idToken);
  
    // 5. กำหนด Salt (User Salt)
    // *สำคัญ* Salt ต้องเป็นความลับและ "เหมือนเดิมเสมอ" สำหรับ User คนเดิม
    // ในโปรดักชั่น ควรมี Salt Service แยกต่างหากเพื่อ Map User ID -> Salt
    const userSalt = '12345678901234567890'; // ตัวอย่าง (จริงๆ ต้องเป็น BigInt string)
  
    // 6. คำนวณหา Sui Address ของ User คนนี้
    const zkLoginAddress = jwtToAddress(idToken, userSalt);
  
    console.log('Sui Address ของ User คือ:', zkLoginAddress);
  

• สร้าง Transaction และส่งขึ้นธุรกรรมขึ้น SUI network

  ขั้นตอนนี้ต้องใช้ Proving Service (บริการสร้าง Zero-Knowledge Proof) ซึ่งปกติ Mysten Labs มีให้ใช้ฟรีใน Devnet หรือเราจะรันเองใน Mainnet ก็ได้

    import { SuiClient } from '@mysten/sui/client';
    import { Transaction } from '@mysten/sui/transactions';
    import { genAddressSeed, getZkLoginSignature } from '@mysten/sui/zklogin';
  
    // เชื่อมต่อ SUI Network
    const client = new SuiClient({ url: 'https://fullnode.devnet.sui.io' });
  
    // --- (ส่วนนี้คือการขอ ZK Proof จาก Proving Service) ---
    // เราต้องส่ง JWT, Salt, Ephemeral Public Key, ฯลฯ ไปที่ Prover API
    // Devnet => https://prover-dev.mystenlabs.com/v1
    // สมมติว่าได้ proof กลับมาแล้วเก็บในตัวแปร `zkProof`
    // const zkProof = await fetchProverService(...); 
  
    // 7. สร้าง Transaction (ตัวอย่างส่งเหรียญ SUI)
    const tx = new Transaction();
    tx.setSender(zkLoginAddress);
    const [coin] = tx.splitCoins(tx.gas, [1000]); // ส่ง 1000 MIST
    tx.transferObjects([coin], '0xRECIPIENT_ADDRESS');
  
    // 8. เซ็น Transaction ด้วย Ephemeral Key (กุญแจชั่วคราว)
    const { bytes, signature: userSignature } = await tx.sign({
        client,
        signer: ephemeralKeyPair, // ใช้ Key ที่สร้างในขั้นตอนที่ 1
    });
  
    // 9. สร้าง Signature (รวม ZK Proof + Signature)
    const addressSeed = genAddressSeed(
        BigInt(userSalt), 
        'sub', 
        decodedJwt.sub, 
        decodedJwt.aud
    ).toString();
  
    const zkLoginSignature = getZkLoginSignature({
        inputs: {
            ...zkProof, // Proof ที่ได้จาก Prover
            addressSeed,
        },
        maxEpoch,
        userSignature, // Signature จาก Ephemeral Key
    });
  
    // 10. ส่ง Transaction ขึ้น SUI network
    const result = await client.executeTransactionBlock({
        transactionBlock: bytes,
        signature: zkLoginSignature,
    });
  
    console.log('Transaction Success:', result.digest);
  

เรียบร้อย พอจะเข้าในการทำงานในแต่ละขั้นตอนใช่ไหม ซึ่งเราสามารถนำความเข้าตรงนี้ไปพัฒนาต่อเป็น Web application (ดูตัวอย่างได้ที่นี้ https://github.com/jovicheng/sui-zklogin-demo) ให้ผู้ใช้งานสามารถสร้างกระเป๋าด้วยบัญชี Google ของเขาได้ทันที หรือ สามารถลองเล่นทีละขั้นตอนได้ที่นี้นะ https://sui-zklogin.vercel.app/ ซึ่งจะมีตัวอย่างให้เห็นอย่างชัดเจนว่าแต่ละขั้นตอนมีการเรียกใช้งานโค๊ดส่วนไหน ลองเอาไปใช้กันดูน๊า เเล้วลูกค้าจะรักในผลิตภัณฑ์เรามากยิ่งขึ้น

Mysticeti v2

เริ่มจากตัวหลักก่อนเลย Mysticeti v2 ซึ่งเป็น Consensus หลักของ SUI โดยทีมได้มีการประกาศอย่างเป็นทางการช่วงเดือน Nov ที่ผ่านมา ตัว v2 แน่นอนได้ต่อยอดจาก v1 ที่เปิดตัวไปเมื่อกลางปี 2024 นู้น ใจความหลักๆเลยคือการปรับปรุงในเรื่องความเร็ว เเละทำให้มีความยืดหยุ่นมากขึ้น โดยมีการปรับปรุงในส่วนของการลดทอนขั้นตอนที่ไม่จำเป็นของ การส่งเเละการยืนยันธุรกรรมในระบบ รวมถึงทำให้มีการใช้ทรัพยากรน้อยลง ส่วนถ้าอยากรู้ว่า Mysticeti v2 ทำงานยังไงเดียวทีม ContributionDAO น่าจะมี Live บน X เเหละ เพื่ออธิบายกันอีกที แต่ก่อนจะเรียนรู้ตรงนี้ อย่างลืมไปดู Live เก่าๆก่อนนะ

• https://www.youtube.com/watch?v=ktE6SVQPEnY

• https://www.youtube.com/watch?v=klhO9NbaFwI

• https://www.youtube.com/watch?v=A18qJrgt7rI

• https://www.youtube.com/watch?v=39I8v4tGvUI

• https://www.youtube.com/watch?v=MTXKsWg-E8Y

5 vdo จุกๆ กันไป

…

Walrus - Programmable Storage

ในเดือนมีนาคม 2025 ที่ผ่านมา ทีม Mysten Labs ได้เปิดตัว Walrus บน Mainnet ซึ่งถือเป็นการเปลี่ยนแปลงเชิงโครงสร้างพื้นฐานที่สำคัญที่สุดสำหรับการจัดการข้อมูลบน Sui ก่อนหน้านี้ การจัดเก็บไฟล์ขนาดใหญ่ (Blobs) เช่น รูปภาพ วิดีโอ หรือโมเดล AI บน Layer 1 โดยตรงนั้นเป็นเรื่องที่เป็นไปไม่ได้ ซึ่ง Walrus ได้เข้ามาแก้ปัญหานี้ด้วยการสร้างเลเยอร์จัดเก็บข้อมูลแบบกระจายศูนย์ที่เชื่อมต่อกับ Sui ecosystem

…

Seal - Data encryption and onchain access control

Privacy ไม่เคย เเละไม่เคยหายไปใหน ถ้าใครอยู่ใน Web 3.0 ecosystem เราจะเห็นเทรนของ Privacy เวียนว่ายตายเกิดกลับมาเป็นระยะ Seal เป็นก็เป็น Privacy player นึงที่สำคัญบน SUI ecosystem ซึ่งได้เปิดตัวบน Mainnet ไปตั้งแต่ช่วงกันยายนปีที่แล้ว โดย use case หลักที่จะเห็นได้ชัดเจนเลยคือการนำ Access Control ของ Seal ไปทำงานควบคู่กับ Walrus ซึ่งทางเราก็เคยเขียนตัวอย่างไว้ละ ลองอ่านย้อนหลังตาม blogs เหล่านี้ดูนะ

• https://onthemove.contributiondao.com/ep-3-walrus-seal-send-secret-message

• https://onthemove.contributiondao.com/ep-4-seal-on-chain-access-control

• https://onthemove.contributiondao.com/ep-5-walrus-seal-send-receive-data

…

The Agentic Web

ก็…AI นั้นเเหละ มีหลายตัวที่เปิดตัวไปแล้ว มีตัวนึงที่เรากำลังศึกษาคือ Nautilus โดยเปิดตัวบน Mainnet ในช่วงกลางปี 2025 ถือเป็นจิ๊กซอว์ชิ้นสำคัญของ Sui Stack ที่เข้ามาจัดการข้อมูลระหว่างโลก On-chain และ Off-chain โดยทำหน้าที่เป็นเลเยอร์สำหรับการ Indexing ข้อมูล และการประมวลผลนอกเชน (Off-chain Computation) เทคโนโลยีนี้ช่วยให้นักพัฒนาสามารถสร้างแอปพลิเคชันที่มีความซับซ้อนสูง เช่น AI Agents โดยไม่ต้องแบกรับต้นทุนในการเก็บข้อมูลหรือประมวลผลทุกอย่างบนบล็อกเชนโดยตรง ซึ่งเป็นจุดเด่นสำคัญของ Nautilus เขาละ ทำให้ เชื่อมต่อข้อมูลจากภายนอกหรือผลลัพธ์การคำนวณที่ซับซ้อนกลับเข้ามาสู่ Smart Contract ได้อย่างถูกต้อง ไว้เดียวเขียน Blog เเยกดีกว่าจะได้เห็นตัวอย่างกันด้วย

กับอีกส่วนนึงที่ทุกคนน่าจะเคยเห็นเเล้วมั่ง…เคยเเหละคือ Agentic Payments Protocol (AP2) ของพี่ใหญ่ Google ของเรานั้นเอง ซึ่ง SUI ก็เป็นหนึ่งในพันธมิตรกับเขาด้วย ก็ต้องรอดูต่อไปว่าจะมีอะไรน่าสนใจมาไหม

…

Move Registry (MVR)

ในช่วงหน้าร้อนของไทย ก็คือเมษาปีที่แล้ว ทีม Mysten Labs ได้เปิดตัว Move Registry (MVR) ซึ่งถือเป็นเครื่องมือใหม่ใน ecosystem ที่ช่วยยกระดับประสบการณ์นักพัฒนาบน Sui เป็นอย่างมาก MVR คือระบบ จัดการแพ็กเกจ (package management) แบบ on-chain สำหรับโค้ด Move ของ Sui ที่ทำหน้าที่คล้ายกับ npm (ของ JavaScript) หรือ crates.io (ของ Rust) ในโลกของบล็อกเชนนั้นเอง โดยนักพัฒนาสามารถ เผยแพร่แพ็กเกจ Move ขึ้นไปยัง MVR ได้ ใครสนใจลองไปส่องกันดูที่นี้นะ https://www.moveregistry.com/

…

Move lang/SDK

ที่เข้าตาเลยก็คือ SUI Stack Messaging SDK ซึ่งเป็นเครื่องมือใหม่ที่เปิดตัวในปี 2025 เพื่อทำให้ระบบส่งข้อความแบบกระจายศูนย์กลายเป็นส่วนหนึ่งของการพัฒนาแอปบน Sui ได้โดยตรง แทนที่จะต้องพึ่งโซลูชันภายนอกหรือ API นักพัฒนาสามารถสร้าง การสื่อสารที่เข้ารหัสลับตั้งแต่ต้นทางถึงปลายทาง (end-to-end encrypted) ที่เชื่อมกับ wallet identity และสามารถจัดเก็บข้อความและไฟล์แนบได้อย่างปลอดภัยบนเครือข่าย Sui พร้อมการเข้าถึงที่กำหนดเองได้ผ่านโมดูลต่าง ๆ ของ stack เช่น Sui blockchain, Walrus decentralized storage, และ Seal access control ซึ่งจาก SDK นี้นักพัฒนาสามารถสร้างฟีเจอร์ที่หลากหลายได้ตั้งแต่ข้อความแบบหนึ่ง-ต่อ-หนึ่ง, ห้องแชทกลุ่ม, ไปจนถึงการสื่อสารที่ถูกทริกเกอร์โดยกิจกรรมบนเชน เช่น การ mint NFT หรือการลงคะแนนโหวต

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

• https://onthemove.contributiondao.com/ep-1-walrus-and-seal เริ่มต้นด้วยตัวอย่างโค๊ด ในการส่งข้อมูลไปเก็บที่ Walrus

• https://onthemove.contributiondao.com/ep-2-walrus-programmable-storage ทำความรู้จักการเขียน Programmable Storage

• https://onthemove.contributiondao.com/ep-3-walrus-seal-send-secret-message รู้จัก Seal และตัวอย่างโค๊ด ในการเข้ารหัสข้อมูล

• https://onthemove.contributiondao.com/ep-4-seal-on-chain-access-control ตัวอย่าง Move Smart Contract ในการจัดการ Access Control

ลองไปอ่านดูย้อนหลังกันก่อนน๊ะ เพราะใน EP เราจะนำทุกอย่างมาประกอบร่างกันแล้วครับ

จากตัวอย่างโค๊ดล่าสุดนั้น เราเขียนละติดปัญหาเกี่ยวกับฟังก์ชั่นของ Walrus พอสมควร เเละพบว่าจริงๆเเล้ว เราสามารถเรียกใช้งาน API ผ่าน Provider endpoint เพื่อ ทำการรับเเละส่งข้อมูลไปยัง Walrus network ได้ เลยขอเปลี่ยนวิธีการรับส่งข้อมูลกันหน่อยนึงนะ

มาเริ่มกันเลย นี้คือตัวอย่างโค๊ดทั้งหมดที่นำมาประกอบร่างและ มีการทำให้โค๊ดอ่านง่ายขึ้นละ

1. ทำการเเก้ไข .env กันก่อน

   SENDER_PRIVATE_KEY=suiprivatekey1xxx // Sender private key
   RECEIVER_PRIVATE_KEY=suiprivatekey1xxx //Receiver private key
   NETWORK=testnet
   PACKAGE_ID=0x0xxxx // Package Id ที่เราได้จาก EP.4
   

2. สร้างไฟล์ config.ts

   import "dotenv/config";
   
   // --- Env Checks ---
   if (!process.env.SENDER_PRIVATE_KEY || !process.env.RECEIVER_PRIVATE_KEY) {
       throw new Error("Bro, you forgot the private keys in .env file.");
   }
   
   export const CONFIG = {
       // Keys
       SENDER_KEY: process.env.SENDER_PRIVATE_KEY,
       RECEIVER_KEY: process.env.RECEIVER_PRIVATE_KEY,
   
       // Network & Package
       SUI_NETWORK: process.env.SUI_NETWORK || "testnet",
       PACKAGE_ID: process.env.PACKAGE_ID
   
       // Seal Key Servers (Testnet)
       KEY_SERVERS: [
           "0x73d05d62c18d9374e3ea529e8e0ed6161da1a141a94d3f76ae3fe4e99356db75",
           "0xf5d14a81a982144ae441cd7d64b09027f116a468bd36e7eca494f750591623c8",
       ],
   
       // Dummy 32-byte hex for initial encryption setup
       PLACEHOLDER_POLICY_ID: "0x" + "0".repeat(64),
   };
   
   // --- Walrus Endpoints ---
   export const WALRUS_CONFIG = {
       EPOCHS: Number(process.env.WALRUS_EPOCHS ?? 1),
   
       PUBLISHERS: [
           "https://publisher.walrus-testnet.walrus.space",
           "https://wal-publisher-testnet.staketab.org",
           "https://walrus-testnet-publisher.redundex.com",
           "https://walrus-testnet-publisher.nodes.guru",
       ].filter(Boolean) as string[],
   
       AGGREGATORS: [
           "https://aggregator.walrus-testnet.walrus.space",
           "https://wal-aggregator-testnet.staketab.org",
           "https://walrus-testnet-aggregator.redundex.com",
           "https://walrus-testnet-aggregator.nodes.guru",
       ].filter(Boolean) as string[],
   };
   

   มีส่วนที่น่าสนใจเพิ่มขึ้นมาคือ WALRUS_CONFIG ซึ่งส่วนนี้จะมีทั้ง

   • WALRUS_EPOCH เป็นการระบุอายุการเก็บรักษาข้อมูลนั้นเอง

   • PUBLISHERS คือ endpoint สำหรับใช้ในการอัพโหลดข้อมูลไปยัง Walrus network

   • AGGREGATORS คือ endpoint สำหรับการอ่านข้อมูลจาก Walrus netwokr

3. สร้างไฟล์ walrus.ts

   import { WALRUS_CONFIG } from "./config";
   
   /**
    * Uploads raw bytes to Walrus.
    * It tries multiple publisher nodes until one works.
    */
   export async function uploadBlob(data: Uint8Array): Promise<string> {
       let lastError: unknown = null;
       for (const baseUrl of WALRUS_CONFIG.PUBLISHERS) {
           const url = `\({baseUrl}/v1/blobs?epochs=\){WALRUS_CONFIG.EPOCHS}`;
           console.log(`☁️  Trying upload to: ${baseUrl}...`);
           try {
               const res = await fetch(url, {
                   method: "PUT",
                   body: data,
               });
   
               if (!res.ok) {
                   throw new Error(`HTTP \({res.status}: \){res.statusText}`);
               }
               const info = (await res.json()) as any;
               const blobId =
                   info.newlyCreated?.blobObject?.blobId ||
                   info.alreadyCertified?.blobId;
   
               if (!blobId) throw new Error("Invalid response format from Walrus");
   
               return blobId; // Success!
           } catch (e) {
               console.error(`-> Failed at ${baseUrl}, trying next...`);
               lastError = e;
           }
       }
       throw new Error(`All Walrus publishers failed. RIP. Error: ${lastError}`);
   }
   
   /**
    * Downloads raw bytes from Walrus.
    * It tries multiple aggregator nodes until one works.
    */
   export async function downloadBlob(blobId: string): Promise<Uint8Array> {
       let lastError: unknown = null;
       for (const baseUrl of WALRUS_CONFIG.AGGREGATORS) {
           const url = `\({baseUrl}/v1/blobs/\){blobId}`;
           console.log(`⬇️  Trying download from: ${baseUrl}...`);
           try {
               const res = await fetch(url);
               if (!res.ok) throw new Error(`HTTP ${res.status}`);
   
               const buffer = await res.arrayBuffer();
               return new Uint8Array(buffer); // Success!
           } catch (e) {
               console.error(`-> Node ${baseUrl} failed, trying next...`);
               lastError = e;
           }
       }
       throw new Error(`All Walrus aggregators failed. Blob might be gone.`);
   }
   

   ตรงไปตรงมาเลย ก่อนหน้านี้เราต้องเรียกผ่าน Walrus library ในการอ่านเเละเขียนข้อมูลใช่ไหม ซึ่งเท่าที่ลองดูเจอปัญหางอแงบ้าง เลยตัดจบด้วยการใช้วิธีเรียกผ่าน HTTP Protocol เลยทีเดียวจบ

4. สร้างไฟล์ main.ts

   import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
   import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
   import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
   import { SealClient, SessionKey, EncryptedObject } from "@mysten/seal";
   import { Transaction } from "@mysten/sui/transactions";
   import { fromHex, toHex } from "@mysten/sui/utils";
   import { randomBytes } from "node:crypto";
   
   import { CONFIG } from "./config";
   import { uploadBlob, downloadBlob } from "./walrus";
   
   
   let suiClient: SuiClient;
   let sealClient: SealClient;
   
   async function main() {
       console.log("🚀 Starting the Walrus x Seal Privacy Demo...");
   
       // 1. Setup Network
       await initClients();
   
       // 2. Setup Users
       const sender = getKeypair(CONFIG.SENDER_KEY);
       const receiver = getKeypair(CONFIG.RECEIVER_KEY);
   
       console.log(`👤 Sender:   ${sender.getPublicKey().toSuiAddress()}`);
       console.log(`👤 Receiver: ${receiver.getPublicKey().toSuiAddress()}`);
   
       const secretMessage = "Yo fam, this is exclusive content! 📸 (Secured by Seal)";
   
       // 3. Sender Flow
       const policyObjectId = await runSenderFlow(secretMessage, receiver, sender);
   
       // 4. Simulate Network Delay
       console.log("\n⏳ Chilling for 5s to let Walrus propagate...");
       await sleep(5000);
   
       // 5. Receiver Flow
       await runReceiverFlow(policyObjectId, receiver);
   
       console.log("\n✨ Boom! Mission accomplished.");
   }
   
   // ============================================================================
   // WORKFLOWS
   // ============================================================================
   
   async function runSenderFlow(
       secret: string,
       recipient: Ed25519Keypair,
       sender: Ed25519Keypair
   ): Promise<string> {
       console.log(`\n--- [Step 1] Sender Turn ---`);
       console.log(`🔒 Encrypting payload...`);
   
       // Prepare a randomized ID for encryption
       // We add a nonce to ensure the ID is unique even if the policy ID is static
       const policyBytes = fromHex(CONFIG.PLACEHOLDER_POLICY_ID);
       const nonce = new Uint8Array(randomBytes(5));
       const idBytes = new Uint8Array(policyBytes.length + nonce.length);
       idBytes.set(policyBytes, 0);
       idBytes.set(nonce, policyBytes.length);
   
       // Encrypt locally
       const plainBytes = new TextEncoder().encode(secret);
       const { encryptedObject } = await sealClient.encrypt({
           threshold: 2,
           packageId: CONFIG.PACKAGE_ID,
           id: toHex(idBytes),
           data: plainBytes,
       });
   
       console.log(`-> Encrypted size: ${encryptedObject.byteLength} bytes`);
   
       // Upload to Walrus (Using our helper)
       const blobId = await uploadBlob(encryptedObject);
       console.log(`✅ Walrus Blob ID: ${blobId}`);
   
       // Mint the Policy Object on Sui
       console.log("⛓️ Minting SecretMessage object on-chain...");
       const tx = new Transaction();
       tx.moveCall({
           target: `${CONFIG.PACKAGE_ID}::message::create_secret_message`,
           arguments: [
               tx.pure.address(recipient.getPublicKey().toSuiAddress()),
               tx.pure.string(blobId)
           ],
       });
   
       const result = await suiClient.signAndExecuteTransaction({
           signer: sender,
           transaction: tx,
           options: { showObjectChanges: true },
       });
   
       // Find the new object ID
       const created = result.objectChanges?.find(
           (c: any) =>
               c.type === "created" &&
               "objectId" in c &&
               c.objectType.includes("::message::SecretMessage")
       );
   
       if (!created || !("objectId" in created)) {
           throw new Error("Tx failed. Could not find created object.");
       }
   
       const objectId = created.objectId as string;
       console.log(`📡 Policy Object created: ${objectId}`);
   
       return objectId;
   }
   
   async function runReceiverFlow(policyObjectId: string, recipient: Ed25519Keypair) {
       console.log(`\n--- [Step 2] Receiver Turn ---`);
       console.log(`📦 Fetching policy object: ${policyObjectId}`);
   
       // 1. Get Blob ID from Chain
       const obj = await suiClient.getObject({
           id: policyObjectId,
           options: { showContent: true },
       });
   
       const fields = (obj.data?.content as any)?.fields;
       if (!fields) throw new Error("Policy object is empty/invalid.");
   
       const blobId = fields.walrus_blob_id;
       console.log(`📦 Found Walrus ID: ${blobId}`);
   
       // 2. Download from Walrus (Using our helper)
       const encryptedBytes = await downloadBlob(blobId);
       console.log(`   -> Got ${encryptedBytes.byteLength} bytes`);
   
       // 3. Validation
       const info = EncryptedObject.parse(encryptedBytes);
       if (!info.id || !info.threshold) throw new Error("Data looks corrupted.");
   
       // 4. Session Key (Ephemeral security)
       console.log(`🔑 Generating temp session key...`);
       const recipientAddr = recipient.getPublicKey().toSuiAddress();
       const sessionKey = await SessionKey.create({
           address: recipientAddr,
           packageId: CONFIG.PACKAGE_ID,
           ttlMin: 10,
           signer: recipient,
           suiClient,
       });
   
       // 5. Build Proof (seal_approve)
       console.log("🛡️  Building auth proof...");
       const tx = new Transaction();
       tx.setSender(recipientAddr);
       tx.moveCall({
           target: `${CONFIG.PACKAGE_ID}::message::seal_approve`,
           arguments: [
               tx.pure.vector("u8", fromHex(info.id)),
               tx.object(policyObjectId),
           ],
       });
   
       const txBytes = await tx.build({ client: suiClient, onlyTransactionKind: true });
   
       // 6. Decrypt
       console.log("🔓 Asking Key Servers to decrypt...");
       const decryptedBytes = await sealClient.decrypt({
           data: encryptedBytes,
           sessionKey,
           txBytes,
       });
   
       const msg = new TextDecoder().decode(decryptedBytes);
       console.log(`\n🎉 SUCCESS! Message: "${msg}"`);
   }
   
   async function initClients() {
       suiClient = new SuiClient({ url: getFullnodeUrl(CONFIG.SUI_NETWORK) });
       sealClient = new SealClient({
           suiClient,
           serverConfigs: CONFIG.KEY_SERVERS.map((id) => ({
               objectId: id,
               weight: 1,
           })),
           verifyKeyServers: false, // skipping strict verification for testnet demo
       });
   }
   
   function getKeypair(secretKey: string) {
       return Ed25519Keypair.fromSecretKey(decodeSuiPrivateKey(secretKey).secretKey);
   }
   
   function sleep(ms: number) {
       return new Promise((r) => setTimeout(r, ms));
   }
   
   main().catch((e) => {
       console.error("FATAL ERROR:", e);
       process.exit(1);
   });
   

   มาถึงไฟล์สุดท้าย พระเอกของเรานั้นเอง มาไล่ทีละขั้นตอนกันนะ

   • เริ่มจากเป็นการ initClients() ก่อนส่วนนี้จะเห็นว่าไม่มีการเรียกใช้งาน Walrus แล้ว เพราะเราจะส่งข้อมูลผ่าน HTTP กัน

   • ส่วนของฟังก์ชั่น runSenderFlow นั้นจะเป็นนำข้อความของเราไปเข้ารหัสด้วย Seal หลังจากนั้นก็ทำการอัพโหลดข้อมูลไปยัง Walrus network นั้นเอง เเละเมื่อเราได้ blobId มาแล้วก็ทำการเรียกใช้งานฟังก์ชั่น Sui smart contract ที่เราได้เขียนไว้เเล้วเพื่อกำหนดผู้รับ

   • ส่วนของฟังก์ชั่น runReceiverFlow ทำตรงกันข้ามนั้นเองโดยนำ blobId ไปดาวโหลดข้อมูลจาก Walrus network ลงมาก่อนแล้วทำการถอดรหัสข้อมูลด้วย Seal หลังจากผู้รับต้องทำการเรียก Sui smart contract เพื่อยืนยันความเป็นเจ้าของนั้นเอง

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

• Client-Side Encryption - ข้อมูลเข้ารหัสบนอุปกรณ์ผู้ใช้

• Decentralized Storage - เก็บบน Walrus แบบกระจายศูนย์

• On-Chain Access Control - Smart Contract ควบคุมสิทธิ์การเข้าถึง

• Threshold Cryptography - ไม่มี Single Point of Failure

• Programmable Ownership - สิทธิ์เป็น Object ที่โอนย้ายได้

ซึ่งจากคุณสมบัติเหล่านี้เราสามารถนำไปต่อยอดเป็น use case อื่นได้อีกมายเลยนะ เช่น

• Creator Platforms ทำพวก Subscription-based content ได้สบายๆ

• Gaming Content ทำพวก Unlockable content ตามเงื่อนไข On-Chain หรือจะทำ Secret quests และ time-limited events ก็ได้นะ

• AI & Data Markets สาย AI ขาย AI models และ datasets แบบ encrypted

• NFT Utilities ทำ NFT ที่มีคอนเทนต์จริงซ่อนอยู่ :P

เอาละ ลองไปต่อยอดกันดูนะ ไว้เจอกันใหม่

ปิดท้ายด้วยเเหล่งข้อมูลที่สามารถศึกษาได้เพิ่ม

• Sui Documentation

• Walrus Website

• Seal Documentation

• Seal GitHub

• EP 1: https://onthemove.contributiondao.com/ep-1-walrus-and-seal

• EP 2: https://onthemove.contributiondao.com/ep-2-walrus-programmable-storage

• EP 3: https://onthemove.contributiondao.com/ep-3-walrus-seal-send-secret-message

สำหรับตอนนี้ เรามาเขียนในส่วนของ Move Smart Contract กันนะ เพราะจากตอนที่แล้ว เราได้เขียน Seal ไว้เรียบร้อยแล้ว แต่ขาดในส่วนของ Smart Contract ในการจัดการเรื่องสิทธิในการเข้าถึง

โดย Seal จะปกป้องข้อมูลของเราจากผู้ใช้งานทั่วไป ด้วยระบบป้องกันดังต่อไปนี้

1. Client-Side Encryption: หลักการสำคัญของ Seal คือข้อมูลที่ละเอียดอ่อนจะถูกเข้ารหัส บนอุปกรณ์ของเราเอง ก่อนที่จะถูกส่งออกไปที่อื่นๆ โดยไม่มีเซิร์ฟเวอร์ แม้แต่ key servers ของ Seal เอง ก็จะไม่เห็นข้อมูล plaintext ของเราเลย

2. Threshold Encryption: เพื่อหลีกเลี่ยงความเสี่ยงจากการจัดการกุญแจแบบรวมศูนย์ Seal ได้ใช้ Threshold Encryption แทนที่จะมีกุญแจถอดรหัสเพียงอันเดียว ซึ่งกุญแจนั้นจะถูกแบ่งออกเป็นหลาย shares และกระจายไปยังเครือข่าย Decentralized Key Servers ที่เป็นอิสระต่อกัน หากต้องการสร้างกุญแจ ต้นฉบับขึ้นมาใหม่เพื่อถอดรหัส จะต้องมี key servers จำนวนหนึ่ง (เช่น 2 ใน 3) ทำงานร่วมกัน ซึ่งขั้นตอนนี่จะช่วยขจัด single point of failure ออกไปได้เลยนั้นเอง

3. On-Chain Access Control: นี่คือส่วนที่ล้ำสมัยที่สุดของสถาปัตยกรรม Seal! โดยตรรกะที่กำหนดว่าใครได้รับอนุญาตให้ถอดรหัสข้อมูลนั้นไม่ได้ถูก hard-coded อยู่ใน off-chain server แต่ถูกกำหนดไว้ใน Move Smart Contract นั้นเอง ซึ่งข้อมูลนี้จะถูกเปิดเผยต่อสาธารณะและตรวจสอบได้บน Sui Network! สิ่งนี้ทำให้เราสามารถสร้าง Access Policies ที่ละเอียดและสามารถ Programmable ได้ เช่น เช่น token-gating (อนุญาตเฉพาะผู้ถือ NFT บางประเภท), time-locks หรือ role-based permissions ที่ซับซ้อน

มาเริ่มกันเลย ต่อไปนี้เราจะลงในส่วนของ Technical แล้วนะ ในคือการเขียน Move Smart Contract หากใครยังไม่ได้เตรียมเครื่องไม้ เครื่องมือ ให้ย้อนกลับไปดูบทความด้านล่างนี้นะ

• https://onthemove.contributiondao.com/walrus-simple-usage

โดย Move Smart Contract ที่เราจะเขียนกันต่อไปนี้ จะมีหัวใจหลักของ Seal อยู่ที่ฟังก์ชั่น seal_approve ซึ่ง

จุดเชื่อมต่อที่สำคัญสำหรับนักพัฒนาคือ entry function ที่มีชื่อเฉพาะใน Move module ของเรา: seal_approve ฟังก์ชันนี้ทำหน้าที่เป็น On-Chain Gatekeeper สำหรับคำขอถอดรหัสทั้งหลาย!

ซึ่งเราจะทดสอบเขียน secret_message.move contract ของเรา กันมาเริ่มกันทีละ step กันเลยครับ

1. สร้างโปรเจ็คขึ้นมาใหม่

    sui move new secret_message
   

2. แก้ไข source code ในไฟล์ secret_message.move

    module secret_message::message {
        // Import เฉพาะตัวที่ต้องใช้จริง (module ส่วนใหญ่ Sui prelude มีให้แล้ว)
        use sui::object::UID;
        use sui::tx_context::TxContext;
        use std::string::String;
   
        /// Error ที่จะเกิดขึ้นเมื่อผู้ใช้ที่ไม่ได้รับอนุญาตพยายามเข้าถึงข้อความลับ
        const ENoAccess: u64 = 0;
   
        /// โครงสร้างของ SecretMessage ซึ่งเป็น Policy Object
        ///
        /// - Policy นี้ไม่เก็บข้อความจริงบน-chain
        /// - ตัวข้อความจะถูกเข้ารหัสและเก็บบน Walrus (off-chain)
        /// - On-chain จะเก็บเฉพาะ metadata และสิทธิ์การเข้าถึง
        ///
        /// ฟิลด์:
        /// - `sender`: address ของผู้สร้าง (ผู้ส่งข้อความลับ)
        /// - `recipient`: address ของผู้รับที่ได้รับอนุญาต
        /// - `walrus_blob_id`: ID ของ blob ที่เก็บ encrypted content บน Walrus
        public struct SecretMessage has key, store {
            id: UID,
            sender: address,
            recipient: address,
            walrus_blob_id: String,
        }
   
        /// ฟังก์ชันสำหรับสร้าง SecretMessage ใหม่
        ///
        /// ขั้นตอน:
        /// 1. ผู้ส่งเรียกฟังก์ชันนี้พร้อมระบุผู้รับ และ Walrus blob ID
        /// 2. ระบบสร้าง Policy Object ใหม่ (SecretMessage)
        /// 3. ส่ง Policy Object ไปยัง wallet ของผู้รับ
        ///
        /// หมายเหตุ:
        /// - ผู้รับเป็นคนเดียวที่ถือ object นี้ → สอดคล้องกับ access control
        public fun create_secret_message(
            recipient: address,
            walrus_blob_id: String,
            ctx: &mut TxContext
        ) {
            let message_policy = SecretMessage {
                id: object::new(ctx),
                sender: ctx.sender(),
                recipient,
                walrus_blob_id,
            };
   
            // โอน Policy Object ไปที่ผู้รับ → เพื่อให้เป็นเจ้าของสิทธิ์การถอดรหัส
            transfer::public_transfer(message_policy, recipient);
        }
   
        /// ฟังก์ชันหลักสำหรับทำงานร่วมกับ Seal (Decentralized Access Control Service)
        ///
        /// Concept:
        /// - Seal Key Servers จะจำลองการเรียกฟังก์ชันนี้ในขั้นตอน Verify Access
        /// - ถ้าฟังก์ชันนี้ "ผ่านเงื่อนไข" → Key Servers จะอนุญาตให้ user รับ key share
        /// - ถ้าไม่ผ่าน → จะไม่ปลดล็อก key share
        ///
        /// มันคือ "On-chain Access Control Policy"
        /// ใช้เงื่อนไขบน-chain ตรวจสอบว่าผู้ที่ขอถอดรหัสเป็น "recipient" ตัวจริงหรือไม่
        ///
        /// พารามิเตอร์:
        /// - `_`: ค่า vector<u8> ที่ Seal ต้องส่งมา (แต่ในที่นี้ไม่ใช้งาน)
        /// - `policy`: reference ไปยัง SecretMessage ของข้อความนั้น
        /// - `ctx`: ใช้ตรวจสอบว่า user ที่เรียกคือใคร
        public fun seal_approve(
            _: vector<u8>,
            policy: &SecretMessage,
            ctx: &TxContext
        ) {
            // อนุญาตเฉพาะผู้รับที่กำหนดไว้ใน policy เท่านั้น
            // ถ้า ctx.sender() ไม่ใช่ recipient → throw error
            assert!(ctx.sender() == policy.recipient, ENoAccess);
        }
    }
   

3. Deploy Move Smart Contract

   เราเริ่มจากการทดสอบ Build กันก่อนนะ ว่าติดปัญหาอะไรไหม อย่าลืมสลับไปใช้งาน Testnet นะครับ

    sui move build
   

   หากทุกอย่างเรียบร้อยก็เตรียมไปสู่ขั้นตอนการ Deploy ไปยัง SUI Testnet ได้เลย

    sui client publish --gas-budget 100000000
   

   เราจะได้หน้าตาประมาณนี้นะ

    ╭──────────────────────────────────────────────────────────────────────────────────────────────────╮
    │ Object Changes                                                                                   │
    ├──────────────────────────────────────────────────────────────────────────────────────────────────┤
    │ Created Objects:                                                                                 │
    │  ┌──                                                                                             │
    │  │ ObjectID: 0x3e841ab9ffb9dd26ef128631030e2fed4ce19d40e2be1521e760fd4c2dbfe18b                  │
    │  │ Sender: 0xc1a83e6ed8a891cc891208e4288290013ed3f1ebf1576eede3f2c7bc4c56e75c                    │
    │  │ Owner: Account Address ( 0xc1a83e6ed8a891cc891208e4288290013ed3f1ebf1576eede3f2c7bc4c56e75c ) │
    │  │ ObjectType: 0x2::package::UpgradeCap                                                          │
    │  │ Version: 349180711                                                                            │
    │  │ Digest: 4zJPCm9Xab7VkY2bfsH347FwFcPQo74rYN75Qz9dddzk                                          │
    │  └──                                                                                             │
    │ Mutated Objects:                                                                                 │
    │  ┌──                                                                                             │
    │  │ ObjectID: 0x0e77d7f999871c0a82f098699b0128715ade05416531deee0902f8a52bee4f9e                  │
    │  │ Sender: 0xc1a83e6ed8a891cc891208e4288290013ed3f1ebf1576eede3f2c7bc4c56e75c                    │
    │  │ Owner: Account Address ( 0xc1a83e6ed8a891cc891208e4288290013ed3f1ebf1576eede3f2c7bc4c56e75c ) │
    │  │ ObjectType: 0x2::coin::Coin<0x2::sui::SUI>                                                    │
    │  │ Version: 349180711                                                                            │
    │  │ Digest: G8GFetS11dJDiDPYJvnvVaJ3kZnvy3ec31CPJfVSZTnu                                          │
    │  └──                                                                                             │
    │ Published Objects:                                                                               │
    │  ┌──                                                                                             │
    │  │ PackageID: 0x04c285b7f84f9db5cbef6e3c0a48a086463fa618a45ddc14154179fbde533c34                 │
    │  │ Version: 1                                                                                    │
    │  │ Digest: AFZExHfnygn3MqDCkfK1Hh9Ht5aaSxuGHu3bovjvbMhG                                          │
    │  │ Modules: message                                                                              │
    │  └──                                                                                             │
    ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
    ╭───────────────────────────────────────────────────────────────────────────────────────────────────╮
    │ Balance Changes                                                                                   │
    ├───────────────────────────────────────────────────────────────────────────────────────────────────┤
    │  ┌──                                                                                              │
    │  │ Owner: Account Address ( 0xc1a83e6ed8a891cc891208e4288290013ed3f1ebf1576eede3f2c7bc4c56e75c )  │
    │  │ CoinType: 0x2::sui::SUI                                                                        │
    │  │ Amount: -8488280                                                                               │
    │  └──                                                                                              │
    ╰───────────────────────────────────────────────────────────────────────────────────────────────────╯
   

   ซึ่งสิ่งที่สำคัญคือ หลังจากที่เราได้ทำการ Deploy สำเร็จเเล้ว เราจะเห็น PackageID เป็น String ยาวๆ 0x... ให้เก็บ PackageID นั้นเอาไว้ เพราะเราจะต้องนำไปใช้ใน EP 3 ซึ่งยังจำกันได้ใช่ไหมว่า ค่าของ PackageID เรายังเป็นค่าที่ยังไม่ได้กำหนด ซึ่งทำให้ตัวอย่างของเราทำงานไม่ได้

   ซึ่งนี้ที่ PackageID ของเราคือ

    0x04c285b7f84f9db5cbef6e3c0a48a086463fa618a45ddc14154179fbde533c34
   

เรียบร้อยครับ ตอนนี้เราได้ PackageID ที่พร้อมจะนำไปใช้งานแล้ว ก่อนที่เราจะไปกันต่อ ขอธิบายเพิ่มเกี่ยวกับการทำงานของ seal_approve กันสักนิดนึง โดยหลักการจะมีประมาณนี้นะ

1. ผู้ใช้ต้องการถอดรหัส: Client application ของผู้ใช้ (เช่น เว็บไซต์ Only… ของเรา) ต้องการเข้าถึงคอนเทนต์ลับ

2. จำลองธุรกรรม: แทนที่จะส่ง transaction ไปรันบน Sui Network ทันที Client application จะสร้าง Sui transaction ที่เรียกฟังก์ชัน seal_approve นี้ (แต่ยังไม่ execute จริง!) แล้วส่ง serialized bytes ของ transaction นี้ไปให้ Seal Key Servers

3. Key Servers ตรวจสอบ: Key Servers หลายตัว จะทำการจำลองการรัน transaction นี้บน Sui แยกกัน

4. ปล่อย Key Shares (ถ้าผ่าน): ถ้าการจำลองสำเร็จ (คือ assert! ในฟังก์ชัน seal_approve เป็นจริง เช่น ctx.sender() คือ recipient ที่ระบุไว้) Key Server นั้นๆ ก็จะปล่อย key share ของตนออกมา

5. ปฏิเสธ (ถ้าไม่ผ่าน): แต่ถ้าการจำลองล้มเหลว (เช่น assert! เป็นเท็จ เพราะผู้ที่พยายามถอดรหัสไม่ใช่ recipient ที่ถูกต้อง) Key Server ก็จะปฏิเสธที่จะให้ key share

Sui ถูกใช้เป็น decentralized และ verifiable access-control oracle ได้อย่างชาญฉลาด! ข้อมูลที่เข้ารหัสสามารถเก็บไว้ที่ไหนก็ได้ — ไม่ว่าจะเป็น Walrus หรือเครือข่ายอื่น—เพราะฟังก์ชัน seal_approve ทำหน้าที่เป็น public, immutable, composable API สำหรับตรวจสอบสิทธิ์การเข้าถึงบน chain โดยตรง

พูดง่ายๆ คือ: ตัว blockchain กลายเป็น access-control engine ที่ทุกระบบเชื่อถือร่วมกันได้ เป็นดีไซน์ที่ทั้งเรียบง่ายและทรงพลังมากๆ เลยใช่ไหมล่ะ?

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

• https://onthemove.contributiondao.com/ep-1-walrus-and-seal

• https://onthemove.contributiondao.com/ep-2-walrus-programmable-storage

ไปทบทวนกันก่อนนะ สำหรับ EP นี้เราจะไปต่อกันที่การนำ Seal มาใช้ในการเข้าหรัสข้อมูลของเรานั้นเอง ซึ่งอย่างที่รู้กันว่า Blockchain ทุกคนสามารถเข้าถึงและตรวจสอบได้ แต่กลายเป็นปัญหาใหญ่สำหรับแอปพลิเคชันที่ต้องจัดการข้อมูลที่ละเอียดอ่อน เช่น ข้อความส่วนตัว, ข้อมูลที่เป็นกรรมสิทธิ์, หรือ คอนเทนต์ลับ ของเรา! ถ้าทุกคนเห็นได้หมด ก็ไม่ Exclusive อะดิ

นี่แหละคือที่มาของ Seal ที่เราสามารถสร้างความเป็นส่วนตัว (Privacy) และการควบคุมการเข้าถึง (Access Control) บน Sui network ได้

Seal คืออะไร?

Seal คือ Decentralized Secrets Management (DSM) ที่ช่วยให้นักพัฒนาจัดการข้อมูลลับ (Secrets) ที่ถูกเข้ารหัสไว้ได้อย่างปลอดภัย โดยใช้ Key Servers บนเครือข่าย Sui Network เพื่อกำหนดและบังคับใช้นโยบายการเข้าถึงข้อมูลลับแบบ Trust-Minimized

Seal ออกแบบมาเพื่อให้:

• ได้ Privacy แบบเดิม: เหมือนระบบเข้ารหัสข้อมูลทั่วไป

• ได้ Security แบบ Web3: ไม่มี single point of failure, ตรวจสอบได้, trust-minimized

• สร้าง dApps ที่ยังคงความ Private ได้ บนระบบ Decentralized เต็มรูปแบบ

พูดง่าย ๆ คือ Seal = ความลับ + Decentralized + ควบคุมสิทธิ์ด้วย Smart Contract

ซึ่งด้วยความสามารถของ Seal นักพัฒนาก็จะสามารถสร้าง dApps ที่ยังมีความเป็นส่วนตัวของผู้ใช้ได้โดยไม่ต้องทิ้งความเป็น Decentralized ไปนั้นเอง

ทำไมต้องใช้ Seal + Walrus คู่กัน?

พอละไปลุยกันเลยดีกว่า ไปเขียนโค๊ดกันเถอะ

เริ่มต้นใช้งาน Seal SDK

1. ติดตั้ง Seal SDK

   ต้องติดตั้ง Seal SDK ก่อนเริ่มใช้งานนะ

    npm install @mysten/seal
   

2. จากนั้นแก้ไขไฟล์ index.ts ของเราเพื่อเพิ่ม SealClient และตั้งค่า Public Key Servers สำหรับ Testnet นอกจากนี้เราจะสร้าง keypair เพิ่มอีกหนึ่งคู่สำหรับจำลองเป็น "ผู้รับ" คอนเทนต์ของเรา:

    // index.ts (เพิ่มโค้ดส่วนนี้)
    import { SealClient, SessionKey, EncryptedObject } from "@mysten/seal";
    import { Transaction } from "@mysten/sui/transactions";
    import { fromHex } from "@mysten/sui/utils";
   
    // Public key server object IDs สำหรับ Sui Testnet (นี่คือ Key Servers ที่จะช่วยจัดการกุญแจ)
    const KEY_SERVER_LIST_TESTNET = [
      "0x73d05d62c18d9374e3ea529e8e0ed6161da1a141a94d3f76ae3fe4e99356db75",
      "0xf5d14a81a982144ae441cd7d64b09027f116a468bd36e7eca494f750591623c8",
    ];
   
    // NOTE: แทนที่ด้วย Package ID ของ Smart Contract Move ที่เราจะ deploy ในอนาคต
    // ตอนนี้อาจจะยังไม่มี ก็ใช้ '0x...' ไปก่อนได้
    const PACKAGE_ID = "0x...";
   
    // ... โค้ดส่วน main() 
    async function main() {
    // สร้าง SealClient ของเรา
      const sealClient = new SealClient({
        suiClient: suiClient,
        serverConfigs: KEY_SERVER_LIST_TESTNET.map((id) => ({
          objectId: id,
          weight: 1,
        })),
        verifyKeyServers: true, // ตรวจสอบความถูกต้องของ Key Servers
      });
    }
   

3. สร้าง ฟังก์ชัน ในการเข้ารหัสข้อมูล

    async function sendSecretMessage(params: { secret: string; recipient: string; sender: Ed25519Keypair; suiClient: SuiClient; walrusClient: any; sealClient: SealClient }): Promise<string> {
        const { secret, recipient, sender, suiClient, walrusClient, sealClient } = params;
   
        console.log(`\nกำลังเข้ารหัสคอนเทนต์ลับสำหรับ ${recipient}...`);
        const placeholderPolicyId = "0x" + "0".repeat(64);
   
        const { encryptedObject } = await sealClient.encrypt({
            threshold: 2,
            packageId: PACKAGE_ID,
            id: placeholderPolicyId,
            data: new TextEncoder().encode(secret),
        });
   
        console.log("กำลังอัปโหลดข้อมูลที่เข้ารหัสไป Walrus...");
        const walrusFile = WalrusFile.from({ contents: encryptedObject });
        const writeResult = await walrusClient.walrus.writeFiles({
            files: [walrusFile],
            signer: sender,
            epochs: 1,
            deletable: false,
        });
   
        const blobId = writeResult[0]?.blobId;
        if (!blobId) throw new Error("Failed to upload encrypted blob to Walrus");
   
        console.log(`Blob ที่เข้ารหัสถูกจัดเก็บแล้ว. Blob ID: ${blobId}`);
   
        console.log("กำลังสร้าง SecretMessage Policy Object บนเชน...");
        const tx = new Transaction();
        tx.moveCall({
            target: `${PACKAGE_ID}::message::create_secret_message`,
            arguments: [tx.pure.address(recipient), tx.pure.string(blobId)],
        });
        const result = await suiClient.signAndExecuteTransaction({
            signer: sender,
            transaction: tx,
            options: { showObjectChanges: true },
        });
        const created = result.objectChanges?.find((c) => c.type === "created" && "objectId" in c && c.objectType.includes("secret_message::message::SecretMessage"));
        if (!created || !("objectId" in created)) {
            throw new Error("SecretMessage object was not created");
        }
        return created.objectId;
    }
   

4. เมื่อต้องการเรียกใช้งานเราสามารถเพิ่ม ฟังก์ชัน ในการใช้งานดังนี้

    async function main() {
     ...
     ...
     ...
     const secret = "My super secret message for you ❤️";
     const policyObjectId = await sendSecretMessage({
        secret,
        recipient,
        sender: keypair,
        suiClient,
        walrusClient,
        sealClient,
      });
      console.log(`✅ SecretMessage policy object id: ${policyObjectId}`);
    }
   

   สำหรับ recipient นั้นคือ address ของผู้รับนั้นเอง เราสามารถกำหนดได้เลยนะว่าจะส่งไปยัง address ไหน

เรียบร้อบ เราได้ฟังก์ชั่น ในการส่งข้อความเเบบเข้ารหัสไปยังปลายทางแล้วครับ แต่บอกไว้ก่อนเลยตัวอย่างโค๊ดชุดนี้ยังทำงานไม่ได้นะ :P เเน่ละสิ เพราะยังไม่ได้เขียน Move Smart Contract เลยนิ ทำให้เรายังไม่มี Package ID นั้นเอง ถ้านำไปทดสอบและ เรียกใช้งาน มันจะเเสดงข้อความ Error ทันที รอติดตาม EP นะ เราจะไปเขียน Move Smart Contract กัน

ส่วนใครยังไม่ได้ตามบทความที่แล้ว เปิดวาปให้ครับ

• https://onthemove.contributiondao.com/ep-1-walrus-and-seal

ปัญหาเดิมๆ ของบล็อกเชนทั่วไป:
บนแพลตฟอร์ม Blockchain อย่าง Ethereum ที่ใช้ account-based model เวลาเราเก็บข้อมูล (แม้จะใช้ IPFS หรือ Arweave) Smart Contract ของเราจะได้แค่ ตัวชี้ ง่ายๆ (เช่น IPFS CID) ซึ่งก็คือ String ธรรมดาๆ เท่านั้นเอง ตัวบล็อกเชนเองไม่รู้หรอกว่า String นั้นหมายถึงอะไร หรือสถานะของข้อมูลที่เก็บอยู่เป็นยังไง มันจึง ไร้ความสามารถ

Walrus เลยพลิกเกมด้วย Object-Centric Model ของ Sui

Walrus สร้างความแตกต่างโดยการใช้ Structure Object-Centric Model ของ Sui โดยเมื่อเราจัดเก็บไฟล์บน Walrus เราจะไม่ได้แค่ได้ off-chain data fragments เท่านั้น แต่เรายังได้ Sui Object ที่มีสถานะอยู่บนเชนเลย โดย Sui Object นี้จะเก็บ metadata และ proof of availability ของ blob นั้นๆเอาไว้ด้วยนั้นเอง

ลองดูตัวอย่างโครงสร้างของ Walrus Object ในภาษา Move กัน

struct WalrusBlob has key, store {
    id: UID, // ID เฉพาะของ Object นี้บน Sui
    blob_id: String, // Unique Walrus ID สำหรับข้อมูล off-chain ของเรา
    owner: address,  // ใครเป็นเจ้าของ Object นี้
    storage_epochs: u64, // ระยะเวลาจัดเก็บที่เหลืออยู่ (เป็นจำนวน Epochs)
    // ... อาจมี metadata อื่นๆ เช่น ขนาดไฟล์, ประเภทไฟล์
}

เพราะว่า storage receipt ตัวนี้เป็น Sui object ดั้งเดิม มันจึงสามารถ เป็นเจ้าของ, โอนย้าย, และจัดการได้โดย Move Smart Contracts เหมือนกับสินทรัพย์ดิจิทัลอื่นๆ! สิ่งนี้เปลี่ยนวิธีการจัดเก็บข้อมูลอย่างสิ้นเชิง! เราเคยเกริ่นเเละยกตัวอย่างไปแล้วถึงคุณสมบัติของ Move Object ตามไปอ่านกันได้ที่นี้นะ

• https://onthemove.contributiondao.com/ep-1-game-item-with-sui-object

• https://onthemove.contributiondao.com/ep-2-game-item-with-sui-object

ทำให้นักพัฒนาจะสามารถสร้างแอปพลิเคชันที่

• เป็นเจ้าของและโอนย้ายได้ (Own and Transfer it): สร้าง Data Marketplaces ที่สามารถซื้อขายสิทธิ์การเข้าถึงชุดข้อมูลขนาดใหญ่ได้ง่ายๆ แค่โอนย้าย WalrusBlob object ไปยังผู้ซื้อเมื่อชำระเงินสำเร็จ

• ใช้ใน DeFi (Use it in DeFi): นำ Sui object ที่แสดงถึงชุดข้อมูลอันมีค่าไปใช้เป็นหลักประกัน (Collateral) ใน Decentralized Lending Protocol

• ทำให้เป็นอัตโนมัติ (Automate it): เขียน Smart Contract เพื่อขยายระยะเวลาจัดเก็บ blob โดยอัตโนมัติ ด้วยการจ่าย WAL tokens เพิ่ม หรือแม้แต่สั่งลบเพื่อเรียกคืนค่าจัดเก็บได้ตามเงื่อนไขก็ได้

Walrus เลยไม่ได้ทำหน้าแค่จัดเก็บไฟล์ แต่กำลังสร้าง on-chain, data-backed assets รูปแบบใหม่! และนี่คือตัวอย่างของ Programmable Storage ที่จะเปลี่ยนการจัดเก็บข้อมูลจากแบบ Passive ไปสู่ สินทรัพย์ ที่สร้างรายได้แบบ Dynamic ได้เลยนะ!

ขอตัดจบกันแค่นี้ก่อน…​ (งานเยอะจัดช่วงนี้) เอาแค่หลักการไปก่อนนะ สำหรับใครอยากเห็นตัวอย่างติดตามกันต่อได้ใน EP.3 4 5 6 :)

ในวันนี้เราจะไปให้ลึกขึ้นกว่าเดิม นั้นคือ….เราจะมาสอนทำ OnlyFans บน Web3 ด้วย Walrus + Seal หวังว่าคอนเทนต์จะไม่ติดเหลืองนะ :P (หลาย EP หน่อยนะ)

ลองแอบไปส่องกันได้ที่ https://only-fins.wal.app/

พร้อมแล้วไปลุยกันเลย

อย่างที่ทุกท่านทราบกันดีว่า… การเก็บข้อมูลขนาดใหญ่บน Blockchain นั้นทั้งแพงและช้าสุดๆ ด้วยเหตุนี้เอง Sui จึงได้พัฒนา Walrus ขึ้นมาเพื่อแก้ปัญหานี้โดย Walrus เป็น Decentralized Storage ที่เป็นมากกว่าแค่ ที่เก็บข้อมูล เพราะหัวใจสำคัญคือ ข้อมูลที่เก็บไว้สามารถนำไปใช้ใน Smart Contracts ได้โดยตรง!

แต่ปัญหาที่ตามมาคือ… ถึงแม้ข้อมูลจะอยู่บน Storage แบบกระจายศูนย์แล้ว แต่บน Blockchain ทุกคนสามารถเข้าถึงข้อมูลได้ แล้วเราจะสร้าง Content แบบ Exclusive ที่ให้สิทธิ์เฉพาะคนที่จ่ายเงินเข้ามาดูเท่านั้นได้ยังไง?

คำตอบก็คือ Seal 🔒 ครับ! ส่วน Seal คืออะไรนั้นไว้เรามาพูดกันในตอนถัดไปนะ

ในซีรีส์นี้ เราจะมาลงมือทำไปพร้อมๆ กัน ตั้งแต่การอัปโหลดไฟล์ไปที่ Walrus ไปจนถึงการใช้ Seal สร้างระบบ Subscription แบบ On-chain กันเลย!

ก่อนจะไปถึงขั้นตอนการสร้างระบบ Subscription สุดปัง เรามาเริ่มจากการทดลองอัปโหลดไฟล์ ลับ ของเราไปที่ Walrus Testnet กันก่อนดีกว่า

เริ่มจากการเตรียมเครื่องมือให้พร้อม

1. ติดตั้ง Rust: เนื่องจาก Sui Binaries ถูกเขียนด้วย Rust เป็นหลัก ถ้ายังไม่มี ไปที่ rust-lang.org เเล้วทำตามขั้นนตอนการติดตั้ง rustup ได้เลย

2. ติดตั้ง Sui CLI: เมื่อ Rust พร้อมแล้ว ก็ติดตั้ง Sui Command Line Interface (CLI) จาก GitHub ของ Mysten Labs ได้เลย เปิด Terminal หรือ Command Prompt แล้วรันคำสั่งนี้:

    cargo install --locked --git https://github.com/MystenLabs/sui.git --branch testnet sui
   

   ขั้นตอนนี้อาจใช้เวลาสักพักนะ เพราะมันจะดาวน์โหลดและคอมไพล์โค้ด

   • ตรวจสอบการติดตั้ง: พิมพ์ sui --version ถ้าเห็นเวอร์ชัน Sui CLI แสดงว่าเรียบร้อย!

3. ตั้งค่า Sui Client และ Wallet

   • รัน sui client แล้วตอบ y เพื่อเชื่อมต่อกับ Sui Fullnode Server เลือก Testnet (หรือถ้าเคย setup แล้วให้รัน sui client switch --env testnet เพื่อเปลี่ยนไปใช้ testnet) ระบบจะสร้าง wallet address พร้อม recovery phrase อันนี้สำคัญมาก! เก็บรักษา Recovery Phrase ของคุณไว้ให้ดีๆ นะ ห้ามทำหายเด็ดขาด!

   • Export Private Key: สำหรับโค้ดของเรา เราจะใช้ private key เพื่อความสะดวกในการรันสคริปต์ ให้ทำตามนี้:

       # ก่อนอื่น ดู address ที่ใช้งานอยู่ของคุณ
       sui client active-address
     
       # จากนั้น export private key ออกมา
       sui keytool export --key-identity <your-address>
     

     เก็บ Private key ไว้นะเราจะต้องเอาไปใส่ใน env ในขั้นตอนถัดไป

   • หา Testnet SUI token เพื่อจ่ายค่า gas เราจะต้องมีเหรียญ SUI สำหรับค่า Gas ในการทำธุรกรรม ไปที่ Discord ของ Sui (ค้นหา Sui Discord) แล้วเข้าไปที่ช่อง #testnet-faucet พิมพ์ !faucet <YOUR_SUI_ADDRESS> (แทนที่ <YOUR_SUI_ADDRESS> ด้วยที่อยู่กระเป๋านั้นเอง)

   • ตรวจสอบยอดคงเหลือ: รัน sui client gas เพื่อดูว่าได้ SUI token เข้ากระเป๋าเราแล้วรึยัง

4. ติดตั้ง Node.js และ TypeScript: ถ้ายังไม่มี Node.js และ npm ก็ติดตั้งให้เรียบร้อย (แนะนำเวอร์ชันล่าสุด) จากนั้นก็สร้างโปรเจกต์ TypeScript:

   ```bash

   1. Create and enter directory

   mkdir walrus-onlyfans && cd walrus-onlyfans

   2. Initialize package.json with ES module support

   npm init -y && npm pkg set type=module

   3. Install all dependencies in one command

   npm install @mysten/sui @mysten/walrus dotenv npm install --save-dev typescript @types/node tsx

4. Initialize TypeScript config

npx tsc --init

5. ติดตั้ง VS Code (แนะนำ): ดาวน์โหลด [Visual Studio Code](https://code.visualstudio.com/) แล้วติดตั้งส่วนขยาย **Move Analyzer** เพื่อความสะดวกในการเขียนโค้ด Move ([https://docs.sui.io/references/ide/move](https://docs.sui.io/references/ide/move))


เรียบร้อยถึงขั้นตอนนี้เราได้เตรียมเครื่องมือทุกอย่างเสร็จสิ้นเเล้ว พร้อมที่จะเริ่มขั้นตอนการเขียนโค๊ดละ

---

**พร้อมแล้ว มาเขียนโค้ดกัน!**

ก่อนอื่นสร้างไฟล์ `.env` ก่อนเพื่อเก็บข้อมูลอาทิเช่น Private key ร่วมถึง Network ที่จะใช้ทดสอบ

```plaintext
SUI_PRIVATE_KEY=suiprivkey1qqen0....
NETWORK=testnet

สร้างไฟล์ใหม่ชื่อ index.ts แล้วใส่โค้ดนี้ลงไปเพื่อตั้งค่า SuiClient และ WalrusClient และเตรียม keypair สำหรับลงชื่อธุรกรรม

import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
import { walrus, WalrusFile } from "@mysten/walrus";
import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
import { writeFileSync } from "fs";
import "dotenv/config";

const PRIVATE_KEY = process.env.SUI_PRIVATE_KEY;
const NETWORK = process.env.NETWORK || "testnet";
const WALRUS_UPLOAD_RELAY = "https://upload-relay.testnet.walrus.space";

async function main() {
    // 1) Init Sui + Walrus (upload ผ่าน relay เพื่อความเสถียร)
    const suiClient = new SuiClient({ url: getFullnodeUrl("testnet") });
    const walrusClient = suiClient.$extend(
        walrus({
            network: NETWORK,
            ไ: {
                host: WALRUS_UPLOAD_RELAY,
                sendTip: { max: 1_000 }, // หน่วย MIST
            },
        })
    );

    // 2) signer
    const { secretKey } = decodeSuiPrivateKey(PRIVATE_KEY);
    const keypair = Ed25519Keypair.fromSecretKey(secretKey);
    console.log(`กำลังใช้ Address: ${keypair.getPublicKey().toSuiAddress()}`);

    // 3) เตรียมเนื้อหา  
    const mySecretContent = "Test content Exclusive for onlyfans!";
    const file = WalrusFile.from({
        contents: new TextEncoder().encode(mySecretContent),
        identifier: "",
    });

    console.log("กำลังอัปโหลดไฟล์ไปที่ Walrus (ผ่าน relay)…");

    // 4) เขียนไฟล์ด้วย writeFiles (รองรับ relay/metadata/retry)
    const res = await walrusClient.walrus.writeFiles({
        files: [file],
        deletable: false,
        epochs: 1,
        signer: keypair,
    });
    const blobId = res[0].blobId;

    console.log(`อัปโหลดไฟล์สำเร็จ! Blob ID: ${blobId}`);

    // 5) รอให้ blob พร้อม แล้วอ่านข้อมูล
    console.log("\nกำลังอ่านไฟล์จาก Walrus...");
    const downloadedFile = await waitForBlobReady(walrusClient, blobId);

    // ✅ อ่านเป็นไบต์ แล้วถอดเป็น UTF-8 เอง (ไม่มี arrayBuffer())
    const u8 = await downloadedFile.bytes(); // Uint8Array
    const text = new TextDecoder("utf-8", { fatal: true }).decode(u8);

    // บันทึกเป็นไฟล์ข้อความ UTF-8 โดยตรง (กันอักขระเพี้ยน)
    const outputPath = "./downloaded-file.txt";
    writeFileSync(outputPath, text, { encoding: "utf8" });
    console.log(`✅ บันทึกไฟล์ไปที่: ${outputPath}`);
    console.log(`เนื้อหาไฟล์: "${text}"`);
}

async function waitForBlobReady(client: any, blobId: string, maxRetries = 10, delayMs = 5_000) {
    for (let i = 0; i < maxRetries; i++) {
        try {
            const [file] = await client.walrus.getFiles({ ids: [blobId] });
            if (file) return file;
        } catch {
            console.error("Wait more...");
        }
        console.log(`⏳ Blob ยังไม่พร้อม (${i + 1}/${maxRetries}) รออีก ${delayMs / 1000}s...`);
        await new Promise((r) => setTimeout(r, delayMs));
    }
}

main().catch((e) => {
    console.error("❌ Error:", e?.message || e);
    process.exit(1);
});

พร้อมแล้วมารันโค๊ดกัน

เปิด Terminal ในโฟลเดอร์ walrus-onlyfans แล้วรันคำสั่งนี้ (ก่อนรันอย่าลืมหา sui testnet กับ wal testnet -> https://stake-wal.wal.app/?network=testnet มาก่อนด้วยนะ)

npx tsx index.ts

เพียงเท่านี้เราก็สามารถอัพโหลดไฟล์ของเราไปเก็บไว้บน Walrus ได้เเล้วละ ซึ่งสามารดูผลลัพธ์ได้โดยการนำ Blob ID ไปค้นหาใน https://walruscan.com/testnet/blob/{Blob ID} นั้นเอง ตัวอย่างเช่น

https://walruscan.com/testnet/blob/-80nLPY2ym912Vg54qhABP63izGm1yFLMy7Fg_92-uU

หลังจากนั้นลองเช็คในไฟล์ downloaded-file.txt ดูนะจะได้ข้อมูลแบบนี้

Test content Exclusive for onlyfans!

อธิบายเพิ่มเติมในเเต่ละขั้นตอน

1. ส่วนนี้จะเป็นการสร้าง connection ซึ่งจริงๆแล้วเราสามารถยิงไปที่ Stroage node ของ Walrus ตรงๆเลยก็ได้ แต่มักจะเกิดปัญหา เราเลยส่งไปที่ Relay แทน แต่ก็เเลกมาด้วยค่า Gas ที่ต้องจ่ายเพิ่มเล็กน้อย

2. ส่วนนี้ตรงไปตรงมา นั้นคือทำการ Import Private Key ของเรานั้นเอง

3. เป็นการเตรียมเนื้อหาเพื่อเตรียมส่งไปที่ Walrus

4. ทำการอัพโหลดข้อมูล ซึ่งเราจะได้ BlogId กลับมาโดยสามารถนำ BlogId ดังกล่าวไปค้นหาผ่าน explorer ได้

5. ส่วนนี้จะเป็นส่วนของ function ที่เขียนมาเพื่อดึงข้อมูลจาก Storage node จะเห็นว่าที่ต้องวนลูปเพราะบางครั้งเราต้องรอให้ข้อมูลพร้อมก่อน ก่อนที่จะดึงข้อมูลกลับลงมานั้นเอง

ง่ายใช้ไหม ง่ายเเหละ :) นี้แค่ตัวอย่างเบื้องต้นนะ ลองเล่นกันดูก่อนนะ เดียวตอนหน้าเราจะมาดูกันว่า เเล้วถ้าเราจะเเก้ไขไฟล์ละ จะทำได้ยังไงบ้าง

มีดาบเเล้ว เทพทรูก็ต้องเข้าละ นั้นคือการตีบวกเพิ่มความสามารถให้กับไอเทมของเรานั้นเอง

ปัญหาที่ต้องแก้ก่อน

Sui จะไม่ให้เรา เพิ่ม field ใหม่ ในโครงสร้างของไอเทมเดิมได้ตรงๆ เพราะจะทำให้ object เก่าพัง (layout ไม่ตรง) แต่ไม่ต้องกลัว! เรามีเวทมนตร์ที่ชื่อว่า Dynamic Field 🔮 ที่จะช่วยให้เพิ่มข้อมูลใหม่โดยไม่แตะ object เดิมเลย

พร้อมแล้วไปลุยกันเลย…

เพิ่มพลังให้ Item ด้วย Extension

เราจะสร้าง object ลูกชื่อ ItemExtra เพิ่มไปในไฟล์เดิมของเรา items.move โดยใช้ dynamic_field ของ Sui Framework

use 0x2::dynamic_field as df;
    public struct ExtraKey has copy, drop, store {}

    public struct ItemExtra has key, store {
        id: UID,
        rarity: u8,
        durability: u64,
        parent: address,
    }

    public fun attach_extra_to_item(
        item: &mut Item,
        rarity: u8,
        durability: u64,
        ctx: &mut TxContext
    ) {
        let extra = ItemExtra {
            id: object::new(ctx),
            rarity,
            durability,
            parent: object::id_address(item),
        };
        df::add(&mut item.id, ExtraKey{}, extra);
    }

    public entry fun set_extra(item: &mut Item, new_rarity: u8, new_durability: u64) {
        let extra_ref = df::borrow_mut<ExtraKey, ItemExtra>(&mut item.id, ExtraKey{});
        extra_ref.rarity = new_rarity;
        extra_ref.durability = new_durability;
    }

ทำการอัพเกรด กันก่อนเลยเพื่อทำให้ตัว Object ของเรามีความสามารถเพิ่มเติมด้วยคำสั่งด้านล่างนี้

sui client upgrade --upgrade-capability $UPGRADE_CAP_ID --gas-budget 100000000

โดย UPGRADE_CAP_ID คือข้อมูล CAP_ID จากบทความที่แล้ว ที่เราได้ deploy ขึ้นไปกันนั้นเอง

เริ่มใช้งาน Extension Object

ทำการเพิ่มคุณสมบัติเพิ่มเติมให้กับ item ของเราก่อนโดยใช้คำสั่ง

sui client call --package $PACKAGE_ID --module items --function attach_extra_to_item --args $ITEM_ID 5 1000 --gas-budget 50000000

หลังจากนั้นในฐานะ gm ของระบบ เราก็สามารถทำการเเก้ไขคุณสมบัติของ item ได้เต็มที่เลยโดยใช้คำสั่ง

sui client call --package $PACKAGE_ID --module items --function set_extra --args $ITEM_ID 6 1200 --gas-budget 50000000

ซึ่งในที้นี้เราได้ทำการเเก้ไข rarity และ durability เป็น 6, 1200 ตามลำดับนั้นเอง

Diagram แสดงความสัมพันธ์

classDiagram
    class Inventory {
        +UID id
        +address owner
    }

    class Item {
        +UID id
        +String name
        +String class
        +u64 power
        +String image_url
    }

    class ItemExtra {
        +UID id
        +u8 rarity
        +u64 durability
        +address parent
    }

    Inventory "1" o-- "many" Item : holds
    Item "1" o-- "1" ItemExtra : dynamic_field

จากตรงนี้ เราก็ได้เรียนรู้วิธีการอัพเดดไอเทมเป็นที่เรียบร้อยแล้ว

✅ อัปเกรดแพ็กเกจโดยไม่ทำของเก่าพัง
✅ เพิ่ม field ใหม่ได้เรื่อย ๆ ผ่าน Extension
✅ ใช้ Dynamic Field ทำให้ Item ขยายได้ไม่จำกัด

ตอนนี้เราก็มีระบบไอเทมที่ อัปเกรดได้ จริง ๆ แล้ว จะเพิ่มระบบตีบวก คราฟต์ของ หรือแม้แต่ marketplace ก็เริ่มต่อยอดได้เลย!

By GANG | ContributionDAO

https://github.com/Contribution-DAO/sui-move-intro-course-thai/blob/main/unit-one/lessons/1_set_up_environment.md

พร้อมแล้วก็ไปกันเลย

เริ่มต้นกันก่อน — ทำไม Sui Object ถึงเหมาะกับเกม?

ในโลกของ Sui นั้นทุกๆ อย่างคือ Object ไม่ใช่แค่ token เหมือน ERC-721 แต่เป็นวัตถุที่ มีชีวิต จริง!

ERC-721 คือ Non-Fungible Token Standard หรือก็คือ NFT ที่เราน่าจะคุ้นๆหรือเคยมีติดมือกันมาบ้างแล้วนั้นเเหละ ซึ่งเป็นที่นิยมใช้งานกันใน EVM Smart Contract

มาลองจินตนาการดูว่า

• Item = ดาบในเกมของคุณ

• Inventory = กระเป๋าเก็บของของผู้เล่น

• Owner = ผู้เล่นคนนั้น (หรือแม้แต่ object อื่น)

ซึ่ง Sui Object มีหลังพิเศษเหล่านี้:

• มี UID เป็นรหัสไม่ซ้ำ เหมือน DNA ของวัตถุ

• มี Owner ที่เปลี่ยนมือได้ (หรือจะอยู่ใน object อื่นก็ยังได้!)

• มี Versioning เวลามีการเปลี่ยนแปลง

• มี Type Safety ด้วยภาษา Move ทำให้ bug ยากจะเกิด

ถึงตรงนี้เราจะไม่เกริ่นเรื่อง Sui Object แล้วนะ ใครไม่เข้าใจมีงอล เพราะเขียนไว้เเล้วที่นี้ https://onthemoveth.hashnode.dev/sui-object เพราะฉะนั้นพูดง่ายๆ คือ SUI Object คือ ไอเทมจริงๆ ที่คุณถืออยู่ในเกมส์

โครงสร้างของเกมส์ที่เราจะสร้างในตอนนี้

เราจะเริ่มจากพื้นฐานเเบบสุดๆกันก่อน

• 🗡️ Item — NFT ไอเทม 1 ชิ้น

• 🎒 Inventory — กระเป๋าเก็บของของผู้เล่น

จากนั้นผู้เล่นจะสามารถเสกของได้ (Mint) เเบบ GM นั้นเอง แล้วเราก็จะเอาของที่เสกขึ้นมาไปเก็บไว้ในกระเป๋า เหมือนตอนเล่นเกมส์จริงๆเลย

มาเขียนโค้ด Move กันเลย

สร้างโปรเจ็คกันก่อน ด้วยคำสั่งด้านล่างนี้ โครงสร้างของโปรเจ็คจะถูกสร้างขึ้นมาโดยอัตโนมัติ

sui move new my_item

แก้ไขไฟล์ Move.toml

ซึ่งตรงนี้เราจะไม่อธิบายแล้วนะ เพราะมีใน https://github.com/Contribution-DAO/sui-move-intro-course-thai/blob/main/unit-one/lessons/2_sui_project_structure.md แล้ว โดยเราจะเพิ่ม dependencies เข้าไป

[dependencies]
Sui = { override = true, git = "https://github.com/example/example.git", subdir = "crates/sui-framework/packages/sui-framework",rev = "testnet-v1.57.2" }

ไฟล์ sources/items.move

module my_items::items {
    use 0x2::object::{Self, UID};
    use 0x2::tx_context::{Self as tx, TxContext};
    use 0x2::transfer;
    use std::string::String;

    // Item: ดาบสุดแกร่งของเรา
    public struct Item has key, store {
        id: UID,
        name: String,
        class: String,
        power: u64,
        image_url: String,
    }

    // Inventory: กระเป๋าผู้เล่น
    public struct Inventory has key, store {
        id: UID,
        owner: address,
    }

    // Mint ไอเทมใหม่ให้ผู้เล่น
    public fun mint_to_sender(
        name: String,
        class: String,
        power: u64,
        image_url: String,
        ctx: &mut TxContext
    ) {
        let item = Item { id: object::new(ctx), name, class, power, image_url };
        transfer::public_transfer(item, tx::sender(ctx));
    }

    // สร้างกระเป๋าใหม่
    public fun create_inventory(ctx: &mut TxContext) {
        let inv = Inventory { id: object::new(ctx), owner: tx::sender(ctx) };
        transfer::public_transfer(inv, tx::sender(ctx));
    }

    // เอาไอเทมใส่กระเป๋า
    public fun put_into_inventory(inv: &Inventory, item: Item) {
        let inv_addr = inv.owner;
        transfer::transfer(item, inv_addr);
    }

    // เอาไอเทมออกจากกระเป๋า
    public fun take_out_from_inventory_to_sender(
        inv: &Inventory, item: Item, ctx: &mut TxContext
    ) {
        assert!(inv.owner == tx::sender(ctx), 1);
        transfer::public_transfer(item, tx::sender(ctx));
    }
}

Code พร้อม มาเริ่ม Deploy กัน

1. เปลี่ยน environment

sui client switch --env testnet

2. ขอเหรียญจาก faucet

sui client faucet

3. Build และ Publish

sui move build
sui client publish --gas-budget 100000000

หลังจาก publish สำเร็จเราก็ได้

• packageId (เหมือน ID ของโปรเจกต์)

• UpgradeCap (กุญแจไว้ใช้ตอนอัปเกรดใน EP2)

ลองเอา packageId ไปเปิดบน Testnet Explorer ดูนะ

https://suiscan.xyz/testnet/object/{packageId}

ทดลองใช้งานจริง

สร้างกระเป๋าเอาไว้เก็บ Item (Inventory)

sui client call \
  --package $PACKAGE_ID \
  --module items \
  --function create_inventory \
  --gas-budget 50000000

Mint ดาบในตำนาน

sui client call \
  --package $PACKAGE_ID \
  --module items \
  --function mint_to_sender \
  --args "Excalibur" "Weapon" 9001 "ipfs://bafy..." \
  --gas-budget 50000000

เก็บดาบใส่กระเป๋าให้เรียบร้อย

sui client call \
  --package $PACKAGE_ID \
  --module items \
  --function put_into_inventory \
  --args $INVENTORY_ID $ITEM_ID \
  --gas-budget 50000000

และนี้คือตัวอย่าง transaction สุดท้ายของเรา

https://suiscan.xyz/testnet/object/0xb020131b5c1004b42a8f0d6ccf9f9c23b0f711ff14199538874fc0219b9f37d7/tx-blocks

ดาบถูกจัดเก็บลงในกระเป๋าละ

Diagram แสดงความสัมพันธ์

classDiagram
    class Inventory {
        +UID id
        +address owner
    }

    class Item {
        +UID id
        +String name
        +String class
        +u64 power
        +String image_url
    }

 Inventory "1" o-- "many" Item : holds

ตอนนี้เราได้สร้างระบบไอเทมในเกมส์ครบแล้ว
✅ สร้างได้
✅ เก็บในกระเป๋าได้
✅ โอนไปมาได้

แต่ถ้าอยากตีบวกดาบให้เทพขึ้นล่ะ? หรือถ้าอยากเพิ่ม rarity, durability? จะทำยังไง… ลองไปปรับเพิ่มกันดูนะครับ ก่อนที่เราจะมาเฉลยใน EP.2 :) เจอกัน

By GANG | ContributionDAO

AI กำลังเปลี่ยนโลกอย่างรวดเร็ว เราคงเห็น AI Agents ที่สามารถทำงานแทนมนุษย์ได้ เช่น ตอบแชทอัตโนมัติ วิเคราะห์ข้อมูล หรือแม้แต่ตัดสินใจลงทุน แต่ปัญหาคือ Agent เหล่านี้ส่วนใหญ่ยังทำงานบน Web2 infrastructure นั้นหมายถึงรันอยู่บน เซิฟเวิร์ค ของบริษัท ขาดความโปร่งใส และไม่สามารถตรวจสอบได้ว่าเบื้องหลังเกิดอะไรขึ้น นั้นเเหละถึงเวลาของ Blockchain แล้ว

Talus จึงเกิดขึ้นมาเพื่อแก้โจทย์นี้: เปลี่ยน AI Agents ให้ทำงานได้บนระบบของ Blockchain ซึ่งจะทำงานอัตโนมัติ, โปร่งใส และมีเศรษฐกิจของตัวเอง (marketplace + tokenomics)

ทำไมต้อง Talus?

อย่างที่รู้กันแล้วว่า Blockchain ปัจจุบันมี Smart contracts ที่ทำงานตาม logic ที่ถูกเขียนไว้ล่วงหน้า ซึ่งทุกอย่างจะถูกกำหนดไว้หมดแล้ว ถ้าหากสถานการณ์ที่ต้องมีการปรับเปลี่ยนการตัดสินใจตามสถานการณ์ละ? นั้นคือสิ่งที่ Talus มี

• สมอง (Reasoning): ความสามารถในการตัดสินใจเชิงซับซ้อน ปรับตัวตามสถานการณ์จริง

• มือ (Action): ความสามารถในการทำงานอัตโนมัติ 24/7 โดยไม่ต้องให้ใครมากดสั่งการ

ปัญหาที่ Talus อยากแก้

• AI Agents ทั่วไปมักรันในระบบแบบ Centralized — ขึ้นกับ Server, API, และโครงสร้างพื้นฐานที่ถูกควบคุมโดยหน่วยงานกลาง

• ถ้า AI Agents ทำธุรกรรม มีทรัพย์สิน จัดการเงิน — ต้องมีความโปร่งใส ตรวจสอบได้ และมีตัวตนที่ชัดเจน

• ต้องการให้ AI Agents สามารถ คิด → ตัดสินใจ → ดำเนินการ ได้อย่างอิสระ พร้อมทำงานร่วมกับระบบอื่น ๆ ได้

เพราะฉะนั้นเเล้วด้วยความสามารถของ Talus จะทำให้เกิดผลิตภัณฑ์ใหม่ที่หลากหลายเช่น

• DAO ที่ปรับตัวอัตโนมัติ วิเคราะห์ proposal และโหวตแทน community

• DeFi ที่เรียนรู้และเปลี่ยนกลยุทธ์ตามตลาด จัดการ yield farming, rebalancing อัตโนมัติ

• AI trader ที่ทำงานตลอดเวลาโดยไม่ต้องมีเจ้าของมา log in

• Agent-as-a-Service (AaaS) — dApp สามารถเรียกใช้ Agent บริการเฉพาะด้านในแอปพลิเคชั่นได้

เริ่มน่าสนใจขึ้นบ้างแล้วใช่ไหม มาดูกันว่า มาดูโครงสร้างหลักๆ ของ Talus มีอะไรกันบ้าง เอาแบบใหญ่คงเเบ่งออกมาได้ประมาณ 4 ส่วนละ

โครงสร้างหลักของ Talus

1. Talus Agentic Framework (TAF)

คือ หัวใจหลักของ Talus ที่นิยามวิธีการทำงานของ Agent ทั้งหมดใน Talus — เป็นมาตรฐานกลางสำหรับจัดการ computation, การส่งข้อมูล, และการจ่ายเงิน

TAF ประกอบด้วยสององค์ประกอบย่อยหลัก:

• Talus Tools: บริการย่อย (onchain หรือ offchain) เช่น oracle, LLM API, smart contract logic ฯลฯ

• Talus Workflows: กราฟลำดับการทำงาน (DAG) ที่เชื่อม Talus Tools เข้าด้วยกันให้เกิด workflow อัตโนมัติ เช่น oracle → AI → swap

2. Nexus Protocol

Nexus ใน Talus ทำหน้าที่เป็น Execution layer สำหรับรัน workflow และตรวจสอบผลลัพธ์แบบ verifiable

Nexus มีสองส่วนหลัก:

• Onchain Components (Nexus Onchain Packages หรือย่อว่าๆ NOP):

  • ชุด Smart contract ที่นิยาม Talus Tools, Workflows, และ registry

  • พัฒนาโดยทีม Talus Labs และแน่นอน deploy บน Sui Network โดยใช้ภาษา Move

  • นักพัฒนาภายนอกสามารถสร้าง Tool Packages และ Agent Packages (TAPs) ที่เชื่อมกับ NOP เพื่อกำหนด agent ของตัวเองได้

• Offchain Components (Leader Network):

  • ระบบตัวกลางที่คอยฟัง event จาก onchain และรัน tools/offchain API ตามลำดับใน workflow

  • ทำหน้าที่เหมือน oracle ที่ปลอดภัย มีระบบ proof, timer, และการจัดการ payment อัตโนมัติ

นั้นหมายถึง Nexus เป็นโครงสร้างที่ทำให้ agent สามารถ คิด–ตัดสินใจ–และลงมือทำ ได้อย่างอิสระ โดยไม่ต้องมีคนมาสั่งนั้นเอง

3. Economic Layers

Talus สร้างระบบเศรษฐกิจ 3 ชั้น เพื่อให้ developer และผู้ใช้มีแรงจูงใจร่วมกัน

• Tool Marketplace:
  นักพัฒนาขาย Talus Tools ของตนเอง (เช่น oracle, AI model) และรับค่าธรรมเนียมทุกครั้งที่ถูกเรียกใช้

• Agent Marketplace:
  ผู้ใช้สามารถเลือกหรือปรับแต่ง AI Agents ที่ทำงานอัตโนมัติใน use case ต่าง ๆ เช่น trading, prediction, automation

• Agent-as-a-Service:
  dApps ภายนอกสามารถเรียกใช้ agent ของ Talus เป็น service ของตนเอง (เหมือน API-as-a-Service แต่เป็น decentralized)

ทุกการใช้งานใช้โทเค็น $US เป็นสื่อกลางการจ่ายเงิน และ Talus จะมีระบบ staking/slashing เพื่อรับประกันความถูกต้องของบริการ

4. Talus Network — Coordination & Infrastructure Layer

   เป็นส่วนที่จะประสานทั้งหมดเข้าด้วยกัน:

• ทำหน้าที่จัดการ การประสานงาน, การส่งข้อมูล, การจ่ายเงิน, และ การตรวจสอบผลลัพธ์

• มีระบบ asynchronous workflow engine เพื่อให้ workflow ทำงานต่อเนื่องโดยไม่ต้องรอการตอบกลับแบบ synchronous ของบล็อกเชน

• รองรับการเชื่อมต่อกับ AI Models, TEE, และ Cross-chain system เพื่อให้ agent สามารถทำงานได้ในหลายระบบพร้อมกัน

อธิบายมาก็เยอะแล้ว ข้อมูลทุกอย่างสามารถดูได้จากใน Docs และ White paper แต่นั้นเเหละข้อมูลเยอะเกิ๊น ข้ามมันไปก่อน มาดูดีกว่าว่าตอนนีเราทำอะไรกับมันได้บ้าง

สำหรับคนที่สนใจสามารถเข้าร่วมทดสอบ Testnet ได้แล้ววันนี้ https://testnet.talus.network/testnet ตัว Talus เองก็พึ่งระดมทุนมาได้ด้วยถึง $10M (https://x.com/Talus_Labs/status/1972662568213987756) มี incentive ให้ด้วยนะ ลองดูได้จากที่นี้ https://x.com/Talus_Labs/status/1973014471246327819

ส่วนสาย Builder เองตอนนี้ก็มี SDK ออกมาแล้วครับ รวมถึงตัวอย่างการใช้งานด้วย ลองดูได้ที้นี้นะ

• https://docs.talus.network/getting-started/math-branching-quickstart

• https://docs.talus.network/developer-docs/index

วันนี้เกริ่นกันแค่นี้ก่อน สารภาพว่าแค่อ่าน Docs ก็หมดแรงแล้ว…

ในโลกการเขียนโปรเเกรม Web 2.0 ที่เราคุ้นเคย ถ้าเราเป็น Web 2.0 Developer เวลาเก็บข้อมูลของผู้ใช้หรือระบบ เรามักจะเก็บเป็น Row ใน Database (เช่น PostgreSQL, MySQL, MongoDB)

• มี user_id เป็น Primary Key

• เก็บข้อมูลเช่น username, email, balance

• เวลาแก้ไข เราแค่รัน UPDATE หรือ DELETE ตามสิทธิ์ที่ระบบกำหนด

คุณคือเจ้าของระบบและ Database ถ้าอยาก rollback หรือ migrate schema ก็ทำได้เองหมด

แต่เดียวก่อน ในจักรวาลของ SUI Network นั้น ทุกอย่างไม่ได้เก็บเป็นแค่ Row/Column แบบที่เราคุ้นเคยกัน แต่เก็บทั้งหมดอยู่ในรูปแบบ Object

• Object = Data + Owner + Version

• ทุกครั้งที่เปลี่ยนแปลง Object จะไม่ใช่การเขียนทับ แต่คือการสร้าง เวอร์ชันใหม่ของสถานะ (state) เพื่อรักษาความถูกต้องและป้องกัน conflict

• เจ้าของ Object (owner) มีสิทธิ์ควบคุมว่าจะโอน ยืมใช้ หรือแก้ไขได้หรือไม่

SUI Object คือ

หน่วยเก็บข้อมูล (data unit) พื้นฐานที่สุดที่ใช้แทนทุกสิ่ง ไม่ว่าจะเป็นโทเค็น, NFT, smart contract state หรือแม้กระทั่งข้อมูลทั่วไป ต่างจาก blockchain อื่นๆ (ที่เก็บข้อมูลในรูปแบบ account + balance หรือ key-value store) Sui ใช้ Object-Centric Model ทำให้แต่ละ Object มีตัวตนแยกชัดเจน (unique identity) และสิทธิ์การเป็นเจ้าของในตัวเอง

คุณสมบัติคร่าวๆของ SUI Object จะมีดังนี้

• มี ID ที่ไม่ซ้ำกัน (Object ID)

  ทุก Object จะมีรหัสเฉพาะ (32 bytes) เพื่อระบุว่าเป็น Object ไหน

• มีเจ้าของ (Ownership)

  Object จะกำหนดว่าใครเป็นเจ้าของหรือสามารถเข้าถึงได้ โดย ownership มีหลายรูปแบบ เช่น

  • Address-owned → เป็นของ address ใด address หนึ่ง นั้นคือมีเจ้าของชัดเจนนั้นเอง ใช้กับ NFT, Token, Item

  • Shared → ใช้ร่วมกันหลายคน เช่น DEX Pool, Counter

  • Immutable → อ่านได้อย่างเดียว เปลี่ยนแปลงไม่ได้ ใช้กับพวก Metadata หรือ Config

  • Wrapped → ถูกเก็บซ้อนอยู่ใน Object อื่น

  • Party → ใช้ร่วมกับ party ของผู้ที่เกี่ยวข้อง

เปรียบเทียบกับ Database

มาดูตัวอย่างกันดีกว่า

Web 2.0 (SQL)

INSERT INTO players (id, name, score) VALUES (1, 'Alice', 10); 
UPDATE players SET score = 20 WHERE id = 1;

SUI (Move)

struct Player has key {
    id: UID,
    name: String,
    score: u64,
}

public entry fun new_player(name: String, ctx: &mut TxContext) {
    let player = Player {
        id: object::new(ctx),
        name,
        score: 0,
    };
    transfer::transfer(player, tx_context::sender(ctx));
}

public entry fun update_score(player: &mut Player, new_score: u64) {
    player.score = new_score;
}

การ Upgrade ของ Object

อีกสิ่งนึงที่น่าสนใจคือกรณีที่เราต้องการเเก้ไขข้อมูลของ SUI Object เพราะจริง ๆ แล้วผูกกับ แนวคิด Versioning ของ Object โดยตรง เพราะทุกครั้งที่มีการแก้ไข (mutate) หรือโอน (transfer) ตัว Object จะไม่ใช่การเขียนทับ แต่คือการสร้าง Version ใหม่ ของ Object นั้น

• Object Versioning

  • ทุกการเปลี่ยนแปลงของ Object = การสร้าง Version ใหม่

  • ระบบจะเก็บคู่ ObjectID + Version เพื่ออ้างอิงสถานะปัจจุบัน

  • ถ้า Transaction ใช้ Object version เก่า → จะล้มเหลวทันที (ป้องกัน conflict)

• Module Upgrade

  • Logic หรือฟังก์ชันการทำงานที่ผูกกับ Object อยู่ใน Move Package

  • เมื่อจะอัปเกรด logic → ไม่ได้แก้ package เดิม แต่ใช้การ Deploy Package ใหม่

  • กลไกนี้ช่วยให้ blockchain ยังคงรักษาความเป็น Immutable ของ code เดิมได้

• Migration Script

  • ใช้เพื่อ ย้ายข้อมูลจาก Object เดิมไปยัง Object ใหม่ ที่สร้างด้วย logic เวอร์ชันล่าสุด

  • เหมาะในกรณีที่โครงสร้างข้อมูล (struct) หรือ logic เปลี่ยนไปจนไม่สามารถใช้ Object เดิมได้

  • เป็นขั้นตอนสำคัญในการรักษาความต่อเนื่องของ state และ user experience

ทำไม Sui Object สำคัญ?

Sui Object เป็นหัวใจของการออกแบบ Sui blockchain เพราะมันทำให้เครือข่าย เร็วขึ้น, ปลอดภัยขึ้น, ยืดหยุ่นกว่า และพัฒนาได้ง่ายกว่า blockchain แบบ account-based เดิม ๆ โดยสามารถสรุปได้เป็น 4 แกนหลักดังนี้

• Scalable (รองรับการขยายตัวสูง)

  • เพราะ Object แยกออกจากกัน → ธุรกรรมที่แตะคนละ Object สามารถประมวลผล พร้อมกัน (parallel execution) ได้

  • ต่างจาก Ethereum ที่ต้องประมวลผลแบบ sequential ทีละธุรกรรม

  • ทำให้ Sui รองรับ throughput สูงและ latency ต่ำ เหมาะกับ dApp ขนาดใหญ่ เช่น DeFi และ GameFi

• Security (ปลอดภัยด้วยสิทธิการเข้าถึง)

  • ทุก Object มี owner ที่ชัดเจน (address, shared, immutable, party ฯลฯ)

  • สิทธิ์การเข้าถึงถูกควบคุมอย่างเข้มงวด → ป้องกันการใช้ object โดยไม่ได้รับอนุญาต

  • ระบบ versioning ทำให้มั่นใจได้ว่าธุรกรรมใช้ object เวอร์ชันล่าสุด ลดปัญหา conflict หรือ double spend

• Programmable Asset (ทรัพย์สินที่โปรแกรมได้)

  • บน Sui, Object ไม่ได้เป็นแค่ data แต่เป็น asset ที่มี logic ของตัวเอง ตัวอย่าง: Sword ในเกมไม่ใช่แค่ metadata ของ NFT แต่สามารถมี logic เช่น upgrade_sword, transfer, หรือ equip อยู่ภายใน

  • เปิดโอกาสให้สร้างแอปที่ซับซ้อนขึ้นได้ โดยใช้ Object เป็น building block

• Upgradable (อัปเกรดได้ต่อเนื่อง)

  • Object Versioning → ทุกครั้งที่แก้ไข object จะสร้าง version ใหม่

  • Module Upgrade → logic เปลี่ยนได้ด้วยการ deploy package ใหม่

  • Migration Script → ย้ายข้อมูลจาก object เดิมไป object ใหม่ได้

  • ทำให้ทั้ง data และ logic สามารถพัฒนาและอัปเกรดได้โดยไม่สูญเสีย state เก่า

ยาวหน่อยนะ เเต่ SUI Object เป็นพื้นฐานที่ต้องเข้าใจจริงๆ ก่อนที่จะเริ่มพัฒนา dApp บน SUI Network ซึ่งจากข้อมูลข้างบนจะเริ่มมีเเตะๆโค๊ดบ้างแล้วเเหละ สำหรับใครที่อยากจะเริ่มสามารถดูคอร์ดเรียนเบื้องต้นภาษาไทยได้จากที่นี้นะ

https://github.com/Contribution-DAO/sui-move-intro-course-thai

โดยในบทเรียนที่ 1 จะสอนเกี่ยวกับการติดตั้งค่า เเละบทเรียนที่ 2 จะสอนเกี่ยวกับ SUI Object นั้นเอง

ของเเถม จริงๆรายละเอียดเบื้องต้นเกี่ยวกับ SUI Object จบไปละ เเต่เนื้อหาข้างล่างเเถมให้

เปรียบเทียบกับ EVM chain

มาดูคำนิยามกันก่อนว่า EVM คืออะไร

• EVM (Ethereum Virtual Machine)

  Smart Contract ที่ deploy แล้ว immutable (เปลี่ยนไม่ได้) ถ้าอยาก upgrade ต้องใช้ Proxy Pattern หรือ deploy contract ใหม่

• Sui Move

  Package (smart contract logic) ถูก deploy ได้ทั้งแบบ immutable และ upgradable และ Object ที่ถูกสร้างจาก package เก่า สามารถ migrate ไปใช้ logic ใหม่ได้

ตัวอย่าง EVM ก็เช่น Ethereum หรือ Layer 2 network อาทิเช่น Arbitrum Optimism เป็นต้น

ตารางเปรียบเทียบมัดต่อมัด

ตัวอย่างการอัพเดต

EVM (UUPS Proxy)

contract Proxy {
    address public implementation;

    function upgrade(address newImpl) external onlyAdmin {
        implementation = newImpl;
    }

    fallback() external payable {
        (bool success, ) = implementation.delegatecall(msg.data);
        require(success);
    }
}

Sui (Upgrade Package + Migration)

// Package V1
struct Player has key {
    id: UID,
    name: String,
    score: u64,
}

// Package V2 (เพิ่ม avatar_url)
struct PlayerV2 has key {
    id: UID,
    name: String,
    score: u64,
    avatar_url: String,
}

public entry fun migrate(old: Player, ctx: &mut TxContext) {
    let new_player = PlayerV2 {
        id: object::new(ctx),
        name: old.name,
        score: old.score,
        avatar_url: String::utf8(b"default.png"),
    };
    transfer::transfer(new_player, tx_context::sender(ctx));
    object::delete(old);
}

จบจริงๆละ รอบหน้าตัดเล็บรอได้เลย เพราะเราจะเริ่มลงมือเขียนโค๊ดกันละ ส่วนข้อมูลฉบับเต็มสามารถดูได้จากเอกสาร https://docs.sui.io/concepts/object-model

By Gang|ContributionDAO

อ่าวละ Walrus คืออะไร?

Walrus เป็น decentralized storage & data availability protocol ที่ถูกออกแบบมาโดยเฉพาะเพื่อเก็บไฟล์ขนาดใหญ่ (หรือที่เรียกว่า blobs) เช่น รูปภาพ วิดีโอ ไฟล์เว็บ หรือ binary files อื่น ๆ

คุณสมบัติหลักของ Walrus คือ:

• Decentralized Storage – ไม่มี server กลาง ข้อมูลจะถูกกระจายไปเก็บตาม node ในเครือข่าย

• Data Availability Layer – การันตีว่าไฟล์ที่ถูกเก็บไว้จะ “หาเจอและโหลดได้จริง” ไม่หายไปกลางทาง

• Optimized for Blobs – ปรับแต่งให้เหมาะสมกับไฟล์ขนาดใหญ่ ต่างจาก blockchain ปกติที่เก็บข้อมูลแบบ state/transaction ซึ่งมีข้อจำกัดด้านขนาด

• Economic Incentives – ผู้ที่เก็บไฟล์ (storage node) จะได้ค่าตอบแทนเป็น incentive ทำให้ระบบมีแรงจูงใจให้ข้อมูลคงอยู่เสมอ

อ่าวแล้ว Walrus กับ Sui (Mysten Labs) เกี่ยวข้องกันยังไงหละ?

Walrus ถูกพัฒนาโดย Mysten Labs ทีมเดียวกับที่สร้าง Sui นั้นเอง โดยทั้งสองโปรเจกต์ออกแบบมาให้ ส่งเสริม กัน

• Sui → เป็น blockchain ที่ทำหน้าที่เก็บ state และ logic ของ smart contract (ข้อมูลที่ต้องการความถูกต้องและ consensus สูง)

• Walrus → เป็น Decentralized Storage ไว้เก็บไฟล์ข้อมูลขนาดใหญ่ ที่ไม่เหมาะจะยัดลง blockchain โดยตรง โดย walrus ต่างจากที่เก็บข้อมูลแบบอื่นตรงที่มีคุณสมบัติ availability และ verifiability

สรุปง่ายๆคือ

• Walrus = Decentralized hosting/storage layer

• Sui = Smart contract & ownership layer

ตอนนี้เรารู้แล้วว่า Walrus คืออะไร และมันทำงานคู่กับ Sui ยังไง ทีนี้ก็ถึงเวลาลอง ลงมือทำจริง กันบ้าง 🎉 Use case ง่ายที่สุดคือการเอา เว็บไซต์เล็ก ๆ ของเราไปฝากบน Walrus แบบไม่ง้อเซิร์ฟเวอร์ และที่สำคัญคือ ไม่มีใครมาลบหรือปิดเว็บเราได้ 🔒

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

วิธีทำเว็บของตัวเองบน Walrus Site แบบง่าย ๆ 🚀

โลก Web3 ตอนนี้มาแรงสุด ๆ หนึ่งในของเล่นใหม่ที่น่าสนใจก็คือ Walrus Site ✨ มันคือการเอาเว็บไปฝากไว้บน เครือข่าย Walrus + Sui โดยไม่ต้องง้อเซิร์ฟเวอร์เอง พูดง่าย ๆ ก็คือ เราได้ โฮสติ้งแบบกระจายศูนย์ (decentralized hosting) ที่เข้าถึงได้ตลอดเวลา และไม่มีใครมาลบหรือปิดเว็บเราได้

ทำไม Walrus Site ถึงน่าสนใจ? 🤔

• Serverless Deployment — อัปโหลดไฟล์เว็บตรงไปบน blockchain ไม่ต้องมีเซิร์ฟเวอร์

• Ownership & Flexibility – เว็บเป็นของคุณโดยสมบูรณ์ สามารถโอนหรืออัปเดตได้ตลอด

• NFT Integration – ผูกเว็บกับ Sui objects เช่น เว็บเฉพาะ NFT หรือโชว์คอลเลกชัน NFT ได้

• High Availability — เพราะอยู่บนระบบกระจายศูนย์

• SuiNS Domain — จดโดเมนผ่าน SuiNS

พร้อมไหม… มาเริ่มกันเลย (คำสั่งอาจจะแตกต่างกันไปแต่ละ OS นะ ในที่นี้เราใช้ Ubuntu ในการติดตั้ง)

1. เตรียมเครื่องมือที่จำเป็น

   • ติดตั้ง Rust

       brew install rustup 
       rustup-init
     

   • ติดตั้ง SUI CLI

       brew install sui
       sui --version #ตรวจสอบว่าติดตั้งถูกต้องใหม
     

   • สร้าง SUI wallet (เลือก ed25519 นะ)

       sui client new-env --alias mainnet --rpc https://fullnode.sui.io:443 #เพื่อ activate client
     

     ขั้นตอนนี้สำคัญมากคือต้องเก็บ Secret Recovery Phrase ไว้นะห้ามหายเด็ดขาด และต้องมั่นใจว่าเก็บในสถานที่ ที่ปลอดภัยด้วย ซึ่งเราสามารถนำ Secret Phrase ไป import เข้ากระเป๋าได้ ซึ่งในที่นี้เเนะนำตัวนี้เลย Slush — A Sui wallet เป็นกระเป๋าหลักของ SUI

   • ติดตั้ง Walrus cli (https://docs.wal.app/usage/setup.html)

       curl -sSf https://install.wal.app | sh 
       walrus --help #ตรวจสอบว่าลงสำเร็จแล้ว
     

   • ติดตั้ง site-builder

     สำหรับ platform อื่นสามารถดูวิธีการติดตั้งเพิ่มเติมได้ที่ https://docs.wal.app/walrus-sites/tutorial-install.html

       SYSTEM=macos-x86_64  # เปลี่ยนตาม OS ของคุณ
       curl https://storage.googleapis.com/mysten-walrus-binaries/site-builder-testnet-latest-$SYSTEM -o site-builder
       mv site-builder /usr/local/bin/
     

     ตรวจสอบว่าติดตั้งถูกต้องไหม

       site-builder --help
     

   • เตรียม walrus site config

       mkdir -p ~/.config/walrus/
       curl https://raw.githubusercontent.com/MystenLabs/walrus-sites/refs/heads/mainnet/sites-config.yaml -o ~/.config/walrus/sites-config.yaml
     

2. เตรียมเว็บที่จะ deploy

   • เว็บต้องมี index.html เป็น entry point

   • ตัวอย่าง repo ของ Walrus โดยเราจะใช้เว็บตัวอย่าง walrus-snake สำหรับฝึก deploy กัน

   •           git clone https://github.com/MystenLabs/example-walrus-sites.git
               cd example-walrus-sites
     

3. เตรียมเหรียญเพื่อใช้เป็นค่าใช้จ่ายสำหรับ Deploy

   • ก่อนอื่นเลยเราต้องมีเหรียญ SUI และ Warlus ก่อนสามารถเข้าไปหาซื้อได้ตาม exchange ต่างๆ ดูข้อมูลได้จากที่นี้ https://coinmarketcap.com/currencies/sui/ และ https://coinmarketcap.com/currencies/walrus-xyz/

   • หลังจากนั้นให้ดาวโหลด wallet extension ซึ่งในที่เราเลือกใช้ Slush — A Sui wallet (https://slush.app/) เมื่อติดตั้ง wallet extension เสร็จเรียบร้อยแล้ว ให้ import ค่า Secret Recovery Phrase จากขั้นตอนก่อนหน้า เเล้วทำการโอนเงินจาก exchange ไปที่กระเป๋าของเรานั้นเอง

     (ส่วนนี้สำหรับมือใหม่ อาจจะ งงๆ นิดหน่อย เเต่โดยหลักการคือ เราต้องหาซื้อ token เพื่อมาใช้สำหรับการทำธุรกรรมเเละค่าธรรมเนียมนั้นเอง แนะนำว่าให้ซื้อประมาณ 1 SUI และ 2 Warlus tokens น่าจะเพียงพอละ หรือใครไม่มีก็ comment กระเป๋ามาเลย เดียวเราโอนให้เพื่อการเรียนรู้ :P )

4. อัปเว็บขึ้น Walrus

   • ใช้คำสั่งด้านล่างนี้เพื่อ upload เว็บไซด์ขึ้นไปเก็บยัง walrus (ใช้ SUI และ Walrus เล็กน้อยสำหรับค่าธรรมเนียม)

       site-builder publish ./walrus-snake --epochs 1
     

     (epochs คืออายุของการเก็บรักษา object นั้น โดย 1 epoch จะมีค่าประมาณ 14 วัน)

   • หลังเสร็จ คุณจะได้ site object ID + URL ในขั้นตอนการทดสอบนั้นเราจะทำไป 2 แบบคือ ทดสอบผ่าน local host หรือทำการผูก site object id กับ SuiNs ซึ่งเราจะไปกันให้สุด นั้นคือไปจด Domain Name กันต่อ สำหรับใครอยากทดสอบผ่าน local host สามารถดูขั้นตอนได้ที่นี้นะ https://docs.wal.app/walrus-sites/portal.html#running-a-local-portal

5. การต่ออายุการใช้งาน

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

       site-builder update --epochs 1 ./walrus-snake 0xYourSiteObjectID
     

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

--force หากต้องการต่ออายุโดยไม่เปลี่ยนเนื้อหา ซึ่งเราสามารถต่ออายุได้สูงสุด 53 epochs (~2 ปี)

6. ผูกชื่อเว็บให้อ่านง่ายด้วย SuiNS

   SuiNS คือ (Sui Name Service) คือ ระบบ Domain Name Service บนเครือข่าย Sui เปรียบเทียบได้เหมือน Domain name ที่เราคุ้นชินกันอยู่แล้วนั้นเอง พร้อมแล้วไปเริ่มกันเลย

   • ไป https://suins.io/ แล้วเชื่อมกับ wallet extension ที่ได้ทำการติดตั้งก่อนหน้า หลังจากนั้นค้นหา domain name ที่เราต้องการ

     

   • ในกรณีที่ Domain name ว่างเราก็สามารถที่จะเลือกซื้อ Domain เหล่านั้นได้ ทำการจ่ายเงินให้เรียบร้อย

   • ไปที่หน้า https://suins.io/account/my-names#your_name ทำการผูก site object ID เข้ากับ Domain name เป็นอันเสร็จสิ้น

     

เป็นไงครับ เหนื่อยกันไหมขั้นตอนอาจจะเยอะเพราะมีการติดตั้งหลายอย่างในครั้งแรก เเละนี้คือผลลัพธ์ที่เราได้มา https://onthemove.wal.app/ เว็บไซด์ที่จะไม่มีวันล่มอีกต่อไป ใครลองแล้วได้เว็บอะไรกันบ้าง เอามาแชร์ในคอมเมนต์ได้นะ

นี้เป็นเพียงตัวอย่างเริ่มต้นเท่านั้นนะ เดียวเจอกันใหม่รอบหน้า มาดูกันว่าเราจะพัฒนา dApp อะไรดี เพื่อดึงความสามารถของเจ้าสิงโตทะเล ให้ทำงานได้อย่างเต็มประสิทธิภาพ เจอกันนนน

By Tee | ContributionDAO

• เว็บแอป: เราเขียน API ด้วย Express (Node.js) หรือ Spring (Java) ต่อกับ Database แล้วส่ง JSON ให้ frontend

• ระบบสมาชิก (Authentication/Authorization): มีการ login, JWT, session, role-based access ที่เราคุมได้หมด

• Business Logic: จะเขียน rule การคิดเงิน, การจัดการ order, การคำนวณส่วนลด ฯลฯ ก็แค่เพิ่ม logic เข้าไปใน backend

• Database: ทุกอย่างสุดท้ายจบลงที่ row/column ใน SQL หรือ document ใน MongoDB

• Deployment: เราเลือกว่าจะ deploy บน AWS, GCP หรือ DigitalOcean จะ scale server ยังไงก็อยู่ที่เรา

แต่รู้ไหมว่าในโลกของ Blockchain ภาษาหลักในการพัฒนาสิ่งที่เรียกว่า Smart Contract นั้น จะเป็นอีกโลกนึง แล้ว Smart contract คืออะไรละ? ต่างจาก สิ่งที่ทุกวันนี้เราเขียน Web application หรือ Backend services ยังไงกันนะ? เอาเเบบไม่ยาวเกินไป Smart contract คือชุดของโปรเเกรมที่ถูกติดตั้งบนระบบของ blockchain สามารถทำงานได้ด้วยตัวมันเองตามเงื่อนไขที่กำหนดเอาไว้ โดยไม่ต้องมีตัวกลาง เอาให้เห็นภาพกันอีกนิดนึด

ในระบบธนาคารเวลาเราโอนเงิน

• ใน Web 2.0 → คุณจะต้องเก็บยอดหรือรายการลงในฐานข้อมูลใช่ม่ะ แล้วก็ต้องเขียนโปรเเกรมเพื่อเรียกดูข้อมูล หรือเวลาจะโอนเงินก็ต้องทำผ่าน API ที่มี server เป็นตัวกลาง

• ใน Web 3.0 → คุณเขียน smart contract บอกว่า ยอดเงินของใครเท่าไหร่ วิธีการโอนเงิน แล้ว deploy บน blockchain เวลาเราจะเรียกดูยอดคงเหลือ หรือจะทำธุรกรรม ก็สามารถทำได้ทันที โดยไม่ต้อผ่านตัวกล่าว เเละยังสามารถตรวจสอบข้อมูลเหล่านั้นได้ตลอดเวลาอีกทีด้วย

ซึ่งภาษาที่ใช้สำหรับการพัฒนา Smart contract ก็จะมี Solidity (EVM เช่น Ethereum), Rust (Solana), Move ซึ่งจะเป็นพระเอกที่เราจะพูดถึงในวันนี้

Move คืออะไร

Move เป็นภาษาโปรแกรมที่ถูกออกแบบมาเพื่อการพัฒนา Smart Contract บน Blockchain โดยเริ่มต้นจาก Libra/Diem ของ Facebook/Meta และปัจจุบันถูกนำไปใช้ในหลาย Blockchain เช่น Aptos และ Sui จุดเด่นของ Move คือการสร้าง “Resource-Oriented Programming” หรือแนวคิดที่ให้ทรัพยากรดิจิทัล (เช่น Token, NFT) มีความปลอดภัยเหมือนกับการถือครองสินทรัพย์จริง ๆ ไม่สามารถคัดลอก ลบ หรือสร้างซ้ำโดยไม่ได้ตั้งใจ

ทำไมต้อง Move

จุดเด่น

• ปลอดภัยกว่า Solidity: Move ออกแบบมาเพื่อลดปัญหาการเขียนโค้ดผิดพลาดที่มักเกิดใน Solidity เช่น การ Re-entrancy Attack หรือ Overflow

• Resource-Oriented: การจัดการ Asset เป็นของจริง (First-class) ไม่เหมือนตัวเลขใน Database ลดความเสี่ยงเรื่องการ Duplicate

• เข้าใจง่ายสำหรับ Developer ที่เคยทำ Web2: Syntax คล้าย Rust/C จึงไม่ยากสำหรับคนที่คุ้นกับภาษา typed language

• ทดสอบง่าย: โค้ด Move ถูกแยกเป็นโมดูล ทำให้เขียน test และ reuse code ได้ชัดเจน

จุดด้อย

• Ecosystem ยังเล็ก เมื่อเทียบกับ Solidity ที่มี DeFi/NFT/DAO Tools ครบวงจร

• Learning Curve ใหม่ เพราะแนวคิด Resource-Oriented ไม่เหมือนกับการเขียนโปรแกรมทั่วไป

• เครื่องมือยังไม่หลากหลาย เมื่อเทียบกับ Ethereum Ecosystem ที่มีทั้ง Hardhat, Foundry, Truffle

Move ต่างจาก Solidity ยังไง

• การจัดการ Asset: Solidity ใช้ตัวเลข (uint) แทน Token balance แต่ Move มอง Asset เป็น Resource จริง ๆ ไม่สามารถ Duplicate ได้

• ความปลอดภัยโดย Design: Move ป้องกัน Error หลายอย่างตั้งแต่ Compile-time ในขณะที่ Solidity ต้องใช้ Audit/Library เสริม

• การเรียนรู้: Solidity ใกล้เคียงกับ JavaScript มาก (คน Web2 ที่เป็น JS dev จะเรียนรู้ได้ไว) แต่ Move คล้าย Rust ที่ strict กว่า ทำให้ปลอดภัยแต่ต้องใช้เวลาเรียนรู้

Object-Oriented Blockchain คืออะไร?

นี้คือหนึ่งในแนวคิดใหม่ที่เกิดขึ้นบน Blockchain ที่ใช้ Move คือ Object-Oriented Blockchain ซึ่งถูกนำมาใช้ใน Sui Blockchain นั้นจึงทำให้ Move แตกต่างจากภาษา Smart Contract อื่นๆ (อย่าง Solidity)

แนวคิดหลัก

แทนที่ทุกอย่างจะถูกเก็บเป็น บัญชี + ตัวเลข (balance) แบบใน Ethereum, Sui ใช้โมเดล Object ซึ่งคล้ายกับแนวคิดของ OOP (Object-Oriented Programming) คุ้นๆกันใช่ไหม

• Object = Resource: แต่ละ Token, NFT หรือแม้แต่ Smart Contract instance จะถูกมองเป็น Object ที่มี state และ owner ชัดเจน

• Object ID: แต่ละ Object มี ID เฉพาะ ไม่ซ้ำกัน (เหมือน primary key ใน database)

• Ownership & Transfer: การโอนย้าย Asset = การเปลี่ยน owner ของ Object ไปยัง address ใหม่

• Composable: Object สามารถซ้อนกันได้ เช่น เกมสามารถสร้าง “ตัวละคร” ที่เป็น Object และเก็บ “Item” ที่เป็น Object ภายในได้อีก

จุดเด่น

• การประมวลผลแบบขนาน (Parallel Execution): เพราะ Object แต่ละตัวไม่แชร์ state กัน จึงสามารถทำธุรกรรมพร้อมกันได้ (TPS หรือ จำนวนธุรกรรมต่อวินาทีสูง)

• ชัดเจนเรื่องสิทธิ์ความเป็นเจ้าของ (Ownership): ง่ายต่อการเขียน DApp ที่มี NFT, เกม หรือ RWA เพราะ Object เป็นตัวแทนสินทรัพย์จริง

• ใกล้เคียง OOP สำหรับ Web2 Developer: นักพัฒนา Web2 ที่คุ้นกับ Class/Object จะเข้าใจโมเดลนี้ได้เร็ว

จุดด้อย

• แนวคิดใหม่ ต้องเปลี่ยนมุมมอง: จาก Account-Based → Object-Based

• Ecosystem ยังเล็กกว่า Ethereum: Tools และ Lib สำหรับ Object-Oriented ยังมีไม่มาก

• ความซับซ้อนของการจัดการ Object: ต้องออกแบบระบบเก็บ, อ้างอิง และ Transfer Object ให้ดี ไม่งั้นจะทำงานยุ่งยาก

มาดูตัวอย่างกันดีกว่า

Solidity (Ethereum Model)

// Balance = ตัวเลขใน mapping
mapping(address => uint) balances;

function transfer(address to, uint amount) public {
    require(balances[msg.sender] >= amount);
    balances[msg.sender] -= amount;
    balances[to] += amount;
}

Move (Sui Object-Oriented Model)

module example::coin {
    struct Coin has key {
        id: UID,          // Object ID
        value: u64,       // จำนวนเงิน
        owner: address,   // เจ้าของ
    }
    public entry fun transfer(coin: Coin, to: address): Coin {
        // เปลี่ยนเจ้าของ Object
        Coin { id: coin.id, value: coin.value, owner: to }
    }
}

จะเห็นได้ว่า ในโมเดลของ Sui นั้น Coin แต่ละเหรียญคือ Object จริง ๆ ไม่ใช่แค่เลข balance ใน mapping

นอกจากนี้ยังมีส่วนอื่นๆที่น่าสนใจอีกด้วยนะ

• Move มี Formal Verification ทำให้สามารถตรวจสอบ Smart Contract เชิงคณิตศาสตร์ได้ ลดความเสี่ยงจากบัค

• Move กำลังได้รับความนิยมใน Blockchain รุ่นใหม่ที่เน้น Performance และ Security เช่น Aptos (Parallel Execution) และ Sui (Object-Oriented Blockchain)

ทำไม Web2 Developer ควรเริ่มเรียน Move ตอนนี้

ถ้าคุณเป็น Web2 Developer ที่คุ้นกับภาษาจำพวก JavaScript, Java, Python หรือแม้แต่ Rust การก้าวเข้าสู่โลก Web3 ด้วย Move Language จะเป็นโอกาสที่เหมาะ เพราะ Move ไม่ได้เป็นแค่ภาษาเขียน Smart Contract ธรรมดา แต่ถูกออกแบบมาเพื่อแก้จุดอ่อนที่เราเห็นใน Ethereum และ Solidity มาอย่างยาวนาน

• ปลอดภัยกว่า: Resource-Oriented ทำให้ Asset บนบล็อกเชนถูกจัดการเหมือน “ของจริง” ไม่มีการ duplicate หรือสูญหายง่าย ๆ

• ใกล้เคียง OOP: ถ้าคุณเคยเขียน Class/Object ใน Web2 การเรียนรู้ Object-Oriented Blockchain ของ Sui จะทำให้คุณรู้สึกว่าโค้ด Smart Contract ไม่ได้ต่างจากการออกแบบระบบ Web app ที่คุณคุ้นเคย

• อนาคตของ Blockchain รุ่นใหม่: Move กำลังถูกใช้ใน Blockchain ที่เน้น performance และ security เช่น Aptos และ Sui ซึ่งกำลังดึงดูดนักพัฒนาและนักลงทุนมากขึ้นเรื่อย ๆ

• First-Mover Advantage: Solidity Dev มีเยอะแล้ว แต่ Move Dev ยังมีน้อยมาก — การเรียนรู้ตอนนี้ทำให้คุณได้เปรียบในตลาดงาน และเปิดโอกาสสร้าง Product ที่แตกต่างได้ก่อนใคร

สรุปสั้นเลยๆนะ ถ้าคุณเป็น Web2 Developer ที่อยากก้าวเข้าสู่ Web3 ด้วยภาษาใหม่ที่ทั้งปลอดภัย เข้าใจง่าย และกำลังเติบโต Move คือภาษาที่ควรเริ่มต้นตอนนี้เลย เราสิ้นสุดการเกริ่นเกี่ยวกับ Move เพียงเท่านี้เพราะต่อไปนี้ ต่อไปต่อจากนี้ เราจะดำดิ่งไปกับการเขียนโค๊ดละ ตัดเล็บรอได้เลย

By Gang | ContributionDAO

Blockchain คือเทคโนโลยีการเก็บข้อมูลแบบกระจายศูนย์ ข้อมูลจะถูกจัดเก็บต่อกันเป็น “บล็อก” ไปเรื่อย ๆ จึงได้ชื่อว่า Blockchain นั่นเอง จุดเด่นคือ ไม่มีตัวกลาง, โปร่งใส, และ ตรวจสอบได้

ถ้าเปรียบเทียบให้เห็นภาพ:

• แอปทั่วไปที่เราใช้ทุกวันจะมีเซิร์ฟเวอร์ที่ถูกควบคุมโดยเจ้าของแอป → เราไม่สามารถเข้าไปตรวจสอบได้

• แต่ใน Blockchain ใคร ๆ ก็ตรวจสอบข้อมูลได้ และยังคัดลอก (สำเนา) ข้อมูลมาเก็บไว้เองได้ทันที

Blockchain Layer 1 คือโครงสร้างหลักของระบบบล็อกเชน ที่สามารถเก็บและยืนยันธุรกรรมได้ด้วยตัวเอง เหมือนเป็น “ระบบปฏิบัติการ” (OS) ของ Blockchain เลย ทำให้แอปต่างๆ สามารถมาสร้างพัฒนาต่อยอดบนระบบได้

ตัวอย่าง Layer-1 ที่หลายคนอาจเคยได้ยิน เช่น Bitcoin, Ethereum, Solana เป็นต้น

SUI เป็น Layer 1 blockchain ที่ออกแบบมาเพื่อรองรับธุรกรรมจำนวนมาก (High throughput) และทำงานด้วยความเร็วสูง (Low latency) ค่าธรรมเนียมต่ำ เหมาะสำหรับการสร้าง dApps (Decentralized Application) ที่มอบประสบการณ์ใช้งานใกล้เคียงกับแอปพลิเคชันที่พวกเราใช้งานกันอยู่ทุกวันนี้ เอาละพวกเรามาเริ่มดูข้อมูลทั่วไปของ SUI กันก่อนดีกว่า

• SUI ถูกพัฒนาโดยบริษัท Mysten Labs ซึ่งเป็นบริษัทที่อดีตวิศวกรจาก Facebook หรือที่เรียกว่า Meta ในปัจจุบัน เป็นผู้ก่อตั้งในเดือนกันยายน 2021 โดยเป็นกลุ่มวิศวกรที่ดูแลโครงการ Novi/Diem นั้นเอง (Diem คือโครงการพัฒนาเกี่ยวกับ Stablecoin เเละ Novi คือโครงการพัฒนาเกี่ยวกับ Crypto wallet)

• ในส่วนผู้ร่วมก่อตั้งนั้นจะมีทั้งหมด 4 ท่านด้วยกัน ซึ่งต้องบอกว่าแต่ละท่านมีประวัติการทำงานที่สุดโหดทั้งนั้น

  • Evan Cheng (CEO) – เคยเป็น Head of R&D ที่ Novi และ Technical Director ที่ Meta (https://x.com/evanweb3)

  • Sam Blackshear (CTO) – เคยเป็นหัวหน้าฝ่ายวิศวกรรมที่ Novi และเป็นผู้เชี่ยวชาญด้านภาษา Move (https://x.com/b1ackd0g)

  • Adeniyi Abiodun (CPO) – เคยเป็นหัวหน้าฝ่าย Product Development ที่ Novi (https://x.com/EmanAbio)

  • George Danezis (Chief Scientist) – เคยทำงานวิจัยที่ Novi (https://x.com/GDanezis)

• ระดมทุนไปได้ทั้งสิ้นกว่า 400 ล้านเหรียญ

• เปิดตัวไปเมื่อวันที่ 3 พฤษาคม 2023 (Mainnet TGE)

SUI ใช้ระยะเวลาเพียง 2 ปีเท่านั้น ก็ได้กระโดดเข้ามาเป็น Layer 1 network เเถวหน้าของโลก ซึ่งปัจจุบันตัวโครงการมีมูลค่ากว่า 33 พันล้านเหรียญ อยู่ใน 10 อันดับแรกของโครงการที่มูลค่าสูงสุดในกลุ่มของ layer 1 ซึ่งปัจจุบันมีสินทรัพย์ที่ถูกฝากอยู่ในตัวโครงการ ถึง 2 พันล้านเหรียญเลยทีเดียว

จุดเด่นหลักๆของ SUI Network คือ

• Layer 1 Blockchain

  มีระบบฉันทามติและการตรวจสอบธุรกรรมของตัวเอง ไม่ต้องพึ่งพาเชนอื่น

• ใช้ภาษา Move

  ภาษาที่เน้นความปลอดภัยและยืดหยุ่น เหมาะกับการจัดการทรัพย์สินดิจิทัล ซึ่งภาษา Move ถูกพัฒนามาจาก Rust อีกถอดนึง

• Object-Centric Model

  ทรัพย์สินถูกเก็บในรูปแบบ วัตถุ (object) ทำให้รองรับการทำงานที่ซับซ้อนได้

ทำไม SUI Network ถึงน่าสนใจนะเหรอ นี้คือ 4 เหตุผลหลักๆ

1. เทคโนโลยีที่ออกแบบมาเพื่ออนาคต
   SUI ทำธุรกรรมได้เร็ว ค่าธรรมเนียมถูก รองรับคนใช้งานพร้อมกันเยอะ ๆ แบบไม่สะดุด

2. ประสบการณ์ผู้ใช้ที่ใกล้เคียง Web2
   การโอน การเล่นเกม หรือใช้งานแอปต่าง ๆ บน SUI แทบจะทันที เหมือนใช้แอปมือถือทั่วไป

3. Ecosystem ที่กำลังเติบโต
   มีทั้งเกม, NFT, DeFi ที่ถูกสร้างบน SUI Ecosystem เป็นจำนวนมาก

4. ทีมผู้ก่อตั้งที่มีประสบการณ์
   มาจากทีม Diem (Facebook) ที่เคยทำโปรเจกต์ใหญ่ระดับโลกมาก่อน เรียกได้ว่าเป็นตัวตึง

เริ่มน่าสนใจขึ้นมาบ้างแล้วใช่ไหมละ… เกริ่นกันแค่นี้ก่อน ยังมีข้อมูลเชิงลึกอีกมากมาย เดียวเราจะเขียนเเยกเป็นเรื่องๆไปนะ โดยเฉพาะสายนักพัฒนา เราจะได้มาเรียน Move ด้วยกันจาก Zero to Hero ฝากกดติดตามไว้ด้วยน๊า…

Facebook group: https://www.facebook.com/groups/onthemoveth

X: https://x.com/onthemoveth

By Por | ContributionDAO