Merge branch 'master' into dev_connection

Author: MacOMNI

Blockchain/Sources/Blockchain/Config/ProtocolConfig.swift

@@ -64,7 +64,7 @@ public struct ProtocolConfig: Sendable, Codable, Equatable {
     // P = 6: The slot period, in seconds.
     public var slotPeriodSeconds: Int
 
-    // Q = 80: The maximum number of items in the authorizations queue.
+    // Q = 80: The number of items in the authorizations queue.
     public var maxAuthorizationsQueueItems: Int
 
     // R = 10: The rotation period of validator-core assignments, in timeslots.
@@ -107,7 +107,7 @@ public struct ProtocolConfig: Sendable, Codable, Equatable {
     // ZI = 2^24: The standard pvm program initialization input data size.
     public var pvmProgramInitInputDataSize: Int
 
-    // ZP = 2^14: The standard pvm program initialization page size.
+    // ZG = 2^14: The standard pvm program initialization page size.
     public var pvmProgramInitPageSize: Int
 
     // ZQ = 2^16: The standard pvm program initialization segment size.

Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift

@@ -186,7 +186,7 @@ extension Accumulation {
             }
 
             switch service {
-            case privilegedServices.empower:
+            case privilegedServices.blessed:
                 newPrivilegedServices = singleOutput.state.privilegedServices
             case privilegedServices.assign:
                 newAuthorizationQueue = singleOutput.state.authorizationQueue

Blockchain/Sources/Blockchain/RuntimeProtocols/Runtime.swift

@@ -60,10 +60,7 @@ public final class Runtime {
             throw Error.invalidHeaderStateRoot
         }
 
-        let expectedExtrinsicHash = try Result { try JamEncoder.encode(block.extrinsic).blake2b256hash() }
-            .mapError(Error.encodeError).get()
-
-        guard block.header.extrinsicsHash == expectedExtrinsicHash else {
+        guard block.header.extrinsicsHash == block.extrinsic.hash() else {
             throw Error.invalidExtrinsicHash
         }
 
@@ -297,7 +294,7 @@ public final class Runtime {
     }
 
     public func updateDisputes(block: BlockRef, state newState: inout State) throws {
-        let (posState, offenders) = try newState.update(config: config, disputes: block.extrinsic.judgements)
+        let (posState, offenders) = try newState.update(config: config, disputes: block.extrinsic.disputes)
         newState.mergeWith(postState: posState)
 
         guard offenders == block.header.offendersMarkers else {
@@ -379,7 +376,7 @@ public final class Runtime {
         return availableReports
     }
 
-    public func updatePreimages(block: BlockRef, state newState: inout State) async throws {
+    public func updatePreimages(block: BlockRef, state newState: inout State, prevState: StateRef) async throws {
         let preimages = block.extrinsic.preimages.preimages
 
         guard preimages.isSortedAndUnique() else {
@@ -388,14 +385,26 @@ public final class Runtime {
 
         for preimage in preimages {
             let hash = preimage.data.blake2b256hash()
+
+            // check prior state
+            let prevPreimageData: Data? = try await prevState.value.get(serviceAccount: preimage.serviceIndex, preimageHash: hash)
+            let prevInfo = try await prevState.value.get(
+                serviceAccount: preimage.serviceIndex, preimageHash: hash, length: UInt32(preimage.data.count)
+            )
+            guard prevPreimageData == nil, prevInfo == nil else {
+                throw Error.duplicatedPreimage
+            }
+
+            // disregard no longer useful ones in new state
             let preimageData: Data? = try await newState.get(serviceAccount: preimage.serviceIndex, preimageHash: hash)
             let info = try await newState.get(
                 serviceAccount: preimage.serviceIndex, preimageHash: hash, length: UInt32(preimage.data.count)
             )
-            guard preimageData == nil, info == nil else {
-                throw Error.duplicatedPreimage
+            if preimageData != nil || info != nil {
+                continue
             }
 
+            // update state
             newState[serviceAccount: preimage.serviceIndex, preimageHash: hash] = preimage.data
             newState[
                 serviceAccount: preimage.serviceIndex, preimageHash: hash, length: UInt32(preimage.data.count)

Blockchain/Sources/Blockchain/State/State+Genesis.swift

@@ -42,6 +42,4 @@ extension State {
 
         return (StateRef(state), block)
     }
-    // TODO: add file genesis
-    // public static func fileGenesis(config: ProtocolConfigRef) throws -> State
 }

Blockchain/Sources/Blockchain/State/State.swift

@@ -230,6 +230,14 @@ public struct State: Sendable {
             await backend.rootHash
         }
     }
+
+    public func read(key: Data32) async throws -> Data? {
+        let res = try layer[key].map { try JamEncoder.encode($0) }
+        if let res {
+            return res
+        }
+        return try await backend.readRaw(key)
+    }
 }
 
 extension State {
@@ -274,7 +282,7 @@ extension State: Dummy {
         let authorizationQueue: StateKeys.AuthorizationQueueKey.Value =
             try! ConfigFixedSizeArray(config: config, defaultValue: ConfigFixedSizeArray(config: config, defaultValue: Data32()))
         let privilegedServices: StateKeys.PrivilegedServicesKey.Value = PrivilegedServices(
-            empower: ServiceIndex(),
+            blessed: ServiceIndex(),
             assign: ServiceIndex(),
             designate: ServiceIndex(),
             basicGas: [:]

Blockchain/Sources/Blockchain/State/StateBackend.swift

@@ -47,11 +47,15 @@ public final class StateBackend: Sendable {
         return ret
     }
 
-    public func write(_ values: any Sequence<(key: any StateKey, value: (Codable & Sendable)?)>) async throws {
-        try await trie.update(values.map { try (key: $0.key.encode(), value: $0.value.map { try JamEncoder.encode($0) }) })
+    public func write(_ values: any Sequence<(key: Data32, value: (Codable & Sendable)?)>) async throws {
+        try await trie.update(values.map { try (key: $0.key, value: $0.value.map { try JamEncoder.encode($0) }) })
         try await trie.save()
     }
 
+    public func readRaw(_ key: Data32) async throws -> Data? {
+        try await trie.read(key: key)
+    }
+
     public func writeRaw(_ values: [(key: Data32, value: Data?)]) async throws {
         try await trie.update(values)
         try await trie.save()

Blockchain/Sources/Blockchain/State/StateKeys.swift

@@ -33,23 +33,23 @@ private func constructKey(_ idx: UInt8, _ service: ServiceIndex) -> Data32 {
     return Data32(data)!
 }
 
-private func constructKey(_ service: ServiceIndex, _ val: UInt32, _: Data) -> Data32 {
-    var data = Data(capacity: 32)
+private func constructKey(_ service: ServiceIndex, _ val: UInt32, _ data: Data) -> Data32 {
+    var stateKey = Data(capacity: 32)
 
     withUnsafeBytes(of: service) { servicePtr in
         withUnsafeBytes(of: val) { valPtr in
-            data.append(servicePtr.load(as: UInt8.self))
-            data.append(valPtr.load(as: UInt8.self))
-            data.append(servicePtr.load(fromByteOffset: 1, as: UInt8.self))
-            data.append(valPtr.load(fromByteOffset: 1, as: UInt8.self))
-            data.append(servicePtr.load(fromByteOffset: 2, as: UInt8.self))
-            data.append(valPtr.load(fromByteOffset: 2, as: UInt8.self))
-            data.append(servicePtr.load(fromByteOffset: 3, as: UInt8.self))
-            data.append(valPtr.load(fromByteOffset: 3, as: UInt8.self))
+            stateKey.append(servicePtr.load(as: UInt8.self))
+            stateKey.append(valPtr.load(as: UInt8.self))
+            stateKey.append(servicePtr.load(fromByteOffset: 1, as: UInt8.self))
+            stateKey.append(valPtr.load(fromByteOffset: 1, as: UInt8.self))
+            stateKey.append(servicePtr.load(fromByteOffset: 2, as: UInt8.self))
+            stateKey.append(valPtr.load(fromByteOffset: 2, as: UInt8.self))
+            stateKey.append(servicePtr.load(fromByteOffset: 3, as: UInt8.self))
+            stateKey.append(valPtr.load(fromByteOffset: 3, as: UInt8.self))
         }
     }
-    data.append(contentsOf: data[relative: 0 ..< 24])
-    return Data32(data)!
+    stateKey.append(contentsOf: data[relative: 0 ..< 24])
+    return Data32(stateKey)!
 }
 
 public enum StateKeys {
@@ -316,7 +316,7 @@ public enum StateKeys {
         }
 
         public func encode() -> Data32 {
-            constructKey(index, length, hash.blake2b256hash().data)
+            constructKey(index, length, hash.blake2b256hash().data[2...])
         }
     }
 }