Add policy resolver

Author: janndriessen

Sources/Core/Transaction/CodableTransaction.swift

@@ -187,6 +187,7 @@ public struct CodableTransaction {
         return self.envelope.encode(for: type)
     }
 
+    @available(*, deprecated, message: "Please use PolicyResolver instead")
     public mutating func resolve(provider: Web3Provider) async {
         // FIXME: Delete force try
         self.gasLimit = try! await self.gasLimitPolicy.resolve(provider: provider, transaction: self)
@@ -299,6 +300,7 @@ extension CodableTransaction {
         case limited(BigUInt)
         case withMargin(Double)
 
+        @available(*, deprecated, message: "Please use PolicyResolver instead")
         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)
@@ -323,6 +325,7 @@ extension CodableTransaction {
         case manual(BigUInt)
         case withMargin(Double)
 
+        @available(*, deprecated, message: "Please use PolicyResolver instead")
         func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
             let oracle = Oracle(provider)
             switch self {
@@ -338,6 +341,7 @@ extension CodableTransaction {
         case automatic
         case manual(BigUInt)
 
+        @available(*, deprecated, message: "Please use PolicyResolver instead")
         public func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
             let oracle = Oracle(provider)
             switch self {
@@ -353,6 +357,7 @@ extension CodableTransaction {
         case automatic
         case manual(BigUInt)
 
+        @available(*, deprecated, message: "Please use PolicyResolver instead")
         public func resolve(provider: Web3Provider, transaction: CodableTransaction? = nil) async throws -> BigUInt {
             let oracle = Oracle(provider)
             switch self {
@@ -364,6 +369,7 @@ extension CodableTransaction {
         }
     }
 
+    @available(*, deprecated, message: "Please use PolicyResolver instead")
     func resolveNonce(provider: Web3Provider) async throws -> BigUInt {
         switch noncePolicy {
         case .pending, .latest, .earliest:

Sources/web3swift/Web3/Web3+Resolver.swift

@@ -0,0 +1,103 @@
+//
+//  Web3+Resolver.swift
+//  
+//
+//  Created by Jann Driessen on 01.11.22.
+//
+
+import Foundation
+import BigInt
+import Core
+
+public class PolicyResolver {
+    private let provider: Web3Provider
+
+    public init(provider: Web3Provider) {
+        self.provider = provider
+    }
+
+    public func resolveAll(for tx: inout CodableTransaction) async throws {
+        if tx.from != nil || tx.sender != nil {
+            // Nonce should be resolved first - as this might be needed for some
+            // tx's gas estimation
+            tx.nonce = try await resolveNonce(for: tx)
+        }
+
+        tx.gasLimit = try await resolveGasEstimate(for: tx)
+
+        if case .eip1559 = tx.type {
+            tx.maxFeePerGas = await resolveGasBaseFee(for: tx.maxFeePerGasPolicy)
+            tx.maxPriorityFeePerGas = await resolveGasPriorityFee(for: tx.maxPriorityFeePerGasPolicy)
+        } else {
+            tx.gasPrice = await resolveGasPrice(for: tx.gasPricePolicy)
+        }
+    }
+
+    public func resolveGasBaseFee(for policy: CodableTransaction.FeePerGasPolicy) async -> BigUInt {
+        let oracle = Oracle(provider)
+        switch policy {
+        case .automatic:
+            return await oracle.baseFeePercentiles().max() ?? 0
+        case .manual(let value):
+            return value
+        }
+    }
+
+    public func resolveGasEstimate(for transaction: CodableTransaction) async throws -> BigUInt {
+        switch transaction.gasLimitPolicy {
+        case .automatic, .withMargin:
+            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: CodableTransaction.GasPricePolicy) async -> BigUInt {
+        let oracle = Oracle(provider)
+        switch policy {
+        case .automatic, .withMargin:
+            return await oracle.gasPriceLegacyPercentiles().max() ?? 0
+        case .manual(let value):
+            return value
+        }
+    }
+
+    public func resolveGasPriorityFee(for policy: CodableTransaction.PriorityFeePerGasPolicy) async -> BigUInt {
+        let oracle = Oracle(provider)
+        switch policy {
+        case .automatic:
+            return await oracle.tipFeePercentiles().max() ?? 0
+        case .manual(let value):
+            return value
+        }
+    }
+
+    public func resolveNonce(for tx: CodableTransaction) async throws -> BigUInt {
+        switch tx.noncePolicy {
+        case .pending, .latest, .earliest:
+            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
+        case .exact(let value):
+            return value
+        }
+    }
+}
+
+// MARK: - Private
+
+extension PolicyResolver {
+    private func estimateGas(for transaction: CodableTransaction) async throws -> BigUInt {
+        let request: APIRequest = .estimateGas(transaction, transaction.callOnBlock ?? .latest)
+        let response: APIResponse<BigUInt> = try await APIRequest.sendRequest(with: provider, for: request)
+        return response.result
+    }
+}

Tests/web3swiftTests/remoteTests/PolicyResolverTests.swift

@@ -0,0 +1,55 @@
+//
+//  PolicyResolverTests.swift
+//  
+//
+//  Created by Jann Driessen on 01.11.22.
+//
+
+import XCTest
+import Core
+
+@testable import web3swift
+
+final class PolicyResolverTests: XCTestCase {
+
+    func testResolveAllForEIP1159Transaction() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        let resolver = PolicyResolver(provider: web3.provider)
+        var tx = CodableTransaction(
+            type: .eip1559,
+            to: EthereumAddress("0xb47292B7bBedA4447564B8336E4eD1f93735e7C7")!,
+            chainID: web3.provider.network!.chainID,
+            value: Utilities.parseToBigUInt("0.1", units: .eth)!,
+            gasLimit: 21_000
+        )
+        // Vitalik's address
+        tx.from = EthereumAddress("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B")!
+        try await resolver.resolveAll(for: &tx)
+        print(tx.gasLimit)
+        print(tx.nonce)
+        XCTAssertGreaterThan(tx.gasLimit, 0)
+        XCTAssertGreaterThan(tx.maxFeePerGas ?? 0, 0)
+        XCTAssertGreaterThan(tx.maxPriorityFeePerGas ?? 0, 0)
+        XCTAssertGreaterThan(tx.nonce, 0)
+    }
+
+    func testResolveAllForLegacyTransaction() async throws {
+        let web3 = await Web3.InfuraMainnetWeb3(accessToken: Constants.infuraToken)
+        let resolver = PolicyResolver(provider: web3.provider)
+        var tx = CodableTransaction(
+            type: .legacy,
+            to: EthereumAddress("0xb47292B7bBedA4447564B8336E4eD1f93735e7C7")!,
+            chainID: web3.provider.network!.chainID,
+            value: Utilities.parseToBigUInt("0.1", units: .eth)!,
+            gasLimit: 21_000
+        )
+        // Vitalik's address
+        tx.from = EthereumAddress("0xAb5801a7D398351b8bE11C439e05C5B3259aeC9B")!
+        try await resolver.resolveAll(for: &tx)
+        print(tx.gasLimit)
+        print(tx.nonce)
+        XCTAssertGreaterThan(tx.gasLimit, 0)
+        XCTAssertGreaterThan(tx.gasPrice ?? 0, 0)
+        XCTAssertGreaterThan(tx.nonce, 0)
+    }
+}