Ước tính phí ưu tiên Solana: Phương thức giao dịch được tuần tự hóa

Phương thức chính xác nhất: Nhận kết quả ước tính phí ưu tiên có độ chính xác cao nhất bằng cách phân tích chính xác giao dịch của bạn. Nên dùng cho các ứng dụng production cần độ chính xác tối đa.

Tổng quan

Giao dịch được tuần tự hóa cung cấp kết quả ước tính phí chính xác nhất vì API có thể phân tích chính xác các tài khoản và thao tác sẽ được thực hiện trong giao dịch của bạn.

Why Use Serialized Transactions

Độ chính xác cao nhất - Phân tích chính xác các thao tác
Phân tích chi tiết - Các mẫu riêng cho từng chỉ thị
Ước tính thực tế - Phản ánh giao dịch thực tế
Sẵn sàng cho production - Được xây dựng cho các ứng dụng quan trọng

Best For

Ứng dụng production
Giao dịch phức tạp
Thao tác quan trọng
Trường hợp cần độ chính xác tối đa

Ưu điểm so với khóa tài khoản

Accuracy Benefits
Real-World Benefits

Instruction-Specific Analysis

API có thể phân tích các thao tác cụ thể và mẫu phí trước đây của chúng, không chỉ hoạt động của tài khoản.

Transaction Size Awareness

Xem xét kích thước và độ phức tạp thực tế của giao dịch để đưa ra kết quả ước tính chính xác hơn.

Read-Only Account Handling

Phân tích tốt hơn cả tài khoản có thể ghi và tài khoản chỉ đọc trong ngữ cảnh giao dịch.

Hướng dẫn triển khai

Build Your Transaction

Tạo giao dịch với tất cả chỉ thị (ngoại trừ phí ưu tiên)

Serialize the Transaction

Chuyển đổi giao dịch sang định dạng tuần tự hóa

Get Fee Estimate

Gọi Priority Fee API bằng giao dịch được tuần tự hóa

Apply Priority Fee

Thêm chỉ thị phí ưu tiên và gửi giao dịch

Ví dụ bắt đầu nhanh

import { 
  Connection, 
  PublicKey, 
  Transaction, 
  SystemProgram, 
  ComputeBudgetProgram 
} from "@solana/web3.js";
import bs58 from "bs58";

const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");

// 1. Build your transaction (without priority fee)
const transaction = new Transaction();
const transferIx = SystemProgram.transfer({
  fromPubkey: senderKeypair.publicKey,
  toPubkey: recipientPublicKey,
  lamports: 1000000, // 0.001 SOL
});
transaction.add(transferIx);

// 2. Set required fields and serialize
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.feePayer = senderKeypair.publicKey;
const serializedTx = bs58.encode(transaction.serialize());

// 3. Get priority fee estimate
const priorityFee = await getPriorityFeeEstimate(connection, serializedTx, "Medium");

// 4. Add priority fee and send
transaction.instructions = []; // Reset
transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
transaction.add(transferIx);
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.sign(senderKeypair);

import requests
import json
from solana.transaction import Transaction
from solana.system_program import transfer, TransferParams

# Build and serialize transaction
def get_serialized_transaction():
    # Build your transaction here
    # Return base58 encoded serialized transaction
    pass

# Get priority fee estimate
def get_priority_fee_estimate(serialized_tx, priority_level="Medium"):
    response = requests.post(
        "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY",
        json={
            "jsonrpc": "2.0",
            "id": "1",
            "method": "getPriorityFeeEstimate",
            "params": [{
                "transaction": serialized_tx,
                "options": {
                    "priorityLevel": priority_level,
                    "recommended": True
                }
            }]
        }
    )
    return response.json()["result"]["priorityFeeEstimate"]

# Usage
serialized_tx = get_serialized_transaction()
fee = get_priority_fee_estimate(serialized_tx, "High")
print(f"Priority fee: {fee} micro-lamports")

Hàm triển khai cốt lõi

Dưới đây là một hàm có thể tái sử dụng để nhận kết quả ước tính phí ưu tiên từ giao dịch được tuần tự hóa:

async function getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: priorityLevel,
          recommended: true 
        }
      }]
    })
  });
  
  const result = await response.json();
  
  if (result.error) {
    throw new Error(`Fee estimation failed: ${JSON.stringify(result.error)}`);
  }
  
  return result.result.priorityFeeEstimate;
}

Ví dụ triển khai hoàn chỉnh

Simple Transfer
Token Transfer
Complex Multi-Instruction

Expand to see complete example

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  SystemProgram, 
  ComputeBudgetProgram, 
  sendAndConfirmTransaction,
  Keypair
} = require("@solana/web3.js");
const bs58 = require("bs58");

// Initialize connection and accounts
const connection = new Connection("https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY");
const senderKeypair = Keypair.fromSecretKey(bs58.decode("YOUR_PRIVATE_KEY"));
const receiverPublicKey = new PublicKey("RECIPIENT_PUBLIC_KEY");

async function sendTransactionWithPriorityFee(amount, priorityLevel = "Medium") {
  // 1. Create transaction with transfer instruction
  const transaction = new Transaction();
  const transferIx = SystemProgram.transfer({
    fromPubkey: senderKeypair.publicKey,
    toPubkey: receiverPublicKey,
    lamports: amount,
  });
  transaction.add(transferIx);
  
  // 2. Set required fields for serialization
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  
  // 3. Serialize the transaction
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 4. Get priority fee estimate
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  console.log(`Estimated ${priorityLevel} priority fee: ${priorityFee} micro-lamports`);
  
  // 5. Reset transaction and add priority fee instruction first
  transaction.instructions = [];
  
  // Add priority fee instruction
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Re-add the original transfer instruction
  transaction.add(transferIx);
  
  // 6. Update blockhash and sign
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  
  // 7. Send the transaction
  try {
    const signature = await sendAndConfirmTransaction(
      connection,
      transaction,
      [senderKeypair],
      { maxRetries: 0 } // Set to 0 for staked connection usage
    );
    console.log(`Transaction successful with signature: ${signature}`);
    return signature;
  } catch (error) {
    console.error("Error sending transaction:", error);
    throw error;
  }
}

// Usage
sendTransactionWithPriorityFee(1000000, "High"); // Send 0.001 SOL with high priority

Expand to see complete example

const { 
  Connection, 
  PublicKey, 
  Transaction, 
  ComputeBudgetProgram,
  sendAndConfirmTransaction,
  Keypair
} = require("@solana/web3.js");
const { 
  createTransferInstruction,
  getAssociatedTokenAddress,
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID
} = require("@solana/spl-token");
const bs58 = require("bs58");

async function sendTokenWithPriorityFee(
  connection,
  senderKeypair,
  recipientPublicKey,
  mintAddress,
  amount,
  priorityLevel = "Medium"
) {
  // 1. Get token account addresses
  const senderTokenAccount = await getAssociatedTokenAddress(
    mintAddress,
    senderKeypair.publicKey
  );
  
  const recipientTokenAccount = await getAssociatedTokenAddress(
    mintAddress,
    recipientPublicKey
  );
  
  // 2. Create transaction with token transfer instruction
  const transaction = new Transaction();
  const transferIx = createTransferInstruction(
    senderTokenAccount,
    recipientTokenAccount,
    senderKeypair.publicKey,
    amount,
    [],
    TOKEN_PROGRAM_ID
  );
  transaction.add(transferIx);
  
  // 3. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = senderKeypair.publicKey;
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 4. Get priority fee estimate
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  console.log(`Token transfer priority fee: ${priorityFee} micro-lamports`);
  
  // 5. Reset and rebuild transaction with priority fee
  transaction.instructions = [];
  
  // Add priority fee instruction first
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Re-add the transfer instruction
  transaction.add(transferIx);
  
  // 6. Update blockhash and send
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(senderKeypair);
  
  const signature = await sendAndConfirmTransaction(
    connection,
    transaction,
    [senderKeypair],
    { maxRetries: 0 }
  );
  
  return signature;
}

Expand to see complete example

async function complexTransactionWithPriorityFee(connection, keypair) {
  // 1. Build complex transaction with multiple instructions
  const transaction = new Transaction();
  
  // Add multiple instructions
  const createAccountIx = SystemProgram.createAccount({
    fromPubkey: keypair.publicKey,
    newAccountPubkey: newAccountKeypair.publicKey,
    lamports: await connection.getMinimumBalanceForRentExemption(165),
    space: 165,
    programId: TOKEN_PROGRAM_ID,
  });
  
  const initializeAccountIx = createInitializeAccountInstruction(
    newAccountKeypair.publicKey,
    mintAddress,
    keypair.publicKey,
    TOKEN_PROGRAM_ID
  );
  
  const transferIx = SystemProgram.transfer({
    fromPubkey: keypair.publicKey,
    toPubkey: recipientPublicKey,
    lamports: 1000000,
  });
  
  transaction.add(createAccountIx);
  transaction.add(initializeAccountIx);
  transaction.add(transferIx);
  
  // 2. Set required fields and serialize
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.feePayer = keypair.publicKey;
  const serializedTransaction = bs58.encode(transaction.serialize());
  
  // 3. Get priority fee estimate for complex transaction
  const priorityFee = await getPriorityFeeEstimate(connection, serializedTransaction, "High");
  console.log(`Complex transaction priority fee: ${priorityFee} micro-lamports`);
  
  // 4. Rebuild transaction with priority fee
  transaction.instructions = [];
  
  // Add priority fee instruction first
  const priorityFeeIx = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: priorityFee
  });
  transaction.add(priorityFeeIx);
  
  // Optional: Set compute unit limit for complex transactions
  const computeLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
    units: 400000 // Adjust based on your transaction complexity
  });
  transaction.add(computeLimitIx);
  
  // Re-add all original instructions
  transaction.add(createAccountIx);
  transaction.add(initializeAccountIx);
  transaction.add(transferIx);
  
  // 5. Update blockhash and send
  transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
  transaction.sign(keypair, newAccountKeypair);
  
  const signature = await sendAndConfirmTransaction(
    connection,
    transaction,
    [keypair, newAccountKeypair],
    { maxRetries: 0 }
  );
  
  return signature;
}

Tùy chọn cấu hình nâng cao

Include All Priority Levels

Nhận kết quả ước tính cho tất cả mức ưu tiên cùng lúc:

async function getAllPriorityLevels(connection, serializedTransaction) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          includeAllPriorityFeeLevels: true
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeLevels;
}

// Usage
const allLevels = await getAllPriorityLevels(connection, serializedTransaction);
console.log("All priority levels:", allLevels);
/*
Output:
{
  "min": 0,
  "low": 1000, 
  "medium": 5000,
  "high": 15000,
  "veryHigh": 50000,
  "unsafeMax": 100000
}
*/

Include Detailed Analysis

Yêu cầu thông tin chi tiết về cách tính phí:

async function getDetailedFeeAnalysis(connection, serializedTransaction) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          includeDetails: true,
          priorityLevel: "Medium"
        }
      }]
    })
  });
  
  const result = await response.json();
  console.log("Detailed analysis:", result.result);
  return result.result;
}

Thông tin này giúp hiểu rõ cách tính phí, bao gồm cả phân tích theo từng tài khoản.

Custom Lookback Period

Điều chỉnh số lượng slot được phân tích:

async function getCustomLookbackEstimate(connection, serializedTransaction, lookbackSlots = 50) {
  const response = await fetch(connection.rpcEndpoint, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "getPriorityFeeEstimate",
      params: [{
        transaction: serializedTransaction,
        options: { 
          priorityLevel: "Medium",
          lookbackSlots: lookbackSlots  // 1-150, default is 150
        }
      }]
    })
  });
  
  const result = await response.json();
  return result.result.priorityFeeEstimate;
}

// Compare different lookback periods
const recentEstimate = await getCustomLookbackEstimate(connection, serializedTx, 30);
const longerEstimate = await getCustomLookbackEstimate(connection, serializedTx, 100);

console.log(`Recent (30 slots): ${recentEstimate} micro-lamports`);
console.log(`Longer (100 slots): ${longerEstimate} micro-lamports`);

Các phương pháp hay nhất

Transaction Serialization

Luôn tuần tự hóa giao dịch thực tế của bạn, không dùng phiên bản đơn giản hóa

// ✅ Good - serialize actual transaction
const transaction = new Transaction();
transaction.add(actualInstruction1);
transaction.add(actualInstruction2);
const serialized = bs58.encode(transaction.serialize());

Instruction Order

Bao gồm tất cả chỉ thị ngoại trừ phí ưu tiên trong giao dịch dùng để ước tính

// ✅ Good - all business logic included
transaction.add(createAccountIx);
transaction.add(initializeIx);
transaction.add(transferIx);

// ❌ Don't include priority fee in estimation

Chiến lược xử lý lỗi

Robust Error Handling
Simple Error Handling

class SerializedTransactionFeeEstimator {
  constructor(connection) {
    this.connection = connection;
    this.fallbackFee = 10000; // 10k micro-lamports
  }

  async getEstimate(serializedTransaction, priorityLevel = "Medium") {
    try {
      // Primary attempt with serialized transaction
      return await this.getPrimaryEstimate(serializedTransaction, priorityLevel);
    } catch (error) {
      console.warn("Serialized transaction estimate failed:", error.message);
      
      // Fallback to account-based estimation
      try {
        return await this.getFallbackEstimate(serializedTransaction, priorityLevel);
      } catch (fallbackError) {
        console.warn("Fallback estimate failed:", fallbackError.message);
        return this.getFallbackFee(priorityLevel);
      }
    }
  }

  async getPrimaryEstimate(serializedTransaction, priorityLevel) {
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          transaction: serializedTransaction,
          options: { 
            priorityLevel: priorityLevel,
            recommended: true 
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }

  async getFallbackEstimate(serializedTransaction, priorityLevel) {
    // Extract account keys from transaction and use account-based estimation
    const transaction = Transaction.from(bs58.decode(serializedTransaction));
    const accountKeys = transaction.instructions
      .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
      .map(key => key.toString());

    const uniqueAccountKeys = [...new Set(accountKeys)];
    
    // Use account-based estimation as fallback
    const response = await fetch(this.connection.rpcEndpoint, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "getPriorityFeeEstimate",
        params: [{
          accountKeys: uniqueAccountKeys,
          options: { 
            priorityLevel: priorityLevel,
            recommended: true 
          }
        }]
      })
    });

    const result = await response.json();
    if (result.error) {
      throw new Error(result.error.message);
    }
    
    return result.result.priorityFeeEstimate;
  }

  getFallbackFee(priorityLevel) {
    const fallbacks = {
      "Low": 1000,
      "Medium": 5000,
      "High": 15000,
      "VeryHigh": 50000
    };
    
    return fallbacks[priorityLevel] || 5000;
  }
}

// Usage
const estimator = new SerializedTransactionFeeEstimator(connection);
const fee = await estimator.getEstimate(serializedTransaction, "High");

async function safeGetPriorityFeeEstimate(connection, serializedTransaction, priorityLevel = "Medium") {
  try {
    return await getPriorityFeeEstimate(connection, serializedTransaction, priorityLevel);
  } catch (error) {
    console.warn(`Priority fee estimation failed: ${error.message}`);
    
    // Extract account keys and fall back to account-based estimation
    try {
      const transaction = Transaction.from(bs58.decode(serializedTransaction));
      const accountKeys = transaction.instructions
        .flatMap(ix => [ix.programId, ...ix.keys.map(k => k.pubkey)])
        .map(key => key.toString());
      
      const uniqueAccountKeys = [...new Set(accountKeys)];
      return await getAccountBasedEstimate(connection, uniqueAccountKeys, priorityLevel);
    } catch (fallbackError) {
      console.warn(`Fallback estimation failed: ${fallbackError.message}`);
      
      // Return reasonable fallback based on priority level
      const fallbacks = {
        "Low": 1000,
        "Medium": 5000,
        "High": 15000,
        "VeryHigh": 50000
      };
      
      return fallbacks[priorityLevel] || 5000;
    }
  }
}

Các vấn đề thường gặp và giải pháp

Transaction Serialization Errors

Vấn đề: Lỗi khi tuần tự hóa giao dịch chưa hoàn chỉnhGiải pháp: Luôn thiết lập các trường bắt buộc trước khi tuần tự hóa:

// ✅ Always set these fields
transaction.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.feePayer = keypair.publicKey;

// Then serialize
const serialized = bs58.encode(transaction.serialize());

Stale Blockhash Issues

Vấn đề: Sử dụng blockhash cũ khiến giao dịch thất bạiGiải pháp: Luôn lấy blockhash mới trước lần gửi cuối cùng:

// Get estimate with temporary blockhash
const tempBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.recentBlockhash = tempBlockhash;
const serialized = bs58.encode(transaction.serialize());

const priorityFee = await getPriorityFeeEstimate(connection, serialized, "Medium");

// Reset and rebuild with fresh blockhash
transaction.instructions = [];
transaction.add(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priorityFee }));
transaction.add(originalInstruction);

// Get FRESH blockhash before sending
const freshBlockhash = (await connection.getLatestBlockhash()).blockhash;
transaction.recentBlockhash = freshBlockhash;

Large Transaction Errors

Vấn đề: Giao dịch quá lớn để tuần tự hóaGiải pháp: Sử dụng giao dịch có phiên bản hoặc chia thành nhiều giao dịch:

import { VersionedTransaction, TransactionMessage } from "@solana/web3.js";

// For large transactions, use versioned transactions
const messageV0 = new TransactionMessage({
  payerKey: keypair.publicKey,
  recentBlockhash: (await connection.getLatestBlockhash()).blockhash,
  instructions: [instruction1, instruction2, instruction3] // Many instructions
}).compileToV0Message();

const versionedTransaction = new VersionedTransaction(messageV0);
const serialized = bs58.encode(versionedTransaction.serialize());

Khi nào nên sử dụng thay vì khóa tài khoản

Use Serialized Transactions

Ứng dụng production

Yêu cầu độ chính xác tối đa
Giao dịch phức tạp có nhiều chỉ thị
Thao tác quan trọng
Ứng dụng nhạy cảm với hiệu năng

Tình huống phát triển

Kiểm thử tích hợp cuối cùng
Tối ưu hóa hiệu năng
Triển khai production

Use Account Keys

Phát triển và tạo nguyên mẫu

Ước tính nhanh trong quá trình phát triển
Giao dịch đơn giản
Lập kế hoạch trước giao dịch
Các hạn chế kiến trúc ngăn cản việc tuần tự hóa

Tình huống phân tích

Phân tích mẫu phí ở cấp tài khoản
Phân tích hàng loạt tài khoản
Nghiên cứu thị trường nhanh

Tài nguyên liên quan

Account Keys Method

Phương thức nâng cao sử dụng khóa tài khoản cho các trường hợp sử dụng chuyên biệt

API Reference

Tài liệu và tham số API đầy đủ

Bắt đầu

Truyền phát dữ liệu & lắng nghe sự kiện

API dữ liệu & RPC

Giao dịch

Gửi giao dịch

Ví dưới dạng dịch vụ

Quyền riêng tư

Tài nguyên

Ước tính phí ưu tiên Solana: Phương thức giao dịch được tuần tự hóa

Tổng quan

Why Use Serialized Transactions

Best For

Ưu điểm so với khóa tài khoản

Instruction-Specific Analysis

Transaction Size Awareness

Read-Only Account Handling

Giao dịch DeFi

Đúc NFT

Giao dịch có nhiều chỉ thị

Tương tác với chương trình

Hướng dẫn triển khai

Ví dụ bắt đầu nhanh

Hàm triển khai cốt lõi

Ví dụ triển khai hoàn chỉnh

Tùy chọn cấu hình nâng cao

Các phương pháp hay nhất

Transaction Serialization

Instruction Order

Chiến lược xử lý lỗi

Các vấn đề thường gặp và giải pháp

Khi nào nên sử dụng thay vì khóa tài khoản

Use Serialized Transactions

Use Account Keys

Tài nguyên liên quan

Account Keys Method

API Reference

​Tổng quan

Why Use Serialized Transactions

Best For

​Ưu điểm so với khóa tài khoản

Instruction-Specific Analysis

Transaction Size Awareness

Read-Only Account Handling

​Giao dịch DeFi

​Đúc NFT

​Giao dịch có nhiều chỉ thị

​Tương tác với chương trình

​Hướng dẫn triển khai

​Ví dụ bắt đầu nhanh

​Hàm triển khai cốt lõi

​Ví dụ triển khai hoàn chỉnh

​Tùy chọn cấu hình nâng cao

​Các phương pháp hay nhất

Transaction Serialization

Instruction Order

​Chiến lược xử lý lỗi

​Các vấn đề thường gặp và giải pháp

​Khi nào nên sử dụng thay vì khóa tài khoản

Use Serialized Transactions

Use Account Keys

​Tài nguyên liên quan

Account Keys Method

API Reference

Tổng quan

Ưu điểm so với khóa tài khoản

Giao dịch DeFi

Đúc NFT

Giao dịch có nhiều chỉ thị

Tương tác với chương trình

Hướng dẫn triển khai

Ví dụ bắt đầu nhanh

Hàm triển khai cốt lõi

Ví dụ triển khai hoàn chỉnh

Tùy chọn cấu hình nâng cao

Các phương pháp hay nhất

Chiến lược xử lý lỗi

Các vấn đề thường gặp và giải pháp

Khi nào nên sử dụng thay vì khóa tài khoản

Tài nguyên liên quan