Rename EncodableTransaction to CodableTransaction

because it's conforms `Codable` rather `Encodable`.

Author: yaroslavyaroslav

Sources/Core/Contract/ContractProtocol.swift

@@ -56,13 +56,13 @@ import BigInt
 /// ```
 ///
 /// ⚠️ If you pass in only constructor or only parameters - it will have no effect on the final transaction object.
-/// Also, you have an option to set any extra bytes at the end of ``EncodableTransaction/data``  attribute.
+/// Also, you have an option to set any extra bytes at the end of ``CodableTransaction/data``  attribute.
 /// Alternatively you can encode constructor parameters outside of the deploy function and only set `extraData` to pass in these
 /// parameters:
 ///
 /// ```swift
 /// // `encodeParameters` call returns `Data?`. Check it for nullability before calling `deploy`
-/// // function to create `EncodableTransaction`.
+/// // function to create `CodableTransaction`.
 /// let encodedConstructorArguments = someConstructor.encodeParameters(arrayOfInputArguments)
 /// constructor.deploy(bytecode: smartContractBytecode, extraData: encodedConstructorArguments)
 /// ```
@@ -123,7 +123,7 @@ public protocol ContractProtocol {
     func deploy(bytecode: Data,
                 constructor: ABI.Element.Constructor?,
                 parameters: [AnyObject]?,
-                extraData: Data?) -> EncodableTransaction?
+                extraData: Data?) -> CodableTransaction?
 
     /// Creates function call transaction with data set as `method` encoded with given `parameters`.
     /// The `method` must be part of the ABI used to init this contract.
@@ -135,7 +135,7 @@ public protocol ContractProtocol {
     ///   - parameters: method input arguments;
     ///   - extraData: additional data to append at the end of `transaction.data` field;
     /// - Returns: transaction object if `method` was found and `parameters` were successfully encoded.
-    func method(_ method: String, parameters: [AnyObject], extraData: Data?) -> EncodableTransaction?
+    func method(_ method: String, parameters: [AnyObject], extraData: Data?) -> CodableTransaction?
 
     /// Decode output data of a function.
     /// - Parameters:
@@ -187,7 +187,7 @@ extension ContractProtocol {
     func deploy(_ bytecode: Data,
                 constructor: ABI.Element.Constructor? = nil,
                 parameters: [AnyObject]? = nil,
-                extraData: Data? = nil) -> EncodableTransaction? {
+                extraData: Data? = nil) -> CodableTransaction? {
         deploy(bytecode: bytecode,
                constructor: constructor,
                parameters: parameters,
@@ -200,7 +200,7 @@ extension ContractProtocol {
     /// See ``ContractProtocol/method(_:parameters:extraData:)`` for details.
     func method(_ method: String = "fallback",
                 parameters: [AnyObject]? = nil,
-                extraData: Data? = nil) -> EncodableTransaction? {
+                extraData: Data? = nil) -> CodableTransaction? {
         self.method(method, parameters: parameters ?? [], extraData: extraData)
     }
 
@@ -219,7 +219,7 @@ extension DefaultContractProtocol {
     public func deploy(bytecode: Data,
                        constructor: ABI.Element.Constructor?,
                        parameters: [AnyObject]?,
-                       extraData: Data?) -> EncodableTransaction? {
+                       extraData: Data?) -> CodableTransaction? {
         var fullData = bytecode
 
         if let constructor = constructor,
@@ -239,11 +239,11 @@ extension DefaultContractProtocol {
         }
 
         // MARK: Writing Data flow
-        return EncodableTransaction(to: .contractDeploymentAddress(),
+        return CodableTransaction(to: .contractDeploymentAddress(),
                                    value: BigUInt(0),
                                    data: fullData
                                    // FIXME: Return parameters
-//                                   parameters: EncodableTransaction()
+//                                   parameters: CodableTransaction()
         )
     }
 
@@ -252,7 +252,7 @@ extension DefaultContractProtocol {
     ///   - method: Method to call
     ///   - parameters: Parameters to pass to method call
     ///   - extraData: Any additional data that needs to be encoded
-    /// - Returns: preset EncodableTransaction with filled date
+    /// - Returns: preset CodableTransaction with filled date
     ///
     /// Returned transaction have filled following priperties:
     ///   - to: contractAddress
@@ -262,16 +262,16 @@ extension DefaultContractProtocol {
     public func method(_ method: String,
                        parameters: [AnyObject],
                        // FIXME: Return type CodableTransaction
-                       extraData: Data?) -> EncodableTransaction? {
+                       extraData: Data?) -> CodableTransaction? {
         guard let to = self.address else { return nil }
 
         // FIXME: This should be changed up to release
-        var transaction = EncodableTransaction(to: to)
+        var transaction = CodableTransaction(to: to)
 
         // MARK: - Encoding ABI Data flow
         if method == "fallback" {
             // FIXME: Return parameters
-            return EncodableTransaction(to: to, value: BigUInt(0), data: extraData ?? Data()//, parameters: params
+            return CodableTransaction(to: to, value: BigUInt(0), data: extraData ?? Data()//, parameters: params
             )
         }
 

Sources/Core/EthereumNetwork/Request/APIRequest.swift

@@ -96,7 +96,7 @@ public enum APIRequest {
     /// - Parameters:
     ///     - TransactionParameters: parameters of planned transaction
     ///     - BlockNumber: block where it should be evalueated
-    case estimateGas(EncodableTransaction, BlockNumber)
+    case estimateGas(CodableTransaction, BlockNumber)
 
     /// Send raw transaction
     /// - Parameters:
@@ -106,7 +106,7 @@ public enum APIRequest {
     /// Send transaction object
     /// - Parameters:
     ///     - TransactionParameters: transaction to be sent into chain
-    case sendTransaction(EncodableTransaction)
+    case sendTransaction(CodableTransaction)
 
     /// Get transaction by hash
     /// - Parameters:
@@ -135,7 +135,7 @@ public enum APIRequest {
     /// - Parameters:
     ///     - TransactionParameters: transaction to be sent into chain
     ///     - BlockNumber: block where it should be evalueated
-    case call(EncodableTransaction, BlockNumber)
+    case call(CodableTransaction, BlockNumber)
 
     /// Get a transaction counts on a given block
     ///

Sources/Core/EthereumNetwork/RequestParameter/RequestParameter+Encodable.swift

@@ -46,7 +46,7 @@ extension RequestParameter: Encodable {
         case is Bool.Type: try enumContainer.encode(rawValue as! Bool)
         case is [Bool].Type: try enumContainer.encode(rawValue as! [Bool])
 
-        case is EncodableTransaction.Type: try enumContainer.encode(rawValue as! EncodableTransaction)
+        case is CodableTransaction.Type: try enumContainer.encode(rawValue as! CodableTransaction)
         case is EventFilterParameters.Type: try enumContainer.encode(rawValue as! EventFilterParameters)
         default: break /// can't be executed, coz possible `self.rawValue` types are strictly defined in it's inplementation.`
         }

Sources/Core/EthereumNetwork/RequestParameter/RequestParameter+RawRepresentable.swift

@@ -37,7 +37,7 @@ extension RequestParameter: RawRepresentable {
         case is Bool.Type: self = .bool(rawValue as! Bool)
         case is [Bool].Type: self = .boolArray(rawValue as! [Bool])
 
-        case is [EncodableTransaction].Type: self = .transaction(rawValue as! EncodableTransaction)
+        case is [CodableTransaction].Type: self = .transaction(rawValue as! CodableTransaction)
         case is [EventFilterParameters].Type: self = .eventFilter(rawValue as! EventFilterParameters)
         default: return nil
         }

Sources/Core/EthereumNetwork/RequestParameter/RequestParameter.swift

@@ -50,6 +50,6 @@ enum RequestParameter {
     case bool(Bool)
     case boolArray([Bool])
 
-    case transaction(EncodableTransaction)
+    case transaction(CodableTransaction)
     case eventFilter(EventFilterParameters)
 }

Sources/Core/Structure/Event+Protocol.swift

@@ -35,11 +35,11 @@ public struct EventParserResult: EventParserResultProtocol {
 
 /// Protocol for generic Ethereum event parser
 public protocol EventParserProtocol {
-    func parseTransaction(_ transaction: EncodableTransaction) async throws -> [EventParserResultProtocol]
+    func parseTransaction(_ transaction: CodableTransaction) async throws -> [EventParserResultProtocol]
     func parseTransactionByHash(_ hash: Data) async throws -> [EventParserResultProtocol]
     func parseBlock(_ block: Block) async throws -> [EventParserResultProtocol]
     func parseBlockByNumber(_ blockNumber: BigUInt) async throws -> [EventParserResultProtocol]
-    func parseTransactionPromise(_ transaction: EncodableTransaction) async throws -> [EventParserResultProtocol]
+    func parseTransactionPromise(_ transaction: CodableTransaction) async throws -> [EventParserResultProtocol]
     func parseTransactionByHashPromise(_ hash: Data) async throws -> [EventParserResultProtocol]
     func parseBlockByNumberPromise(_ blockNumber: BigUInt) async throws -> [EventParserResultProtocol]
     func parseBlockPromise(_ block: Block) async throws -> [EventParserResultProtocol]

Sources/Core/Structure/Transaction/TransactionDetails.swift

@@ -12,7 +12,7 @@ public struct TransactionDetails: Decodable {
     public var blockHash: Data?
     public var blockNumber: BigUInt?
     public var transactionIndex: BigUInt?
-    public var transaction: EncodableTransaction
+    public var transaction: CodableTransaction
 
     enum CodingKeys: String, CodingKey {
         case blockHash
@@ -25,6 +25,6 @@ public struct TransactionDetails: Decodable {
         self.blockNumber = try? container.decodeHex(BigUInt.self, forKey: .blockNumber)
         self.blockHash = try?  container.decodeHex(Data.self, forKey: .blockHash)
         self.transactionIndex = try? container.decodeHex(BigUInt.self, forKey: .transactionIndex)
-        self.transaction = try EncodableTransaction(from: decoder)
+        self.transaction = try CodableTransaction(from: decoder)
     }
 }

Sources/Core/Structure/Transaction/TransactionInBlock.swift

@@ -9,15 +9,15 @@ import Foundation
 
 public enum TransactionInBlock: Decodable {
     case hash(Data)
-    case transaction(EncodableTransaction)
+    case transaction(CodableTransaction)
     case null
 
     public init(from decoder: Decoder) throws {
         let value = try decoder.singleValueContainer()
         if let string = try? value.decode(String.self) {
             guard let d = Data.fromHex(string) else {throw Web3Error.dataError}
             self = .hash(d)
-        } else if let transaction = try? value.decode(EncodableTransaction.self) {
+        } else if let transaction = try? value.decode(CodableTransaction.self) {
             self = .transaction(transaction)
         } else {
             self = .null

Sources/Core/Transaction/EncodableTransaction.swift renamed to Sources/Core/Transaction/CodableTransaction.swift

@@ -10,7 +10,7 @@ import BigInt
 ///  Structure capable of carying the parameters for any transaction type.
 ///  while all fields in this struct are optional, they are not necessarily
 ///  optional for the type of transaction they apply to.
-public struct EncodableTransaction {
+public struct CodableTransaction {
     /// internal acccess only. The transaction envelope object itself that contains all the transaction data
     /// and type specific implementation
     internal var envelope: AbstractEnvelope
@@ -170,7 +170,7 @@ public struct EncodableTransaction {
 //        self.envelope = newEnvelope
     }
 
-    /// Create a new EncodableTransaction from a raw stream of bytes from the blockchain
+    /// Create a new CodableTransaction from a raw stream of bytes from the blockchain
     public init?(rawValue: Data) {
         guard let env = EnvelopeFactory.createEnvelope(rawValue: rawValue) else { return nil }
         self.envelope = env
@@ -197,10 +197,10 @@ public struct EncodableTransaction {
         self.accessList = options.accessList
     }
 
-    public static var emptyTransaction = EncodableTransaction(to: EthereumAddress("0xa64f2fD4F60cEBE072997010cB0cb22695FDdCc5")!)
+    public static var emptyTransaction = CodableTransaction(to: EthereumAddress("0xa64f2fD4F60cEBE072997010cB0cb22695FDdCc5")!)
 }
 
-extension EncodableTransaction: Codable {
+extension CodableTransaction: Codable {
     enum CodingKeys: String, CodingKey {
         case type
         case from
@@ -273,7 +273,7 @@ extension EncodableTransaction: Codable {
 
 }
 
-extension EncodableTransaction: CustomStringConvertible {
+extension CodableTransaction: CustomStringConvertible {
     /// required by CustomString convertable
     /// returns a string description for the transaction and its data
     public var description: String {
@@ -286,9 +286,9 @@ extension EncodableTransaction: CustomStringConvertible {
     }
 }
 
-extension EncodableTransaction {
+extension CodableTransaction {
     // the kitchen sink init: can produce a transaction of any type
-    /// Universal initializer to create a new EncodableTransaction object
+    /// Universal initializer to create a new CodableTransaction object
     /// - Parameters:
     ///   - type: TransactionType enum for selecting the type of transaction to create (default is .legacy)
     ///   - to: EthereumAddress of the destination for this transaction (required)
@@ -314,4 +314,4 @@ extension EncodableTransaction {
     }
 }
 
-extension EncodableTransaction: APIRequestParameterType { }
+extension CodableTransaction: APIRequestParameterType { }

Sources/Core/Transaction/Envelope/AbstractEnvelope.swift

@@ -18,7 +18,7 @@ import BigInt
     Adding a new transaction type in the future should be as straight forward as adding to the TransactionType enum here
     then creating a new struct that implements to `EIP2718Envelope`, and implementing the required elements for the type
     Finally adding the type specific inits to the factory routines in `EnvelopeFactory` so that objectts of the new type 
-    will get generated when `EncodableTransaction` is being created with data for the new type
+    will get generated when `CodableTransaction` is being created with data for the new type
 */
 
 /// Enumeration for supported transaction types
@@ -60,7 +60,7 @@ public enum EncodeType {
 }
 
 /// Protocol definition for all transaction envelope types
-/// All envelopes must conform to this protocol to work with `EncodableTransaction`
+/// All envelopes must conform to this protocol to work with `CodableTransaction`
 /// each implememtation holds all the type specific data
 /// and implments the type specific encoding/decoding
 public protocol AbstractEnvelope: CustomStringConvertible { // possibly add Codable?
@@ -105,16 +105,16 @@ public protocol AbstractEnvelope: CustomStringConvertible { // possibly add Coda
 
     // required initializers
     // for Decodable support
-    /// initializer for creating an `EncodableTransaction` with the Decodable protocol
-    /// will return an new `EncodableTransaction` object on success
+    /// initializer for creating an `CodableTransaction` with the Decodable protocol
+    /// will return an new `CodableTransaction` object on success
     /// thows a `Web3.dataError` if an error occurs while trying to decode a value
     /// returns nil if a required field is not found in the decoder stream
     init?(from decoder: Decoder) throws // Decodable Protocol
 
     // initializes from a raw stream of bytes
     // can fail if input stream is not of the right size/cannot be decoded
-    /// initializer for creating an `EncodableTransaction` with raw bytestream data
-    /// will return an new `EncodableTransaction` object on success
+    /// initializer for creating an `CodableTransaction` with raw bytestream data
+    /// will return an new `CodableTransaction` object on success
     /// returns nil if a required field is not found in the decoder stream, or can't be decoded
     init?(rawValue: Data) // Decode from Ethereum Data