Replace getRecentBlockhash to getLatestBlockhash. Improve calculate fee for prepared transaction

Author: MaksymVereshchaka

Sources/SolanaSwift/APIClient/APIClient+Extension.swift

@@ -22,19 +22,14 @@ public extension SolanaAPIClient {
         try await getMinimumBalanceForRentExemption(dataLength: span, commitment: "recent")
     }
 
-    func getRecentBlockhash() async throws -> String {
-        try await getRecentBlockhash(commitment: nil)
+    func getLatestBlockhash() async throws -> String {
+        try await getLatestBlockhash(commitment: nil)
     }
 
     func observeSignatureStatus(signature: String) -> AsyncStream<PendingTransactionStatus> {
         observeSignatureStatus(signature: signature, timeout: 60, delay: 2)
     }
 
-    /// Get fee per signature
-    func getLamportsPerSignature() async throws -> UInt64? {
-        try await getFees(commitment: nil).feeCalculator?.lamportsPerSignature
-    }
-
     /// Convenience method for request(method:params:) with no params
     func request<Entity>(method: String) async throws -> Entity where Entity: Decodable {
         try await request(method: method, params: [])

Sources/SolanaSwift/APIClient/Networking/JSONRPCAPIClient.swift

@@ -89,11 +89,6 @@ public class JSONRPCAPIClient: SolanaAPIClient {
     public func getEpochInfo(commitment: Commitment? = nil) async throws -> EpochInfo {
         try await get(method: "getEpochInfo", params: [RequestConfiguration(commitment: commitment)])
     }
-
-    public func getFees(commitment: Commitment? = nil) async throws -> Fee {
-        let result: Rpc<Fee> = try await get(method: "getFees", params: [RequestConfiguration(commitment: commitment)])
-        return result.value
-    }
 
     public func getFeeForMessage(message: String, commitment: Commitment? = nil) async throws -> Lamports {
         let result: Rpc<Lamports> = try await get(method: "getFeeForMessage", params: [message, RequestConfiguration(commitment: commitment)])
@@ -109,9 +104,9 @@ public class JSONRPCAPIClient: SolanaAPIClient {
         )
     }
 
-    public func getRecentBlockhash(commitment: Commitment? = nil) async throws -> String {
-        let result: Rpc<Fee> = try await get(method: "getRecentBlockhash",
-                                             params: [RequestConfiguration(commitment: commitment)])
+    public func getLatestBlockhash(commitment: Commitment? = nil) async throws -> String {
+        let result: Rpc<GetLatestBlockhashResponse> = try await get(method: "getLatestBlockhash",
+                                                                    params: [RequestConfiguration(commitment: commitment)])
         guard let blockhash = result.value.blockhash else {
             throw APIClientError.blockhashNotFound
         }

Sources/SolanaSwift/APIClient/SolanaAPIClient.swift

@@ -110,17 +110,14 @@ public protocol SolanaAPIClient {
     ///
     func getEpochInfo(commitment: Commitment?) async throws -> EpochInfo
 
-    /// Returns a recent block hash from the ledger, a fee schedule that can be used to compute the cost of submitting a
-    /// transaction using it, and the last slot in which the blockhash will be valid.
+    /// Get the fee the network will charge for a particular Message
     /// - Parameters:
+    ///  - message: Base-64 encoded Message; Required
     ///  - commitment: Optional
+    ///  - minContextSlot: Optional
     /// - Throws: APIClientError
-    /// - Returns The result field will be an array of u64 integers listing confirmed blocks starting at start_slot for
-    /// up to limit blocks, inclusive
-    /// - SeeAlso https://docs.solana.com/developing/clients/jsonrpc-api#getfees
-    ///
-    func getFees(commitment: Commitment?) async throws -> Fee
-
+    /// - Returns Fee corresponding to the message at the specified blockhash
+    /// - SeeAlso https://solana.com/docs/rpc/http/getfeeformessage
     func getFeeForMessage(message: String, commitment: Commitment?) async throws -> Lamports
 
     /// Returns minimum balance required to make account rent exempt
@@ -281,14 +278,13 @@ public protocol SolanaAPIClient {
     ///
     func observeSignatureStatus(signature: String, timeout: Int, delay: Int) -> AsyncStream<PendingTransactionStatus>
 
-    /// Returns a recent block hash from the ledger, and a fee schedule that can be used to compute the cost of
-    /// submitting a transaction using it.
+    /// Returns the latest blockhash
     /// - Parameters:
     ///  - commitment: (optional) Commitment
     /// - Throws: APIClientError
-    /// - SeeAlso https://docs.solana.com/developing/clients/jsonrpc-api#getrecentblockhash
+    /// - SeeAlso https://solana.com/docs/rpc/http/getlatestblockhash
     ///
-    func getRecentBlockhash(commitment: Commitment?) async throws -> String
+    func getLatestBlockhash(commitment: Commitment?) async throws -> String
 
     /// Returns signatures for confirmed transactions that include the given address in their accountKeys list.
     /// Returns signatures backwards in time from the provided signature or most recent confirmed block

Sources/SolanaSwift/BlockchainClient/BlockchainClient.swift

@@ -19,40 +19,24 @@ public class BlockchainClient: SolanaBlockchainClient {
     ///   - instructions: the instructions of the transaction
     ///   - signers: the signers of the transaction
     ///   - feePayer: the feePayer of the transaction
-    ///   - feeCalculator: (Optional) fee custom calculator for calculating fee
     /// - Returns: PreparedTransaction, can be sent or simulated using SolanaBlockchainClient
     public func prepareTransaction(
         instructions: [TransactionInstruction],
         signers: [KeyPair],
-        feePayer: PublicKey,
-        feeCalculator fc: FeeCalculator? = nil
+        feePayer: PublicKey
     ) async throws -> PreparedTransaction {
         // form transaction
         var transaction = Transaction(instructions: instructions, recentBlockhash: nil, feePayer: feePayer)
 
-        let feeCalculator: FeeCalculator
-        if let fc = fc {
-            feeCalculator = fc
-        } else {
-            let (lps, minRentExemption) = try await(
-                apiClient.getFees(commitment: nil).feeCalculator?.lamportsPerSignature,
-                apiClient.getMinimumBalanceForRentExemption(span: 165)
-            )
-            let lamportsPerSignature = lps ?? 5000
-            feeCalculator = DefaultFeeCalculator(
-                lamportsPerSignature: lamportsPerSignature,
-                minRentExemption: minRentExemption
-            )
-        }
-        let expectedFee = try feeCalculator.calculateNetworkFee(transaction: transaction)
-
-        let blockhash = try await apiClient.getRecentBlockhash()
+        let blockhash = try await apiClient.getLatestBlockhash()
         transaction.recentBlockhash = blockhash
 
         // if any signers, sign
         if !signers.isEmpty {
             try transaction.sign(signers: signers)
         }
+        
+        let expectedFee = try await apiClient.getFeeForMessage(message: transaction.serializeMessage().base64EncodedString(), commitment: nil)
 
         // return formed transaction
         return .init(transaction: transaction, signers: signers, expectedFee: expectedFee)
@@ -112,7 +96,6 @@ public class BlockchainClient: SolanaBlockchainClient {
     ///   - amount: amount to be sent
     ///   - feePayer: (Optional) if the transaction would be paid by another user
     ///   - transferChecked: (Default: false) use transferChecked instruction instead of transfer transaction
-    ///   - minRentExemption: (Optional) pre-calculated min rent exemption, will be fetched if not provided
     /// - Returns: (preparedTransaction: PreparedTransaction, realDestination: String), preparedTransaction can be sent
     /// or simulated using SolanaBlockchainClient, the realDestination is the real spl address of destination. Can be
     /// different from destinationAddress if destinationAddress is a native Solana address
@@ -125,9 +108,7 @@ public class BlockchainClient: SolanaBlockchainClient {
         to destinationAddress: String,
         amount: UInt64,
         feePayer: PublicKey? = nil,
-        transferChecked: Bool = false,
-        lamportsPerSignature: Lamports,
-        minRentExemption: Lamports
+        transferChecked: Bool = false
     ) async throws -> (preparedTransaction: PreparedTransaction, realDestination: String) {
         let feePayer = feePayer ?? account.publicKey
 
@@ -150,7 +131,6 @@ public class BlockchainClient: SolanaBlockchainClient {
         var instructions = [TransactionInstruction]()
 
         // create associated token address
-        var accountsCreationFee: UInt64 = 0
         if splDestination.isUnregisteredAsocciatedToken {
             let mint = try PublicKey(string: mintAddress)
             let owner = try PublicKey(string: destinationAddress)
@@ -162,7 +142,6 @@ public class BlockchainClient: SolanaBlockchainClient {
                 tokenProgramId: tokenProgramId
             )
             instructions.append(createATokenInstruction)
-            accountsCreationFee += minRentExemption
         }
 
         // send instruction
@@ -222,11 +201,7 @@ public class BlockchainClient: SolanaBlockchainClient {
         let preparedTransaction = try await prepareTransaction(
             instructions: instructions,
             signers: [account],
-            feePayer: feePayer,
-            feeCalculator: DefaultFeeCalculator(
-                lamportsPerSignature: lamportsPerSignature,
-                minRentExemption: minRentExemption
-            )
+            feePayer: feePayer
         )
         return (preparedTransaction, realDestination)
     }

Sources/SolanaSwift/BlockchainClient/FeeCalculator/FeeCalculator.swift

@@ -12,13 +12,11 @@ public protocol SolanaBlockchainClient: AnyObject {
     ///   - signers: the signers
     ///   - feePayer: the feePayer, usually is the first signer
     ///   - recentBlockhash: recentBlockhash, can be fetched lately when the value is nil
-    ///   - feeCalculator: the fee calculator, leave it nil to use DefaultFeeCalculator
     /// - Returns: information of a prepared transaction
     func prepareTransaction(
         instructions: [TransactionInstruction],
         signers: [KeyPair],
-        feePayer: PublicKey,
-        feeCalculator: FeeCalculator?
+        feePayer: PublicKey
     ) async throws -> PreparedTransaction
 
     /// Send transaction
@@ -48,7 +46,7 @@ public extension SolanaBlockchainClient {
             retryDelay: 1,
             timeoutInSeconds: 60
         ) {
-            let recentBlockhash = try await self.apiClient.getRecentBlockhash()
+            let recentBlockhash = try await self.apiClient.getLatestBlockhash()
             let serializedTransaction = try self.signAndSerialize(
                 preparedTransaction: preparedTransaction,
                 recentBlockhash: recentBlockhash
@@ -67,7 +65,7 @@ public extension SolanaBlockchainClient {
     func simulateTransaction(
         preparedTransaction: PreparedTransaction
     ) async throws -> SimulationResult {
-        let recentBlockhash = try await apiClient.getRecentBlockhash()
+        let recentBlockhash = try await apiClient.getLatestBlockhash()
         let serializedTransaction = try signAndSerialize(
             preparedTransaction: preparedTransaction,
             recentBlockhash: recentBlockhash

Sources/SolanaSwift/BlockchainClient/SolanaBlockchainClient.swift

@@ -97,23 +97,9 @@ public struct EpochSchedule: Decodable {
     public let firstNormalSlot: UInt64
 }
 
-public struct Fee: Decodable {
-    public let feeCalculator: FeeCalculatorResponse?
-    public let feeRateGovernor: FeeRateGovernor?
+public struct GetLatestBlockhashResponse: Decodable {
     public let blockhash: String?
-    public let lastValidSlot: UInt64?
-}
-
-public struct FeeCalculatorResponse: Decodable {
-    public let lamportsPerSignature: Lamports
-}
-
-public struct FeeRateGovernor: Decodable {
-    public let burnPercent: UInt64
-    public let maxLamportsPerSignature: Lamports
-    public let minLamportsPerSignature: Lamports
-    public let targetLamportsPerSignature: Lamports
-    public let targetSignaturesPerSlot: UInt64
+    public let lastValidBlockHeight: UInt64?
 }
 
 public struct Identity: Decodable {

Sources/SolanaSwift/Models/Models.swift

@@ -2,15 +2,15 @@ import Foundation
 
 /// The prepared transaction that can be sent or simulate in SolanaBlockchainClient
 public struct PreparedTransaction: Equatable {
-    public init(transaction: Transaction, signers: [KeyPair], expectedFee: FeeAmount) {
+    public init(transaction: Transaction, signers: [KeyPair], expectedFee: Lamports) {
         self.transaction = transaction
         self.signers = signers
         self.expectedFee = expectedFee
     }
 
     public var transaction: Transaction
     public var signers: [KeyPair]
-    public var expectedFee: FeeAmount
+    public var expectedFee: Lamports
 
     public mutating func sign() throws {
         try transaction.sign(signers: signers)