Add Felt(fromSigned) initializer; Support u128, i128, timestamp types in StarknetTypedData

Sources/Starknet/Data/Numbers/Felt.swift

@@ -28,6 +28,21 @@ public struct Felt: NumAsHexProtocol {
         self.value = value < Felt.prime ? value : Felt.prime - 1
     }
 
+    /// Initializes a new Felt instance from a signed integer.
+    ///
+    /// Calculated as `fromSigned mod Felt.prime`.
+    ///
+    /// - Parameter fromSigned: The signed integer to convert to Felt. The integer must be greater than `-Felt.prime` and less than `Felt.prime`.
+    public init?(fromSigned exactly: some BinaryInteger) {
+        let value = BigInt(exactly: exactly)
+
+        guard let value, abs(value) < Felt.prime else {
+            return nil
+        }
+
+        self.value = BigUInt(value.modulus(BigInt(Felt.prime)))
+    }
+
     public init?(fromHex hex: String) {
         guard hex.hasPrefix("0x") else { return nil }
 

Sources/Starknet/Data/TypedData/StarknetTypedData.swift

@@ -18,6 +18,7 @@ public enum StarknetTypedDataError: Error, Equatable {
     case contextNotDefined
     case parentNotDefined
     case keyNotDefined
+    case invalidNumericValue(StarknetTypedData.Element)
     case invalidBool(StarknetTypedData.Element)
     case invalidMerkleTree
     case invalidShortString
@@ -222,6 +223,10 @@ public struct StarknetTypedData: Codable, Equatable, Hashable {
         switch (typeName, revision) {
         case ("felt", _), ("string", .v0), ("shortstring", .v1), ("ContractAddress", .v1), ("ClassHash", .v1):
             return try unwrapFelt(from: element)
+        case ("u128", .v1), ("timestamp", .v1):
+            return try unwrapU128(from: element)
+        case ("i128", .v1):
+            return try unwrapI128(from: element)
         case ("bool", _):
             return try unwrapBool(from: element)
         case ("string", .v1):
@@ -340,6 +345,7 @@ public extension StarknetTypedData {
         case array([Element])
         case string(String)
         case felt(Felt)
+        case signedFelt(Felt)
         case bool(Bool)
 
         public init(from decoder: Decoder) throws {
@@ -355,13 +361,21 @@ public extension StarknetTypedData {
                       let felt = Felt(uint)
             {
                 self = .felt(felt)
+            } else if let int = try? container.decode(Int64.self),
+                      let felt = Felt(fromSigned: int)
+            {
+                self = .signedFelt(felt)
             } else if let bool = try? container.decode(Bool.self) {
                 self = .bool(bool)
             } else if let string = try? container.decode(String.self) {
                 if let uint = BigUInt(string),
                    let felt = Felt(uint)
                 {
                     self = .felt(felt)
+                } else if let int = BigInt(string),
+                          let felt = Felt(fromSigned: int)
+                {
+                    self = .signedFelt(felt)
                 } else {
                     self = .string(string)
                 }
@@ -376,6 +390,8 @@ public extension StarknetTypedData {
                 try string.encode(to: encoder)
             case let .felt(felt):
                 try felt.encode(to: encoder)
+            case let .signedFelt(felt):
+                try felt.encode(to: encoder)
             case let .object(object):
                 try object.encode(to: encoder)
             case let .array(array):
@@ -389,7 +405,7 @@ public extension StarknetTypedData {
 
 private extension StarknetTypedData {
     static let basicTypesV0: Set = ["felt", "bool", "string", "selector", "merkletree"]
-    static let basicTypesV1: Set = basicTypesV0.union(["ContractAddress", "ClassHash", "shortstring"])
+    static let basicTypesV1: Set = basicTypesV0.union(["u128", "i128", "ContractAddress", "ClassHash", "timestamp", "shortstring"])
 
     func getBasicTypes() -> Set<String> {
         switch revision {
@@ -437,6 +453,35 @@ extension StarknetTypedData {
         }
     }
 
+    func unwrapU128(from element: Element) throws -> Felt {
+        guard case let .felt(felt) = element else {
+            throw StarknetTypedDataError.invalidNumericValue(element)
+        }
+
+        guard felt.value < BigUInt(2).power(128) else {
+            throw StarknetTypedDataError.invalidNumericValue(element)
+        }
+
+        return felt
+    }
+
+    func unwrapI128(from element: Element) throws -> Felt {
+        let felt = switch element {
+        case let .felt(felt):
+            felt
+        case let .signedFelt(signedFelt):
+            signedFelt
+        default:
+            throw StarknetTypedDataError.invalidNumericValue(element)
+        }
+
+        guard felt.value < BigUInt(2).power(127) || felt.value >= Felt.prime - BigUInt(2).power(127) else {
+            throw StarknetTypedDataError.invalidNumericValue(element)
+        }
+
+        return felt
+    }
+
     func unwrapSelector(from element: Element) throws -> Felt {
         switch element {
         case let .felt(felt):

Tests/StarknetTests/Data/FeltTests.swift

@@ -27,6 +27,21 @@ final class FeltTests: XCTestCase {
         XCTAssertEqual(numAsHex4, NumAsHex(0))
     }
 
+    func testFromSigned() {
+        XCTAssertEqual(Felt(fromSigned: -1), Felt.max)
+        XCTAssertEqual(Felt(fromSigned: -BigInt(Felt.max.value)), Felt.one)
+        XCTAssertEqual(
+            Felt(fromSigned: -Int.max),
+            Felt(BigInt(Felt.prime) - BigInt(Int.max))
+        )
+        XCTAssertEqual(
+            Felt(fromSigned: -Int64.max),
+            Felt(BigInt(Felt.prime) - BigInt(Int64.max))
+        )
+        XCTAssertNil(Felt(fromSigned: Felt.prime))
+        XCTAssertNil(Felt(fromSigned: -BigInt(Felt.prime)))
+    }
+
     func testShortStringEncoding() {
         let encoded = Felt(fromHex: "0x68656c6c6f")!.toShortString()
 

Tests/StarknetTests/Data/TypedDataTests.swift

@@ -4,6 +4,7 @@
 //
 //  Created by Bartosz Rybarski on 14/02/2023.
 //
+import BigInt
 @testable import Starknet
 import XCTest
 
@@ -92,7 +93,7 @@ final class TypedDataTests: XCTestCase {
         let basicTypesV0 = [
             "felt", "bool", "string", "selector", "merkletree",
         ]
-        let basicTypesV1 = basicTypesV0 + ["ContractAddress", "ClassHash", "shortstring"]
+        let basicTypesV1 = basicTypesV0 + ["u128", "i128", "ContractAddress", "ClassHash", "timestamp", "shortstring"]
 
         try XCTAssertNoThrow(makeTypedData("myType", .v0))
         try basicTypesV0.forEach { type in
@@ -161,6 +162,78 @@ final class TypedDataTests: XCTestCase {
         }
     }
 
+    func testEncodeU128() throws {
+        let cases: [(any Encodable, Felt)] = [
+            (0, .zero),
+            (1, .one),
+            (1_000_000, 1_000_000),
+            ("0x0", .zero),
+            ("0x1", .one),
+            ("0x3e8", 1000),
+            ((BigUInt(2).power(128) - 1).description, Felt(BigUInt(2).power(128) - 1)!),
+        ]
+
+        for (input, expected) in cases {
+            let element = try JSONDecoder().decode(StarknetTypedData.Element.self, from: JSONEncoder().encode(input))
+            let encodedValue = try CasesRev1.td.encode(element: element, forType: "u128")
+
+            XCTAssertEqual(encodedValue, expected)
+        }
+    }
+
+    func testEncodeInvalidU128() throws {
+        let cases: [any Encodable] = [
+            -1,
+            "-1",
+            "0x" + String(BigUInt(2).power(128), radix: 16),
+            (BigUInt(2).power(128) + 1).description,
+        ]
+
+        for input in cases {
+            let element = try JSONDecoder().decode(StarknetTypedData.Element.self, from: JSONEncoder().encode(input))
+            XCTAssertThrowsError(try CasesRev1.td.encode(element: element, forType: "u128")) { error in
+                XCTAssertEqual(error as? StarknetTypedDataError, .invalidNumericValue(element))
+            }
+        }
+    }
+
+    func testEncodeI128() throws {
+        let cases: [(any Encodable, Felt)] = [
+            (0, .zero),
+            (1, .one),
+            (1_000_000, 1_000_000),
+            ("0x0", .zero),
+            ("0x1", .one),
+            ("0x3e8", 1000),
+            ((BigUInt(2).power(127) - 1).description, Felt(BigUInt(2).power(127) - 1)!),
+            (-1, Felt(fromSigned: -1)!),
+            (-1_000_000, Felt(fromSigned: -1_000_000)!),
+            ("-1", Felt(fromSigned: -1)!),
+            ((-BigInt(2).power(127)).description, Felt(fromSigned: -BigInt(2).power(127))!),
+        ]
+
+        for (input, expected) in cases {
+            let element = try JSONDecoder().decode(StarknetTypedData.Element.self, from: JSONEncoder().encode(input))
+            let encodedValue = try CasesRev1.td.encode(element: element, forType: "i128")
+
+            XCTAssertEqual(encodedValue, expected)
+        }
+    }
+
+    func testEncodeInvalidI128() throws {
+        let cases: [any Encodable] = [
+            (-BigInt(2).power(127) - 1).description,
+            "0x" + String(BigUInt(2).power(127), radix: 16),
+        ]
+
+        for input in cases {
+            let element = try JSONDecoder().decode(StarknetTypedData.Element.self, from: JSONEncoder().encode(input))
+            XCTAssertThrowsError(try CasesRev1.td.encode(element: element, forType: "i128")) { error in
+                XCTAssertEqual(error as? StarknetTypedDataError, .invalidNumericValue(element))
+            }
+        }
+    }
+
     func testEncodeType() throws {
         let cases: [(StarknetTypedData, String, String)] =
             [