Merge pull request #658 from yaroslavyaroslav/resolver-enhance

Author: yaroslavyaroslav

Sources/Core/Oracle/GasOracle.swift

@@ -136,8 +136,7 @@ final public class Oracle {
             let block: BigUInt = try await combineRequest(request: .blockNumber)
             latestBlockNumber = block
         case let .exact(number): latestBlockNumber = number
-            // Error throws since pending and erliest are unable to be used in this method.
-        default: throw Web3Error.valueError
+        default: throw Web3Error.valueError(desc: "Unable to use '\(block)' policy to resolve block number to calculate gas fee suggestion.")
         }
 
         /// checking if latest block number is greather than number of blocks to take in account

Sources/Core/Transaction/Policies.swift

@@ -10,56 +10,37 @@ 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 {
+/// Policies for resolving values like:
+/// - gas required for transaction execution
+/// - gas price
+/// - maximum fee per gas (see [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559))
+/// - maximum priority fee per gas (see [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559))
+public enum ValueResolutionPolicy {
+    /// What ever value will be resolved is the one to be applied
     case automatic
+    /// Specific value to be applied
     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 let gasLimitPolicy: ValueResolutionPolicy
+    public let gasPricePolicy: ValueResolutionPolicy
+    public let maxFeePerGasPolicy: ValueResolutionPolicy
+    public let maxPriorityFeePerGasPolicy: ValueResolutionPolicy
 
     public init(
         noncePolicy: NoncePolicy = .latest,
-        gasLimitPolicy: GasLimitPolicy = .automatic,
-        gasPricePolicy: GasPricePolicy = .automatic,
-        maxFeePerGasPolicy: FeePerGasPolicy = .automatic,
-        maxPriorityFeePerGasPolicy: PriorityFeePerGasPolicy = .automatic) {
+        gasLimitPolicy: ValueResolutionPolicy = .automatic,
+        gasPricePolicy: ValueResolutionPolicy = .automatic,
+        maxFeePerGasPolicy: ValueResolutionPolicy = .automatic,
+        maxPriorityFeePerGasPolicy: ValueResolutionPolicy = .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
-        )
-    }
+    public static let auto = Policies()
 }

Sources/Core/Web3Error/Web3Error.swift

@@ -13,7 +13,7 @@ public enum Web3Error: Error {
 
     case dataError
     case typeError
-    case valueError
+    case valueError(desc: String? = nil)
     case serverError(code: Int)
     case clientError(code: Int)
 

Sources/web3swift/Operations/ReadTransaction.swift renamed to Sources/web3swift/Operations/ReadOperation.swift

@@ -16,7 +16,7 @@ public class ReadOperation {
     public var method: String
     public var data: Data? { transaction.data }
 
-    var resolver: PolicyResolver
+    var policyResolver: PolicyResolver
     var web3: Web3
 
     // FIXME: Rewrite this to CodableTransaction
@@ -31,12 +31,11 @@ public class ReadOperation {
         if let network = self.web3.provider.network {
             self.transaction.chainID = network.chainID
         }
-        self.resolver = PolicyResolver(provider: web3.provider)
+        self.policyResolver = PolicyResolver(provider: web3.provider)
     }
 
     // TODO: Remove type erasing here, some broad wide protocol should be added instead
     public func callContractMethod() async throws -> [String: Any] {
-        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,12 +11,12 @@ import Core
 public class WriteOperation: ReadOperation {
 
     // FIXME: Rewrite this to CodableTransaction
-    /// Sends (raw) transaction for write operation.
+    /// 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)
+        try await policyResolver.resolveAll(for: &transaction, with: policies)
         if let attachedKeystoreManager = self.web3.provider.attachedKeystoreManager {
             do {
                 try Web3Signer.signTX(transaction: &transaction,

Sources/web3swift/Utils/Hooks/NonceMiddleware.swift

@@ -21,6 +21,8 @@ public class PolicyResolver {
             // Nonce should be resolved first - as this might be needed for some
             // tx's gas estimation
             tx.nonce = try await resolveNonce(for: tx, with: policies.noncePolicy)
+        } else {
+            throw Web3Error.valueError(desc: "Could not be resolved with both from and sender are nil")
         }
 
         tx.gasLimit = try await resolveGasEstimate(for: tx, with: policies.gasLimitPolicy)
@@ -33,47 +35,37 @@ public class PolicyResolver {
         }
     }
 
-    public func resolveGasBaseFee(for policy: FeePerGasPolicy) async -> BigUInt {
-        let oracle = Oracle(provider)
+    public func resolveGasBaseFee(for policy: ValueResolutionPolicy) async -> BigUInt {
         switch policy {
         case .automatic:
-            return await oracle.baseFeePercentiles().max() ?? 0
+            return await Oracle(provider).baseFeePercentiles().max() ?? 0
         case .manual(let value):
             return value
         }
     }
 
-    public func resolveGasEstimate(for transaction: CodableTransaction, with policy: GasLimitPolicy) async throws -> BigUInt {
+    public func resolveGasEstimate(for transaction: CodableTransaction, with policy: ValueResolutionPolicy) async throws -> BigUInt {
         switch policy {
-        case .automatic, .withMargin:
+        case .automatic:
             return try await estimateGas(for: transaction)
         case .manual(let value):
             return value
-        case .limited(let limit):
-            let result = try await estimateGas(for: transaction)
-            if limit <= result {
-                return result
-            } else {
-                return limit
-            }
         }
     }
 
-    public func resolveGasPrice(for policy: GasPricePolicy) async -> BigUInt {
-        let oracle = Oracle(provider)
+    public func resolveGasPrice(for policy: ValueResolutionPolicy) async -> BigUInt {
         switch policy {
-        case .automatic, .withMargin:
-            return await oracle.gasPriceLegacyPercentiles().max() ?? 0
+        case .automatic:
+            return await Oracle(provider).gasPriceLegacyPercentiles().max() ?? 0
         case .manual(let value):
             return value
         }
     }
 
-    public func resolveGasPriorityFee(for policy: PriorityFeePerGasPolicy) async -> BigUInt {
-        let oracle = Oracle(provider)
+    public func resolveGasPriorityFee(for policy: ValueResolutionPolicy) async -> BigUInt {
         switch policy {
         case .automatic:
-            return await oracle.tipFeePercentiles().max() ?? 0
+            return await Oracle(provider).tipFeePercentiles().max() ?? 0
         case .manual(let value):
             return value
         }
@@ -82,7 +74,7 @@ public class PolicyResolver {
     public func resolveNonce(for tx: CodableTransaction, with policy: NoncePolicy) async throws -> BigUInt {
         switch policy {
         case .pending, .latest, .earliest:
-            guard let address = tx.from ?? tx.sender else { throw Web3Error.valueError }
+            guard let address = tx.from ?? tx.sender else { throw Web3Error.valueError() }
             let request: APIRequest = .getTransactionCount(address.address, tx.callOnBlock ?? .latest)
             let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)
             return response.result