cleanup post merge

Author: pharms-eth

Sources/Core/KeystoreManager/BIP32Keystore.swift

@@ -63,7 +63,7 @@ public class BIP32Keystore: AbstractKeystore {
 
     private static let KeystoreParamsBIP32Version = 4
 
-    private (set) var addressStorage: PathAddressStorage
+    public private(set) var addressStorage: PathAddressStorage
 
     public convenience init?(_ jsonString: String) {
         let lowercaseJSON = jsonString.lowercased()

Sources/Core/Transaction/CodableTransaction.swift

@@ -188,27 +188,6 @@ public struct CodableTransaction {
         return self.envelope.encode(for: type)
     }
 
-    public mutating func resolve(provider: Web3Provider) async throws {
-        // 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())
 }
 
@@ -285,95 +264,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

Sources/web3swift/Operations/WriteOperation.swift

@@ -63,16 +63,16 @@ public class WriteOperation: ReadOperation {
     }
 
     // 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
-        }
-    }
+//    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
+//        }
+//    }
 }

Tests/web3swiftTests/remoteTests/ENSTests.swift

@@ -44,10 +44,10 @@ class ENSTests: XCTestCase {
         let ens = ENS(web3: web3)
         let domain = "somename.eth"
         let resolver = try await ens?.registry.getResolver(forDomain: domain)
-        let isAddrSupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.addr.hash())
-        let isNameSupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.name.hash())
-        let isABIsupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.ABI.hash())
-        let isPubkeySupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.pubkey.hash())
+        let isAddrSupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.addr.rawValue)
+        let isNameSupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.name.rawValue)
+        let isABIsupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.ABI.rawValue)
+        let isPubkeySupports = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.pubkey.rawValue)
         XCTAssertEqual(isAddrSupports, true)
         XCTAssertEqual(isNameSupports, true)
         XCTAssertEqual(isABIsupports, true)
@@ -59,7 +59,7 @@ class ENSTests: XCTestCase {
         let ens = ENS(web3: web3)
         let domain = "somename.eth"
         let resolver = try await ens?.registry.getResolver(forDomain: domain)
-        if let isABIsupported = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.ABI.hash()),
+        if let isABIsupported = try await resolver?.supportsInterface(interfaceID: ENS.Resolver.InterfaceName.ABI.rawValue),
             isABIsupported {
             let res = try await resolver?.getContractABI(forNode: domain, contentType: .zlibCompressedJSON)
             XCTAssert(res?.0 == 0)