Get TransactionFee

Introduction

Get TransactionFee is used to obtain the priority fee and tip of Solana transactions in aggregate, supports gRPC protocol, endpoint: grpc.solana-fee.blockrazor.me:443

Rate Limit

	Tier 4	Tier 3	Tier 2	Tier 1	Tier 0
TPS	1	5	10	50	100

Request Parameter

Parameters	Mandatory	Format	Exampl	Remark
accounts	optional	string[]	["DH4xma……HFtNYJ"]	If account is not specified, priority fee and tip of all transactions in the specified slot range will be counted.
percentile	mandatory	int	50	Get the priority fee and tip of the specified quantile, enumerated value: 25, 50, 75, 95, 99
slotRange	mandatory	int	150	Statistics of priorityFee and tip of transactions in the last N confirmed slots, N ranges from 1 to 150

Request Example

package main

import (
    "context"
    "crypto/tls"
    "log"

    // directory of the generated code using the provided proto file
    pb "fee-test/feepb"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
)

const (
    gRPCEndpoint = "grpc.solana-fee.blockrazor.xyz:443" // endpoint address
    auth         = "your auth" // auth to be verified
    testAccount1 = "DH4xmaWDnTzKXehVaPSNy9tMKJxnYL5Mo5U3oTHFtNYJ" // query priority fee and tip of transactions involving a specified account 
    testAccount2 = "CAPhoEse9xEH95XmdnJjYrZdNCA8xfUWdy3aWymHa1Vj" 
)

func main() {
    // open gRPC connection to endpoint
    conn, err := grpc.Dial(
        gRPCEndpoint,
        grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
        grpc.WithPerRPCCredentials(&Authentication{auth}),
    )
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // use the gRPC client
    client := pb.NewServerClient(conn)

    req := &pb.TransactionFee{
        Accounts:   []string{}, //do not set accounts
        Percentile: 75,
        SlotRange:  150,
    }

  // send gRPC request1
    resp, err := client.GetTransactionFee(context.Background(), req)
    if err != nil {
        panic(err)
    }
    log.Printf("Response PriorityFee Percentile: %+v", resp.PriorityFee.Percentile)
    log.Printf("Response PriorityFee Value: %+v", resp.PriorityFee.Value)
    log.Printf("Response Tip Percentile: %+v", resp.Tip.Percentile)
    log.Printf("Response Tip Value: %+v", resp.Tip.Value)

    req2 := &pb.TransactionFee{
        Accounts:   []string{testAccount1, testAccount2}, //set specified accounts
        Percentile: 75,
        SlotRange:  150,
    }

    // send gRPC request2
    resp2, err := client.GetTransactionFee(context.Background(), req2)
    if err != nil {
        panic(err)
    }
    log.Printf("Response2 PriorityFee Percentile: %+v", resp2.PriorityFee.Percentile)
    log.Printf("Response2 PriorityFee Value: %+v", resp2.PriorityFee.Value)
    log.Printf("Response2 Tip Percentile: %+v", resp2.Tip.Percentile)
    log.Printf("Response2 Tip Value: %+v", resp2.Tip.Value)
}

type Authentication struct {
    auth string
}

func (a *Authentication) GetRequestMetadata(context.Context, ...string) (map[string]string, error) {
    return map[string]string{"apiKey": a.auth}, nil
}

func (a *Authentication) RequireTransportSecurity() bool {
    return false
}

Proto

syntax = "proto3";

package feepb;

option go_package = "./pb/feepb";

service Server {
    rpc GetTransactionFee(TransactionFee) returns(TransactionFeeResponse) {};
}

message TransactionFee {
    repeated string accounts = 1;
    int32 percentile = 2;
    int32 slotRange = 3;
}

message TransactionFeeResponse {
    FeeValue priorityFee = 1;
    FeeValue tip = 2;
}

message FeeValue {
    int32 percentile = 1;
    double value = 2;
}

Response Example

Response PriorityFee Percentile: 75
Response PriorityFee Value: 10000 // The priority fee corresponding to the quantile, in micro-lamports
Response Tip Percentile: 75 
Response Tip Value: 0.0001 // The tip corresponding to the quantile, in Sol
Response2 PriorityFee Percentile: 75
Response2 PriorityFee Value: 432313.2435833086
Response2 Tip Percentile: 75
Response2 Tip Value: 0.0001