Support RPC 0.8.0

Sources/Starknet/Crypto/FeeCalculation.swift

@@ -4,11 +4,11 @@ import Foundation
 public extension StarknetFeeEstimate {
     /// Convert estimated fee to resource bounds with applied multipliers
     ///
-    /// Calculates `maxAmountL1 = overallFee / l1GasPrice`, unless `l1GasPrice` is 0, then `maxAmount` is 0.
-    /// Calculates `maxAmountL2 = overallFee / l2GasPrice`, unless `l2GasPrice` is 0, then `maxAmount` is 0.
+    /// Calculates `maxAmountL1 = overallFee / l1GasPrice`, unless `l1GasPrice` is 0, then `maxAmountL1` is 0.
+    /// Calculates `maxAmountL2 = overallFee / l2GasPrice`, unless `l2GasPrice` is 0, then `maxAmountL2` is 0.
     /// Calculates `maxPricePerUnitL1 = gasPriceL1`.
     /// Calculates `maxPricePerUnitL2 = gasPriceL2`.
-    /// Then multiplies `maxAmountL1` and `maxAmountL2` by **round((amountMultiplier) \* 100)** and `maxPricePerUnit` by **round((unitPriceMultiplier) \* 100)** and performs integer division by 100 on both.
+    /// Then multiplies `maxAmountL1` and `maxAmountL2` by **round((amountMultiplier) \* 100)** and `maxPricePerUnitL1` and `maxPricePerUnitL2` by **round((unitPriceMultiplier) \* 100)** and performs integer division by 100 on each.
     ///
     ///
     /// - Parameters:

Sources/Starknet/Data/StorageProof/ContractStorageKey.swift

@@ -1,9 +1,9 @@
-public struct ContractStorageKey: Encodable {
+public struct ContractStorageKeys: Encodable {
     let contractAddress: Felt
-    let key: Felt
+    let storageKeys: [Felt]
 
     enum CodingKeys: String, CodingKey {
         case contractAddress = "contract_address"
-        case key
+        case storageKeys = "storage_keys"
     }
 }

Sources/Starknet/Data/StorageProof/MerkleNode.swift

@@ -0,0 +1,74 @@
+import Foundation
+
+public enum MerkleNode: Codable, Equatable {
+    case binaryNode(BinaryNode)
+    case edgeNode(EdgeNode)
+
+    public init(from decoder: Decoder) throws {
+        let binaryNodeKeys = Set(BinaryNode.CodingKeys.allCases.map(\.stringValue))
+        let edgeNodeKeys = Set(EdgeNode.CodingKeys.allCases.map(\.stringValue))
+
+        let binaryNodeContainer = try decoder.container(keyedBy: BinaryNode.CodingKeys.self)
+
+        if Set(binaryNodeContainer.allKeys.map(\.stringValue)) == binaryNodeKeys {
+            let binaryNode = try BinaryNode(from: decoder)
+            self = .binaryNode(binaryNode)
+        } else if let edgeNodeContainer = try? decoder.container(keyedBy: EdgeNode.CodingKeys.self),
+                  Set(edgeNodeContainer.allKeys.map(\.stringValue)) == edgeNodeKeys
+        {
+            let edgeNode = try EdgeNode(from: decoder)
+            self = .edgeNode(edgeNode)
+        } else {
+            let context = DecodingError.Context(
+                codingPath: decoder.codingPath,
+                // TODO: Improve error message.
+                debugDescription: "Failed to decode MerkleNode from the given data."
+            )
+            throw DecodingError.dataCorrupted(context)
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+
+        switch self {
+        case let .binaryNode(binaryNode):
+            try container.encode(binaryNode)
+        case let .edgeNode(edgeNode):
+            try container.encode(edgeNode)
+        }
+    }
+
+    public static func == (lhs: MerkleNode, rhs: MerkleNode) -> Bool {
+        switch (lhs, rhs) {
+        case let (.binaryNode(lhsBinaryNode), .binaryNode(rhsBinaryNode)):
+            lhsBinaryNode == rhsBinaryNode
+        case let (.edgeNode(lhsEdgeNode), .edgeNode(rhsEdgeNode)):
+            lhsEdgeNode == rhsEdgeNode
+        default:
+            false
+        }
+    }
+}
+
+public struct BinaryNode: Codable, Equatable {
+    let left: Felt
+    let right: Felt
+
+    enum CodingKeys: String, CodingKey, CaseIterable {
+        case left
+        case right
+    }
+}
+
+public struct EdgeNode: Codable, Equatable {
+    let path: NumAsHex
+    let length: Int
+    let child: Felt
+
+    enum CodingKeys: String, CodingKey, CaseIterable {
+        case path
+        case length
+        case child
+    }
+}

Sources/Starknet/Data/StorageProof/NodeHashToNodeMappingItem.swift

@@ -2,7 +2,7 @@ public typealias NodeHashToNodeMapping = [NodeHashToNodeMappingItem]
 
 public struct NodeHashToNodeMappingItem: Decodable, Equatable {
     public let nodeHash: Felt
-    public let node: any MerkleNode
+    public let node: MerkleNode
 
     enum CodingKeys: String, CodingKey {
         case nodeHash = "node_hash"
@@ -11,27 +11,12 @@ public struct NodeHashToNodeMappingItem: Decodable, Equatable {
 
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
-        nodeHash = try container.decode(Felt.self, forKey: .nodeHash)
 
-        let nodeContainer = try container.decode(NodeTypeContainer.self, forKey: .node)
-        switch nodeContainer.type {
-        case .binaryNode:
-            node = try container.decode(BinaryNode.self, forKey: .node)
-        case .edgeNode:
-            node = try container.decode(EdgeNode.self, forKey: .node)
-        }
+        nodeHash = try container.decode(Felt.self, forKey: .nodeHash)
+        node = try container.decode(MerkleNode.self, forKey: .node)
     }
 
     public static func == (lhs: NodeHashToNodeMappingItem, rhs: NodeHashToNodeMappingItem) -> Bool {
-        lhs.nodeHash == rhs.nodeHash && (try? lhs.node.isEqual(to: rhs.node)) ?? false
-    }
-
-    private struct NodeTypeContainer: Decodable {
-        let type: NodeType
-
-        enum NodeType: String, Decodable {
-            case binaryNode = "BinaryNode"
-            case edgeNode = "EdgeNode"
-        }
+        lhs.nodeHash == rhs.nodeHash && lhs.node == rhs.node
     }
 }

Sources/Starknet/Network/StarknetRequest.swift

@@ -140,8 +140,8 @@ public enum RequestBuilder {
         return StarknetRequest(method: .getEvents, params: .getEvents(params))
     }
 
-    public static func getStorageProof(blockId: StarknetBlockId, classHashes: [Felt]?, contractAddresses: [Felt], contractStorageKeys: [ContractStorageKey]) -> StarknetRequest<StarknetGetStorageProofResponse> {
-        let params = GetStorageProofParams(blockId: blockId, classHashes: classHashes, contractAddresses: contractAddresses, contractStorageKeys: contractStorageKeys)
+    public static func getStorageProof(blockId: StarknetBlockId, classHashes: [Felt]?, contractAddresses: [Felt]?, contractsStorageKeys: [ContractStorageKeys]?) -> StarknetRequest<StarknetGetStorageProofResponse> {
+        let params = GetStorageProofParams(blockId: blockId, classHashes: classHashes, contractAddresses: contractAddresses, contractsStorageKeys: contractsStorageKeys)
 
         return StarknetRequest(method: .getStorageProof, params: .getStorageProof(params))
     }

Sources/Starknet/Providers/StarknetProvider/JsonRpcParams.swift

@@ -111,13 +111,13 @@ struct GetStorageProofParams: Encodable {
     let blockId: StarknetBlockId
     let classHashes: [Felt]?
     let contractAddresses: [Felt]?
-    let contractStorageKeys: [ContractStorageKey]?
+    let contractsStorageKeys: [ContractStorageKeys]?
 
     enum CodingKeys: String, CodingKey {
         case blockId = "block_id"
         case classHashes = "class_hashes"
         case contractAddresses = "contract_addresses"
-        case contractStorageKeys = "contract_storage_keys"
+        case contractsStorageKeys = "contracts_storage_keys"
     }
 }
 

Tests/StarknetTests/Data/MerkleNodeTests.swift

@@ -0,0 +1,85 @@
+import XCTest
+
+@testable import Starknet
+
+final class MerkleNodeTests: XCTestCase {
+    func testBinaryNode() throws {
+        let json = """
+        {
+            "left": "0x123",
+            "right": "0x456"
+        }
+        """.data(using: .utf8)!
+
+        let decoder = JSONDecoder()
+
+        let node = try decoder.decode(MerkleNode.self, from: json)
+
+        if case let .binaryNode(binaryNode) = node {
+            XCTAssertEqual(binaryNode.left, Felt(0x123))
+            XCTAssertEqual(binaryNode.right, Felt(0x456))
+        } else {
+            XCTFail("Expected a binaryNode, but got \(node)")
+        }
+    }
+
+    func testInvalidBinaryNode() throws {
+        let json = """
+        {
+            "left": "0x123"
+        }
+        """.data(using: .utf8)!
+
+        let decoder = JSONDecoder()
+
+        XCTAssertThrowsError(try decoder.decode(MerkleNode.self, from: json))
+    }
+
+    func testEdgeNode() throws {
+        let json = """
+        {
+            "path": "0x123",
+            "length": 456,
+            "child": "0x789"
+        }
+        """.data(using: .utf8)!
+
+        let decoder = JSONDecoder()
+
+        let node = try decoder.decode(MerkleNode.self, from: json)
+        if case let .edgeNode(edgeNode) = node {
+            XCTAssertEqual(edgeNode.path, 123)
+            XCTAssertEqual(edgeNode.length, 456)
+            XCTAssertEqual(edgeNode.child, Felt("0x789"))
+        } else {
+            XCTFail("Expected an edgeNode, but got \(node)")
+        }
+    }
+
+    func testInvalidEdgeNode() throws {
+        let json = """
+        {
+            "path": "0x123",
+            "length": 456
+        }
+        """.data(using: .utf8)!
+
+        let decoder = JSONDecoder()
+
+        XCTAssertThrowsError(try decoder.decode(MerkleNode.self, from: json))
+    }
+
+    func testInvalidNodeWithMixedKeys() throws {
+        let json = """
+        {
+            "path": "0x123",
+            "length": "456",
+            "left": 10
+        }
+        """.data(using: .utf8)!
+
+        let decoder = JSONDecoder()
+
+        XCTAssertThrowsError(try decoder.decode(MerkleNode.self, from: json))
+    }
+}

Tests/StarknetTests/Providers/ProviderTests.swift

@@ -235,7 +235,7 @@ final class ProviderTests: XCTestCase {
         let params1 = StarknetInvokeParamsV3(nonce: nonce, resourceBounds: StarknetResourceBoundsMapping.zero)
         let tx1 = try account.signV3(calls: [call], params: params1, forFeeEstimation: true)
 
-        let params2 = StarknetInvokeParamsV3(nonce: Felt(nonce.value + 1)!, resourceBounds: resourceBounds)
+        let params2 = StarknetInvokeParamsV3(nonce: Felt(nonce.value + 1)!, resourceBounds: StarknetResourceBoundsMapping.zero)
         let tx2 = try account.signV3(calls: [call, call2], params: params2, forFeeEstimation: true)
 
         let _ = try await provider.send(request: RequestBuilder.estimateFee(for: [tx1, tx2], simulationFlags: []))