separate config limited decode and validate

Author: qiweiii

Blockchain/Sources/Blockchain/RuntimeProtocols/Validate.swift

@@ -62,16 +62,24 @@ extension Array where Element: Validate {
 
 extension ConfigLimitedSizeArray: Validate where T: Validate {
     public func validate(config: Config) throws {
+        try validateThrowing()
         try array.validate(config: config)
     }
 }
 
 extension LimitedSizeArray: Validate where T: Validate {
     public func validate(config: Config) throws {
+        try validateThrowing()
         try array.validate(config: config)
     }
 }
 
+extension ConfigSizeBitString: Validate {
+    public func validate(config _: Config) throws {
+        try validateThrowing()
+    }
+}
+
 extension Ref: Validate where T: Validate {
     public func validate(config: Config) throws {
         try value.validate(config: config)

Blockchain/Sources/Blockchain/Types/EpochMarker.swift

@@ -38,3 +38,5 @@ extension EpochMarker: Dummy {
         )
     }
 }
+
+extension EpochMarker: Validate {}

Blockchain/Sources/Blockchain/Types/WorkReport.swift

@@ -81,7 +81,7 @@ extension WorkReport: Validate {
         case tooManyDependencies
     }
 
-    public func validate(config: Config) throws(WorkReportError) {
+    public func validateSelf(config: Config) throws(WorkReportError) {
         guard refinementContext.prerequisiteWorkPackages.count + lookup.count <= config.value.maxDepsInWorkReport else {
             throw .tooManyDependencies
         }

JAMTests/Tests/JAMTests/jamtestnet/FuzzTests.swift

@@ -38,18 +38,10 @@ struct FuzzTests {
             // empty to include all
         ],
         ignore: [
-            ("0.7.1/1763371098", "00000006"), // tooFewElements (block decode fail, expected to fail)
-            ("0.7.1/1763371531", "00000006"), // tooFewElements
-            ("0.7.1/1763371531", "00000008"), // tooFewElements
-            ("0.7.1/1763371531", "00000011"), // tooFewElements
-            ("0.7.1/1763371531", "00000014"), // tooFewElements
-            ("0.7.1/1763371531", "00000023"), // tooFewElements
-            ("0.7.1/1763371531", "00000028"), // tooFewElements
-            ("0.7.1/1763371531", "00000030"), // tooFewElements
-            ("0.7.1/1763371531", "00000032"), // tooFewElements
-            ("0.7.1/1763371531", "00000038"), // tooFewElements
             ("0.7.1/1763371531", "00000042"), // missing "keyvals": [] in prestate (expected to fail)
-            ("0.7.1/1763372314", "00000094"), // tooFewElements
+            ("0.7.1/1763487981", "00000050"), // missing "keyvals": [] in prestate (expected to fail)
+            ("0.7.1/1763488328", "00000050"), // missing "keyvals": [] in prestate (expected to fail)
+            ("0.7.1/1763489287", "00000872"), // missing "keyvals": [] in prestate (expected to fail)
         ]
     ))
     func v071(input: Testcase) async throws {

Utils/Sources/Utils/ConfigLimitedSizeArray.swift

@@ -40,7 +40,7 @@ public struct ConfigLimitedSizeArray<T, TMinLength: ReadInt, TMaxLength: ReadInt
         try self.init(array, minLength: minLength, maxLength: maxLength)
     }
 
-    private init(_ array: [T], minLength: Int, maxLength: Int) throws(ConfigLimitedSizeArrayError) {
+    private init(_ array: [T], minLength: Int, maxLength: Int, validate: Bool = true) throws(ConfigLimitedSizeArrayError) {
         guard minLength >= 0 else {
             throw ConfigLimitedSizeArrayError.invalidMinLength
         }
@@ -52,15 +52,17 @@ public struct ConfigLimitedSizeArray<T, TMinLength: ReadInt, TMaxLength: ReadInt
         self.minLength = minLength
         self.maxLength = maxLength
 
-        try validateThrowing()
+        if validate {
+            try validateThrowing()
+        }
     }
 
     private func validate() {
         assert(array.count >= minLength, "count \(array.count) >= minLength \(minLength)")
         assert(array.count <= maxLength, "count \(array.count) <= maxLength \(maxLength)")
     }
 
-    private func validateThrowing() throws(ConfigLimitedSizeArrayError) {
+    public func validateThrowing() throws(ConfigLimitedSizeArrayError) {
         guard array.count >= minLength else {
             throw ConfigLimitedSizeArrayError.tooFewElements
         }
@@ -231,19 +233,19 @@ extension ConfigLimitedSizeArray: Decodable where T: Decodable {
             for _ in 0 ..< minLength {
                 try arr.append(container.decode(T.self))
             }
-            try self.init(arr, minLength: minLength, maxLength: maxLength)
+            try self.init(arr, minLength: minLength, maxLength: maxLength, validate: false)
         } else {
             // variable size array
             var container = try decoder.unkeyedContainer()
             if decoder.isJamCodec {
                 let array = try container.decode([T].self)
-                try self.init(array, minLength: minLength, maxLength: maxLength)
+                try self.init(array, minLength: minLength, maxLength: maxLength, validate: false)
             } else {
                 var array = [T]()
                 while !container.isAtEnd {
                     try array.append(container.decode(T.self))
                 }
-                try self.init(array, minLength: minLength, maxLength: maxLength)
+                try self.init(array, minLength: minLength, maxLength: maxLength, validate: false)
             }
         }
     }

Utils/Sources/Utils/ConfigSizeBitString.swift

@@ -17,12 +17,12 @@ public struct ConfigSizeBitString<TBitLength: ReadInt>: Equatable, Sendable, Cod
         (length + 7) / 8
     }
 
-    public init(config: TBitLength.TConfig, data: Data) throws(ConfigSizeBitStringError) {
+    public init(config: TBitLength.TConfig, data: Data, validate: Bool = true) throws(ConfigSizeBitStringError) {
         length = TBitLength.read(config: config)
         bytes = data
 
-        if byteLength != data.count {
-            throw .invalidData
+        if validate {
+            try validateThrowing()
         }
     }
 
@@ -32,6 +32,12 @@ public struct ConfigSizeBitString<TBitLength: ReadInt>: Equatable, Sendable, Cod
         bytes = Data(repeating: 0, count: byteLength)
     }
 
+    public func validateThrowing() throws(ConfigSizeBitStringError) {
+        if byteLength != bytes.count {
+            throw .invalidData
+        }
+    }
+
     private func at(unchecked index: Int) -> Bool {
         let byteIndex = index / 8
         let bitIndex = index % 8
@@ -129,7 +135,7 @@ extension ConfigSizeBitString: FixedLengthData {
         guard let config = decoder.getConfig(TBitLength.TConfig.self) else {
             throw ConfigSizeBitStringError.missingConfig
         }
-        try self.init(config: config, data: data)
+        try self.init(config: config, data: data, validate: false)
     }
 }
 
@@ -150,3 +156,7 @@ extension ConfigSizeBitString: DataPtrRepresentable {
         try data.withUnsafeBytes(cb)
     }
 }
+
+extension ConfigSizeBitString: HasConfig {
+    public typealias Config = TBitLength.TConfig
+}

Utils/Sources/Utils/LimitedSizeArray.swift

@@ -19,20 +19,22 @@ public struct LimitedSizeArray<T, TMinLength: ConstInt, TMaxLength: ConstInt> {
         self.init(Array(repeating: defaultValue, count: Self.minLength))
     }
 
-    public init(_ array: [T]) {
+    public init(_ array: [T], validate: Bool = true) {
         assert(Self.minLength >= 0)
         assert(Self.maxLength >= Self.minLength)
         self.array = array
 
-        validate()
+        if validate {
+            self.validate()
+        }
     }
 
     private func validate() {
         assert(array.count >= Self.minLength)
         assert(array.count <= Self.maxLength)
     }
 
-    private func validateThrowing() throws(LimitedSizeArrayError) {
+    public func validateThrowing() throws(LimitedSizeArrayError) {
         guard array.count >= Self.minLength else {
             throw LimitedSizeArrayError.tooFewElements
         }
@@ -149,7 +151,7 @@ extension LimitedSizeArray: Encodable where T: Encodable {
 
 extension LimitedSizeArray: Decodable where T: Decodable {
     public init(from decoder: any Decoder) throws {
-        array = []
+        var arr = [T]()
         var container = try decoder.unkeyedContainer()
         var length = TMaxLength.value
 
@@ -168,10 +170,10 @@ extension LimitedSizeArray: Decodable where T: Decodable {
         }
 
         for _ in 0 ..< length {
-            try array.append(container.decode(T.self))
+            try arr.append(container.decode(T.self))
         }
 
-        try validateThrowing()
+        self.init(arr, validate: false)
     }
 }