rename withConfig

open-web3-stack · Jul 2, 2024 · 3a7339e · 3a7339e
1 parent 2654e72
commit 3a7339e
Show file tree

Hide file tree

Showing 23 changed files with 97 additions and 97 deletions.
diff --git a/Blockchain/Sources/Blockchain/Types/AvailabilitySpecifications.swift b/Blockchain/Sources/Blockchain/Types/AvailabilitySpecifications.swift
@@ -29,7 +29,7 @@ public struct AvailabilitySpecifications: Sendable {
 
 extension AvailabilitySpecifications: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> AvailabilitySpecifications {
+    public static func dummy(config _: Config) -> AvailabilitySpecifications {
         AvailabilitySpecifications(
             workPackageHash: Data32(),
             length: 0,

diff --git a/Blockchain/Sources/Blockchain/Types/Block.swift b/Blockchain/Sources/Blockchain/Types/Block.swift
@@ -15,19 +15,19 @@ public typealias BlockRef = Ref<Block>
 
 extension Block: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> Block {
+    public static func dummy(config: Config) -> Block {
         Block(
-            header: Header.dummy(withConfig: config),
-            extrinsic: Extrinsic.dummy(withConfig: config)
+            header: Header.dummy(config: config),
+            extrinsic: Extrinsic.dummy(config: config)
         )
     }
 }
 
 extension Block: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            header: Header(withConfig: config, from: &decoder),
-            extrinsic: Extrinsic(withConfig: config, from: &decoder)
+            header: Header(config: config, from: &decoder),
+            extrinsic: Extrinsic(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/Extrinsic.swift b/Blockchain/Sources/Blockchain/Types/Extrinsic.swift
@@ -36,25 +36,25 @@ public struct Extrinsic: Sendable {
 
 extension Extrinsic: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> Extrinsic {
+    public static func dummy(config: Config) -> Extrinsic {
         Extrinsic(
-            tickets: ExtrinsicTickets.dummy(withConfig: config),
-            judgements: ExtrinsicJudgement.dummy(withConfig: config),
-            preimages: ExtrinsicPreimages.dummy(withConfig: config),
-            availability: ExtrinsicAvailability.dummy(withConfig: config),
-            reports: ExtrinsicGuarantees.dummy(withConfig: config)
+            tickets: ExtrinsicTickets.dummy(config: config),
+            judgements: ExtrinsicJudgement.dummy(config: config),
+            preimages: ExtrinsicPreimages.dummy(config: config),
+            availability: ExtrinsicAvailability.dummy(config: config),
+            reports: ExtrinsicGuarantees.dummy(config: config)
         )
     }
 }
 
 extension Extrinsic: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
             tickets: decoder.decode(),
-            judgements: ExtrinsicJudgement(withConfig: config, from: &decoder),
+            judgements: ExtrinsicJudgement(config: config, from: &decoder),
             preimages: decoder.decode(),
-            availability: ExtrinsicAvailability(withConfig: config, from: &decoder),
-            reports: ExtrinsicGuarantees(withConfig: config, from: &decoder)
+            availability: ExtrinsicAvailability(config: config, from: &decoder),
+            reports: ExtrinsicGuarantees(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/ExtrinsicAvailability.swift b/Blockchain/Sources/Blockchain/Types/ExtrinsicAvailability.swift
@@ -43,15 +43,15 @@ public struct ExtrinsicAvailability: Sendable {
 
 extension ExtrinsicAvailability: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> ExtrinsicAvailability {
-        ExtrinsicAvailability(assurances: ConfigLimitedSizeArray(withConfig: config))
+    public static func dummy(config: Config) -> ExtrinsicAvailability {
+        ExtrinsicAvailability(assurances: ConfigLimitedSizeArray(config: config))
     }
 }
 
 extension ExtrinsicAvailability: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            assurances: ConfigLimitedSizeArray(withConfig: config, from: &decoder)
+            assurances: ConfigLimitedSizeArray(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/ExtrinsicGuarantees.swift b/Blockchain/Sources/Blockchain/Types/ExtrinsicGuarantees.swift
@@ -43,22 +43,22 @@ public struct ExtrinsicGuarantees: Sendable {
         self.guarantees = guarantees
     }
 
-    public init(withConfig config: ProtocolConfigRef) {
-        guarantees = ConfigLimitedSizeArray(withConfig: config)
+    public init(config: ProtocolConfigRef) {
+        guarantees = ConfigLimitedSizeArray(config: config)
     }
 }
 
 extension ExtrinsicGuarantees: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> ExtrinsicGuarantees {
-        ExtrinsicGuarantees(withConfig: config)
+    public static func dummy(config: Config) -> ExtrinsicGuarantees {
+        ExtrinsicGuarantees(config: config)
     }
 }
 
 extension ExtrinsicGuarantees: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            guarantees: ConfigLimitedSizeArray(withConfig: config, from: &decoder) { try GuaranteeItem(withConfig: config, from: &$0) }
+            guarantees: ConfigLimitedSizeArray(config: config, from: &decoder) { try GuaranteeItem(config: config, from: &$0) }
         )
     }
 
@@ -68,10 +68,10 @@ extension ExtrinsicGuarantees: ScaleCodec.Encodable {
 }
 
 extension ExtrinsicGuarantees.GuaranteeItem: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
             coreIndex: decoder.decode(),
-            workReport: WorkReport(withConfig: config, from: &decoder),
+            workReport: WorkReport(config: config, from: &decoder),
             timeslot: decoder.decode(),
             credential: decoder.decode()
         )

diff --git a/Blockchain/Sources/Blockchain/Types/ExtrinsicJudgement.swift b/Blockchain/Sources/Blockchain/Types/ExtrinsicJudgement.swift
@@ -50,15 +50,15 @@ public struct ExtrinsicJudgement: Sendable {
 
 extension ExtrinsicJudgement: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> ExtrinsicJudgement {
+    public static func dummy(config _: Config) -> ExtrinsicJudgement {
         ExtrinsicJudgement(judgements: [])
     }
 }
 
 extension ExtrinsicJudgement: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            judgements: decoder.decode(.array { try JudgementItem(withConfig: config, from: &$0) })
+            judgements: decoder.decode(.array { try JudgementItem(config: config, from: &$0) })
         )
     }
 
@@ -68,10 +68,10 @@ extension ExtrinsicJudgement: ScaleCodec.Encodable {
 }
 
 extension ExtrinsicJudgement.JudgementItem: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
             reportHash: decoder.decode(),
-            signatures: ConfigFixedSizeArray(withConfig: config, from: &decoder)
+            signatures: ConfigFixedSizeArray(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/ExtrinsicPreimages.swift b/Blockchain/Sources/Blockchain/Types/ExtrinsicPreimages.swift
@@ -24,7 +24,7 @@ public struct ExtrinsicPreimages: Sendable {
 
 extension ExtrinsicPreimages: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> ExtrinsicPreimages {
+    public static func dummy(config _: Config) -> ExtrinsicPreimages {
         ExtrinsicPreimages(preimages: [])
     }
 }

diff --git a/Blockchain/Sources/Blockchain/Types/ExtrinsicTickets.swift b/Blockchain/Sources/Blockchain/Types/ExtrinsicTickets.swift
@@ -26,7 +26,7 @@ public struct ExtrinsicTickets: Sendable {
 
 extension ExtrinsicTickets: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> ExtrinsicTickets {
+    public static func dummy(config _: Config) -> ExtrinsicTickets {
         ExtrinsicTickets(tickets: [])
     }
 }

diff --git a/Blockchain/Sources/Blockchain/Types/Header.swift b/Blockchain/Sources/Blockchain/Types/Header.swift
@@ -91,7 +91,7 @@ public struct Header: Sendable {
 
 extension Header: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> Header {
+    public static func dummy(config _: Config) -> Header {
         Header(
             parentHash: Data32(),
             priorStateRoot: Data32(),
@@ -108,14 +108,14 @@ extension Header: Dummy {
 }
 
 extension Header: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
             parentHash: decoder.decode(),
             priorStateRoot: decoder.decode(),
             extrinsicsRoot: decoder.decode(),
             timeslotIndex: decoder.decode(),
-            epoch: EpochMarker(withConfig: config, from: &decoder),
-            winningTickets: ConfigFixedSizeArray(withConfig: config, from: &decoder),
+            epoch: EpochMarker(config: config, from: &decoder),
+            winningTickets: ConfigFixedSizeArray(config: config, from: &decoder),
             judgementsMarkers: decoder.decode(),
             authorKey: decoder.decode(),
             vrfSignature: decoder.decode(),
@@ -138,10 +138,10 @@ extension Header: ScaleCodec.Encodable {
 }
 
 extension Header.EpochMarker: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
             entropy: decoder.decode(),
-            validators: ConfigFixedSizeArray(withConfig: config, from: &decoder)
+            validators: ConfigFixedSizeArray(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/JudgementsState.swift b/Blockchain/Sources/Blockchain/Types/JudgementsState.swift
@@ -26,7 +26,7 @@ public struct JudgementsState: Sendable {
 
 extension JudgementsState: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> JudgementsState {
+    public static func dummy(config _: Config) -> JudgementsState {
         JudgementsState(
             allowSet: [],
             banSet: [],

diff --git a/Blockchain/Sources/Blockchain/Types/RefinementContext.swift b/Blockchain/Sources/Blockchain/Types/RefinementContext.swift
@@ -37,7 +37,7 @@ public struct RefinementContext: Sendable {
 
 extension RefinementContext: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> RefinementContext {
+    public static func dummy(config _: Config) -> RefinementContext {
         RefinementContext(
             anchor: (
                 headerHash: Data32(),

diff --git a/Blockchain/Sources/Blockchain/Types/SafroleState.swift b/Blockchain/Sources/Blockchain/Types/SafroleState.swift
@@ -59,27 +59,27 @@ public struct SafroleState: Sendable {
 
 extension SafroleState: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> SafroleState {
+    public static func dummy(config: Config) -> SafroleState {
         SafroleState(
-            nextValidators: ConfigFixedSizeArray(withConfig: config, defaultValue: ValidatorKey.dummy(withConfig: config)),
+            nextValidators: ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config)),
             ticketsVerifierKey: BandersnatchRingVRFRoot(),
-            ticketsOrKeys: .right(ConfigFixedSizeArray(withConfig: config, defaultValue: BandersnatchPublicKey())),
-            ticketsAccumulator: ConfigLimitedSizeArray(withConfig: config)
+            ticketsOrKeys: .right(ConfigFixedSizeArray(config: config, defaultValue: BandersnatchPublicKey())),
+            ticketsAccumulator: ConfigLimitedSizeArray(config: config)
         )
     }
 }
 
 extension SafroleState: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            nextValidators: ConfigFixedSizeArray(withConfig: config, from: &decoder),
+            nextValidators: ConfigFixedSizeArray(config: config, from: &decoder),
             ticketsVerifierKey: decoder.decode(),
             ticketsOrKeys: Either(
                 from: &decoder,
-                decodeLeft: { try ConfigFixedSizeArray(withConfig: config, from: &$0) },
-                decodeRight: { try ConfigFixedSizeArray(withConfig: config, from: &$0) }
+                decodeLeft: { try ConfigFixedSizeArray(config: config, from: &$0) },
+                decodeRight: { try ConfigFixedSizeArray(config: config, from: &$0) }
             ),
-            ticketsAccumulator: ConfigLimitedSizeArray(withConfig: config, from: &decoder)
+            ticketsAccumulator: ConfigLimitedSizeArray(config: config, from: &decoder)
         )
     }
 

diff --git a/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift b/Blockchain/Sources/Blockchain/Types/ServiceAccount.swift
@@ -57,7 +57,7 @@ public struct ServiceAccount: Sendable {
 
 extension ServiceAccount: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> ServiceAccount {
+    public static func dummy(config _: Config) -> ServiceAccount {
         ServiceAccount(
             storage: [:],
             preimages: [:],

diff --git a/Blockchain/Sources/Blockchain/Types/State.swift b/Blockchain/Sources/Blockchain/Types/State.swift
@@ -144,36 +144,36 @@ public typealias StateRef = Ref<State>
 
 extension State: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig config: Config) -> State {
+    public static func dummy(config: Config) -> State {
         State(
-            coreAuthorizationPool: ConfigFixedSizeArray(withConfig: config, defaultValue: ConfigLimitedSizeArray(withConfig: config)),
-            lastBlock: Block.dummy(withConfig: config),
-            safroleState: SafroleState.dummy(withConfig: config),
+            coreAuthorizationPool: ConfigFixedSizeArray(config: config, defaultValue: ConfigLimitedSizeArray(config: config)),
+            lastBlock: Block.dummy(config: config),
+            safroleState: SafroleState.dummy(config: config),
             serviceAccounts: [:],
             entropyPool: (Data32(), Data32(), Data32(), Data32()),
-            validatorQueue: ConfigFixedSizeArray(withConfig: config, defaultValue: ValidatorKey.dummy(withConfig: config)),
-            currentValidators: ConfigFixedSizeArray(withConfig: config, defaultValue: ValidatorKey.dummy(withConfig: config)),
-            previousValidators: ConfigFixedSizeArray(withConfig: config, defaultValue: ValidatorKey.dummy(withConfig: config)),
-            reports: ConfigFixedSizeArray(withConfig: config, defaultValue: nil),
+            validatorQueue: ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config)),
+            currentValidators: ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config)),
+            previousValidators: ConfigFixedSizeArray(config: config, defaultValue: ValidatorKey.dummy(config: config)),
+            reports: ConfigFixedSizeArray(config: config, defaultValue: nil),
             timestamp: 0,
             authorizationQueue: ConfigFixedSizeArray(
-                withConfig: config,
-                defaultValue: ConfigFixedSizeArray(withConfig: config, defaultValue: Data32())
+                config: config,
+                defaultValue: ConfigFixedSizeArray(config: config, defaultValue: Data32())
             ),
             privilegedServiceIndices: (
                 empower: ServiceIdentifier(),
                 assign: ServiceIdentifier(),
                 designate: ServiceIdentifier()
             ),
-            judgements: JudgementsState.dummy(withConfig: config)
+            judgements: JudgementsState.dummy(config: config)
         )
     }
 }
 
 extension State.ReportItem: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            workReport: WorkReport(withConfig: config, from: &decoder),
+            workReport: WorkReport(config: config, from: &decoder),
             guarantors: decoder.decode(),
             timestamp: decoder.decode()
         )
@@ -187,22 +187,22 @@ extension State.ReportItem: ScaleCodec.Encodable {
 }
 
 extension State: ScaleCodec.Encodable {
-    public init(withConfig config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
+    public init(config: ProtocolConfigRef, from decoder: inout some ScaleCodec.Decoder) throws {
         try self.init(
-            coreAuthorizationPool: ConfigFixedSizeArray(withConfig: config, from: &decoder) {
-                try ConfigLimitedSizeArray(withConfig: config, from: &$0) { try $0.decode() }
+            coreAuthorizationPool: ConfigFixedSizeArray(config: config, from: &decoder) {
+                try ConfigLimitedSizeArray(config: config, from: &$0) { try $0.decode() }
             },
-            lastBlock: Block(withConfig: config, from: &decoder),
-            safroleState: SafroleState(withConfig: config, from: &decoder),
+            lastBlock: Block(config: config, from: &decoder),
+            safroleState: SafroleState(config: config, from: &decoder),
             serviceAccounts: decoder.decode(),
             entropyPool: decoder.decode(),
-            validatorQueue: ConfigFixedSizeArray(withConfig: config, from: &decoder),
-            currentValidators: ConfigFixedSizeArray(withConfig: config, from: &decoder),
-            previousValidators: ConfigFixedSizeArray(withConfig: config, from: &decoder),
-            reports: ConfigFixedSizeArray(withConfig: config, from: &decoder) { try ReportItem(withConfig: config, from: &$0) },
+            validatorQueue: ConfigFixedSizeArray(config: config, from: &decoder),
+            currentValidators: ConfigFixedSizeArray(config: config, from: &decoder),
+            previousValidators: ConfigFixedSizeArray(config: config, from: &decoder),
+            reports: ConfigFixedSizeArray(config: config, from: &decoder) { try ReportItem(config: config, from: &$0) },
             timestamp: decoder.decode(),
-            authorizationQueue: ConfigFixedSizeArray(withConfig: config, from: &decoder) {
-                try ConfigFixedSizeArray(withConfig: config, from: &$0)
+            authorizationQueue: ConfigFixedSizeArray(config: config, from: &decoder) {
+                try ConfigFixedSizeArray(config: config, from: &$0)
             },
             privilegedServiceIndices: decoder.decode(),
             judgements: decoder.decode()

diff --git a/Blockchain/Sources/Blockchain/Types/Ticket.swift b/Blockchain/Sources/Blockchain/Types/Ticket.swift
@@ -8,7 +8,7 @@ public struct Ticket: Sendable {
 
 extension Ticket: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> Ticket {
+    public static func dummy(config _: Config) -> Ticket {
         Ticket(id: Data32(), attempt: 0)
     }
 }

diff --git a/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift b/Blockchain/Sources/Blockchain/Types/ValidatorKey.swift
@@ -22,7 +22,7 @@ public struct ValidatorKey: Sendable {
 
 extension ValidatorKey: Dummy {
     public typealias Config = ProtocolConfigRef
-    public static func dummy(withConfig _: Config) -> ValidatorKey {
+    public static func dummy(config _: Config) -> ValidatorKey {
         ValidatorKey(
             bandersnatch: BandersnatchPublicKey(),
             ed25519: Ed25519PublicKey(),