Solana 우선 수수료 추정: 직렬화된 트랜잭션 방법

가장 정확한 방법: 정확한 트랜잭션을 분석하여 가장 정밀한 우선 수수료 추정을 얻습니다. 정확도가 가장 중요한 프로덕션 애플리케이션에 권장됩니다.

개요

직렬화된 트랜잭션은 가장 정확한 수수료 추정을 제공합니다. API는 트랜잭션에서 수행될 정확한 계정 및 작업을 분석할 수 있기 때문입니다.

직렬화된 트랜잭션을 사용하는 이유

가장 높은 정확도 - 정확한 작업 분석
상세 분석 - 명령어별 패턴
현실적인 추정치 - 실제 트랜잭션 반영
프로덕션 준비 완료 - 중요한 애플리케이션에 적합

적합 대상

프로덕션 애플리케이션
복잡한 트랜잭션
중요한 작업
최대 정확도 필요

계정 키 대비 장점

정확도 이점
실제 이점

명령어별 분석

API는 계정 활동뿐만 아니라 특정 작업 및 그에 따른 역사적 수수료 패턴을 분석할 수 있습니다.

트랜잭션 크기 인식

트랜잭션의 실제 크기와 복잡성을 고려하여 더 정확한 추정을 제공합니다.

읽기 전용 계정 처리

트랜잭션 문맥에서 읽기 및 쓰기 가능한 계정을 더 잘 분석합니다.

구현 가이드

트랜잭션 작성

모든 명령어(우선 수수료 제외)와 함께 트랜잭션을 생성합니다.

트랜잭션 직렬화

트랜잭션을 직렬화된 형식으로 변환합니다.

수수료 추정 받기

직렬화된 트랜잭션으로 우선 수수료 API를 호출합니다.

우선 수수료 적용

우선 수수료 명령어를 추가하고 트랜잭션을 전송합니다.

빠른 시작 예제

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")

핵심 구현 함수

여기 직렬화된 트랜잭션에서 우선 수수료 추정을 위한 재사용 가능한 함수가 있습니다:

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;
}

완전한 구현 예제

간단한 전송
토큰 전송
복잡한 다중 명령어

완전한 예제를 보려면 확장

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

완전한 예제를 보려면 확장

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;
}

완전한 예제를 보려면 확장

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;
}

고급 구성 옵션

모든 우선 순위 수준 포함

모든 우선 순위 수준에 대한 추정을 한 번에 얻습니다:

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
}
*/

상세 분석 포함

수수료 계산에 대한 상세한 정보를 요청합니다:

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;
}

이는 수수료 계산 방식에 대한 통찰력을 제공합니다. 계정별 분석을 포함합니다.

사용자 지정 조회 기간

분석된 슬롯 수를 조정합니다:

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`);

모범 사례

트랜잭션 직렬화

항상 실제 트랜잭션을 직렬화 하세요, 단순화된 버전이 아닙니다

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

명령어 순서

우선 수수료를 제외한 모든 명령어를 추정 트랜잭션에 포함하세요

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

// ❌ Don't include priority fee in estimation

오류 처리 전략

견고한 오류 처리
간단한 오류 처리

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;
    }
  }
}

일반적인 문제 및 해결책

트랜잭션 직렬화 오류

문제: 불완전한 트랜잭션 직렬화 오류해결책: 직렬화 전에 필요한 필드를 항상 설정하세요:

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

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

오래된 블록해시 문제

문제: 오래된 블록해시 사용으로 인한 트랜잭션 실패해결책: 최종 전송 전에 항상 최신 블록해시를 받으세요:

// 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;

큰 트랜잭션 오류

문제: 직렬화에 너무 큰 트랜잭션해결책: 버전화된 트랜잭션을 사용하거나 여러 트랜잭션으로 나누세요:

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());

언제 사용해야 하는지 vs 계정 키

직렬화된 트랜잭션 사용

프로덕션 애플리케이션

최대 정확도 필요
복잡한 다중 명령어 트랜잭션
중요한 작업
성능 민감 애플리케이션

개발 시나리오

최종 통합 테스트
성능 최적화
프로덕션 배포

계정 키 사용

개발 및 프로토타이핑

개발 중 빠른 추정
간단한 트랜잭션
사전 트랜잭션 계획
직렬화를 허용하지 않는 아키텍처 제약

분석 시나리오

계정 수준의 수수료 패턴 분석
배치 계정 분석
빠른 시장 조사

계정 키 방법

특수한 사용 사례를 위한 계정 키를 사용하는 고급 방법

API 참고 자료

전체 API 문서 및 매개변수

시작하기

데이터 스트리밍 및 이벤트 수신

데이터 API 및 RPC

거래

거래 보내기

서비스로서의 지갑

안내서

리소스

Solana 우선 수수료 추정: 직렬화된 트랜잭션 방법

개요

직렬화된 트랜잭션을 사용하는 이유

적합 대상

계정 키 대비 장점

명령어별 분석

트랜잭션 크기 인식

읽기 전용 계정 처리

디파이 거래

NFT 민팅

다중 명령어 트랜잭션

프로그램 상호작용

구현 가이드

빠른 시작 예제

핵심 구현 함수

완전한 구현 예제

고급 구성 옵션

모범 사례

트랜잭션 직렬화

명령어 순서

오류 처리 전략

일반적인 문제 및 해결책

언제 사용해야 하는지 vs 계정 키

직렬화된 트랜잭션 사용

계정 키 사용

관련 자료

계정 키 방법

API 참고 자료

​개요

직렬화된 트랜잭션을 사용하는 이유

적합 대상

​계정 키 대비 장점

명령어별 분석

트랜잭션 크기 인식

읽기 전용 계정 처리

​디파이 거래

​NFT 민팅

​다중 명령어 트랜잭션

​프로그램 상호작용

​구현 가이드

​빠른 시작 예제

​핵심 구현 함수

​완전한 구현 예제

​고급 구성 옵션

​모범 사례

트랜잭션 직렬화

명령어 순서

​오류 처리 전략

​일반적인 문제 및 해결책

​언제 사용해야 하는지 vs 계정 키

직렬화된 트랜잭션 사용

계정 키 사용

​관련 자료

계정 키 방법

API 참고 자료

개요

계정 키 대비 장점

디파이 거래

NFT 민팅

다중 명령어 트랜잭션

프로그램 상호작용

구현 가이드

빠른 시작 예제

핵심 구현 함수

완전한 구현 예제

고급 구성 옵션

모범 사례

오류 처리 전략

일반적인 문제 및 해결책

언제 사용해야 하는지 vs 계정 키

관련 자료