diff --git a/.swift-version b/.swift-version
index 39ee137b..19b860c1 100644
--- a/.swift-version
+++ b/.swift-version
@@ -1 +1 @@
-6.3.1
\ No newline at end of file
+6.4.0
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/AccumulateFunction.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/AccumulateFunction.swift
index 3d2f476b..f24847b4 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/AccumulateFunction.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/AccumulateFunction.swift
@@ -117,7 +117,7 @@ public struct AccumulateState: Sendable {
     /// a
     public var assigners: ConfigFixedSizeArray<ServiceIndex, ProtocolConfig.TotalNumberOfCores>
     /// v
-    public var delegator: ServiceIndex
+    public var designator: ServiceIndex
     /// r
     public var registrar: ServiceIndex
     /// z
@@ -132,7 +132,7 @@ public struct AccumulateState: Sendable {
             authorizationQueue: authorizationQueue,
             manager: manager,
             assigners: assigners,
-            delegator: delegator,
+            designator: designator,
             registrar: registrar,
             alwaysAcc: alwaysAcc,
             entropy: entropy,
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift
index ba644f5e..281759e4 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/Accumulation.swift
@@ -82,7 +82,7 @@ public struct AccountChanges: Sendable {
         case updateAccount(ServiceIndex, ServiceAccountDetails)
         case updateStorage(ServiceIndex, Data, Data?)
         case updatePreimage(ServiceIndex, Data32, Data?)
-        case updatePreimageInfo(ServiceIndex, Data32, UInt32, StateKeys.ServiceAccountPreimageInfoKey.Value?)
+        case updateLookup(ServiceIndex, Data32, UInt32, StateKeys.ServiceAccountLookupKey.Value?)
     }
 
     // records for checking conflicts
@@ -125,14 +125,14 @@ public struct AccountChanges: Sendable {
         updates.append(.updatePreimage(index, hash, value))
     }
 
-    public mutating func addPreimageInfoUpdate(
+    public mutating func addLookupUpdate(
         index: ServiceIndex,
         hash: Data32,
         length: UInt32,
-        value: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        value: StateKeys.ServiceAccountLookupKey.Value?,
     ) {
         altered.insert(index)
-        updates.append(.updatePreimageInfo(index, hash, length, value))
+        updates.append(.updateLookup(index, hash, length, value))
     }
 
     public func apply(to accounts: ServiceAccountsMutRef) async throws {
@@ -164,7 +164,7 @@ public struct AccountChanges: Sendable {
             case let .updatePreimage(index, hash, value):
                 guard !removedIndices.contains(index) else { continue }
                 accounts.set(serviceAccount: index, preimageHash: hash, value: value)
-            case let .updatePreimageInfo(index, hash, length, value):
+            case let .updateLookup(index, hash, length, value):
                 guard !removedIndices.contains(index) else { continue }
                 try await accounts.set(serviceAccount: index, preimageHash: hash, length: length, value: value)
             }
@@ -380,7 +380,7 @@ extension Accumulation {
         from batchResults: [(ServiceIndex, AccumulationResult)],
     ) {
         let initialManager = currentState.manager
-        let initialDelegator = currentState.delegator
+        let initialDesignator = currentState.designator
         let initialRegistrar = currentState.registrar
         let initialAssigners = currentState.assigners
 
@@ -391,17 +391,17 @@ extension Accumulation {
                 temp[index] = singleOutput.state.assigners[index]
                 currentState.assigners = temp
             }
-            // v' - New delegator
-            if service == initialDelegator {
-                currentState.delegator = singleOutput.state.delegator
+            // v' - New designator
+            if service == initialDesignator {
+                currentState.designator = singleOutput.state.designator
             }
             // r' - New registrar
             if service == initialRegistrar {
                 currentState.registrar = singleOutput.state.registrar
             }
 
-            // i' - Current delegator service can update validator queue
-            if service == initialDelegator {
+            // i' - Current designator service can update validator queue
+            if service == initialDesignator {
                 currentState.validatorQueue = singleOutput.state.validatorQueue
             }
             // q' - Current assigners update authorization queue
@@ -420,9 +420,9 @@ extension Accumulation {
             if initialAssigners != managerResult.state.assigners {
                 currentState.assigners = managerResult.state.assigners
             }
-            // v' - if manager changed delegator from initial, use manager's value
-            if initialDelegator != managerResult.state.delegator {
-                currentState.delegator = managerResult.state.delegator
+            // v' - if manager changed designator from initial, use manager's value
+            if initialDesignator != managerResult.state.designator {
+                currentState.designator = managerResult.state.designator
             }
             // r' - if manager changed registrar from initial, use manager's value
             if initialRegistrar != managerResult.state.registrar {
@@ -510,7 +510,7 @@ extension Accumulation {
             let serviceIndex = item.serviceIndex
             let preimage = item.preimage
             let preimageHash = Blake2b256.hash(preimage)
-            guard let preimageInfo = try await accounts.value.get(
+            guard let lookupHistory = try await accounts.value.get(
                 serviceAccount: serviceIndex,
                 preimageHash: preimageHash,
                 length: UInt32(preimage.count),
@@ -518,7 +518,7 @@ extension Accumulation {
                 continue
             }
 
-            if preimageInfo.isEmpty {
+            if lookupHistory.isEmpty {
                 try await accounts.set(
                     serviceAccount: serviceIndex,
                     preimageHash: preimageHash,
@@ -641,7 +641,7 @@ extension Accumulation {
             authorizationQueue: authorizationQueue,
             manager: privilegedServices.manager,
             assigners: privilegedServices.assigners,
-            delegator: privilegedServices.delegator,
+            designator: privilegedServices.designator,
             registrar: privilegedServices.registrar,
             alwaysAcc: privilegedServices.alwaysAcc,
             entropy: entropy,
@@ -662,7 +662,7 @@ extension Accumulation {
         privilegedServices = PrivilegedServices(
             manager: accumulateOutput.state.manager,
             assigners: accumulateOutput.state.assigners,
-            delegator: accumulateOutput.state.delegator,
+            designator: accumulateOutput.state.designator,
             registrar: accumulateOutput.state.registrar,
             alwaysAcc: accumulateOutput.state.alwaysAcc,
         )
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/Assurances.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/Assurances.swift
index 80118489..72172c3f 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/Assurances.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/Assurances.swift
@@ -7,7 +7,7 @@ public enum AssurancesError: Error {
 }
 
 public protocol Assurances {
-    var reports:
+    var availabilityAssignments:
         ConfigFixedSizeArray<
             ReportItem?,
             ProtocolConfig.TotalNumberOfCores,
@@ -47,18 +47,18 @@ extension Assurances {
         timeslot: TimeslotIndex,
         extrinsic: ExtrinsicAvailability,
     ) throws -> (
-        newReports: ConfigFixedSizeArray<
+        newAvailabilityAssignments: ConfigFixedSizeArray<
             ReportItem?,
             ProtocolConfig.TotalNumberOfCores,
         >,
         availableReports: [WorkReport],
     ) {
-        var newReports = reports
+        var newAvailabilityAssignments = availabilityAssignments
 
-        for i in 0 ..< newReports.count {
-            if let report = newReports[i] {
+        for i in 0 ..< newAvailabilityAssignments.count {
+            if let report = newAvailabilityAssignments[i] {
                 if (report.timeslot + UInt32(config.value.preimageReplacementPeriod)) <= timeslot {
-                    newReports[i] = nil
+                    newAvailabilityAssignments[i] = nil
                 }
             }
         }
@@ -74,17 +74,17 @@ extension Assurances {
         var availableReports = [WorkReport]()
 
         for (idx, count) in availabilityCount.enumerated() where count > 0 {
-            guard let report = reports[idx] else {
+            guard let report = availabilityAssignments[idx] else {
                 throw AssurancesError.assuranceForEmptyCore
             }
             if count >= ProtocolConfig.TwoThirdValidatorsPlusOne.read(config: config) {
                 availableReports.append(report.workReport)
-                newReports[idx] = nil // remove available report from pending reports
+                newAvailabilityAssignments[idx] = nil // remove available report from pending assignments
             }
         }
 
         return (
-            newReports: newReports,
+            newAvailabilityAssignments: newAvailabilityAssignments,
             availableReports: availableReports,
         )
     }
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/Disputes.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/Disputes.swift
index a7fb7f78..0f787ca8 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/Disputes.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/Disputes.swift
@@ -34,26 +34,26 @@ extension ReportItem: Validate {
 
 public struct DisputesPostState: Sendable, Equatable {
     public var judgements: JudgementsState
-    public var reports: ConfigFixedSizeArray<
+    public var availabilityAssignments: ConfigFixedSizeArray<
         ReportItem?,
         ProtocolConfig.TotalNumberOfCores,
     >
 
     public init(
         judgements: JudgementsState,
-        reports: ConfigFixedSizeArray<
+        availabilityAssignments: ConfigFixedSizeArray<
             ReportItem?,
             ProtocolConfig.TotalNumberOfCores,
         >,
     ) {
         self.judgements = judgements
-        self.reports = reports
+        self.availabilityAssignments = availabilityAssignments
     }
 }
 
 public protocol Disputes {
     var judgements: JudgementsState { get }
-    var reports: ConfigFixedSizeArray<
+    var availabilityAssignments: ConfigFixedSizeArray<
         ReportItem?,
         ProtocolConfig.TotalNumberOfCores,
     > { get }
@@ -79,7 +79,7 @@ extension Disputes {
         offenders: [Ed25519PublicKey],
     ) {
         var newJudgements = judgements
-        var newReports = reports
+        var newAvailabilityAssignments = availabilityAssignments
         var offenders: [Ed25519PublicKey] = []
 
         let epochLength = UInt32(config.value.epochLength)
@@ -135,10 +135,10 @@ extension Disputes {
 
         var allReports = Set(disputes.verdicts.map(\.reportHash))
         allReports.formUnion(judgements.goodSet)
-        allReports.formUnion(judgements.banSet)
+        allReports.formUnion(judgements.badSet)
         allReports.formUnion(judgements.wonkySet)
 
-        let expectedReportCount = disputes.verdicts.count + judgements.goodSet.count + judgements.banSet.count + judgements.wonkySet.count
+        let expectedReportCount = disputes.verdicts.count + judgements.goodSet.count + judgements.badSet.count + judgements.wonkySet.count
 
         guard allReports.count == expectedReportCount else {
             throw .duplicatedReport
@@ -161,7 +161,7 @@ extension Disputes {
                 }
 
                 tobeRemoved.insert(hash)
-                newJudgements.banSet.insert(hash)
+                newJudgements.badSet.insert(hash)
 
                 let faults = disputes.faults.filter { $0.reportHash == hash }
                 for fault in faults {
@@ -195,16 +195,16 @@ extension Disputes {
         }
 
         for culprit in disputes.culprits {
-            guard newJudgements.banSet.contains(culprit.reportHash) else {
+            guard newJudgements.badSet.contains(culprit.reportHash) else {
                 throw .invalidCulprit
             }
         }
 
-        for i in 0 ..< newReports.count {
-            if let report = newReports[i]?.workReport {
+        for i in 0 ..< newAvailabilityAssignments.count {
+            if let report = newAvailabilityAssignments[i]?.workReport {
                 let hash = report.hash()
                 if tobeRemoved.contains(hash) {
-                    newReports[i] = nil
+                    newAvailabilityAssignments[i] = nil
                 }
             }
         }
@@ -212,7 +212,7 @@ extension Disputes {
         return (
             state: DisputesPostState(
                 judgements: newJudgements,
-                reports: newReports,
+                availabilityAssignments: newAvailabilityAssignments,
             ),
             offenders: offenders,
         )
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/Guaranteeing.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/Guaranteeing.swift
index 64245cb2..34b5434d 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/Guaranteeing.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/Guaranteeing.swift
@@ -32,7 +32,7 @@ public protocol Guaranteeing {
     var previousValidators: ConfigFixedSizeArray<
         ValidatorKey, ProtocolConfig.TotalNumberOfValidators,
     > { get }
-    var reports: ConfigFixedSizeArray<
+    var availabilityAssignments: ConfigFixedSizeArray<
         ReportItem?,
         ProtocolConfig.TotalNumberOfCores,
     > { get }
@@ -114,7 +114,7 @@ extension Guaranteeing {
                 hashes.formUnion(item.workReport.refinementContext.prerequisiteWorkPackages)
             }
         }
-        for report in reports {
+        for report in availabilityAssignments {
             if let report {
                 hashes.formUnion(report.workReport.refinementContext.prerequisiteWorkPackages)
             }
@@ -160,7 +160,7 @@ extension Guaranteeing {
                     throw .invalidResultCodeHash
                 }
 
-                guard digest.gasLimit >= acc.minAccumlateGas else {
+                guard digest.gasLimit >= acc.minItemGas else {
                     throw .invalidServiceGas
                 }
 
@@ -179,7 +179,7 @@ extension Guaranteeing {
         extrinsic: ExtrinsicGuarantees,
         ancestry: ConfigLimitedSizeArray<AncestryItem, ProtocolConfig.Int0, ProtocolConfig.MaxLookupAnchorAge>?,
     ) async throws(GuaranteeingError) -> (
-        newReports: ConfigFixedSizeArray<
+        newAvailabilityAssignments: ConfigFixedSizeArray<
             ReportItem?,
             ProtocolConfig.TotalNumberOfCores,
         >,
@@ -265,7 +265,7 @@ extension Guaranteeing {
 
             let coreIndex = Int(report.coreIndex)
 
-            if let existingReport = reports[coreIndex] {
+            if let existingReport = availabilityAssignments[coreIndex] {
                 guard timeslot >= (existingReport.timeslot + UInt32(config.value.preimageReplacementPeriod)) else {
                     throw .coreNotAvailable
                 }
@@ -323,13 +323,13 @@ extension Guaranteeing {
             }
         }
 
-        var newReports = reports
+        var newAvailabilityAssignments = availabilityAssignments
         var reported = [WorkReport]()
 
         for guarantee in extrinsic.guarantees {
             let report = guarantee.workReport
             let coreIndex = Int(report.coreIndex)
-            newReports[coreIndex] = ReportItem(
+            newAvailabilityAssignments[coreIndex] = ReportItem(
                 workReport: report,
                 timeslot: timeslot,
             )
@@ -339,6 +339,6 @@ extension Guaranteeing {
         reported.sort { $0.packageSpecification.workPackageHash < $1.packageSpecification.workPackageHash }
         let reportersArr = Array(reporters).sorted()
 
-        return (newReports, reported, reportersArr)
+        return (newAvailabilityAssignments, reported, reportersArr)
     }
 }
diff --git a/Blockchain/Sources/Blockchain/RuntimeProtocols/Runtime.swift b/Blockchain/Sources/Blockchain/RuntimeProtocols/Runtime.swift
index ba383fb7..e62077d2 100644
--- a/Blockchain/Sources/Blockchain/RuntimeProtocols/Runtime.swift
+++ b/Blockchain/Sources/Blockchain/RuntimeProtocols/Runtime.swift
@@ -80,7 +80,7 @@ public final class Runtime {
             throw Error.invalidHeaderStateRoot
         }
 
-        guard block.header.extrinsicsHash == block.extrinsic.hash() else {
+        guard block.header.extrinsicHash == block.extrinsic.hash() else {
             throw Error.invalidExtrinsicHash
         }
 
@@ -92,7 +92,7 @@ public final class Runtime {
 
         // winning tickets is validated at apply time by Safrole
 
-        // offendersMarkers is validated at apply time by Disputes
+        // offendersMarker is validated at apply time by Disputes
     }
 
     public func validateHeaderSeal(block: BlockRef, state: State) throws(Error) {
@@ -142,7 +142,7 @@ public final class Runtime {
         }
 
         _ = try Result {
-            try blockAuthorKey.ietfVRFVerify(vrfInputData: entropyVRFInputData, signature: block.header.vrfSignature)
+            try blockAuthorKey.ietfVRFVerify(vrfInputData: entropyVRFInputData, signature: block.header.entropySource)
         }.mapError { _ in Error.invalidVrfSignature }.get()
     }
 
@@ -222,7 +222,7 @@ public final class Runtime {
             // after reports as reports need old recent history
             try updateRecentHistory(block: block, state: &newState, accumulateRoot: accumulateRoot)
 
-            // update authorization pool and queue
+            // update authorization pool α′ from the fresh queue
             do {
                 let authorizationResult = try newState.update(
                     config: config,
@@ -279,13 +279,13 @@ public final class Runtime {
         let safroleResult = try newState.updateSafrole(
             config: config,
             slot: block.header.timeslot,
-            entropy: Bandersnatch.getIetfSignatureOutput(signature: block.header.vrfSignature),
+            entropy: Bandersnatch.getIetfSignatureOutput(signature: block.header.entropySource),
             offenders: newState.judgements.punishSet,
             extrinsics: block.extrinsic.tickets,
         )
         newState.mergeWith(postState: safroleResult.state)
 
-        guard safroleResult.epochMark == block.header.epoch else {
+        guard safroleResult.epochMark == block.header.epochMarker else {
             throw Error.invalidHeaderEpochMarker
         }
 
@@ -298,7 +298,7 @@ public final class Runtime {
         let (posState, offenders) = try newState.update(config: config, disputes: block.extrinsic.disputes)
         newState.mergeWith(postState: posState)
 
-        guard offenders == block.header.offendersMarkers else {
+        guard offenders == block.header.offendersMarker else {
             throw Error.invalidHeaderOffendersMarkers
         }
     }
@@ -306,14 +306,14 @@ public final class Runtime {
     /// returns available reports
     public func updateAssurances(block: BlockRef, state newState: inout State) async throws -> [WorkReport] {
         let (
-            newReports: newReports, availableReports: availableReports,
+            newAvailabilityAssignments: newAvailabilityAssignments, availableReports: availableReports,
         ) = try newState.update(
             config: config,
             timeslot: block.header.timeslot,
             extrinsic: block.extrinsic.availability,
         )
 
-        newState.reports = newReports
+        newState.availabilityAssignments = newAvailabilityAssignments
         return availableReports
     }
 
@@ -321,7 +321,7 @@ public final class Runtime {
         let result = try await newState.update(
             config: config, timeslot: newState.timeslot, extrinsic: block.extrinsic.reports, ancestry: ancestry,
         )
-        newState.reports = result.newReports
+        newState.availabilityAssignments = result.newAvailabilityAssignments
         return result.reporters
     }
 
diff --git a/Blockchain/Sources/Blockchain/State/ServiceAccounts.swift b/Blockchain/Sources/Blockchain/State/ServiceAccounts.swift
index 103effcf..d6933a0d 100644
--- a/Blockchain/Sources/Blockchain/State/ServiceAccounts.swift
+++ b/Blockchain/Sources/Blockchain/State/ServiceAccounts.swift
@@ -9,7 +9,7 @@ public protocol ServiceAccounts: Sendable {
     func get(serviceAccount index: ServiceIndex, preimageHash hash: Data32) async throws -> Data?
     func get(
         serviceAccount index: ServiceIndex, preimageHash hash: Data32, length: UInt32,
-    ) async throws -> StateKeys.ServiceAccountPreimageInfoKey.Value?
+    ) async throws -> StateKeys.ServiceAccountLookupKey.Value?
 
     func historicalLookup(serviceAccount index: ServiceIndex, timeslot: TimeslotIndex, preimageHash hash: Data32) async throws -> Data?
 
@@ -26,7 +26,7 @@ public protocol ServiceAccounts: Sendable {
         serviceAccount index: ServiceIndex,
         preimageHash hash: Data32,
         length: UInt32,
-        value: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        value: StateKeys.ServiceAccountLookupKey.Value?,
     ) async throws
 
     mutating func remove(serviceAccount index: ServiceIndex) async throws
@@ -97,7 +97,7 @@ public class ServiceAccountsMutRef: @unchecked Sendable {
         value: LimitedSizeArray<TimeslotIndex, ConstInt0, ConstInt3>?,
     ) async throws {
         try await ref.value.set(serviceAccount: index, preimageHash: hash, length: length, value: value)
-        changes.addPreimageInfoUpdate(index: index, hash: hash, length: length, value: value)
+        changes.addLookupUpdate(index: index, hash: hash, length: length, value: value)
     }
 
     public func addNew(serviceAccount index: ServiceIndex, account: ServiceAccount) async throws {
@@ -113,7 +113,7 @@ public class ServiceAccountsMutRef: @unchecked Sendable {
         for (key, value) in account.preimages {
             ref.value.set(serviceAccount: index, preimageHash: key, value: value)
         }
-        for (key, value) in account.preimageInfos {
+        for (key, value) in account.lookup {
             try await ref.value.set(serviceAccount: index, preimageHash: key.hash, length: key.length, value: value)
         }
         changes.addNewAccount(index: index, account: account)
diff --git a/Blockchain/Sources/Blockchain/State/State.swift b/Blockchain/Sources/Blockchain/State/State.swift
index 81127be3..635ff6db 100644
--- a/Blockchain/Sources/Blockchain/State/State.swift
+++ b/Blockchain/Sources/Blockchain/State/State.swift
@@ -112,13 +112,13 @@ public struct State: Sendable {
         }
     }
 
-    // ρ: The ρending reports, per core, which are being made available prior to accumulation.
-    public var reports: StateKeys.ReportsKey.Value {
+    // ρ: The availability assignments, one per core.
+    public var availabilityAssignments: StateKeys.AvailabilityAssignmentsKey.Value {
         get {
-            layer.reports
+            layer.availabilityAssignments
         }
         set {
-            layer.reports = newValue
+            layer.availabilityAssignments = newValue
         }
     }
 
@@ -217,7 +217,7 @@ public struct State: Sendable {
     /// l
     public subscript(
         serviceAccount index: ServiceIndex, preimageHash hash: Data32, length length: UInt32,
-    ) -> StateKeys.ServiceAccountPreimageInfoKey.Value? {
+    ) -> StateKeys.ServiceAccountLookupKey.Value? {
         get {
             layer[serviceAccount: index, preimageHash: hash, length: length]
         }
@@ -297,14 +297,14 @@ extension State: Dummy {
             try! ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config))
         let previousValidators: StateKeys.PreviousValidatorsKey.Value =
             try! ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config))
-        let reports: StateKeys.ReportsKey.Value = try! ConfigFixedSizeArray(config: config, defaultValue: nil)
+        let availabilityAssignments: StateKeys.AvailabilityAssignmentsKey.Value = try! ConfigFixedSizeArray(config: config, defaultValue: nil)
         let timeslot: StateKeys.TimeslotKey.Value = block?.header.timeslot ?? 0
         let authorizationQueue: StateKeys.AuthorizationQueueKey.Value =
             try! ConfigFixedSizeArray(config: config, defaultValue: ConfigFixedSizeArray(config: config, defaultValue: Data32()))
         let privilegedServices: StateKeys.PrivilegedServicesKey.Value = PrivilegedServices(
             manager: ServiceIndex(),
             assigners: try! ConfigFixedSizeArray(config: config, defaultValue: ServiceIndex()),
-            delegator: ServiceIndex(),
+            designator: ServiceIndex(),
             registrar: ServiceIndex(),
             alwaysAcc: [:],
         )
@@ -330,7 +330,7 @@ extension State: Dummy {
             (StateKeys.ValidatorQueueKey(), validatorQueue),
             (StateKeys.CurrentValidatorsKey(), currentValidators),
             (StateKeys.PreviousValidatorsKey(), previousValidators),
-            (StateKeys.ReportsKey(), reports),
+            (StateKeys.AvailabilityAssignmentsKey(), availabilityAssignments),
             (StateKeys.TimeslotKey(), timeslot),
             (StateKeys.PrivilegedServicesKey(), privilegedServices),
             (StateKeys.ActivityStatisticsKey(), activityStatistics),
@@ -390,14 +390,14 @@ extension State: ServiceAccounts {
 
     public func get(
         serviceAccount index: ServiceIndex, preimageHash hash: Data32, length: UInt32,
-    ) async throws -> StateKeys.ServiceAccountPreimageInfoKey.Value? {
+    ) async throws -> StateKeys.ServiceAccountLookupKey.Value? {
         if layer.isDeleted(serviceAccount: index, preimageHash: hash, length: length) {
             return nil
         }
         if let res = layer[serviceAccount: index, preimageHash: hash, length: length] {
             return res
         }
-        return try await backend.read(StateKeys.ServiceAccountPreimageInfoKey(index: index, hash: hash, length: length))
+        return try await backend.read(StateKeys.ServiceAccountLookupKey(index: index, hash: hash, length: length))
     }
 
     public func historicalLookup(
@@ -406,15 +406,15 @@ extension State: ServiceAccounts {
         preimageHash hash: Data32,
     ) async throws -> Data? {
         if let preimage = try await get(serviceAccount: index, preimageHash: hash),
-           let preimageInfo = try await get(serviceAccount: index, preimageHash: hash, length: UInt32(preimage.count))
+           let lookupHistory = try await get(serviceAccount: index, preimageHash: hash, length: UInt32(preimage.count))
         {
             var isAvailable = false
-            if preimageInfo.count == 1 {
-                isAvailable = preimageInfo[0] <= timeslot
-            } else if preimageInfo.count == 2 {
-                isAvailable = preimageInfo[0] <= timeslot && timeslot < preimageInfo[1]
-            } else if preimageInfo.count == 3 {
-                isAvailable = preimageInfo[0] <= timeslot && timeslot < preimageInfo[1] && preimageInfo[2] <= timeslot
+            if lookupHistory.count == 1 {
+                isAvailable = lookupHistory[0] <= timeslot
+            } else if lookupHistory.count == 2 {
+                isAvailable = lookupHistory[0] <= timeslot && timeslot < lookupHistory[1]
+            } else if lookupHistory.count == 3 {
+                isAvailable = lookupHistory[0] <= timeslot && timeslot < lookupHistory[1] && lookupHistory[2] <= timeslot
             }
 
             return isAvailable ? preimage : nil
@@ -459,7 +459,7 @@ extension State: ServiceAccounts {
         serviceAccount index: ServiceIndex,
         preimageHash hash: Data32,
         length: UInt32,
-        value: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        value: StateKeys.ServiceAccountLookupKey.Value?,
     ) async throws {
         // update footprint
         let oldValue = try await get(serviceAccount: index, preimageHash: hash, length: length)
@@ -544,7 +544,7 @@ extension State: Assurances {}
 extension State: Disputes {
     public mutating func mergeWith(postState: DisputesPostState) {
         judgements = postState.judgements
-        reports = postState.reports
+        availabilityAssignments = postState.availabilityAssignments
     }
 }
 
diff --git a/Blockchain/Sources/Blockchain/State/StateKeys.swift b/Blockchain/Sources/Blockchain/State/StateKeys.swift
index 44167f32..ae9c8211 100644
--- a/Blockchain/Sources/Blockchain/State/StateKeys.swift
+++ b/Blockchain/Sources/Blockchain/State/StateKeys.swift
@@ -69,7 +69,7 @@ public enum StateKeys {
         ValidatorQueueKey(),
         CurrentValidatorsKey(),
         PreviousValidatorsKey(),
-        ReportsKey(),
+        AvailabilityAssignmentsKey(),
         TimeslotKey(),
         PrivilegedServicesKey(),
         ActivityStatisticsKey(),
@@ -190,7 +190,7 @@ public enum StateKeys {
         }
     }
 
-    public struct ReportsKey: StateKey {
+    public struct AvailabilityAssignmentsKey: StateKey {
         public typealias Value = ConfigFixedSizeArray<
             ReportItem?,
             ProtocolConfig.TotalNumberOfCores,
@@ -324,7 +324,7 @@ public enum StateKeys {
         }
     }
 
-    public struct ServiceAccountPreimageInfoKey: StateKey {
+    public struct ServiceAccountLookupKey: StateKey {
         public typealias Value = LimitedSizeArray<TimeslotIndex, ConstInt0, ConstInt3>
         public static var optional: Bool {
             true
diff --git a/Blockchain/Sources/Blockchain/State/StateLayer.swift b/Blockchain/Sources/Blockchain/State/StateLayer.swift
index 4aa0dc2d..c63c523b 100644
--- a/Blockchain/Sources/Blockchain/State/StateLayer.swift
+++ b/Blockchain/Sources/Blockchain/State/StateLayer.swift
@@ -70,7 +70,7 @@ private enum FixedStateLayerKeys {
     static let validatorQueue = StateKeys.ValidatorQueueKey().encode()
     static let currentValidators = StateKeys.CurrentValidatorsKey().encode()
     static let previousValidators = StateKeys.PreviousValidatorsKey().encode()
-    static let reports = StateKeys.ReportsKey().encode()
+    static let availabilityAssignments = StateKeys.AvailabilityAssignmentsKey().encode()
     static let timeslot = StateKeys.TimeslotKey().encode()
     static let privilegedServices = StateKeys.PrivilegedServicesKey().encode()
     static let activityStatistics = StateKeys.ActivityStatisticsKey().encode()
@@ -190,13 +190,13 @@ public struct StateLayer: Sendable {
         }
     }
 
-    // ρ: The ρending reports, per core, which are being made available prior to accumulation.
-    public var reports: StateKeys.ReportsKey.Value {
+    // ρ: The availability assignments, one per core.
+    public var availabilityAssignments: StateKeys.AvailabilityAssignmentsKey.Value {
         get {
-            changes[FixedStateLayerKeys.reports]!.value()!
+            changes[FixedStateLayerKeys.availabilityAssignments]!.value()!
         }
         set {
-            changes[FixedStateLayerKeys.reports] = .init(newValue)
+            changes[FixedStateLayerKeys.availabilityAssignments] = .init(newValue)
         }
     }
 
@@ -230,7 +230,7 @@ public struct StateLayer: Sendable {
         }
     }
 
-    // ϑ: The accumulation queue.
+    // ω: The accumulation queue.
     public var accumulationQueue: StateKeys.AccumulationQueueKey.Value {
         get {
             changes[FixedStateLayerKeys.accumulationQueue]!.value()!
@@ -295,17 +295,17 @@ public struct StateLayer: Sendable {
     /// l
     public subscript(
         serviceAccount index: ServiceIndex, preimageHash hash: Data32, length length: UInt32,
-    ) -> StateKeys.ServiceAccountPreimageInfoKey.Value? {
+    ) -> StateKeys.ServiceAccountLookupKey.Value? {
         get {
             changes[
-                StateKeys.ServiceAccountPreimageInfoKey(
+                StateKeys.ServiceAccountLookupKey(
                     index: index, hash: hash, length: length,
                 ).encode(),
             ]?.value()
         }
         set {
             changes[
-                StateKeys.ServiceAccountPreimageInfoKey(
+                StateKeys.ServiceAccountLookupKey(
                     index: index, hash: hash, length: length,
                 ).encode(),
             ] = .init(newValue)
@@ -359,6 +359,6 @@ extension StateLayer {
     }
 
     public func isDeleted(serviceAccount index: ServiceIndex, preimageHash hash: Data32, length: UInt32) -> Bool {
-        changes[StateKeys.ServiceAccountPreimageInfoKey(index: index, hash: hash, length: length).encode()]?.isDeleted ?? false
+        changes[StateKeys.ServiceAccountLookupKey(index: index, hash: hash, length: length).encode()]?.isDeleted ?? false
     }
 }
diff --git a/Blockchain/Sources/Blockchain/Types/Extrinsic.swift b/Blockchain/Sources/Blockchain/Types/Extrinsic.swift
index 8aa557f4..4beddf8b 100644
--- a/Blockchain/Sources/Blockchain/Types/Extrinsic.swift
+++ b/Blockchain/Sources/Blockchain/Types/Extrinsic.swift
@@ -9,7 +9,7 @@ public struct Extrinsic: Sendable, Equatable, Codable {
     // permissioning of block authoring
     public var tickets: ExtrinsicTickets
 
-    // EP: Static data which is presently being requested to be available for workloads to be able to fetch on demand
+    // EP: Preimage data supplied for prior requests, integrated after accumulation
     public var preimages: ExtrinsicPreimages
 
     // EG: Reports of newly completed workloads whose accuracy is guaranteed by specific validators
@@ -19,7 +19,7 @@ public struct Extrinsic: Sendable, Equatable, Codable {
     // correctly received and are storing locally
     public var availability: ExtrinsicAvailability
 
-    // ED: Votes, by validators, on dispute(s) arising between them presently taking place
+    // ED: Verdicts, culprits, and faults for disputed work-reports
     public var disputes: ExtrinsicDisputes
 
     public init(
diff --git a/Blockchain/Sources/Blockchain/Types/Header.swift b/Blockchain/Sources/Blockchain/Types/Header.swift
index ba6c66c3..839d5c44 100644
--- a/Blockchain/Sources/Blockchain/Types/Header.swift
+++ b/Blockchain/Sources/Blockchain/Types/Header.swift
@@ -13,16 +13,16 @@ public struct Header: Sendable, Equatable {
         public var priorStateRoot: Data32 // state root of the after parent block execution
 
         // Hx: extrinsic hash
-        public var extrinsicsHash: Data32
+        public var extrinsicHash: Data32
 
         // Ht: timeslot index
         public var timeslot: TimeslotIndex
 
-        // He: the epoch
+        // He: the epoch marker
         // the header’s epoch marker He is either empty or, if the block is the first in a new epoch,
         // then a tuple of the epoch randomness and a sequence of Bandersnatch keys
         // defining the Bandersnatch validator keys (kb) beginning in the next epoch
-        public var epoch: EpochMarker?
+        public var epochMarker: EpochMarker?
 
         // Hw: winning-tickets
         // The winning-tickets marker Hw is either empty or,
@@ -38,34 +38,34 @@ public struct Header: Sendable, Equatable {
         public var authorIndex: ValidatorIndex
 
         // Hv: the entropy-yielding vrf signature
-        public var vrfSignature: BandersnatchSignature
+        public var entropySource: BandersnatchSignature
 
-        // Ho: The offenders markers must contain exactly the sequence of keys of all new offenders.
-        public var offendersMarkers: [Ed25519PublicKey]
+        // Ho: The offenders marker must contain exactly the sequence of keys of all new offenders.
+        public var offendersMarker: [Ed25519PublicKey]
 
         public init(
             parentHash: Data32,
             priorStateRoot: Data32,
-            extrinsicsHash: Data32,
+            extrinsicHash: Data32,
             timeslot: TimeslotIndex,
-            epoch: EpochMarker?,
+            epochMarker: EpochMarker?,
             winningTickets: ConfigFixedSizeArray<
                 Ticket,
                 ProtocolConfig.EpochLength,
             >?,
             authorIndex: ValidatorIndex,
-            vrfSignature: BandersnatchSignature,
-            offendersMarkers: [Ed25519PublicKey],
+            entropySource: BandersnatchSignature,
+            offendersMarker: [Ed25519PublicKey],
         ) {
             self.parentHash = parentHash
             self.priorStateRoot = priorStateRoot
-            self.extrinsicsHash = extrinsicsHash
+            self.extrinsicHash = extrinsicHash
             self.timeslot = timeslot
-            self.epoch = epoch
+            self.epochMarker = epochMarker
             self.winningTickets = winningTickets
-            self.offendersMarkers = offendersMarkers
+            self.offendersMarker = offendersMarker
             self.authorIndex = authorIndex
-            self.vrfSignature = vrfSignature
+            self.entropySource = entropySource
         }
     }
 
@@ -84,13 +84,13 @@ extension Header: Codable {
     enum CodingKeys: String, CodingKey {
         case parentHash
         case priorStateRoot
-        case extrinsicsHash
+        case extrinsicHash
         case timeslot
-        case epoch
+        case epochMarker
         case winningTickets
-        case offendersMarkers
+        case offendersMarker
         case authorIndex
-        case vrfSignature
+        case entropySource
         case seal
     }
 
@@ -100,16 +100,16 @@ extension Header: Codable {
             unsigned: Unsigned(
                 parentHash: container.decode(Data32.self, forKey: .parentHash),
                 priorStateRoot: container.decode(Data32.self, forKey: .priorStateRoot),
-                extrinsicsHash: container.decode(Data32.self, forKey: .extrinsicsHash),
+                extrinsicHash: container.decode(Data32.self, forKey: .extrinsicHash),
                 timeslot: container.decode(UInt32.self, forKey: .timeslot),
-                epoch: container.decodeIfPresent(EpochMarker.self, forKey: .epoch),
+                epochMarker: container.decodeIfPresent(EpochMarker.self, forKey: .epochMarker),
                 winningTickets: container.decodeIfPresent(
                     ConfigFixedSizeArray<Ticket, ProtocolConfig.EpochLength>.self,
                     forKey: .winningTickets,
                 ),
                 authorIndex: container.decode(ValidatorIndex.self, forKey: .authorIndex),
-                vrfSignature: container.decode(BandersnatchSignature.self, forKey: .vrfSignature),
-                offendersMarkers: container.decode([Ed25519PublicKey].self, forKey: .offendersMarkers),
+                entropySource: container.decode(BandersnatchSignature.self, forKey: .entropySource),
+                offendersMarker: container.decode([Ed25519PublicKey].self, forKey: .offendersMarker),
             ),
             seal: container.decode(BandersnatchSignature.self, forKey: .seal),
         )
@@ -119,13 +119,13 @@ extension Header: Codable {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(unsigned.parentHash, forKey: .parentHash)
         try container.encode(unsigned.priorStateRoot, forKey: .priorStateRoot)
-        try container.encode(unsigned.extrinsicsHash, forKey: .extrinsicsHash)
+        try container.encode(unsigned.extrinsicHash, forKey: .extrinsicHash)
         try container.encode(unsigned.timeslot, forKey: .timeslot)
-        try container.encodeIfPresent(unsigned.epoch, forKey: .epoch)
+        try container.encodeIfPresent(unsigned.epochMarker, forKey: .epochMarker)
         try container.encodeIfPresent(unsigned.winningTickets, forKey: .winningTickets)
         try container.encode(unsigned.authorIndex, forKey: .authorIndex)
-        try container.encode(unsigned.vrfSignature, forKey: .vrfSignature)
-        try container.encode(unsigned.offendersMarkers, forKey: .offendersMarkers)
+        try container.encode(unsigned.entropySource, forKey: .entropySource)
+        try container.encode(unsigned.offendersMarker, forKey: .offendersMarker)
         try container.encode(seal, forKey: .seal)
     }
 }
@@ -153,13 +153,13 @@ extension Header.Unsigned: Dummy {
         Header.Unsigned(
             parentHash: Data32(),
             priorStateRoot: Data32(),
-            extrinsicsHash: Data32(),
+            extrinsicHash: Data32(),
             timeslot: 0,
-            epoch: EpochMarker.dummy(config: config),
+            epochMarker: EpochMarker.dummy(config: config),
             winningTickets: nil,
             authorIndex: 0,
-            vrfSignature: BandersnatchSignature(),
-            offendersMarkers: [],
+            entropySource: BandersnatchSignature(),
+            offendersMarker: [],
         )
     }
 }
@@ -183,32 +183,32 @@ extension Header {
         unsigned.priorStateRoot
     }
 
-    public var extrinsicsHash: Data32 {
-        unsigned.extrinsicsHash
+    public var extrinsicHash: Data32 {
+        unsigned.extrinsicHash
     }
 
     public var timeslot: TimeslotIndex {
         unsigned.timeslot
     }
 
-    public var epoch: EpochMarker? {
-        unsigned.epoch
+    public var epochMarker: EpochMarker? {
+        unsigned.epochMarker
     }
 
     public var winningTickets: ConfigFixedSizeArray<Ticket, ProtocolConfig.EpochLength>? {
         unsigned.winningTickets
     }
 
-    public var offendersMarkers: [Ed25519PublicKey] {
-        unsigned.offendersMarkers
+    public var offendersMarker: [Ed25519PublicKey] {
+        unsigned.offendersMarker
     }
 
     public var authorIndex: ValidatorIndex {
         unsigned.authorIndex
     }
 
-    public var vrfSignature: BandersnatchSignature {
-        unsigned.vrfSignature
+    public var entropySource: BandersnatchSignature {
+        unsigned.entropySource
     }
 }
 
diff --git a/Blockchain/Sources/Blockchain/Types/JudgementsState.swift b/Blockchain/Sources/Blockchain/Types/JudgementsState.swift
index 8a008101..614f61a8 100644
--- a/Blockchain/Sources/Blockchain/Types/JudgementsState.swift
+++ b/Blockchain/Sources/Blockchain/Types/JudgementsState.swift
@@ -6,7 +6,7 @@ public struct JudgementsState: Sendable, Equatable, Codable {
     @CodingAs<SortedSet<Data32>> public var goodSet: Set<Data32>
 
     // ψb: Work-reports judged to be incorrect
-    @CodingAs<SortedSet<Data32>> public var banSet: Set<Data32>
+    @CodingAs<SortedSet<Data32>> public var badSet: Set<Data32>
 
     // ψw: Work-reports whose validity is judged to be unknowable
     @CodingAs<SortedSet<Data32>> public var wonkySet: Set<Data32>
@@ -16,12 +16,12 @@ public struct JudgementsState: Sendable, Equatable, Codable {
 
     public init(
         goodSet: Set<Data32>,
-        banSet: Set<Data32>,
+        badSet: Set<Data32>,
         wonkySet: Set<Data32>,
         punishSet: Set<Ed25519PublicKey>,
     ) {
         self.goodSet = goodSet
-        self.banSet = banSet
+        self.badSet = badSet
         self.wonkySet = wonkySet
         self.punishSet = punishSet
     }
@@ -32,7 +32,7 @@ extension JudgementsState: Dummy {
     public static func dummy(config _: Config) -> JudgementsState {
         JudgementsState(
             goodSet: [],
-            banSet: [],
+            badSet: [],
             wonkySet: [],
             punishSet: [],
         )
diff --git a/Blockchain/Sources/Blockchain/Types/PrivilegedServices.swift b/Blockchain/Sources/Blockchain/Types/PrivilegedServices.swift
index 49df949f..3699f156 100644
--- a/Blockchain/Sources/Blockchain/Types/PrivilegedServices.swift
+++ b/Blockchain/Sources/Blockchain/Types/PrivilegedServices.swift
@@ -7,7 +7,7 @@ public struct PrivilegedServices: Sendable, Equatable, Codable {
     /// a
     public var assigners: ConfigFixedSizeArray<ServiceIndex, ProtocolConfig.TotalNumberOfCores>
     /// v
-    public var delegator: ServiceIndex
+    public var designator: ServiceIndex
     /// r
     public var registrar: ServiceIndex
     /// z
@@ -16,13 +16,13 @@ public struct PrivilegedServices: Sendable, Equatable, Codable {
     public init(
         manager: ServiceIndex,
         assigners: ConfigFixedSizeArray<ServiceIndex, ProtocolConfig.TotalNumberOfCores>,
-        delegator: ServiceIndex,
+        designator: ServiceIndex,
         registrar: ServiceIndex,
         alwaysAcc: [ServiceIndex: Gas],
     ) {
         self.manager = manager
         self.assigners = assigners
-        self.delegator = delegator
+        self.designator = designator
         self.registrar = registrar
         self.alwaysAcc = alwaysAcc
     }
@@ -31,7 +31,7 @@ public struct PrivilegedServices: Sendable, Equatable, Codable {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         manager = try container.decode(ServiceIndex.self, forKey: .manager)
         assigners = try container.decode(ConfigFixedSizeArray<ServiceIndex, ProtocolConfig.TotalNumberOfCores>.self, forKey: .assigners)
-        delegator = try container.decode(ServiceIndex.self, forKey: .delegator)
+        designator = try container.decode(ServiceIndex.self, forKey: .designator)
         registrar = try container.decode(ServiceIndex.self, forKey: .registrar)
         let compactGas = try container.decode(SortedKeyValues<ServiceIndex, Compact<Gas>>.self, forKey: .alwaysAcc)
         alwaysAcc = compactGas.alias.mapValues { $0.alias }
@@ -41,13 +41,13 @@ public struct PrivilegedServices: Sendable, Equatable, Codable {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(manager, forKey: .manager)
         try container.encode(assigners, forKey: .assigners)
-        try container.encode(delegator, forKey: .delegator)
+        try container.encode(designator, forKey: .designator)
         try container.encode(registrar, forKey: .registrar)
         let compactGas = SortedKeyValues(alias: alwaysAcc.mapValues { Compact(alias: $0) })
         try container.encode(compactGas, forKey: .alwaysAcc)
     }
 
     private enum CodingKeys: String, CodingKey {
-        case manager, assigners, delegator, registrar, alwaysAcc
+        case manager, assigners, designator, registrar, alwaysAcc
     }
 }
diff --git a/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift b/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift
index 3b503866..f60fb18a 100644
--- a/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift
+++ b/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift
@@ -12,10 +12,10 @@ public struct ServiceAccountDetails: Sendable, Equatable, Codable {
     public var balance: Balance
 
     /// g
-    public var minAccumlateGas: Gas
+    public var minItemGas: Gas
 
     /// m
-    public var minMemoGas: Gas
+    public var minDeferredTransferGas: Gas
 
     // o: the total number of octets used in storage
     public var totalByteLength: UInt64
@@ -63,8 +63,8 @@ public struct ServiceAccountDetails: Sendable, Equatable, Codable {
     }
 
     public mutating func updateFootprintPreimage(
-        oldValue: StateKeys.ServiceAccountPreimageInfoKey.Value?,
-        newValue: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        oldValue: StateKeys.ServiceAccountLookupKey.Value?,
+        newValue: StateKeys.ServiceAccountLookupKey.Value?,
         length: UInt32,
     ) {
         if oldValue != nil {
@@ -95,7 +95,7 @@ public struct ServiceAccount: Sendable, Equatable, Codable {
     public var preimages: [Data32: Data]
 
     /// l
-    public var preimageInfos: [
+    public var lookup: [
         HashAndLength: LimitedSizeArray<TimeslotIndex, ConstInt0, ConstInt3>
     ]
 
@@ -106,10 +106,10 @@ public struct ServiceAccount: Sendable, Equatable, Codable {
     public var balance: Balance
 
     /// g
-    public var minAccumlateGas: Gas
+    public var minItemGas: Gas
 
     /// m
-    public var minMemoGas: Gas
+    public var minDeferredTransferGas: Gas
 
     /// f
     public var gratisStorage: Balance
@@ -127,11 +127,11 @@ public struct ServiceAccount: Sendable, Equatable, Codable {
         version: UInt8,
         storage: [Data: Data],
         preimages: [Data32: Data],
-        preimageInfos: [HashAndLength: LimitedSizeArray<TimeslotIndex, ConstInt0, ConstInt3>],
+        lookup: [HashAndLength: LimitedSizeArray<TimeslotIndex, ConstInt0, ConstInt3>],
         codeHash: Data32,
         balance: Balance,
-        minAccumlateGas: Gas,
-        minMemoGas: Gas,
+        minItemGas: Gas,
+        minDeferredTransferGas: Gas,
         gratisStorage: Balance,
         createdAt: TimeslotIndex,
         lastAccAt: TimeslotIndex,
@@ -140,11 +140,11 @@ public struct ServiceAccount: Sendable, Equatable, Codable {
         self.version = version
         self.storage = storage
         self.preimages = preimages
-        self.preimageInfos = preimageInfos
+        self.lookup = lookup
         self.codeHash = codeHash
         self.balance = balance
-        self.minAccumlateGas = minAccumlateGas
-        self.minMemoGas = minMemoGas
+        self.minItemGas = minItemGas
+        self.minDeferredTransferGas = minDeferredTransferGas
         self.gratisStorage = gratisStorage
         self.createdAt = createdAt
         self.lastAccAt = lastAccAt
@@ -156,8 +156,8 @@ public struct ServiceAccount: Sendable, Equatable, Codable {
             version: version,
             codeHash: codeHash,
             balance: balance,
-            minAccumlateGas: minAccumlateGas,
-            minMemoGas: minMemoGas,
+            minItemGas: minItemGas,
+            minDeferredTransferGas: minDeferredTransferGas,
             totalByteLength: totalByteLength,
             gratisStorage: gratisStorage,
             itemsCount: itemsCount,
@@ -175,11 +175,11 @@ extension ServiceAccount: Dummy {
             version: 0,
             storage: [:],
             preimages: [:],
-            preimageInfos: [:],
+            lookup: [:],
             codeHash: Data32(),
             balance: Balance(0),
-            minAccumlateGas: Gas(0),
-            minMemoGas: Gas(0),
+            minItemGas: Gas(0),
+            minDeferredTransferGas: Gas(0),
             gratisStorage: Balance(0),
             createdAt: TimeslotIndex(0),
             lastAccAt: TimeslotIndex(0),
@@ -191,14 +191,14 @@ extension ServiceAccount: Dummy {
 extension ServiceAccount {
     // i: number of items in storage
     public var itemsCount: UInt32 {
-        UInt32(2 * preimageInfos.count + storage.count)
+        UInt32(2 * lookup.count + storage.count)
     }
 
     // o: the total number of octets used in storage
     public var totalByteLength: UInt64 {
-        let preimageInfosBytes = preimageInfos.keys.reduce(into: 0) { $0 += 81 + $1.length }
+        let lookupBytes = lookup.keys.reduce(into: 0) { $0 += 81 + $1.length }
         let storageBytes = storage.enumerated().reduce(into: 0) { $0 += 34 + $1.element.key.count + $1.element.value.count }
-        return UInt64(preimageInfosBytes) + UInt64(storageBytes)
+        return UInt64(lookupBytes) + UInt64(storageBytes)
     }
 
     // t: the minimum, or threshold, balance needed for any given service account in terms of its storage footprint
diff --git a/Blockchain/Sources/Blockchain/Types/WorkItem.swift b/Blockchain/Sources/Blockchain/Types/WorkItem.swift
index 6f619fef..b6810f37 100644
--- a/Blockchain/Sources/Blockchain/Types/WorkItem.swift
+++ b/Blockchain/Sources/Blockchain/Types/WorkItem.swift
@@ -106,7 +106,7 @@ public struct WorkItem: Sendable, Equatable, Codable, Hashable {
     public var inputs: [ImportedDataSegment]
 
     // x: a sequence of hashed of blob hashes and lengths to be introduced in this block
-    public var outputs: [HashAndLength]
+    public var extrinsics: [HashAndLength]
 
     public init(
         serviceIndex: ServiceIndex,
@@ -115,7 +115,7 @@ public struct WorkItem: Sendable, Equatable, Codable, Hashable {
         refineGasLimit: Gas,
         accumulateGasLimit: Gas,
         inputs: [ImportedDataSegment],
-        outputs: [HashAndLength],
+        extrinsics: [HashAndLength],
         exportsCount: UInt16,
     ) {
         self.serviceIndex = serviceIndex
@@ -124,7 +124,7 @@ public struct WorkItem: Sendable, Equatable, Codable, Hashable {
         self.refineGasLimit = refineGasLimit
         self.accumulateGasLimit = accumulateGasLimit
         self.inputs = inputs
-        self.outputs = outputs
+        self.extrinsics = extrinsics
         self.exportsCount = exportsCount
     }
 }
@@ -139,7 +139,7 @@ extension WorkItem: Dummy {
             refineGasLimit: Gas(0),
             accumulateGasLimit: Gas(0),
             inputs: [],
-            outputs: [],
+            extrinsics: [],
             exportsCount: 0,
         )
     }
diff --git a/Blockchain/Sources/Blockchain/VMInvocations/HostCall/AccumulateHostCalls.swift b/Blockchain/Sources/Blockchain/VMInvocations/HostCall/AccumulateHostCalls.swift
index edff1105..8ff690f4 100644
--- a/Blockchain/Sources/Blockchain/VMInvocations/HostCall/AccumulateHostCalls.swift
+++ b/Blockchain/Sources/Blockchain/VMInvocations/HostCall/AccumulateHostCalls.swift
@@ -51,14 +51,14 @@ public class Bless: HostCall {
         } else {
             logger.debug("manager: \(regs[0])")
             logger.debug("assigners: \(String(describing: assigners))")
-            logger.debug("delegator: \(regs[2])")
+            logger.debug("designator: \(regs[2])")
             logger.debug("registrar: \(regs[3])")
             logger.debug("alwaysAcc: \(String(describing: alwaysAcc))")
 
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.OK.rawValue)
             x.state.manager = ServiceIndex(regs[0])
             x.state.assigners = assigners!
-            x.state.delegator = ServiceIndex(regs[2])
+            x.state.designator = ServiceIndex(regs[2])
             x.state.registrar = ServiceIndex(regs[3])
             x.state.alwaysAcc = alwaysAcc!
         }
@@ -139,8 +139,8 @@ public class Designate: HostCall {
 
         if validatorQueue == nil {
             throw VMInvocationsError.panic
-        } else if x.serviceIndex != x.state.delegator {
-            logger.debug("Designate HUH: \(x.serviceIndex) != \(x.state.delegator)")
+        } else if x.serviceIndex != x.state.designator {
+            logger.debug("Designate HUH: \(x.serviceIndex) != \(x.state.designator)")
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.HUH.rawValue)
         } else {
             x.state.validatorQueue = try ConfigFixedSizeArray(config: config, array: validatorQueue!)
@@ -196,8 +196,8 @@ public class New: HostCall {
         logger.debug("codeHash: \(codeHash?.description ?? "nil")")
         logger.debug("new service index: \(x.nextAccountIndex)")
 
-        let minAccumlateGas = Gas(regs[2])
-        let minMemoGas = Gas(regs[3])
+        let minItemGas = Gas(regs[2])
+        let minDeferredTransferGas = Gas(regs[3])
         let gratisStorage = Balance(regs[4])
 
         var newAccount: ServiceAccount?
@@ -206,11 +206,11 @@ public class New: HostCall {
                 version: 0,
                 storage: [:],
                 preimages: [:],
-                preimageInfos: [HashAndLength(hash: codeHash, length: UInt32(truncatingIfNeeded: regs[1])): []],
+                lookup: [HashAndLength(hash: codeHash, length: UInt32(truncatingIfNeeded: regs[1])): []],
                 codeHash: codeHash,
                 balance: Balance(0),
-                minAccumlateGas: minAccumlateGas,
-                minMemoGas: minMemoGas,
+                minItemGas: minItemGas,
+                minDeferredTransferGas: minDeferredTransferGas,
                 gratisStorage: gratisStorage,
                 createdAt: timeslot,
                 lastAccAt: 0,
@@ -287,8 +287,8 @@ public class Upgrade: HostCall {
 
         if let codeHash, var acc = try await x.state.accounts.value.get(serviceAccount: x.serviceIndex) {
             acc.codeHash = codeHash
-            acc.minAccumlateGas = Gas(regs[1])
-            acc.minMemoGas = Gas(regs[2])
+            acc.minItemGas = Gas(regs[1])
+            acc.minDeferredTransferGas = Gas(regs[2])
             x.state.accounts.set(serviceAccount: x.serviceIndex, account: acc)
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.OK.rawValue)
         } else {
@@ -340,7 +340,7 @@ public class Transfer: HostCall {
             return .exit(.panic(.trap))
         } else if destAccount == nil {
             (resultCode, additionalGas) = (HostCallResultCode.WHO.rawValue, Gas(0))
-        } else if gasLimit < destAccount!.minMemoGas {
+        } else if gasLimit < destAccount!.minDeferredTransferGas {
             (resultCode, additionalGas) = (HostCallResultCode.LOW.rawValue, Gas(0))
         } else if let srcAccount, srcAccount.balance - amount < srcAccount.thresholdBalance(config: config) {
             (resultCode, additionalGas) = (HostCallResultCode.CASH.rawValue, Gas(0))
@@ -410,7 +410,7 @@ public class Eject: HostCall {
             return
         }
 
-        let preimageInfo = try await x.state.accounts.value.get(
+        let lookupHistory = try await x.state.accounts.value.get(
             serviceAccount: ejectIndex,
             preimageHash: Data32(preimageHash!)!,
             length: max(81, UInt32(ejectAccount!.totalByteLength)) - 81,
@@ -418,10 +418,10 @@ public class Eject: HostCall {
 
         let minHoldSlot = max(0, Int(timeslot) - Int(minHoldPeriod))
 
-        if ejectAccount!.itemsCount != 2 || preimageInfo == nil {
-            logger.debug("Eject HUH: itemsCount != 2 or preimageInfo is nil")
+        if ejectAccount!.itemsCount != 2 || lookupHistory == nil {
+            logger.debug("Eject HUH: itemsCount != 2 or lookupHistory is nil")
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.HUH.rawValue)
-        } else if preimageInfo!.count == 2, preimageInfo![1] < minHoldSlot {
+        } else if lookupHistory!.count == 2, lookupHistory![1] < minHoldSlot {
             // accumulating service definitely exist
             var destAccount = try await x.state.accounts.value.get(serviceAccount: x.serviceIndex)!
             destAccount.balance += ejectAccount!.balance
@@ -430,13 +430,13 @@ public class Eject: HostCall {
             logger.debug("Eject OK: successfully ejected service account")
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.OK.rawValue)
         } else {
-            logger.debug("Eject HUH: preimageInfo conditions not met")
+            logger.debug("Eject HUH: lookupHistory conditions not met")
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.HUH.rawValue)
         }
     }
 }
 
-/// Query preimage info
+/// Query preimage lookup history
 public class Query: HostCall {
     public static var identifier: UInt8 {
         22
@@ -455,29 +455,29 @@ public class Query: HostCall {
             throw VMInvocationsError.panic
         }
 
-        let preimageInfo = try await x.state.accounts.value.get(
+        let lookupHistory = try await x.state.accounts.value.get(
             serviceAccount: x.serviceIndex,
             preimageHash: Data32(preimageHash)!,
             length: length,
         )
-        guard let preimageInfo else {
+        guard let lookupHistory else {
             state.writeRegister(Registers.Index(raw: 7), HostCallResultCode.NONE.rawValue)
             state.writeRegister(Registers.Index(raw: 8), 0)
             return
         }
 
-        if preimageInfo.isEmpty {
+        if lookupHistory.isEmpty {
             state.writeRegister(Registers.Index(raw: 7), 0)
             state.writeRegister(Registers.Index(raw: 8), 0)
-        } else if preimageInfo.count == 1 {
-            state.writeRegister(Registers.Index(raw: 7), 1 + (1 << 32) * UInt64(preimageInfo[0]))
+        } else if lookupHistory.count == 1 {
+            state.writeRegister(Registers.Index(raw: 7), 1 + (1 << 32) * UInt64(lookupHistory[0]))
             state.writeRegister(Registers.Index(raw: 8), 0)
-        } else if preimageInfo.count == 2 {
-            state.writeRegister(Registers.Index(raw: 7), 2 + (1 << 32) * UInt64(preimageInfo[0]))
-            state.writeRegister(Registers.Index(raw: 8), UInt64(preimageInfo[1]))
-        } else if preimageInfo.count == 3 {
-            state.writeRegister(Registers.Index(raw: 7), 3 + (1 << 32) * UInt64(preimageInfo[0]))
-            state.writeRegister(Registers.Index(raw: 8), UInt64(preimageInfo[1]) + (1 << 32) * UInt64(preimageInfo[2]))
+        } else if lookupHistory.count == 2 {
+            state.writeRegister(Registers.Index(raw: 7), 2 + (1 << 32) * UInt64(lookupHistory[0]))
+            state.writeRegister(Registers.Index(raw: 8), UInt64(lookupHistory[1]))
+        } else if lookupHistory.count == 3 {
+            state.writeRegister(Registers.Index(raw: 7), 3 + (1 << 32) * UInt64(lookupHistory[0]))
+            state.writeRegister(Registers.Index(raw: 8), UInt64(lookupHistory[1]) + (1 << 32) * UInt64(lookupHistory[2]))
         }
     }
 }
@@ -507,15 +507,15 @@ public class Solicit: HostCall {
             throw VMInvocationsError.panic
         }
 
-        let preimageInfo = try await x.state.accounts.value.get(
+        let lookupHistory = try await x.state.accounts.value.get(
             serviceAccount: x.serviceIndex,
             preimageHash: hash,
             length: length,
         )
-        logger.debug("previous info: \(String(describing: preimageInfo))")
+        logger.debug("previous lookup history: \(String(describing: lookupHistory))")
 
-        let notRequestedYet = preimageInfo == nil
-        let isPreviouslyAvailable = preimageInfo?.count == 2
+        let notRequestedYet = lookupHistory == nil
+        let isPreviouslyAvailable = lookupHistory?.count == 2
         let canSolicit = notRequestedYet || isPreviouslyAvailable
 
         if !canSolicit {
@@ -530,9 +530,9 @@ public class Solicit: HostCall {
             let oldValue = try await x.state.accounts.value.get(serviceAccount: x.serviceIndex, preimageHash: hash, length: length)
             if notRequestedYet {
                 tempAcc.updateFootprintPreimage(oldValue: oldValue, newValue: [], length: length)
-            } else if isPreviouslyAvailable, var preimageInfo {
-                try preimageInfo.append(timeslot)
-                tempAcc.updateFootprintPreimage(oldValue: oldValue, newValue: preimageInfo, length: length)
+            } else if isPreviouslyAvailable, var lookupHistory {
+                try lookupHistory.append(timeslot)
+                tempAcc.updateFootprintPreimage(oldValue: oldValue, newValue: lookupHistory, length: length)
             }
             acc = tempAcc
         }
@@ -544,21 +544,21 @@ public class Solicit: HostCall {
             if notRequestedYet {
                 logger.debug("solicit new preimage")
                 try await x.state.accounts.set(serviceAccount: x.serviceIndex, preimageHash: hash, length: length, value: [])
-            } else if isPreviouslyAvailable, var preimageInfo {
+            } else if isPreviouslyAvailable, var lookupHistory {
                 logger.debug("solicit existing preimage")
-                try preimageInfo.append(timeslot)
+                try lookupHistory.append(timeslot)
                 try await x.state.accounts.set(
                     serviceAccount: x.serviceIndex,
                     preimageHash: hash,
                     length: length,
-                    value: preimageInfo,
+                    value: lookupHistory,
                 )
             }
         }
     }
 }
 
-/// Forget data made available in-core (through preimage lookups)
+/// Cancel, mark unavailable, or expunge a preimage lookup
 public class Forget: HostCall {
     public static var identifier: UInt8 {
         24
@@ -581,17 +581,17 @@ public class Forget: HostCall {
             throw VMInvocationsError.panic
         }
 
-        let preimageInfo = try await x.state.accounts.value.get(
+        let lookupHistory = try await x.state.accounts.value.get(
             serviceAccount: x.serviceIndex,
             preimageHash: hash,
             length: length,
         )
-        let historyCount = preimageInfo?.count
+        let historyCount = lookupHistory?.count
         let minHoldSlot = max(0, Int(timeslot) - config.value.preimagePurgePeriod)
 
-        let canExpunge = historyCount == 0 || (historyCount == 2 && preimageInfo![1] < minHoldSlot)
+        let canExpunge = historyCount == 0 || (historyCount == 2 && lookupHistory![1] < minHoldSlot)
         let isAvailable1 = historyCount == 1
-        let isAvailable3 = historyCount == 3 && (preimageInfo![1] < minHoldSlot)
+        let isAvailable3 = historyCount == 3 && (lookupHistory![1] < minHoldSlot)
 
         let canForget = canExpunge || isAvailable1 || isAvailable3
 
@@ -602,28 +602,28 @@ public class Forget: HostCall {
             if canExpunge {
                 try await x.state.accounts.set(serviceAccount: x.serviceIndex, preimageHash: hash, length: length, value: nil)
                 x.state.accounts.set(serviceAccount: x.serviceIndex, preimageHash: hash, value: nil)
-            } else if isAvailable1, var preimageInfo {
-                try preimageInfo.append(timeslot)
+            } else if isAvailable1, var lookupHistory {
+                try lookupHistory.append(timeslot)
                 try await x.state.accounts.set(
                     serviceAccount: x.serviceIndex,
                     preimageHash: hash,
                     length: length,
-                    value: preimageInfo,
+                    value: lookupHistory,
                 )
-            } else if isAvailable3, var preimageInfo {
-                preimageInfo = [preimageInfo[2], timeslot]
+            } else if isAvailable3, var lookupHistory {
+                lookupHistory = [lookupHistory[2], timeslot]
                 try await x.state.accounts.set(
                     serviceAccount: x.serviceIndex,
                     preimageHash: hash,
                     length: length,
-                    value: preimageInfo,
+                    value: lookupHistory,
                 )
             }
         }
     }
 }
 
-/// Yield accumulation hash
+/// Set the service's accumulation output hash
 public class Yield: HostCall {
     public static var identifier: UInt8 {
         25
@@ -647,7 +647,7 @@ public class Yield: HostCall {
     }
 }
 
-/// Provide some preimages (will be made available after invocation)
+/// Queue a requested preimage for integration after accumulation
 public class Provide: HostCall {
     public static var identifier: UInt8 {
         26
diff --git a/Blockchain/Sources/Blockchain/VMInvocations/HostCall/GeneralHostCalls.swift b/Blockchain/Sources/Blockchain/VMInvocations/HostCall/GeneralHostCalls.swift
index 2c1c5a6a..b32e40d2 100644
--- a/Blockchain/Sources/Blockchain/VMInvocations/HostCall/GeneralHostCalls.swift
+++ b/Blockchain/Sources/Blockchain/VMInvocations/HostCall/GeneralHostCalls.swift
@@ -74,7 +74,7 @@ public class Fetch: HostCall {
         try encoder.encode(item.accumulateGasLimit)
         try encoder.encode(item.exportsCount)
         try encoder.encode(UInt16(item.inputs.count))
-        try encoder.encode(UInt16(item.outputs.count))
+        try encoder.encode(UInt16(item.extrinsics.count))
         try encoder.encode(UInt32(item.payloadBlob.count))
         return encoder.data
     }
@@ -101,17 +101,17 @@ public class Fetch: HostCall {
         case 3:
             if let workPackage, let serviceAccounts, reg11 < workPackage.workItems.count {
                 let item = workPackage.workItems[Int(reg11)]
-                let outputs = item.outputs
-                if reg12 < outputs.count {
-                    value = try await serviceAccounts.value.get(serviceAccount: item.serviceIndex, preimageHash: outputs[Int(reg12)].hash)
+                let extrinsics = item.extrinsics
+                if reg12 < extrinsics.count {
+                    value = try await serviceAccounts.value.get(serviceAccount: item.serviceIndex, preimageHash: extrinsics[Int(reg12)].hash)
                 }
             }
         case 4:
             if let workItemIndex, let workPackage, let serviceAccounts {
                 let item = workPackage.workItems[workItemIndex]
-                let outputs = item.outputs
-                if reg11 < outputs.count {
-                    value = try await serviceAccounts.value.get(serviceAccount: item.serviceIndex, preimageHash: outputs[Int(reg11)].hash)
+                let extrinsics = item.extrinsics
+                if reg11 < extrinsics.count {
+                    value = try await serviceAccounts.value.get(serviceAccount: item.serviceIndex, preimageHash: extrinsics[Int(reg11)].hash)
                 }
             }
         case 5:
@@ -432,8 +432,8 @@ public class Info: HostCall {
                 account.codeHash,
                 account.balance,
                 account.thresholdBalance(config: config),
-                account.minAccumlateGas,
-                account.minMemoGas,
+                account.minItemGas,
+                account.minDeferredTransferGas,
                 account.totalByteLength,
                 account.itemsCount,
                 account.gratisStorage,
diff --git a/Blockchain/Sources/Blockchain/Validator/BlockAuthor.swift b/Blockchain/Sources/Blockchain/Validator/BlockAuthor.swift
index 650bfcf0..227192ac 100644
--- a/Blockchain/Sources/Blockchain/Validator/BlockAuthor.swift
+++ b/Blockchain/Sources/Blockchain/Validator/BlockAuthor.swift
@@ -98,7 +98,7 @@ public final class BlockAuthor: ServiceBase2, @unchecked Sendable, OnBeforeEpoch
             vrfOutput = try secretKey.getOutput(vrfInputData: inputData)
         }
 
-        let vrfSignature = try secretKey.ietfVRFSign(vrfInputData: SigningContext.entropyInputData(entropy: vrfOutput))
+        let entropySource = try secretKey.ietfVRFSign(vrfInputData: SigningContext.entropyInputData(entropy: vrfOutput))
 
         let authorIndex = state.value.currentValidators.firstIndex { publicKey.data == $0.bandersnatch }
         guard let authorIndex else {
@@ -108,7 +108,7 @@ public final class BlockAuthor: ServiceBase2, @unchecked Sendable, OnBeforeEpoch
         let safroleResult = try state.value.updateSafrole(
             config: config,
             slot: timeslot,
-            entropy: Bandersnatch.getIetfSignatureOutput(signature: vrfSignature),
+            entropy: Bandersnatch.getIetfSignatureOutput(signature: entropySource),
             offenders: state.value.judgements.punishSet,
             extrinsics: extrinsic.tickets,
         )
@@ -116,13 +116,13 @@ public final class BlockAuthor: ServiceBase2, @unchecked Sendable, OnBeforeEpoch
         let unsignedHeader = Header.Unsigned(
             parentHash: parentHash,
             priorStateRoot: stateRoot,
-            extrinsicsHash: extrinsic.hash(),
+            extrinsicHash: extrinsic.hash(),
             timeslot: timeslot,
-            epoch: safroleResult.epochMark,
+            epochMarker: safroleResult.epochMark,
             winningTickets: safroleResult.ticketsMark,
             authorIndex: ValidatorIndex(authorIndex),
-            vrfSignature: vrfSignature,
-            offendersMarkers: [], // Judged offenders who will be marked in this block
+            entropySource: entropySource,
+            offendersMarker: [], // Judged offenders who will be marked in this block
         )
 
         let encodedHeader = try JamEncoder.encode(unsignedHeader)
diff --git a/Blockchain/Sources/Blockchain/Validator/GuaranteeingService.swift b/Blockchain/Sources/Blockchain/Validator/GuaranteeingService.swift
index 86d5f813..480dbcfc 100644
--- a/Blockchain/Sources/Blockchain/Validator/GuaranteeingService.swift
+++ b/Blockchain/Sources/Blockchain/Validator/GuaranteeingService.swift
@@ -191,7 +191,7 @@ public final class GuaranteeingService: ServiceBase2, @unchecked Sendable, OnBef
         let bundleSize = bundle.workPackage.authorizationToken.count
             + bundle.workPackage.configurationBlob.count
             + bundle.workPackage.workItems.array.reduce(0) { total, item in
-                let extrinsicsSize = item.outputs.reduce(0) { $0 + Int($1.length) }
+                let extrinsicsSize = item.extrinsics.reduce(0) { $0 + Int($1.length) }
                 return total + item.payloadBlob.count
                     + item.inputs.count * config.value.segmentFootprint
                     + extrinsicsSize
@@ -724,8 +724,8 @@ public final class GuaranteeingService: ServiceBase2, @unchecked Sendable, OnBef
                 gasUsed: UInt(refineGasUsed.value),
                 importsCount: UInt(item.inputs.count),
                 exportsCount: UInt(item.exportsCount),
-                extrinsicsCount: UInt(item.outputs.count),
-                extrinsicsSize: UInt(item.outputs.reduce(into: 0) { $0 += $1.length }),
+                extrinsicsCount: UInt(item.extrinsics.count),
+                extrinsicsSize: UInt(item.extrinsics.reduce(into: 0) { $0 += $1.length }),
             )
             workDigests.append(workDigest)
 
diff --git a/Blockchain/Tests/BlockchainTests/AccumulationCoreTests.swift b/Blockchain/Tests/BlockchainTests/AccumulationCoreTests.swift
index 0e391d0d..55eae55f 100644
--- a/Blockchain/Tests/BlockchainTests/AccumulationCoreTests.swift
+++ b/Blockchain/Tests/BlockchainTests/AccumulationCoreTests.swift
@@ -137,14 +137,14 @@ struct AccumulationCoreTests {
 
         var updated = existing
         updated.balance = Balance(250)
-        let preimageInfo: StateKeys.ServiceAccountPreimageInfoKey.Value = [9]
+        let lookupHistory: StateKeys.ServiceAccountLookupKey.Value = [9]
 
         var changes = AccountChanges()
         changes.addNewAccount(index: 30, account: newAccount)
         changes.addAccountUpdate(index: 31, account: updated)
         changes.addStorageUpdate(index: 31, key: Data([7]), value: Data([8]))
         changes.addPreimageUpdate(index: 31, hash: data32(9), value: Data([10]))
-        changes.addPreimageInfoUpdate(index: 31, hash: data32(9), length: 1, value: preimageInfo)
+        changes.addLookupUpdate(index: 31, hash: data32(9), length: 1, value: lookupHistory)
 
         try await changes.apply(to: accounts)
 
@@ -156,7 +156,7 @@ struct AccumulationCoreTests {
         #expect(try await accounts.value.get(serviceAccount: 31)?.balance == Balance(250))
         #expect(try await accounts.value.get(serviceAccount: 31, storageKey: Data([7])) == Data([8]))
         #expect(try await accounts.value.get(serviceAccount: 31, preimageHash: data32(9)) == Data([10]))
-        #expect(try await accounts.value.get(serviceAccount: 31, preimageHash: data32(9), length: 1) == preimageInfo)
+        #expect(try await accounts.value.get(serviceAccount: 31, preimageHash: data32(9), length: 1) == lookupHistory)
     }
 
     @Test
@@ -211,7 +211,7 @@ struct AccumulationCoreTests {
         changes.addAccountUpdate(index: 32, account: ServiceAccount.dummy(config: config).toDetails())
         changes.addStorageUpdate(index: 32, key: Data([1]), value: Data([2]))
         changes.addPreimageUpdate(index: 32, hash: data32(3), value: Data([4]))
-        changes.addPreimageInfoUpdate(index: 32, hash: data32(3), length: 1, value: [5])
+        changes.addLookupUpdate(index: 32, hash: data32(3), length: 1, value: [5])
         changes.addRemovedAccount(index: 32)
 
         try await changes.apply(to: accounts)
diff --git a/Blockchain/Tests/BlockchainTests/AccumulationMergeTests.swift b/Blockchain/Tests/BlockchainTests/AccumulationMergeTests.swift
index 9270dbd3..6c388c59 100644
--- a/Blockchain/Tests/BlockchainTests/AccumulationMergeTests.swift
+++ b/Blockchain/Tests/BlockchainTests/AccumulationMergeTests.swift
@@ -7,12 +7,12 @@ struct AccumulationMergeTests {
     private let config = ProtocolConfigRef.tiny
 
     @Test
-    func delegatorCanDesignateWhenItChangesDelegatorInSameBatch() throws {
-        var state = try makeAccumulateState(delegator: 0)
+    func designatorCanDesignateWhenItChangesDesignatorInSameBatch() throws {
+        var state = try makeAccumulateState(designator: 0)
         let designatedQueue = try makeValidatorQueue(startingAt: 10)
 
         var outputState = state.copy()
-        outputState.delegator = 7
+        outputState.designator = 7
         outputState.validatorQueue = designatedQueue
 
         State.mergePrivilegedUpdates(
@@ -20,7 +20,7 @@ struct AccumulationMergeTests {
             from: [(0, makeResult(state: outputState))],
         )
 
-        #expect(state.delegator == 7)
+        #expect(state.designator == 7)
         #expect(state.validatorQueue == designatedQueue)
     }
 
@@ -53,7 +53,7 @@ struct AccumulationMergeTests {
 
     private func makeAccumulateState(
         assigners: [ServiceIndex]? = nil,
-        delegator: ServiceIndex = 0,
+        designator: ServiceIndex = 0,
     ) throws -> AccumulateState {
         let baseState = State.dummy(config: config)
         let assignerValues = assigners ?? Array(repeating: ServiceIndex(0), count: config.value.totalNumberOfCores)
@@ -64,7 +64,7 @@ struct AccumulationMergeTests {
             authorizationQueue: makeAuthorizationQueue(startingAt: 1),
             manager: 0,
             assigners: ConfigFixedSizeArray(config: config, array: assignerValues),
-            delegator: delegator,
+            designator: designator,
             registrar: 0,
             alwaysAcc: [:],
             entropy: Data32(),
diff --git a/Blockchain/Tests/BlockchainTests/AssurancesRuntimeTests.swift b/Blockchain/Tests/BlockchainTests/AssurancesRuntimeTests.swift
index a3b9a7ca..298cb585 100644
--- a/Blockchain/Tests/BlockchainTests/AssurancesRuntimeTests.swift
+++ b/Blockchain/Tests/BlockchainTests/AssurancesRuntimeTests.swift
@@ -11,7 +11,7 @@ struct AssurancesRuntimeTests {
         let staleReport = makeReport(coreIndex: 0, timeslot: 5)
         let freshReport = makeReport(coreIndex: 1, timeslot: 6)
         let state = try AssuranceState(
-            reports: makeReports([staleReport, freshReport]),
+            availabilityAssignments: makeAvailabilityAssignments([staleReport, freshReport]),
             currentValidators: makeValidators(),
         )
 
@@ -21,8 +21,8 @@ struct AssurancesRuntimeTests {
             extrinsic: ExtrinsicAvailability.dummy(config: config),
         )
 
-        #expect(result.newReports[0] == nil)
-        #expect(result.newReports[1] == freshReport)
+        #expect(result.newAvailabilityAssignments[0] == nil)
+        #expect(result.newAvailabilityAssignments[1] == freshReport)
         #expect(result.availableReports.isEmpty)
     }
 
@@ -30,7 +30,7 @@ struct AssurancesRuntimeTests {
     func updateMakesReportAvailableAfterValidatorThreshold() throws {
         let report = makeReport(coreIndex: 0, timeslot: 6)
         let state = try AssuranceState(
-            reports: makeReports([report, nil]),
+            availabilityAssignments: makeAvailabilityAssignments([report, nil]),
             currentValidators: makeValidators(),
         )
         let threshold = ProtocolConfig.TwoThirdValidatorsPlusOne.read(config: config)
@@ -45,15 +45,15 @@ struct AssurancesRuntimeTests {
         )
 
         #expect(result.availableReports == [report.workReport])
-        #expect(result.newReports[0] == nil)
-        #expect(result.newReports[1] == nil)
+        #expect(result.newAvailabilityAssignments[0] == nil)
+        #expect(result.newAvailabilityAssignments[1] == nil)
     }
 
     @Test
     func updateRejectsAssuranceForEmptyCore() throws {
         let report = makeReport(coreIndex: 0, timeslot: 6)
         let state = try AssuranceState(
-            reports: makeReports([report, nil]),
+            availabilityAssignments: makeAvailabilityAssignments([report, nil]),
             currentValidators: makeValidators(),
         )
 
@@ -72,10 +72,10 @@ struct AssurancesRuntimeTests {
         return ReportItem(workReport: workReport, timeslot: timeslot)
     }
 
-    private func makeReports(
-        _ reports: [ReportItem?],
+    private func makeAvailabilityAssignments(
+        _ assignments: [ReportItem?],
     ) throws -> ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores> {
-        try ConfigFixedSizeArray(config: config, array: reports)
+        try ConfigFixedSizeArray(config: config, array: assignments)
     }
 
     private func makeValidators() throws -> ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators> {
@@ -102,6 +102,6 @@ struct AssurancesRuntimeTests {
 }
 
 private struct AssuranceState: Assurances {
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var currentValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
 }
diff --git a/Blockchain/Tests/BlockchainTests/BlockHeaderRefTests.swift b/Blockchain/Tests/BlockchainTests/BlockHeaderRefTests.swift
index b8f912fe..8a0cfb0d 100644
--- a/Blockchain/Tests/BlockchainTests/BlockHeaderRefTests.swift
+++ b/Blockchain/Tests/BlockchainTests/BlockHeaderRefTests.swift
@@ -11,13 +11,13 @@ struct BlockHeaderRefTests {
 
         #expect(header.parentHash == data32(1))
         #expect(header.priorStateRoot == data32(2))
-        #expect(header.extrinsicsHash == data32(3))
+        #expect(header.extrinsicHash == data32(3))
         #expect(header.timeslot == 99)
-        #expect(header.epoch == nil)
+        #expect(header.epochMarker == nil)
         #expect(header.winningTickets == nil)
-        #expect(header.offendersMarkers == [data32(4), data32(5)])
+        #expect(header.offendersMarker == [data32(4), data32(5)])
         #expect(header.authorIndex == 2)
-        #expect(header.vrfSignature == Data96(repeating: 6))
+        #expect(header.entropySource == Data96(repeating: 6))
     }
 
     @Test
@@ -107,13 +107,13 @@ struct BlockHeaderRefTests {
             unsigned: Header.Unsigned(
                 parentHash: data32(1),
                 priorStateRoot: data32(2),
-                extrinsicsHash: data32(3),
+                extrinsicHash: data32(3),
                 timeslot: 99,
-                epoch: nil,
+                epochMarker: nil,
                 winningTickets: nil,
                 authorIndex: authorIndex,
-                vrfSignature: Data96(repeating: 6),
-                offendersMarkers: [data32(4), data32(5)],
+                entropySource: Data96(repeating: 6),
+                offendersMarker: [data32(4), data32(5)],
             ),
             seal: Data96(repeating: 7),
         )
diff --git a/Blockchain/Tests/BlockchainTests/BlockchainDataProviderTests.swift b/Blockchain/Tests/BlockchainTests/BlockchainDataProviderTests.swift
index a6591414..9b916e2d 100644
--- a/Blockchain/Tests/BlockchainTests/BlockchainDataProviderTests.swift
+++ b/Blockchain/Tests/BlockchainTests/BlockchainDataProviderTests.swift
@@ -124,7 +124,7 @@ struct BlockchainDataProviderTests {
 
         // Verify fork removal
         let fork = BlockRef.dummy(config: config, parent: block1).mutate {
-            $0.header.unsigned.extrinsicsHash = Data32.random() // so it is different
+            $0.header.unsigned.extrinsicHash = Data32.random() // so it is different
         }
         try await provider.add(block: fork)
         try await provider.setFinalizedHead(hash: block2.hash)
diff --git a/Blockchain/Tests/BlockchainTests/DisputesRuntimeTests.swift b/Blockchain/Tests/BlockchainTests/DisputesRuntimeTests.swift
index 7ed49100..74c3e885 100644
--- a/Blockchain/Tests/BlockchainTests/DisputesRuntimeTests.swift
+++ b/Blockchain/Tests/BlockchainTests/DisputesRuntimeTests.swift
@@ -25,10 +25,10 @@ struct DisputesRuntimeTests {
 
         let result = try state.update(config: config, disputes: disputes)
 
-        #expect(result.state.judgements.banSet == [reportHash])
+        #expect(result.state.judgements.badSet == [reportHash])
         #expect(result.state.judgements.goodSet.isEmpty)
         #expect(result.state.judgements.wonkySet.isEmpty)
-        #expect(result.state.reports[0] == nil)
+        #expect(result.state.availabilityAssignments[0] == nil)
         #expect(Set(result.offenders) == [keys[0].publicKey, keys[1].publicKey])
     }
 
@@ -51,8 +51,8 @@ struct DisputesRuntimeTests {
         let result = try state.update(config: config, disputes: disputes)
 
         #expect(result.state.judgements.goodSet == [reportHash])
-        #expect(result.state.judgements.banSet.isEmpty)
-        #expect(result.state.reports[0]?.workReport == report)
+        #expect(result.state.judgements.badSet.isEmpty)
+        #expect(result.state.availabilityAssignments[0]?.workReport == report)
         #expect(result.offenders == [keys[5].publicKey])
     }
 
@@ -73,8 +73,8 @@ struct DisputesRuntimeTests {
         let result = try state.update(config: config, disputes: disputes)
 
         #expect(result.state.judgements.wonkySet == [reportHash])
-        #expect(result.state.judgements.banSet.isEmpty)
-        #expect(result.state.reports[0] == nil)
+        #expect(result.state.judgements.badSet.isEmpty)
+        #expect(result.state.availabilityAssignments[0] == nil)
         #expect(result.offenders.isEmpty)
     }
 
@@ -102,7 +102,7 @@ struct DisputesRuntimeTests {
         let state = try DisputesState(
             config: config,
             keys: keys,
-            judgements: JudgementsState(goodSet: [reportHash], banSet: [], wonkySet: [], punishSet: []),
+            judgements: JudgementsState(goodSet: [reportHash], badSet: [], wonkySet: [], punishSet: []),
         )
         let disputes = try ExtrinsicDisputes(
             verdicts: [
@@ -226,7 +226,7 @@ private struct DisputeValidatorKey {
 
 private struct DisputesState: Disputes {
     var judgements: JudgementsState
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var timeslot: TimeslotIndex
     var currentValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
     var previousValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
@@ -247,12 +247,12 @@ private struct DisputesState: Disputes {
         if let report {
             reportSlots[0] = ReportItem(workReport: report, timeslot: timeslot)
         }
-        reports = try ConfigFixedSizeArray(config: config, array: reportSlots)
+        availabilityAssignments = try ConfigFixedSizeArray(config: config, array: reportSlots)
     }
 
     mutating func mergeWith(postState: DisputesPostState) {
         judgements = postState.judgements
-        reports = postState.reports
+        availabilityAssignments = postState.availabilityAssignments
     }
 }
 
diff --git a/Blockchain/Tests/BlockchainTests/ExtrinsicTypeTests.swift b/Blockchain/Tests/BlockchainTests/ExtrinsicTypeTests.swift
index a67b416e..91eb6c92 100644
--- a/Blockchain/Tests/BlockchainTests/ExtrinsicTypeTests.swift
+++ b/Blockchain/Tests/BlockchainTests/ExtrinsicTypeTests.swift
@@ -154,7 +154,7 @@ struct ExtrinsicTypeTests {
         let services = PrivilegedServices(
             manager: 1,
             assigners: try ConfigFixedSizeArray(config: config, array: [2, 3]),
-            delegator: 4,
+            designator: 4,
             registrar: 5,
             alwaysAcc: [6: Gas(7), 8: Gas(9)],
         )
diff --git a/Blockchain/Tests/BlockchainTests/GuaranteeingRuntimeTests.swift b/Blockchain/Tests/BlockchainTests/GuaranteeingRuntimeTests.swift
index a65f6778..0b734ecd 100644
--- a/Blockchain/Tests/BlockchainTests/GuaranteeingRuntimeTests.swift
+++ b/Blockchain/Tests/BlockchainTests/GuaranteeingRuntimeTests.swift
@@ -41,7 +41,7 @@ struct GuaranteeingRuntimeTests {
 
     @Test
     func validateGuaranteesAcceptsMatchingServiceCodeAndGas() async throws {
-        let account = makeAccount(codeHash: data32(1), minAccumlateGas: Gas(10))
+        let account = makeAccount(codeHash: data32(1), minItemGas: Gas(10))
         let state = try GuaranteeingState(config: config, serviceAccounts: [7: account])
         let extrinsic = try makeExtrinsic(digests: [
             makeDigest(serviceIndex: 7, codeHash: data32(1), gasLimit: Gas(10)),
@@ -64,7 +64,7 @@ struct GuaranteeingRuntimeTests {
 
     @Test
     func validateGuaranteesRejectsMismatchedCodeHash() async throws {
-        let account = makeAccount(codeHash: data32(1), minAccumlateGas: Gas(10))
+        let account = makeAccount(codeHash: data32(1), minItemGas: Gas(10))
         let state = try GuaranteeingState(config: config, serviceAccounts: [7: account])
         let extrinsic = try makeExtrinsic(digests: [
             makeDigest(serviceIndex: 7, codeHash: data32(2), gasLimit: Gas(10)),
@@ -77,7 +77,7 @@ struct GuaranteeingRuntimeTests {
 
     @Test
     func validateGuaranteesRejectsDigestBelowServiceMinimumGas() async throws {
-        let account = makeAccount(codeHash: data32(1), minAccumlateGas: Gas(11))
+        let account = makeAccount(codeHash: data32(1), minItemGas: Gas(11))
         let state = try GuaranteeingState(config: config, serviceAccounts: [7: account])
         let extrinsic = try makeExtrinsic(digests: [
             makeDigest(serviceIndex: 7, codeHash: data32(1), gasLimit: Gas(10)),
@@ -90,7 +90,7 @@ struct GuaranteeingRuntimeTests {
 
     @Test
     func validateGuaranteesRejectsTotalGasOverBlockLimit() async throws {
-        let account = makeAccount(codeHash: data32(1), minAccumlateGas: Gas(0))
+        let account = makeAccount(codeHash: data32(1), minItemGas: Gas(0))
         let state = try GuaranteeingState(config: config, serviceAccounts: [7: account])
         let extrinsic = try makeExtrinsic(digests: [
             makeDigest(
@@ -105,10 +105,10 @@ struct GuaranteeingRuntimeTests {
         }
     }
 
-    private func makeAccount(codeHash: Data32, minAccumlateGas: Gas) -> ServiceAccountDetails {
+    private func makeAccount(codeHash: Data32, minItemGas: Gas) -> ServiceAccountDetails {
         var account = ServiceAccount.dummy(config: config).toDetails()
         account.codeHash = codeHash
-        account.minAccumlateGas = minAccumlateGas
+        account.minItemGas = minItemGas
         return account
     }
 
@@ -160,7 +160,7 @@ private struct GuaranteeingState: Guaranteeing {
     var entropyPool: EntropyPool
     var currentValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
     var previousValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var coreAuthorizationPool: ConfigFixedSizeArray<
         ConfigLimitedSizeArray<Data32, ProtocolConfig.Int0, ProtocolConfig.MaxAuthorizationsPoolItems>,
         ProtocolConfig.TotalNumberOfCores,
@@ -178,7 +178,7 @@ private struct GuaranteeingState: Guaranteeing {
         entropyPool = EntropyPool((Data32(), Data32(), Data32(), Data32()))
         currentValidators = try ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey())
         previousValidators = try ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey())
-        reports = try ConfigFixedSizeArray(
+        availabilityAssignments = try ConfigFixedSizeArray(
             config: config,
             array: Array(repeating: nil, count: config.value.totalNumberOfCores),
         )
diff --git a/Blockchain/Tests/BlockchainTests/WorkItemCodecTests.swift b/Blockchain/Tests/BlockchainTests/WorkItemCodecTests.swift
index 50e98c44..c3a2ff9e 100644
--- a/Blockchain/Tests/BlockchainTests/WorkItemCodecTests.swift
+++ b/Blockchain/Tests/BlockchainTests/WorkItemCodecTests.swift
@@ -53,7 +53,7 @@ struct WorkItemCodecTests {
                 WorkItem.ImportedDataSegment(root: .segmentRoot(data32(5)), index: 1),
                 WorkItem.ImportedDataSegment(root: .workPackageHash(data32(6)), index: 2),
             ],
-            outputs: [
+            extrinsics: [
                 HashAndLength(hash: data32(7), length: 8),
             ],
             exportsCount: 3,
diff --git a/Blockchain/Tests/BlockchainTests/WorkPackageReportTests.swift b/Blockchain/Tests/BlockchainTests/WorkPackageReportTests.swift
index 082d1218..27c292a9 100644
--- a/Blockchain/Tests/BlockchainTests/WorkPackageReportTests.swift
+++ b/Blockchain/Tests/BlockchainTests/WorkPackageReportTests.swift
@@ -224,7 +224,7 @@ private struct StubServiceAccounts: ServiceAccounts {
         serviceAccount _: ServiceIndex,
         preimageHash _: Data32,
         length _: UInt32,
-    ) async throws -> StateKeys.ServiceAccountPreimageInfoKey.Value? {
+    ) async throws -> StateKeys.ServiceAccountLookupKey.Value? {
         nil
     }
 
@@ -253,7 +253,7 @@ private struct StubServiceAccounts: ServiceAccounts {
         serviceAccount _: ServiceIndex,
         preimageHash _: Data32,
         length _: UInt32,
-        value _: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        value _: StateKeys.ServiceAccountLookupKey.Value?,
     ) async throws {}
 
     mutating func remove(serviceAccount _: ServiceIndex) async throws {}
diff --git a/JAMTests/Benchmarks/Benchmarks/Runtime.swift b/JAMTests/Benchmarks/Benchmarks/Runtime.swift
index a70cd6f4..60fbc843 100644
--- a/JAMTests/Benchmarks/Benchmarks/Runtime.swift
+++ b/JAMTests/Benchmarks/Benchmarks/Runtime.swift
@@ -34,10 +34,10 @@ func runtimeBenchmarks() {
     Benchmark("runtime.validate.header") { benchmark in
         let (parentBlock, parentState) = try await createGenesis(config: config)
         let stateRoot = await parentState.value.stateRoot
-        // Create a block with the correct priorStateRoot and extrinsicsHash
+        // Create a block with the correct priorStateRoot and extrinsicHash
         let block = BlockRef.dummy(config: config, parent: parentBlock).mutate { b in
             b.header.unsigned.priorStateRoot = stateRoot
-            b.header.unsigned.extrinsicsHash = b.extrinsic.hash()
+            b.header.unsigned.extrinsicHash = b.extrinsic.hash()
         }
         let runtime = Runtime(config: config, ancestry: nil)
         let validatedBlock = try block.toValidated(config: config)
@@ -51,10 +51,10 @@ func runtimeBenchmarks() {
     Benchmark("runtime.validate.block") { benchmark in
         let (parentBlock, parentState) = try await createGenesis(config: config)
         let stateRoot = await parentState.value.stateRoot
-        // Create a block with the correct priorStateRoot and extrinsicsHash
+        // Create a block with the correct priorStateRoot and extrinsicHash
         let block = BlockRef.dummy(config: config, parent: parentBlock).mutate { b in
             b.header.unsigned.priorStateRoot = stateRoot
-            b.header.unsigned.extrinsicsHash = b.extrinsic.hash()
+            b.header.unsigned.extrinsicHash = b.extrinsic.hash()
         }
         let runtime = Runtime(config: config, ancestry: nil)
         let validatedBlock = try block.toValidated(config: config)
@@ -162,7 +162,7 @@ func runtimeBenchmarks() {
     }
 
     Benchmark("runtime.guaranteeing.validate.repeatedService", configuration: BokaBenchmark.configuration()) { benchmark in
-        let account = runtimeServiceAccount(codeHash: runtimeData32(1), minAccumlateGas: Gas(10), config: config)
+        let account = runtimeServiceAccount(codeHash: runtimeData32(1), minItemGas: Gas(10), config: config)
         let state = try RuntimeGuaranteeingBenchmarkState(config: config, serviceAccounts: [7: account])
         let extrinsic = try runtimeGuaranteingExtrinsic(
             config: config,
@@ -183,7 +183,7 @@ private struct RuntimeGuaranteeingBenchmarkState: Guaranteeing {
     var entropyPool: EntropyPool
     var currentValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
     var previousValidators: ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var coreAuthorizationPool: ConfigFixedSizeArray<
         ConfigLimitedSizeArray<Data32, ProtocolConfig.Int0, ProtocolConfig.MaxAuthorizationsPoolItems>,
         ProtocolConfig.TotalNumberOfCores,
@@ -201,7 +201,7 @@ private struct RuntimeGuaranteeingBenchmarkState: Guaranteeing {
         entropyPool = EntropyPool((Data32(), Data32(), Data32(), Data32()))
         currentValidators = try ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey())
         previousValidators = try ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey())
-        reports = try ConfigFixedSizeArray(
+        availabilityAssignments = try ConfigFixedSizeArray(
             config: config,
             array: Array(repeating: nil, count: config.value.totalNumberOfCores),
         )
@@ -261,12 +261,12 @@ private func runtimeGuaranteingExtrinsic(
 
 private func runtimeServiceAccount(
     codeHash: Data32,
-    minAccumlateGas: Gas,
+    minItemGas: Gas,
     config: ProtocolConfigRef,
 ) -> ServiceAccountDetails {
     var account = ServiceAccount.dummy(config: config).toDetails()
     account.codeHash = codeHash
-    account.minAccumlateGas = minAccumlateGas
+    account.minItemGas = minItemGas
     return account
 }
 
diff --git a/JAMTests/Benchmarks/Benchmarks/Validator.swift b/JAMTests/Benchmarks/Benchmarks/Validator.swift
index 86feb32f..798337b5 100644
--- a/JAMTests/Benchmarks/Benchmarks/Validator.swift
+++ b/JAMTests/Benchmarks/Benchmarks/Validator.swift
@@ -27,7 +27,7 @@ func validatorBenchmarks() {
         var block = BlockRef.dummy(config: config, parent: parent)
         for _ in 0 ..< 100 {
             block = BlockRef.dummy(config: config, parent: parent).mutate { b in
-                b.header.unsigned.extrinsicsHash = Data32.random()
+                b.header.unsigned.extrinsicHash = Data32.random()
             }
         }
         benchmark.stopMeasurement()
diff --git a/JAMTests/Tests/JAMTests/jamtestnet/TraceTest.swift b/JAMTests/Tests/JAMTests/jamtestnet/TraceTest.swift
index 7164fb1d..021956da 100644
--- a/JAMTests/Tests/JAMTests/jamtestnet/TraceTest.swift
+++ b/JAMTests/Tests/JAMTests/jamtestnet/TraceTest.swift
@@ -41,7 +41,7 @@ enum TraceTest {
             #expect(stateRef.value.validatorQueue == expectedState.validatorQueue)
             #expect(stateRef.value.currentValidators == expectedState.currentValidators)
             #expect(stateRef.value.previousValidators == expectedState.previousValidators)
-            #expect(stateRef.value.reports == expectedState.reports)
+            #expect(stateRef.value.availabilityAssignments == expectedState.availabilityAssignments)
             #expect(stateRef.value.timeslot == expectedState.timeslot)
             #expect(stateRef.value.privilegedServices == expectedState.privilegedServices)
             #expect(stateRef.value.activityStatistics == expectedState.activityStatistics)
diff --git a/JAMTests/Tests/JAMTests/w3f/AccumulateTests.swift b/JAMTests/Tests/JAMTests/w3f/AccumulateTests.swift
index ac757181..15a26263 100644
--- a/JAMTests/Tests/JAMTests/w3f/AccumulateTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/AccumulateTests.swift
@@ -25,7 +25,7 @@ private struct PreimageRequestKey: Codable, Equatable {
 
 private struct PreimageRequestMapEntry: Codable, Equatable {
     var key: PreimageRequestKey
-    var value: StateKeys.ServiceAccountPreimageInfoKey.Value
+    var value: StateKeys.ServiceAccountLookupKey.Value
 }
 
 private struct StorageMapEntry: Codable, Equatable {
@@ -127,7 +127,7 @@ private struct FullAccumulateState: Accumulation {
     var accounts: [ServiceIndex: ServiceAccountDetails] = [:]
     var storages: [ServiceIndex: [Data: Data]] = [:]
     var preimages: [ServiceIndex: [Data32: Data]] = [:]
-    var preimageInfo: [ServiceIndex: [HashAndLength: StateKeys.ServiceAccountPreimageInfoKey.Value]] = [:]
+    var lookup: [ServiceIndex: [HashAndLength: StateKeys.ServiceAccountLookupKey.Value]] = [:]
 
     func copy() -> ServiceAccounts {
         self
@@ -149,8 +149,8 @@ private struct FullAccumulateState: Accumulation {
         serviceAccount index: ServiceIndex,
         preimageHash hash: Data32,
         length: UInt32,
-    ) async throws -> StateKeys.ServiceAccountPreimageInfoKey.Value? {
-        preimageInfo[index]?[HashAndLength(hash: hash, length: length)]
+    ) async throws -> StateKeys.ServiceAccountLookupKey.Value? {
+        lookup[index]?[HashAndLength(hash: hash, length: length)]
     }
 
     func historicalLookup(serviceAccount _: ServiceIndex, timeslot _: TimeslotIndex, preimageHash _: Data32) async throws -> Data? {
@@ -190,24 +190,24 @@ private struct FullAccumulateState: Accumulation {
         serviceAccount index: ServiceIndex,
         preimageHash hash: Data32,
         length: UInt32,
-        value: StateKeys.ServiceAccountPreimageInfoKey.Value?,
+        value: StateKeys.ServiceAccountLookupKey.Value?,
     ) {
         let key = HashAndLength(hash: hash, length: length)
         // update footprint
-        let oldValue = preimageInfo[index]?[key]
+        let oldValue = lookup[index]?[key]
         logger.debug("preimage footprint before: \(accounts[index]?.itemsCount ?? 0) items, \(accounts[index]?.totalByteLength ?? 0) bytes")
         accounts[index]?.updateFootprintPreimage(oldValue: oldValue, newValue: value, length: length)
         logger.debug("preimage footprint after: \(accounts[index]?.itemsCount ?? 0) items, \(accounts[index]?.totalByteLength ?? 0) bytes")
 
         // update value
-        preimageInfo[index, default: [:]][key] = value
+        lookup[index, default: [:]][key] = value
     }
 
     mutating func remove(serviceAccount index: ServiceIndex) async throws {
         accounts[index] = nil
         storages[index] = nil
         preimages[index] = nil
-        preimageInfo[index] = nil
+        lookup[index] = nil
     }
 }
 
@@ -243,7 +243,7 @@ struct AccumulateTests {
             }
             for preimageRequest in entry.data.preimageRequests {
                 let key = HashAndLength(hash: preimageRequest.key.hash, length: preimageRequest.key.length)
-                fullState.preimageInfo[entry.index, default: [:]][key] = preimageRequest.value
+                fullState.lookup[entry.index, default: [:]][key] = preimageRequest.value
             }
         }
 
@@ -279,7 +279,7 @@ struct AccumulateTests {
                     for preimageRequest in entry.data.preimageRequests {
                         let key = HashAndLength(hash: preimageRequest.key.hash, length: preimageRequest.key.length)
                         #expect(
-                            fullState.preimageInfo[entry.index]?[key] == preimageRequest.value,
+                            fullState.lookup[entry.index]?[key] == preimageRequest.value,
                         )
                     }
                 }
diff --git a/JAMTests/Tests/JAMTests/w3f/AssurancesTests.swift b/JAMTests/Tests/JAMTests/w3f/AssurancesTests.swift
index 66da6698..9071ca01 100644
--- a/JAMTests/Tests/JAMTests/w3f/AssurancesTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/AssurancesTests.swift
@@ -12,7 +12,7 @@ struct AssurancesInput: Codable {
 }
 
 struct AssuranceState: Equatable, Codable, Assurances {
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var currentValidators:
         ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
 }
@@ -47,10 +47,10 @@ struct AssurancesTests {
             )
         }
         switch result {
-        case let .success((newReports, availableReports)):
+        case let .success((newAvailabilityAssignments, availableReports)):
             switch testcase.output {
             case let .left(reports):
-                state.reports = newReports
+                state.availabilityAssignments = newAvailabilityAssignments
                 #expect(state == testcase.postState)
                 #expect(availableReports == reports)
             case .right:
diff --git a/JAMTests/Tests/JAMTests/w3f/CodecTests.swift b/JAMTests/Tests/JAMTests/w3f/CodecTests.swift
index 6138917e..4ab6848f 100644
--- a/JAMTests/Tests/JAMTests/w3f/CodecTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/CodecTests.swift
@@ -150,7 +150,7 @@ struct CodecTests {
                         "index": item["index"]!,
                     ].json
                 }.json,
-                "extrinsic": json["outputs"]!.array!.map { item in
+                "extrinsic": json["extrinsics"]!.array!.map { item in
                     [
                         "hash": item["hash"]!,
                         "len": item["length"]!,
@@ -216,13 +216,13 @@ struct CodecTests {
             return [
                 "parent": json["parentHash"]!,
                 "parent_state_root": json["priorStateRoot"]!,
-                "extrinsic_hash": json["extrinsicsHash"]!,
+                "extrinsic_hash": json["extrinsicHash"]!,
                 "slot": json["timeslot"]!,
-                "epoch_mark": transform(json["epoch"] ?? .null, value: value.epoch as Any),
+                "epoch_mark": transform(json["epochMarker"] ?? .null, value: value.epochMarker as Any),
                 "tickets_mark": transform(json["winningTickets"] ?? .null, value: value.winningTickets as Any),
                 "author_index": json["authorIndex"]!,
-                "entropy_source": json["vrfSignature"]!,
-                "offenders_mark": transform(json["offendersMarkers"]!, value: value.offendersMarkers),
+                "entropy_source": json["entropySource"]!,
+                "offenders_mark": transform(json["offendersMarker"]!, value: value.offendersMarker),
                 "seal": json["seal"]!,
             ].json
         }
diff --git a/JAMTests/Tests/JAMTests/w3f/DisputesTests.swift b/JAMTests/Tests/JAMTests/w3f/DisputesTests.swift
index 421f922e..710ee044 100644
--- a/JAMTests/Tests/JAMTests/w3f/DisputesTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/DisputesTests.swift
@@ -7,7 +7,7 @@ import Utils
 
 struct DisputesState: Equatable, Codable, Disputes {
     var judgements: JudgementsState
-    var reports: ConfigFixedSizeArray<
+    var availabilityAssignments: ConfigFixedSizeArray<
         ReportItem?,
         ProtocolConfig.TotalNumberOfCores,
     >
@@ -21,7 +21,7 @@ struct DisputesState: Equatable, Codable, Disputes {
 
     mutating func mergeWith(postState: DisputesPostState) {
         judgements = postState.judgements
-        reports = postState.reports
+        availabilityAssignments = postState.availabilityAssignments
     }
 }
 
diff --git a/JAMTests/Tests/JAMTests/w3f/PreimagesTests.swift b/JAMTests/Tests/JAMTests/w3f/PreimagesTests.swift
index edcd37d4..3cded1df 100644
--- a/JAMTests/Tests/JAMTests/w3f/PreimagesTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/PreimagesTests.swift
@@ -5,11 +5,11 @@ import Foundation
 import Testing
 import Utils
 
-private struct PreimageInfo: Codable, Equatable, Hashable, Comparable {
+private struct PreimageMapEntry: Codable, Equatable, Hashable, Comparable {
     var hash: Data32
     var blob: Data
 
-    static func < (lhs: PreimageInfo, rhs: PreimageInfo) -> Bool {
+    static func < (lhs: PreimageMapEntry, rhs: PreimageMapEntry) -> Bool {
         lhs.hash < rhs.hash
     }
 }
@@ -21,7 +21,7 @@ private struct HistoryEntry: Codable, Equatable {
 
 private struct AccountsMapEntry: Codable, Equatable {
     var index: ServiceIndex
-    @CodingAs<SortedSet<PreimageInfo>> var preimages: Set<PreimageInfo>
+    @CodingAs<SortedSet<PreimageMapEntry>> var preimages: Set<PreimageMapEntry>
     @CodingAs<SortedKeyValues<HashAndLength, [TimeslotIndex]>> var history: [HashAndLength: [TimeslotIndex]]
 }
 
@@ -56,7 +56,7 @@ private struct PreimagesState: Equatable, Codable, Preimages {
             }
             if let accountIndex {
                 var account = accounts[accountIndex]
-                account.preimages.insert(PreimageInfo(hash: update.hash, blob: update.data))
+                account.preimages.insert(PreimageMapEntry(hash: update.hash, blob: update.data))
                 account.history[HashAndLength(hash: update.hash, length: update.length)] = [update.timeslot]
                 accounts[accountIndex] = account
             }
diff --git a/JAMTests/Tests/JAMTests/w3f/ReportsTests.swift b/JAMTests/Tests/JAMTests/w3f/ReportsTests.swift
index f5af3067..1de01825 100644
--- a/JAMTests/Tests/JAMTests/w3f/ReportsTests.swift
+++ b/JAMTests/Tests/JAMTests/w3f/ReportsTests.swift
@@ -6,7 +6,7 @@ import Testing
 import Utils
 
 struct ReportsTestcaseState: Codable, Equatable {
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var currentValidators:
         ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
     var previousValidators:
@@ -40,7 +40,7 @@ struct ReportsOutput: Codable, Equatable {
 }
 
 struct ReportsState: Guaranteeing {
-    var reports: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
+    var availabilityAssignments: ConfigFixedSizeArray<ReportItem?, ProtocolConfig.TotalNumberOfCores>
     var currentValidators:
         ConfigFixedSizeArray<ValidatorKey, ProtocolConfig.TotalNumberOfValidators>
     var previousValidators:
@@ -85,7 +85,7 @@ struct ReportsTests {
         let testcase = try decoder.decode(ReportsTestcase.self)
 
         let state = ReportsState(
-            reports: testcase.preState.reports,
+            availabilityAssignments: testcase.preState.availabilityAssignments,
             currentValidators: testcase.preState.currentValidators,
             previousValidators: testcase.preState.previousValidators,
             entropyPool: testcase.preState.entropyPool,
@@ -107,11 +107,11 @@ struct ReportsTests {
             )
         }
         switch result {
-        case let .success((newReports, reported, reporters)):
+        case let .success((newAvailabilityAssignments, reported, reporters)):
             switch testcase.output {
             case let .left(output):
                 let expectedPostState = ReportsTestcaseState(
-                    reports: newReports,
+                    availabilityAssignments: newAvailabilityAssignments,
                     currentValidators: state.currentValidators,
                     previousValidators: state.previousValidators,
                     entropyPool: state.entropyPool,
diff --git a/README.md b/README.md
index 2f2da516..ea6fb544 100644
--- a/README.md
+++ b/README.md
@@ -8,12 +8,12 @@ Install tools and dependencies:
 
 **macOS**
 ```bash
-brew install swiftlint swiftformat rocksdb openssl
+brew install swiftlint swiftformat rocksdb openssl jemalloc zstd
 ```
 
 **Linux**
 ```bash
-apt-get install librocksdb-dev libzstd-dev libbz2-dev liblz4-dev libssl-dev
+apt-get install librocksdb-dev libzstd-dev libbz2-dev liblz4-dev libssl-dev libjemalloc-dev
 ```
 
 Setup the project:
@@ -36,24 +36,40 @@ make deps
 
 ## CLI Usage
 
-The Boka CLI supports the following arguments:
+The Boka CLI supports the following options:
 
-- `--base-path <path>`: Base path to database files.
-- `--chain <chain>`: A preset config or path to chain config file. Default: `minimal`.
-- `--rpc <address>`: Listen address for RPC server. Pass 'no' to disable. Default: `127.0.0.1:9955`.
+- `-b <path>` / `--base-path <path>`: Directory for the database and keys. Without it, both are in memory.
+- `--chain <chain>`: Preset (`minimal`, `dev`, `tiny`, `mainnet`) or path to a chain spec file. Default: `minimal`.
+- `--rpc <address>`: Listen address for RPC server. Pass `no` to disable. Default: `127.0.0.1:9955`.
 - `--p2p <address>`: Listen address for P2P protocol. Default: `127.0.0.1:0`.
-- `--peers <address>`: Specify peer P2P addresses.
+- `--peers <address>`: Add a P2P peer. Repeat `--peers` to add more.
 - `--validator`: Run as a validator.
-- `--operator-rpc <address>`: Listen address for operator RPC server. Pass 'false' to disable.
 - `--dev-seed <seed>`: For development only. Seed for validator keys.
 - `--name <name>`: Node name. For telemetry only.
 - `--local`: Enable local mode, whereas peers are not expected.
 - `--dev`: Enable dev mode. This is equivalent to `--local --validator`.
 
+Subcommands:
+
+- `generate <output>`: Create a chainspec file at the required output path.
+  - `--config <preset>`: `minimal` (default), `dev`, `tiny`, or `mainnet`.
+  - `--chainspec <path>`: Use an existing chainspec instead of a preset.
+  - `--id <id>`: Override the chain ID.
+- `fuzz target`: Wait for JAM conformance fuzzer connections.
+  - `--socket-path <path>`: Unix socket path (default: `/tmp/jam_conformance.sock`).
+  - `--config <tiny|full>`: Protocol configuration (default: `tiny`).
+- `fuzz fuzzer`: Connect to a target and run the JAM conformance fuzzer.
+  - `--socket-path <path>`: Unix socket path (default: `/tmp/jam_conformance.sock`).
+  - `--config <tiny|full>`: Protocol configuration (default: `tiny`).
+  - `--seed <number>`: Random seed (random by default).
+  - `--blocks <count>`: Number of blocks to process (default: `200`).
+  - `--traces-dir <path>`: Directory containing trace test vectors.
+
 ## Testing
 
 - Run all Swift tests: `make test`
 - Run specific package: `cd <package> && swift test`
+- Run specific package from the repository root: `swift test --package-path <package>`
 - Run with filter: `cd <package> && swift test --filter <test-name>`
 - Verbose output: `swift test --verbose`
 - Run Rust tests: `make test-cargo`
@@ -137,3 +153,11 @@ Regression thresholds are configured alongside the benchmark code in
   - The JAM codec implementation.
 - Utils
   - Provide the common utilities for the blockchain node.
+- TracingUtils
+  - Logging and tracing utilities.
+- JAMTests
+  - JAM test vectors and benchmarks.
+- Fuzzing
+  - JAM conformance fuzzing tools.
+- Tools
+  - Developer utilities for PVM, RPC, and proof-of-concept workflows.
diff --git a/Utils/Sources/Utils/ErasureCoding.swift b/Utils/Sources/Utils/ErasureCoding.swift
index 783310de..dffb3d7f 100644
--- a/Utils/Sources/Utils/ErasureCoding.swift
+++ b/Utils/Sources/Utils/ErasureCoding.swift
@@ -117,24 +117,19 @@ public enum ErasureCoding {
     }
 
     private static func withDataPointers<R>(_ data: [Data], _ body: ([UnsafePointer<UInt8>?]) throws -> R) throws -> R {
-        var pointers: [UnsafePointer<UInt8>?] = []
-        pointers.reserveCapacity(data.count)
+        let bytes = UnsafeMutablePointer<UInt8>.allocate(capacity: data.reduce(0) { $0 + $1.count })
+        defer { bytes.deallocate() }
 
-        func helper(index: Int) throws -> R {
-            if index == data.count {
-                return try body(pointers)
-            }
-
-            return try data[index].withUnsafeBytes { buffer in
-                pointers.append(buffer.baseAddress?.assumingMemoryBound(to: UInt8.self))
-                defer {
-                    pointers.removeLast()
-                }
-                return try helper(index: index + 1)
-            }
+        var offset = 0
+        let pointers: [UnsafePointer<UInt8>?] = data.map { shard in
+            guard !shard.isEmpty else { return nil }
+            let pointer = bytes.advanced(by: offset)
+            shard.copyBytes(to: pointer, count: shard.count)
+            offset += shard.count
+            return UnsafePointer(pointer)
         }
 
-        return try helper(index: 0)
+        return try body(pointers)
     }
 
     /// join k data of length n into one data of length k * n