Merge pull request #645 from janndriessen/feat/add-policy-resolver

Author: yaroslavyaroslav

Sources/Core/Structure/Block/BlockNumber.swift

@@ -39,18 +39,3 @@ extension BlockNumber: APIRequestParameterType {
         try container.encode(description)
     }
 }
-
-extension BlockNumber: Policyable {
-    public func resolve(provider: Web3Provider, transaction: CodableTransaction?) async throws -> BigUInt {
-        guard let transaction = transaction else { throw Web3Error.valueError }
-        switch self {
-        case .pending, .latest, .earliest:
-            guard let address = transaction.from ?? transaction.sender else { throw Web3Error.valueError }
-            let request: APIRequest = .getTransactionCount(address.address, transaction.callOnBlock ?? .latest)
-            let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)
-            return response.result
-        case .exact(let value):
-            return value
-        }
-    }
-}

Sources/Core/Structure/Web3ProviderProtocol.swift

@@ -10,6 +10,7 @@ import Foundation
 public protocol Web3Provider {
     var network: Networks? {get set}
     var attachedKeystoreManager: KeystoreManager? {get set}
+    var policies: Policies {get set}
     var url: URL {get}
     var session: URLSession {get}
 }

Sources/Core/Transaction/CodableTransaction.swift

@@ -7,11 +7,10 @@
 import Foundation
 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.
+/// Structure capable of carying the parameters for any transaction type.
+/// While most fields in this struct are optional, they are not necessarily
+/// optional for the type of transaction they apply to.
 public struct CodableTransaction {
-    public typealias NoncePolicy = BlockNumber
     /// internal acccess only. The transaction envelope object itself that contains all the transaction data
     /// and type specific implementation
     internal var envelope: AbstractEnvelope
@@ -62,32 +61,32 @@ public struct CodableTransaction {
     // MARK: - Properties transaction type related either sends to a node if exist
 
     /// the nonce for the transaction
-    internal var nonce: BigUInt {
+    public var nonce: BigUInt {
         get { return envelope.nonce }
         set { envelope.nonce = newValue }
     }
 
     /// the max number of gas units allowed to process this transaction
-    internal var gasLimit: BigUInt {
+    public var gasLimit: BigUInt {
         get { return envelope.gasLimit }
         set { return envelope.gasLimit = newValue }
     }
 
     /// the price per gas unit for the tranaction (Legacy and EIP-2930 only)
-    internal var gasPrice: BigUInt? {
+    public var gasPrice: BigUInt? {
         get { return envelope.gasPrice }
         set { return envelope.gasPrice = newValue }
     }
 
     /// the max base fee per gas unit (EIP-1559 only)
     /// this value must be >= baseFee + maxPriorityFeePerGas
-    internal var maxFeePerGas: BigUInt? {
+    public var maxFeePerGas: BigUInt? {
         get { return envelope.maxFeePerGas }
         set { return envelope.maxFeePerGas = newValue }
     }
 
     /// the maximum tip to pay the miner (EIP-1559 only)
-    internal var maxPriorityFeePerGas: BigUInt? {
+    public var maxPriorityFeePerGas: BigUInt? {
         get { return envelope.maxPriorityFeePerGas }
         set { return envelope.maxPriorityFeePerGas = newValue }
     }
@@ -175,39 +174,13 @@ public struct CodableTransaction {
         self.envelope = env
         // FIXME: This is duplication and should be fixed.
         data = Data()
-        noncePolicy = .latest
-        gasLimitPolicy = .automatic
-        gasPricePolicy = .automatic
-        maxFeePerGasPolicy = .automatic
-        maxPriorityFeePerGasPolicy = .automatic
     }
 
     /// - Returns: a raw bytestream of the transaction, encoded according to the transactionType
     public func encode(for type: EncodeType = .transaction) -> Data? {
         return self.envelope.encode(for: type)
     }
 
-    public mutating func resolve(provider: Web3Provider) async {
-        // FIXME: Delete force try
-        self.gasLimit = try! await self.gasLimitPolicy.resolve(provider: provider, transaction: self)
-
-        if from != nil || sender != nil {
-            self.nonce = try! await self.resolveNonce(provider: provider)
-        }
-        if case .eip1559 = type {
-            self.maxFeePerGas = try! await self.maxFeePerGasPolicy.resolve(provider: provider)
-            self.maxPriorityFeePerGas = try! await self.maxPriorityFeePerGasPolicy.resolve(provider: provider)
-        } else {
-            self.gasPrice = try! await self.gasPricePolicy.resolve(provider: provider)
-        }
-    }
-
-    public var noncePolicy: NoncePolicy
-    public var maxFeePerGasPolicy: FeePerGasPolicy
-    public var maxPriorityFeePerGasPolicy: PriorityFeePerGasPolicy
-    public var gasPricePolicy: GasPricePolicy
-    public var gasLimitPolicy: GasLimitPolicy
-
     public static var emptyTransaction = CodableTransaction(to: EthereumAddress.contractDeploymentAddress())
 }
 
@@ -235,12 +208,6 @@ extension CodableTransaction: Codable {
         // FIXME: This is duplication and should be fixed.
         data = Data()
 
-        noncePolicy = .latest
-        gasLimitPolicy = .automatic
-        gasPricePolicy = .automatic
-        maxFeePerGasPolicy = .automatic
-        maxPriorityFeePerGasPolicy = .automatic
-
         // capture any metadata that might be present
         self.meta = try TransactionMetadata(from: decoder)
     }
@@ -292,96 +259,6 @@ extension CodableTransaction: Codable {
 
 }
 
-public protocol Policyable {
-    func resolve(provider: Web3Provider, transaction: CodableTransaction?) async throws -> BigUInt
-}
-
-extension CodableTransaction {
-    public enum GasLimitPolicy {
-        case automatic
-        case manual(BigUInt)
-        case limited(BigUInt)
-        case withMargin(Double)
-
-        func resolve(provider: Web3Provider, transaction: CodableTransaction?) async throws -> BigUInt {
-            guard let transaction = transaction else { throw Web3Error.valueError }
-            let request: APIRequest = .estimateGas(transaction, transaction.callOnBlock ?? .latest)
-            let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)
-            switch self {
-            case .automatic, .withMargin:
-                return response.result
-            case .manual(let value):
-                return value
-            case .limited(let limit):
-                if limit <= response.result {
-                    return response.result
-                } else {
-                    return limit
-                }
-            }
-        }
-    }
-
-    public enum GasPricePolicy {
-        case automatic
-        case manual(BigUInt)
-        case withMargin(Double)
-
-        func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
-            let oracle = Oracle(provider)
-            switch self {
-            case .automatic, .withMargin:
-                return await oracle.gasPriceLegacyPercentiles().max() ?? 0
-            case .manual(let value):
-                return value
-            }
-        }
-    }
-
-    public enum PriorityFeePerGasPolicy: Policyable {
-        case automatic
-        case manual(BigUInt)
-
-        public func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
-            let oracle = Oracle(provider)
-            switch self {
-            case .automatic:
-                return await oracle.tipFeePercentiles().max() ?? 0
-            case .manual(let value):
-                return value
-            }
-        }
-    }
-
-    public enum FeePerGasPolicy: Policyable {
-        case automatic
-        case manual(BigUInt)
-
-        public func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
-            let oracle = Oracle(provider)
-            switch self {
-            case .automatic:
-                return await oracle.baseFeePercentiles().max() ?? 0
-            case .manual(let value):
-                return value
-            }
-        }
-    }
-
-    func resolveNonce(provider: Web3Provider) async throws -> BigUInt {
-        switch noncePolicy {
-        case .pending, .latest, .earliest:
-            guard let address = from ?? sender else { throw Web3Error.valueError }
-            let request: APIRequest = .getTransactionCount(address.address, callOnBlock ?? .latest)
-            let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)
-            return response.result
-        case .exact(let value):
-            return value
-        }
-    }
-
-}
-
 extension CodableTransaction: CustomStringConvertible {
     /// required by CustomString convertable
     /// returns a string description for the transaction and its data
@@ -416,11 +293,6 @@ extension CodableTransaction {
         // FIXME: This is duplication and should be fixed.
         self.data = data
         self.accessList = accessList
-        self.gasLimitPolicy = .automatic
-        self.noncePolicy = .pending
-        self.gasPricePolicy = .automatic
-        self.maxFeePerGasPolicy = .automatic
-        self.maxPriorityFeePerGasPolicy = .automatic
         self.callOnBlock = .latest
 
         self.envelope = EnvelopeFactory.createEnvelope(type: type, to: to, nonce: nonce, chainID: chainID, value: value, data: data, gasLimit: gasLimit, maxFeePerGas: maxFeePerGas, maxPriorityFeePerGas: maxPriorityFeePerGas, gasPrice: gasPrice, accessList: accessList, v: v, r: r, s: s)

Sources/Core/Transaction/Policies.swift

@@ -0,0 +1,65 @@
+//
+//  Policies.swift
+//  
+//
+//  Created by Jann Driessen on 01.11.22.
+//
+
+import Foundation
+import BigInt
+
+public typealias NoncePolicy = BlockNumber
+
+public enum GasLimitPolicy {
+    case automatic
+    case manual(BigUInt)
+    case limited(BigUInt)
+    case withMargin(Double)
+}
+
+public enum GasPricePolicy {
+    case automatic
+    case manual(BigUInt)
+    case withMargin(Double)
+}
+
+public enum FeePerGasPolicy {
+    case automatic
+    case manual(BigUInt)
+}
+
+public enum PriorityFeePerGasPolicy {
+    case automatic
+    case manual(BigUInt)
+}
+
+public struct Policies {
+    public let noncePolicy: NoncePolicy
+    public let gasLimitPolicy: GasLimitPolicy
+    public let gasPricePolicy: GasPricePolicy
+    public let maxFeePerGasPolicy: FeePerGasPolicy
+    public let maxPriorityFeePerGasPolicy: PriorityFeePerGasPolicy
+
+    public init(
+        noncePolicy: NoncePolicy = .latest,
+        gasLimitPolicy: GasLimitPolicy = .automatic,
+        gasPricePolicy: GasPricePolicy = .automatic,
+        maxFeePerGasPolicy: FeePerGasPolicy = .automatic,
+        maxPriorityFeePerGasPolicy: PriorityFeePerGasPolicy = .automatic) {
+            self.noncePolicy = noncePolicy
+            self.gasLimitPolicy = gasLimitPolicy
+            self.gasPricePolicy = gasPricePolicy
+            self.maxFeePerGasPolicy = maxFeePerGasPolicy
+            self.maxPriorityFeePerGasPolicy = maxPriorityFeePerGasPolicy
+        }
+
+    public static var auto: Policies {
+        return Policies(
+            noncePolicy: .latest,
+            gasLimitPolicy: .automatic,
+            gasPricePolicy: .automatic,
+            maxFeePerGasPolicy: .automatic,
+            maxPriorityFeePerGasPolicy: .automatic
+        )
+    }
+}

Sources/web3swift/Operations/ReadTransaction.swift

@@ -16,6 +16,7 @@ public class ReadOperation {
     public var method: String
     public var data: Data? { transaction.data }
 
+    var resolver: PolicyResolver
     var web3: Web3
 
     // FIXME: Rewrite this to CodableTransaction
@@ -30,11 +31,12 @@ public class ReadOperation {
         if let network = self.web3.provider.network {
             self.transaction.chainID = network.chainID
         }
+        self.resolver = PolicyResolver(provider: web3.provider)
     }
 
     // TODO: Remove type erasing here, some broad wide protocol should be added instead
     public func callContractMethod() async throws -> [String: Any] {
-        await transaction.resolve(provider: web3.provider)
+        try await resolver.resolveAll(for: &transaction)
         // MARK: Read data from ABI flow
         // FIXME: This should be dropped, and after `execute()` call, just to decode raw data.
         let data: Data = try await self.web3.eth.callTransaction(transaction)

Sources/web3swift/Operations/WriteOperation.swift

@@ -11,8 +11,12 @@ import Core
 public class WriteOperation: ReadOperation {
 
     // FIXME: Rewrite this to CodableTransaction
-    public func writeToChain(password: String) async throws -> TransactionSendingResult {
-        await transaction.resolve(provider: web3.provider)
+    /// Sends (raw) transaction for write operation.
+    /// - Parameters:
+    ///   - password: Password for private key.
+    ///   - policies: Custom policies for how to resolve (optional). Default is auto.
+    public func writeToChain(password: String, policies: Policies = .auto) async throws -> TransactionSendingResult {
+        try await resolver.resolveAll(for: &transaction, with: policies)
         if let attachedKeystoreManager = self.web3.provider.attachedKeystoreManager {
             do {
                 try Web3Signer.signTX(transaction: &transaction,
@@ -28,18 +32,4 @@ public class WriteOperation: ReadOperation {
         // MARK: Sending Data flow
         return try await web3.eth.send(transaction)
     }
-
-    // FIXME: Rewrite this to CodableTransaction
-    func nonce(for policy: CodableTransaction.NoncePolicy, from: EthereumAddress) async throws -> BigUInt {
-        switch policy {
-        case .latest:
-            return try await self.web3.eth.getTransactionCount(for: from, onBlock: .latest)
-        case .pending:
-            return try await self.web3.eth.getTransactionCount(for: from, onBlock: .pending)
-        case .earliest:
-            return try await self.web3.eth.getTransactionCount(for: from, onBlock: .earliest)
-        case .exact(let nonce):
-            return nonce
-        }
-    }
 }

Sources/web3swift/Tokens/ERC1155/Web3+ERC1155.swift

@@ -136,7 +136,6 @@ public class ERC1155: IERC1155 {
     public func supportsInterface(interfaceID: String) async throws -> Bool {
         let contract = self.contract
         self.transaction.callOnBlock = .latest
-        self.transaction.gasLimitPolicy = .manual(30000)
         let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod()
         guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res

Sources/web3swift/Tokens/ERC1400/Web3+ERC1400.swift

@@ -686,7 +686,6 @@ extension ERC1400: IERC777 {
     public func supportsInterface(interfaceID: String) async throws -> Bool {
         let contract = self.contract
         self.transaction.callOnBlock = .latest
-        self.transaction.gasLimitPolicy = .manual(30000)
         let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod()
         guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res

Sources/web3swift/Tokens/ERC1410/Web3+ERC1410.swift

@@ -452,7 +452,6 @@ extension ERC1410: IERC777 {
     public func supportsInterface(interfaceID: String) async throws -> Bool {
         let contract = self.contract
         self.transaction.callOnBlock = .latest
-        self.transaction.gasLimitPolicy = .manual(30000)
         let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod()
         guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res

Sources/web3swift/Tokens/ERC1633/Web3+ERC1633.swift

@@ -180,7 +180,6 @@ public class ERC1633: IERC1633, ERC20BaseProperties {
     public func supportsInterface(interfaceID: String) async throws -> Bool {
         let contract = self.contract
         self.transaction.callOnBlock = .latest
-        self.transaction.gasLimitPolicy = .manual(30000)
         let result = try await contract.createReadOperation("supportsInterface", parameters: [interfaceID] as [AnyObject], extraData: Data() )!.callContractMethod()
         guard let res = result["0"] as? Bool else {throw Web3Error.processingError(desc: "Failed to get result of expected type from the Ethereum node")}
         return res