Fix encoding error

Sesame/API Extensions/Message.swift

@@ -56,8 +56,13 @@ struct Message: Equatable, Hashable {
             throw MessageResult.invalidMessageTypeFromDevice
         }
         self.messageType = messageType
-        self.clientChallenge = UInt32(data: data.dropFirst().prefix(UInt32.byteSize))
-        self.serverChallenge = UInt32(data: data.dropFirst(UInt32.byteSize+1).prefix(UInt32.byteSize))
+        let messageTypeEndIndex = data.startIndex+1
+        let clientChallengeEndIndex = messageTypeEndIndex + UInt32.byteSize
+        let clientChallengeData = Array(data[messageTypeEndIndex..<clientChallengeEndIndex])
+        self.clientChallenge = UInt32(bytes: clientChallengeData)
+        let serverChallengeEndIndex = clientChallengeEndIndex + UInt32.byteSize
+        let serverChallengeData = Array(data[clientChallengeEndIndex..<serverChallengeEndIndex])
+        self.serverChallenge = UInt32(bytes: serverChallengeData)
         guard let result = MessageResult(rawValue: data.last!) else {
             print("Invalid message result \(data.last!)")
             throw MessageResult.unknownMessageResultFromDevice

Sesame/API/Extensions/Data+Coding.swift

@@ -2,12 +2,6 @@ import Foundation
 
 extension Data {
 
-    func convert<T>(into value: T) -> T {
-        withUnsafeBytes {
-            $0.baseAddress!.load(as: T.self)
-        }
-    }
-
     init<T>(from value: T) {
         var target = value
         self = Swift.withUnsafeBytes(of: &target) {

Sesame/API/Extensions/UInt32+Coding.swift

@@ -6,8 +6,8 @@ extension UInt32 {
      Create a value from a little-endian data representation (MSB first)
      - Note: The data must contain exactly four bytes.
      */
-    init(data: Data) {
-        let value = data.convert(into: UInt32.zero)
+    init(bytes: [UInt8]) {
+        let value = bytes.convert(to: UInt32.self)
         self = CFSwapInt32LittleToHost(value)
     }
 

Sesame/API/Extensions/UInt8+Extensions.swift

@@ -0,0 +1,12 @@
+import Foundation
+
+extension Array where Element == UInt8 {
+    
+    func convert<T>(to _: T.Type) -> T {
+        withUnsafeBufferPointer {
+            $0.baseAddress!.withMemoryRebound(to: T.self, capacity: 1) {
+                $0.pointee
+            }
+        }
+    }
+}