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

.github/workflows/checks.yml

@@ -5,12 +5,15 @@ on:
 
 jobs:
   test_and_lint:
-    runs-on: macos-12
+    runs-on: macos-14
     env:
       DEVNET_SHA: fa1238e8039a53101b5d2d764d3622ff0403a527
     steps:
       - uses: actions/checkout@v3
-
+      - name: Setup Xcode 15.3
+        uses: maxim-lobanov/setup-xcode@60606e260d2fc5762a71e64e74b2174e8ea3c8bd # v1.6.0
+        with:
+          xcode-version: 15.3
       - name: Cache/Restore Mint packages
         id: mint-cache
         uses: actions/cache@v2

.swift-version

@@ -1 +1 @@
-5.7.1
+5.10.0

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.6
+// swift-tools-version: 5.10
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

Sources/Starknet/Crypto/StarknetHashMethod.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public enum StarknetHashMethod {
+    case pedersen
+    case poseidon
+
+    func hash(values: [Felt]) -> Felt {
+        switch self {
+        case .pedersen:
+            StarknetCurve.pedersenOn(values)
+        case .poseidon:
+            StarknetPoseidon.poseidonHash(values)
+        }
+    }
+
+    func hash(first: Felt, second: Felt) -> Felt {
+        switch self {
+        case .pedersen:
+            StarknetCurve.pedersen(first: first, second: second)
+        case .poseidon:
+            StarknetPoseidon.poseidonHash(first: first, second: second)
+        }
+    }
+}

Sources/Starknet/Data/Execution.swift

@@ -125,9 +125,9 @@ public struct StarknetDeployAccountParamsV1 {
 public func starknetCallsToExecuteCalldata(calls: [StarknetCall], cairoVersion: CairoVersion) -> [Felt] {
     switch cairoVersion {
     case .zero:
-        return starknetCallsToExecuteCalldataCairo0(calls: calls)
+        starknetCallsToExecuteCalldataCairo0(calls: calls)
     case .one:
-        return starknetCallsToExecuteCalldataCairo1(calls: calls)
+        starknetCallsToExecuteCalldataCairo1(calls: calls)
     }
 }
 

Sources/Starknet/Data/MerkleTree.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+public struct MerkleTree {
+    public let leaves: [Felt]
+    public let hashMethod: StarknetHashMethod
+    public let rootHash: Felt
+    public let branches: [[Felt]]
+
+    public init?(leafHashes: [Felt], hashMethod: StarknetHashMethod) {
+        self.leaves = leafHashes
+        self.hashMethod = hashMethod
+
+        guard !leaves.isEmpty else {
+            return nil
+        }
+        (self.rootHash, self.branches) = Self.build(leafHashes: leafHashes, hashMethod: hashMethod)
+    }
+
+    private static func build(leafHashes: [Felt], hashMethod: StarknetHashMethod) -> (Felt, [[Felt]]) {
+        var leaves = leafHashes
+        var branches: [[Felt]] = []
+
+        while leaves.count > 1 {
+            if leaves.count != leafHashes.count {
+                branches.append(leaves)
+            }
+            leaves = stride(from: 0, to: leaves.count, by: 2).map {
+                Self.hash(leaves[$0], ($0 + 1) < leaves.count ? leaves[$0 + 1] : .zero, hashMethod)
+            }
+        }
+
+        return (leaves[0], branches)
+    }
+
+    public static func hash(_ a: Felt, _ b: Felt, _ hashMethod: StarknetHashMethod) -> Felt {
+        let (aSorted, bSorted) = a < b ? (a, b) : (b, a)
+
+        return hashMethod.hash(first: aSorted, second: bSorted)
+    }
+}

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 }