Support Starknet 0.13

Sources/Starknet/Accounts/StarknetAccount.swift

@@ -134,6 +134,9 @@ public class StarknetAccount: StarknetAccountProtocol {
             if errorMessage.contains("Signature"), errorMessage.contains("is invalid") {
                 return false
             }
+            if let unwrappedData = data, unwrappedData.contains("Signature"), unwrappedData.contains("is invalid") {
+                return false
+            }
 
             throw StarknetProviderError.jsonRpcError(code, errorMessage, data)
         }

Sources/Starknet/Data/Execution.swift

@@ -1,6 +1,8 @@
 import Foundation
 
 public typealias StarknetCalldata = [Felt]
+public typealias StarknetPaymasterData = [Felt]
+public typealias StarknetAccountDeploymentData = [Felt]
 public typealias StarknetSignature = [Felt]
 
 public struct StarknetCall: Codable, Equatable {

Sources/Starknet/Data/Numbers/UInt128AsHex.swift

@@ -0,0 +1,45 @@
+import BigInt
+import Foundation
+
+public struct UInt128AsHex: NumAsHexProtocol {
+    public let value: BigUInt
+
+    public static let zero = UInt128AsHex(0)
+    public static let one = UInt128AsHex(1)
+
+    public static let min = UInt128AsHex.zero
+    public static let max = UInt128AsHex(maxValue)!
+    private static let maxValue = BigUInt(2).power(128) - 1
+
+    public init?(_ exactly: some BinaryInteger) {
+        let value = BigUInt(exactly: exactly)
+
+        guard let value, value <= UInt128AsHex.maxValue else {
+            return nil
+        }
+
+        self.value = value
+    }
+
+    public init(clamping: some BinaryInteger) {
+        let value = BigUInt(clamping: clamping)
+
+        self.value = value <= UInt128AsHex.maxValue ? value : UInt128AsHex.maxValue
+    }
+
+    public init?(fromHex hex: String) {
+        guard hex.hasPrefix("0x") else { return nil }
+
+        if let value = BigUInt(hex.dropFirst(2), radix: 16) {
+            self.init(value)
+        } else {
+            return nil
+        }
+    }
+}
+
+extension UInt128AsHex: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        "UInt128AsHex: \(self.value)"
+    }
+}

Sources/Starknet/Data/Numbers/UInt64AsHex.swift

@@ -0,0 +1,45 @@
+import BigInt
+import Foundation
+
+public struct UInt64AsHex: NumAsHexProtocol {
+    public let value: BigUInt
+
+    public static let zero = UInt64AsHex(0)
+    public static let one = UInt64AsHex(1)
+
+    public static let min = UInt64AsHex.zero
+    public static let max = UInt64AsHex(maxValue)!
+    private static let maxValue = BigUInt(2).power(64) - 1
+
+    public init?(_ exactly: some BinaryInteger) {
+        let value = BigUInt(exactly: exactly)
+
+        guard let value, value <= UInt64AsHex.maxValue else {
+            return nil
+        }
+
+        self.value = value
+    }
+
+    public init(clamping: some BinaryInteger) {
+        let value = BigUInt(clamping: clamping)
+
+        self.value = value <= UInt64AsHex.maxValue ? value : UInt64AsHex.maxValue
+    }
+
+    public init?(fromHex hex: String) {
+        guard hex.hasPrefix("0x") else { return nil }
+
+        if let value = BigUInt(hex.dropFirst(2), radix: 16) {
+            self.init(value)
+        } else {
+            return nil
+        }
+    }
+}
+
+extension UInt64AsHex: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        "UInt64AsHex: \(self.value)"
+    }
+}

Sources/Starknet/Data/Transaction/Data/DAMode.swift

@@ -0,0 +1,16 @@
+import BigInt
+import Foundation
+
+public enum StarknetDAMode: String, Codable {
+    case l1 = "L1"
+    case l2 = "L2"
+
+    public var value: BigUInt {
+        switch self {
+        case .l1:
+            return 0
+        case .l2:
+            return 1
+        }
+    }
+}

Sources/Starknet/Data/Transaction/Data/ResourceBounds.swift

@@ -0,0 +1,36 @@
+import Foundation
+
+public struct StarknetResourceBounds: Codable, Equatable, Hashable {
+    public let maxAmount: UInt64AsHex
+    public let maxPricePerUnit: UInt128AsHex
+
+    public static let zero = StarknetResourceBounds(
+        maxAmount: .zero,
+        maxPricePerUnit: .zero
+    )
+
+    public init(maxAmount: UInt64AsHex, maxPricePerUnit: UInt128AsHex) {
+        self.maxAmount = maxAmount
+        self.maxPricePerUnit = maxPricePerUnit
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case maxAmount = "max_amount"
+        case maxPricePerUnit = "max_price_per_unit"
+    }
+}
+
+public struct StarknetResourceBoundsMapping: Codable, Equatable, Hashable {
+    public let l1Gas: StarknetResourceBounds
+    public let l2Gas: StarknetResourceBounds
+
+    public init(l1Gas: StarknetResourceBounds) {
+        self.l1Gas = l1Gas
+        self.l2Gas = StarknetResourceBounds.zero
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case l1Gas = "l1_gas"
+        case l2Gas = "l2_gas"
+    }
+}