Support RPC 0.9.0-rc.2

Sources/Starknet/Data/Block.swift

@@ -2,7 +2,6 @@ public enum BlockStatus: String, Codable {
     case preConfirmed = "PRE_CONFIRMED"
     case acceptedOnL1 = "ACCEPTED_ON_L1"
     case acceptedOnL2 = "ACCEPTED_ON_L2"
-    case rejected = "REJECTED"
 }
 
 public protocol StarknetBlock: Codable {

Sources/Starknet/Data/StarknetBlockId.swift

@@ -2,6 +2,7 @@ import Foundation
 
 public enum StarknetBlockId: Equatable {
     public enum BlockTag: String, Codable {
+        case l1Accepted = "l1_accepted"
         case latest
         case preConfirmed = "pre_confirmed"
     }

Sources/Starknet/Helpers/Tip.swift

@@ -0,0 +1,89 @@
+import BigInt
+import Foundation
+
+/// Estimates the transaction tip by taking the median of all V3 transaction tips in the latest block.
+///
+/// - Parameter provider: The provider used to interact with Starknet.
+/// - Returns: The estimated median tip.
+/// - Throws: An error if the RPC call fails or no transactions are found.
+public func estimateTip(provider: StarknetProviderProtocol) async throws -> UInt64AsHex {
+    try await estimateTip(provider: provider, blockId: .tag(.latest))
+}
+
+/// Estimates the transaction tip by taking the median of all V3 transaction tips in the latest block.
+///
+/// - Parameters:
+///   - provider: The provider used to interact with Starknet.
+///   - blockHash: The block hash to estimate tip for.
+/// - Returns: The estimated median tip.
+/// - Throws: An error if the RPC call fails or no transactions are found.
+public func estimateTip(provider: StarknetProviderProtocol, blockHash: Felt) async throws -> UInt64AsHex {
+    try await estimateTip(provider: provider, blockId: .hash(blockHash))
+}
+
+/// Estimates the transaction tip by taking the median of all V3 transaction tips in the latest block.
+///
+/// - Parameters:
+///   - provider: The provider used to interact with Starknet.
+///   - blockNumber: The block number to estimate tip for.
+/// - Returns: The estimated median tip.
+/// - Throws: An error if the RPC call fails or no transactions are found.
+public func estimateTip(provider: StarknetProviderProtocol, blockNumber: Int) async throws -> UInt64AsHex {
+    try await estimateTip(provider: provider, blockId: .number(blockNumber))
+}
+
+/// Estimates the transaction tip by taking the median of all V3 transaction tips in the latest block.
+///
+/// - Parameters:
+///   - provider: The provider used to interact with Starknet.
+///   - blockTag: The block tag to estimate tip for.
+/// - Returns: The estimated median tip.
+/// - Throws: An error if the RPC call fails or no transactions are found.
+public func estimateTip(provider: StarknetProviderProtocol, blockTag: StarknetBlockId.BlockTag) async throws -> UInt64AsHex {
+    try await estimateTip(provider: provider, blockId: .tag(blockTag))
+}
+
+/// Estimates the transaction tip by taking the median of all V3 transaction tips in the specified block.
+///
+/// - Parameters:
+///   - provider: The provider used to interact with Starknet.
+///   - blockId: The block identifier to estimate the tip for (hash, number, or tag).
+/// - Returns: The estimated median tip.
+/// - Throws: An error if the RPC call fails or no transactions are found.
+private func estimateTip(provider: StarknetProviderProtocol, blockId: StarknetBlockId) async throws -> UInt64AsHex {
+    let request = RequestBuilder.getBlockWithTxs(blockId)
+    let blockWithTxs = try await provider.send(request: request)
+
+    let transactions: [TransactionWrapper] = switch blockWithTxs {
+    case let .processed(block): block.transactions
+    case let .preConfirmed(block): block.transactions
+    }
+
+    let tips = transactions.compactMap { transactionWrapper in
+        switch transactionWrapper {
+        case let .invokeV3(invokeV3): invokeV3.tip.value
+        case let .deployAccountV3(deployAccountV3): deployAccountV3.tip.value
+        case let .declareV3(declareV3): declareV3.tip.value
+        default: nil
+        }
+    }
+
+    if tips.isEmpty {
+        return UInt64AsHex.zero
+    }
+
+    let sortedTips = tips.sorted()
+    let count = sortedTips.count
+
+    let median = if count % 2 == 1 {
+        sortedTips[count / 2]
+    } else {
+        (sortedTips[count / 2 - 1] + sortedTips[count / 2]) / 2
+    }
+
+    if let median = median.toUInt64AsHex() {
+        return median
+    } else {
+        fatalError("Failed to convert BigUInt to UInt64AsHex")
+    }
+}

Sources/Starknet/Network/MockURLProtocol.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+final class MockURLProtocol: URLProtocol {
+    static var mockResponse: (statusCode: Int, body: Data)?
+
+    override class func canInit(with _: URLRequest) -> Bool {
+        true
+    }
+
+    override class func canonicalRequest(for request: URLRequest) -> URLRequest {
+        request
+    }
+
+    override func startLoading() {
+        guard let mock = MockURLProtocol.mockResponse else {
+            fatalError("Mock response not set")
+        }
+
+        let response = HTTPURLResponse(
+            url: request.url!,
+            statusCode: mock.statusCode,
+            httpVersion: nil,
+            headerFields: nil
+        )!
+
+        client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
+        client?.urlProtocol(self, didLoad: mock.body)
+        client?.urlProtocolDidFinishLoading(self)
+    }
+
+    override func stopLoading() {}
+}
+
+func makeMockedURLSession(
+    statusCode: Int = 200,
+    data: Data
+) -> URLSession {
+    MockURLProtocol.mockResponse = (
+        statusCode: statusCode,
+        body: data
+    )
+
+    let config = URLSessionConfiguration.ephemeral
+    config.protocolClasses = [MockURLProtocol.self]
+
+    return URLSession(configuration: config)
+}

Tests/NetworkTests/Providers/ProviderTests.swift

@@ -16,19 +16,30 @@ final class ProviderTests: XCTestCase {
         provider = StarknetProvider(url: "https://rpc.pathfinder.equilibrium.co/testnet-sepolia/rpc/v0_9")
     }
 
+    func testGetBlockWithTxsWithL1AcceptedBlockTag() async throws {
+        let result = try await provider.send(request: RequestBuilder.getBlockWithTxs(StarknetBlockId.BlockTag.l1Accepted))
+
+        guard case .processed = result else {
+            XCTFail("Expected result to be of type .processed")
+            return
+        }
+    }
+
     func testGetBlockWithTxsWithLatestBlockTag() async throws {
         let result = try await provider.send(request: RequestBuilder.getBlockWithTxs(StarknetBlockId.BlockTag.latest))
 
-        if case .preConfirmed = result {
-            XCTFail("Expected .processed")
+        guard case .processed = result else {
+            XCTFail("Expected result to be of type .processed")
+            return
         }
     }
 
     func testGetBlockWithTxsWithPreConfirmedBlockTag() async throws {
         let result = try await provider.send(request: RequestBuilder.getBlockWithTxs(StarknetBlockId.BlockTag.preConfirmed))
 
-        if case .processed = result {
-            XCTFail("Expected .preConfirmed")
+        guard case .preConfirmed = result else {
+            XCTFail("Expected result to be of type .preConfirmed")
+            return
         }
     }