วิธีใช้ Solana API: คู่มือฉบับสมบูรณ์สำหรับนักพัฒนา

จะเป็นอย่างไรหากคุณสามารถสร้างแอปพลิเคชันบล็อกเชนที่ประมวลผลธุรกรรมได้ 65,000 รายการต่อวินาทีด้วยความสมบูรณ์ของธุรกรรมภายใน 400 มิลลิวินาที? API ของ Solana ทำให้สิ่งนี้เป็นไปได้ โดยนำเสนออินเทอร์เฟซ JSON-RPC ที่ช่วยให้คุณสามารถสอบถามบัญชี ส่งธุรกรรม และสมัครรับการอัปเดตแบบเรียลไทม์โดยไม่ต้องจัดการโครงสร้างพื้นฐานของผู้ตรวจสอบความถูกต้องด้วยตนเอง

การพัฒนาบล็อกเชนแบบดั้งเดิมบังคับให้คุณต้องเลือกระหว่างความเร็วและการกระจายอำนาจ 15 TPS ของ Ethereum สร้างคอขวดระหว่างที่เครือข่ายแออัด โซลูชัน Layer 2 เพิ่มความซับซ้อน Solana ขจัดข้อแลกเปลี่ยนนี้ด้วยกลไกฉันทามติแบบ Proof-of-History (PoH) ที่รวมเข้ากับ Proof-of-Stake (PoS) ซึ่งให้ประสิทธิภาพระดับ Web2 พร้อมการรับประกันของ Web3 คุณสามารถสร้างแอปพลิเคชันที่ให้ความรู้สึกฉับไวในขณะที่ยังคงรักษาการต่อต้านการเซ็นเซอร์

สารบัญ:

• ทำความเข้าใจสถาปัตยกรรมของ Solana
• การตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ
• วิธีการ Core RPC API
• การสร้างธุรกรรมด้วย Web3.js
• แนวปฏิบัติที่ดีที่สุดด้านความปลอดภัย
• สรุป

ทำความเข้าใจสถาปัตยกรรมของ Solana

Solana ใช้สถาปัตยกรรมที่เป็นเอกลักษณ์ซึ่งมีศูนย์กลางอยู่ที่ Solana Program Library (SPL) และรันไทม์ที่มีปริมาณงานสูง การทำความเข้าใจพื้นฐานเหล่านี้ช่วยให้คุณสามารถเขียนการเรียก API ได้อย่างมีประสิทธิภาพ

Proof of History (PoH)

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

บัญชีและโปรแกรม

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

ทุกบัญชีมีที่อยู่ 32 ไบต์ที่ไม่ซ้ำกัน ซึ่งได้มาจากคีย์สาธารณะ Ed25519 บัญชีจะจ่ายค่าธรรมเนียม (rent) เป็น lamports (1 SOL = 10^9 lamports) เพื่อให้อยู่บนเชนต่อไป บัญชีที่ได้รับการยกเว้นค่าธรรมเนียม—คือบัญชีที่ถือค่าธรรมเนียมอย่างน้อย 2 ปี—จะคงอยู่ตลอดไปโดยไม่เสื่อมสลาย

ระดับการยืนยัน (Commitment Levels)

Solana มีระดับการยืนยันสามระดับ:

• Processed: ธุรกรรมถูกประมวลผลโดยผู้นำปัจจุบันแต่ยังไม่ได้รับการยืนยัน การตอบสนองที่เร็วที่สุด ความแน่นอนต่ำที่สุด
• Confirmed: ธุรกรรมได้รับการยืนยันโดยคลัสเตอร์ โดยเฉลี่ยประมาณ 5-10 วินาที
• Finalized: ธุรกรรมถูกฝังรากและไม่สามารถย้อนกลับได้ ประมาณ 12-15 วินาที

ระบุระดับการยืนยันในการเรียก API เพื่อสร้างสมดุลระหว่างความเร็วกับการรับประกันความสมบูรณ์ของธุรกรรม

การตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ

คุณต้องมีสามองค์ประกอบ: Solana CLI สำหรับการจัดการคีย์และการปรับใช้, RPC endpoint สำหรับการเข้าถึงบล็อกเชน และ JavaScript SDK สำหรับการรวมแอปพลิเคชัน

การติดตั้ง Solana CLI

ติดตั้งเครื่องมือ CLI อย่างเป็นทางการ:

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

ตรวจสอบการติดตั้ง:

solana --version

กำหนดค่าสภาพแวดล้อมของคุณสำหรับ Devnet (สำหรับการทดสอบ) หรือ Mainnet (สำหรับการผลิต):

# For development
solana config set --url https://api.devnet.solana.com

# For production
solana config set --url https://api.mainnet-beta.solana.com

การสร้างกระเป๋าเงิน

สร้างคู่คีย์ใหม่สำหรับการลงนามธุรกรรม:

solana-keygen new --outfile ~/.config/solana/id.json

CLI จะแสดงที่อยู่สาธารณะของคุณและวลีรหัสผ่าน 12 คำ (seed phrase) จัดเก็บวลีรหัสผ่านอย่างปลอดภัย—ซึ่งใช้ในการกู้คืนกระเป๋าเงินของคุณ ไฟล์ JSON มีคีย์ส่วนตัวของคุณ; ปกป้องด้วยการตั้งค่าสิทธิ์ไฟล์ (chmod 600)

ตรวจสอบยอดคงเหลือของคุณ:

solana balance

เติมเงินในกระเป๋าเงิน Devnet ของคุณด้วย SOL ฟรี:

solana airdrop 2

การแจกจ่าย Airdrop ของ Devnet จะให้ 2 SOL ต่อคำขอ จำกัดเพียงหนึ่งคำขอต่อ 10 วินาที สำหรับ Mainnet จำเป็นต้องซื้อ SOL ผ่านการแลกเปลี่ยน

การเลือกผู้ให้บริการ RPC

แม้ว่า Solana จะมี RPC endpoints สาธารณะ แต่แอปพลิเคชันที่ใช้งานจริงจำเป็นต้องมีโครงสร้างพื้นฐานเฉพาะ ตัวเลือกได้แก่:

• Helius: https://mainnet.helius-rpc.com/?api-key=YOUR_KEY
• QuickNode: https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY
• Chainstack: โหนดเฉพาะระดับองค์กร

โดยทั่วไปแล้วแพ็กเกจฟรีจะอนุญาตให้ส่งคำขอได้ 100,000 ครั้งต่อเดือน แผนแบบชำระเงินจะเสนอขีดจำกัดที่สูงขึ้น, การเชื่อมต่อแบบ Stake สำหรับการยืนยันธุรกรรม และ API สำหรับค่าธรรมเนียมลำดับความสำคัญ

การติดตั้ง Web3.js

Solana's JavaScript SDK มีสองเวอร์ชันหลัก เวอร์ชัน 2.0 เป็นการเขียนใหม่ทั้งหมดด้วยรูปแบบการเขียนโปรแกรมเชิงฟังก์ชัน, ความสามารถในการตัดโค้ดที่ไม่จำเป็นออก (tree-shakability) และไม่มีการพึ่งพาใดๆ (zero dependencies)

ติดตั้งเวอร์ชัน 2.0:

npm install @solana/web3.js@2 @solana-program/system @solana-program/compute-budget

สำหรับการใช้งานร่วมกับเวอร์ชัน 1.x:

npm install @solana/web3.js

เคล็ดลับApidogSolana

วิธีการ Core Solana RPC API

JSON-RPC ของ Solana API มี HTTP endpoints สำหรับการสอบถามและ WebSocket endpoints สำหรับการสมัครรับข้อมูล คำขอทั้งหมดเป็นไปตามข้อกำหนด JSON-RPC 2.0

การดำเนินการเกี่ยวกับบัญชี

รับข้อมูลบัญชีและยอดคงเหลือ:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getAccountInfo",
    "params": [
      "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
      {"encoding": "base58"}
    ]
  }'

เรียกข้อมูลหลายบัญชีอย่างมีประสิทธิภาพ:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getMultipleAccounts",
    "params": [
      [
        "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
        "4fYNw3dojWGPgVMtUU7ziPwq1r2VMGrhCrKZC9EQTbkV"
      ],
      {"encoding": "base64"}
    ]
  }'

การสอบถามบล็อกและธุรกรรม

รับ blockhash ล่าสุดสำหรับการสร้างธุรกรรม:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getLatestBlockhash",
    "params": [{"commitment": "confirmed"}]
  }'

สอบถามสถานะธุรกรรม:

curl https://api.devnet.solana.com \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "getSignatureStatuses",
    "params": [
      [
        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpEz7CmGVZxhEHppBrGK"
      ],
      {"searchTransactionHistory": true}
    ]
  }'

การสมัครรับข้อมูล WebSocket

ตรวจสอบการเปลี่ยนแปลงบัญชีแบบเรียลไทม์:

import { createSolanaRpcSubscriptions } from "@solana/web3.js";

const rpcSubscriptions = createSolanaRpcSubscriptions(
  "wss://api.devnet.solana.com"
);

const abortController = new AbortController();

await rpcSubscriptions.accountNotifications(
  "vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36zEGQp",
  { commitment: "confirmed" },
  (notification) => {
    console.log("Account changed:", notification);
  },
  { abortSignal: abortController.signal }
);

// Stop listening after 60 seconds
setTimeout(() => abortController.abort(), 60000);

การเชื่อมต่อ WebSocket ต้องมีการส่ง ping เป็นระยะทุกๆ 30-60 วินาทีเพื่อให้ยังคงทำงานอยู่ได้ ใช้วิธีการเชื่อมต่อใหม่ (reconnection logic) สำหรับแอปพลิเคชันที่ใช้งานจริง

เคล็ดลับมือโปรApidogSolana

การสร้างธุรกรรมด้วย Web3.js

ธุรกรรมของ Solana ประกอบด้วยคำสั่งตั้งแต่หนึ่งคำสั่งขึ้นไปที่มุ่งเป้าไปที่โปรแกรมเฉพาะ แต่ละคำสั่งจะระบุโปรแกรม บัญชีที่โปรแกรมโต้ตอบด้วย และข้อมูลที่ถูกจัดเรียง (serialized data)

การสร้างธุรกรรมการโอน

โอน SOL ระหว่างบัญชีโดยใช้ SDK เวอร์ชัน 2.0:

import {
  airdropFactory,
  createKeyPairSignerFromBytes,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  generateKeyPairSigner,
  lamports,
  sendAndConfirmTransactionFactory,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  signTransactionMessageWithSigners,
  getSignatureFromTransaction,
} from "@solana/web3.js";
import { getTransferSolInstruction } from "@solana-program/system";

const LAMPORTS_PER_SOL = BigInt(1_000_000_000);

// Setup RPC connections
const rpc = createSolanaRpc("https://api.devnet.solana.com");
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");
const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });

// Generate sender and recipient
const sender = await generateKeyPairSigner();
const recipient = await generateKeyPairSigner();

// Fund sender with airdrop
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: sender.address,
  lamports: lamports(2n * LAMPORTS_PER_SOL),
  commitment: "confirmed",
});

// Get latest blockhash
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// Build transaction using pipe
const transactionMessage = pipe(
  createTransactionMessage({ version: 0 }),
  (msg) => setTransactionMessageFeePayer(sender.address, msg),
  (msg) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
  (msg) => appendTransactionMessageInstruction(
    getTransferSolInstruction({
      amount: lamports(LAMPORTS_PER_SOL / BigInt(2)),
      destination: recipient.address,
      source: sender,
    }),
    msg
  )
);

// Sign and send
const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
console.log("Transaction signed");

await sendAndConfirmTransaction(signedTransaction, {
  commitment: "confirmed",
  maxRetries: 0n,
  skipPreflight: true,
});

console.log("Confirmed:", getSignatureFromTransaction(signedTransaction));

ฟังก์ชัน pipe สร้างสายโซ่ฟังก์ชันที่แต่ละขั้นตอนจะแปลงข้อความธุรกรรม รูปแบบนี้ช่วยขจัดสถานะที่เปลี่ยนแปลงได้ (mutable state) และทำให้การสร้างธุรกรรมเป็นแบบประกาศ (declarative)

การปรับปรุงประสิทธิภาพด้วยค่าธรรมเนียมลำดับความสำคัญ (Priority Fees)

ในระหว่างที่เครือข่ายแออัด ค่าธรรมเนียมลำดับความสำคัญ (priority fees) ช่วยให้มั่นใจว่าธุรกรรมจะถูกรวมอยู่ด้วย ดึงค่าธรรมเนียมที่แนะนำจาก Helius API:

import { getBase64EncodedWireTransaction } from "@solana/web3.js";

const base64Transaction = getBase64EncodedWireTransaction(signedTransaction);

const response = await fetch("https://mainnet.helius-rpc.com/?api-key=YOUR_KEY", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    id: "priority-fee-request",
    method: "getPriorityFeeEstimate",
    params: [{
      transaction: base64Transaction,
      options: { recommended: true }
    }]
  })
});

const { result } = await response.json();
const priorityFee = result.priorityFeeEstimate;

// Add priority fee instruction
import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";

const optimizedMessage = pipe(
  transactionMessage,
  (msg) => appendTransactionMessageInstruction(
    getSetComputeUnitPriceInstruction({ microLamports: priorityFee }),
    msg
  )
);

ค่าธรรมเนียมลำดับความสำคัญจะระบุเป็น micro-lamports ต่อ compute unit ค่าธรรมเนียมที่สูงขึ้นจะเพิ่มลำดับความสำคัญของธุรกรรมในระหว่างที่เครือข่ายแออัด

การจัดการข้อผิดพลาด

Solana จะส่งคืนรหัสข้อผิดพลาดเฉพาะสำหรับข้อผิดพลาดทั่วไป:

import { isSolanaError, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE } from "@solana/web3.js";

try {
  await sendAndConfirmTransaction(signedTransaction);
} catch (error) {
  if (isSolanaError(error)) {
    switch (error.contextErrorCode) {
      case SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE:
        console.error("Preflight failed:", error.message);
        break;
      default:
        console.error("Solana error:", error);
    }
  }
}

ข้อผิดพลาดทั่วไป ได้แก่ เงินไม่เพียงพอ (0x1), blockhash ไม่ถูกต้อง (หมดอายุ) และบัญชีถูกใช้งานอยู่ (ข้อขัดแย้งในการทำธุรกรรม)

แนวทางปฏิบัติที่ดีที่สุดด้านความปลอดภัย

ปริมาณงานที่สูงของ Solana ทำให้เกิดข้อพิจารณาด้านความปลอดภัยที่ไม่เหมือนใคร ใช้วิธีการเหล่านี้เพื่อปกป้องแอปพลิเคชันและผู้ใช้ของคุณ

การจัดการคีย์

ห้ามคอมมิตคีย์ส่วนตัวไปยังระบบควบคุมเวอร์ชัน (version control) โดยเด็ดขาด ใช้ตัวแปรสภาพแวดล้อม (environment variables) แทน:

# .env
SOLANA_PRIVATE_KEY="[1,2,3,...]"

โหลดคีย์อย่างปลอดภัยในแอปพลิเคชันของคุณ:

import { createKeyPairSignerFromBytes } from "@solana/web3.js";
import { getBase58Encoder } from "@solana/codecs";

const secretKey = JSON.parse(process.env.SOLANA_PRIVATE_KEY);
const signer = await createKeyPairSignerFromBytes(
  new Uint8Array(secretKey)
);

สำหรับแอปพลิเคชันเบราว์เซอร์ ให้รวมอะแดปเตอร์กระเป๋าเงิน (เช่น Phantom, Solflare) แทนที่จะจัดการคีย์ส่วนตัวโดยตรง ผู้ใช้ลงนามธุรกรรมผ่านส่วนขยายกระเป๋าเงินของตน เพื่อรักษาคีย์ให้ปลอดภัย

การจำลองธุรกรรม

ควรจำลองธุรกรรมก่อนส่งเสมอเพื่อตรวจจับข้อผิดพลาดตั้งแต่เนิ่นๆ:

const simulationResult = await rpc.simulateTransaction(signedTransaction).send();

if (simulationResult.value.err) {
  console.error("Simulation failed:", simulationResult.value.err);
  // Handle error without wasting fees
}

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

การป้องกันการเล่นซ้ำ (Replaying Protection)

ธุรกรรมของ Solana จะมี blockhash ล่าสุดที่หมดอายุหลังจากประมาณ 90 วินาที ซึ่งช่วยป้องกันการโจมตีแบบเล่นซ้ำ (replay attacks)—คือการส่งธุรกรรมเดียวกันหลายครั้ง สำหรับการดำเนินการที่ทำซ้ำได้ผลลัพธ์เหมือนเดิม (idempotent operations) ให้สร้างข้อมูลคำสั่งหรือบัญชีที่ไม่ซ้ำกันสำหรับแต่ละธุรกรรม

การจำกัดอัตรา (Rate Limiting)

RPC endpoints สาธารณะมีการจำกัดอัตราที่เข้มงวด (โดยทั่วไปคือ 100 คำขอต่อ 10 วินาที) ใช้วิธี exponential backoff:

async function withRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429) {
        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, i)));
        continue;
      }
      throw error;
    }
  }
}

สำหรับการใช้งานจริง ให้ใช้โหนด RPC เฉพาะหรือแพ็กเกจผู้ให้บริการแบบชำระเงินที่มีขีดจำกัดสูงกว่า

การตรวจสอบโปรแกรม

ก่อนที่จะโต้ตอบกับโปรแกรมของบุคคลที่สาม ให้ตรวจสอบซอร์สโค้ดของโปรแกรมเหล่านั้นบน explorer เช่น SolanaFM หรือ Solscan มองหาเครื่องหมาย "verified" ที่ระบุว่า bytecode ที่ถูกปรับใช้นั้นตรงกับที่เก็บโอเพนซอร์ส โปรแกรมที่ไม่ได้รับการยืนยันอาจมีตรรกะที่เป็นอันตรายที่สามารถดูดเงินของผู้ใช้ไปได้

สรุป

API ของ Solana มอบประสิทธิภาพที่แอปพลิเคชันสมัยใหม่ต้องการ—ความสมบูรณ์ของธุรกรรมภายในหนึ่งวินาที (sub-second finality), ปริมาณงานสูง และค่าธรรมเนียมที่คาดการณ์ได้ คุณสามารถสอบถามสถานะบัญชีผ่าน JSON-RPC, สมัครรับการอัปเดตแบบเรียลไทม์ผ่าน WebSocket และสร้างธุรกรรมโดยใช้ Web3.js 2.0 SDK ที่เป็นเชิงฟังก์ชัน สถาปัตยกรรมที่อิงบัญชีช่วยให้การดำเนินการแบบขนานเป็นไปได้ ในขณะที่ระดับการยืนยัน (commitment levels) ช่วยให้คุณเลือกความสมดุลระหว่างความปลอดภัยและความเร็วได้

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

เริ่มต้นใช้งาน Apidog วันนี้—นำเข้า Solana API endpoints ของคุณได้ในไม่กี่วินาที และเริ่มทดสอบได้ทันทีโดยไม่ต้องตั้งค่าใดๆ