Merge branch 'develop'

Example/Sources/MainViewModel.swift

@@ -149,17 +149,16 @@ class MainViewModel {
 
     private func setupSmartContractAccount(credentials: EthereumAccount) {
         do {
+            let connectionConfig = ConnectionConfig(apiKey: alchemyApiKey, jwt: nil, rpcUrl: nil)
             let provider = try AlchemyProvider(
                 entryPointAddress: chain.getDefaultEntryPointAddress(),
-                config: AlchemyProviderConfig(
+                config: ProviderConfig(
                     chain: chain,
-                    connectionConfig: ConnectionConfig(apiKey: alchemyApiKey,
-                                                       jwt: nil,
-                                                       rpcUrl: nil),
+                    connectionConfig: connectionConfig,
                     opts: SmartAccountProviderOpts(txMaxRetries: 50, txRetryIntervalMs: 500)
                 )
             ).withAlchemyGasManager(
-                config: AlchemyGasManagerConfig(policyId: alchemyGasPolicyId)
+                config: AlchemyGasManagerConfig(policyId: alchemyGasPolicyId, connectionConfig: connectionConfig)
             )
 
             let account = try LightSmartContractAccount(

Package.swift

@@ -20,6 +20,9 @@ let package = Package(
         .library(
             name: "Alchemy",
             targets: ["AASwiftAlchemy"]),
+        .library(
+            name: "Coinbase",
+            targets: ["AASwiftCoinbase"]),
     ],
     dependencies: [
         .package(url: "https://github.com/attaswift/BigInt.git", .upToNextMajor(from: "5.3.0")),
@@ -46,6 +49,16 @@ let package = Package(
             path: "Sources",
             sources: ["Alchemy"]
         ),
+        .target(
+            name: "AASwiftCoinbase",
+            dependencies: [
+                "AASwift",
+                .product(name: "BigInt", package: "BigInt"),
+                .product(name: "web3.swift", package: "web3.swift"),
+            ],
+            path: "Sources",
+            sources: ["Coinbase"]
+        ),
         .testTarget(
             name: "AASwiftTests",
             dependencies: ["AASwift", "MockSwift"]),

Sources/Alchemy/Account/Utils.swift

@@ -51,7 +51,7 @@ extension Chain {
              Chain.BaseGoerli.id,
              Chain.BaseSepolia.id: lightAccountVersions[version]!.factoryAddress
 
-        default: throw AlchemyError.noFactoryAddress("no default light account factory contract exists for \(name)")
+        default: throw ProviderError.noFactoryAddress("no default light account factory contract exists for \(name)")
         }
     }
 }

Sources/Alchemy/AlchemyError.swift

@@ -5,8 +5,3 @@
 //  and is released under the MIT License: https://opensource.org/licenses/MIT
 //
 
-public enum AlchemyError: Error {
-    case unsupportedChain(String)
-    case rpcUrlNotFound(String)
-    case noFactoryAddress(String)
-}

Sources/Alchemy/Chain.swift

@@ -44,7 +44,7 @@ extension Chain {
         case Chain.BaseGoerli:
             return "https://base-goerli.g.alchemy.com/v2"
         case Chain.BaseSepolia:
-            return "https://base-sepolia.g.alchemy.com/v2/"
+            return "https://base-sepolia.g.alchemy.com/v2"
         default:
             return nil
         }

Sources/Alchemy/Middleware/AlchemyClient.swift

@@ -10,6 +10,6 @@ import BigInt
 
 public protocol AlchemyClient: Erc4337Client {
     func maxPriorityFeePerGas() async throws -> BigUInt
-    func requestPaymasterAndData(params: PaymasterAndDataParams) async throws -> AlchemyPaymasterAndData
+    func requestPaymasterAndData(params: PaymasterAndDataParams) async throws -> PaymasterAndData
     func requestGasAndPaymasterAndData(params: PaymasterAndDataParams) async throws -> AlchemyGasAndPaymasterAndData
 }

Sources/Alchemy/Middleware/AlchemyGasAndPaymasterAndData.swift

@@ -5,7 +5,7 @@
 //  and is released under the MIT License: https://opensource.org/licenses/MIT
 //
 
-import Foundation
+import AASwift
 import web3
 import BigInt
 

Sources/Alchemy/Middleware/AlchemyRpcClient.swift

@@ -11,7 +11,7 @@ import BigInt
 import web3
 
 class AlchemyRpcClient: Erc4337RpcClient, AlchemyClient {
-    override func maxPriorityFeePerGas() async throws -> BigUInt {
+    public func maxPriorityFeePerGas() async throws -> BigUInt {
         do {
             let emptyParams: [Bool] = []
             let data = try await networkProvider.send(method: "rundler_maxPriorityFeePerGas", params: emptyParams, receive: String.self)
@@ -26,10 +26,10 @@ class AlchemyRpcClient: Erc4337RpcClient, AlchemyClient {
         }
     }
 
-    public func requestPaymasterAndData(params: PaymasterAndDataParams) async throws -> AlchemyPaymasterAndData {
+    public func requestPaymasterAndData(params: PaymasterAndDataParams) async throws -> PaymasterAndData {
         do {
-            let data = try await networkProvider.send(method: "alchemy_requestPaymasterAndData", params: [params], receive: AlchemyPaymasterAndData.self)
-            if let result = data as? AlchemyPaymasterAndData {
+            let data = try await networkProvider.send(method: "alchemy_requestPaymasterAndData", params: [params], receive: PaymasterAndData.self)
+            if let result = data as? PaymasterAndData {
                 return result
             } else {
                 throw EthereumClientError.unexpectedReturnValue

Sources/Alchemy/Middleware/CreateClient.swift

@@ -14,6 +14,14 @@ public func createAlchemyClient(
     url: String,
     chain: Chain,
     headers: [String: String] = [:]
-) -> AlchemyClient {
-    return AlchemyRpcClient(url: URL(string: url)!, network: EthereumNetwork.custom(String(describing: chain.id)), headers: headers)
+) throws -> AlchemyClient {
+    guard let validUrl = URL(string: url) else {
+        throw ProviderError.invalidUrl("Invalid URL format: \(url)")
+    }
+
+    return AlchemyRpcClient(
+        url: validUrl,
+        network: EthereumNetwork.custom(chain.id.description),
+        headers: headers
+    )
 }

Sources/Alchemy/Middleware/GasManager.swift

@@ -11,9 +11,11 @@ import AASwift
 
 public struct AlchemyGasManagerConfig {
     public let policyId: String
+    public let connectionConfig: ConnectionConfig
 
-    public init(policyId: String) {
+    public init(policyId: String, connectionConfig: ConnectionConfig) {
         self.policyId = policyId
+        self.connectionConfig = connectionConfig
     }
 }
 
@@ -33,7 +35,7 @@ public struct AlchemyGasEstimationOptions {
     }
 }
 
-extension AlchemyProvider {
+extension SmartAccountProvider {
     /// This middleware wraps the Alchemy Gas Manager APIs to provide more flexible UserOperation gas sponsorship.
     ///
     /// If `estimateGas` is true, it will use `alchemy_requestGasAndPaymasterAndData` to get all of the gas estimates + paymaster data
@@ -50,28 +52,11 @@ extension AlchemyProvider {
     public func withAlchemyGasManager(
         config: AlchemyGasManagerConfig, 
         gasEstimationOptions: AlchemyGasEstimationOptions? = nil
-    ) -> Self {
+    ) throws -> Self {
         let fallbackFeeDataGetter = gasEstimationOptions?.fallbackFeeDataGetter ?? alchemyFeeEstimator
         let fallbackGasEstimator = gasEstimationOptions?.fallbackGasEstimator ?? defaultGasEstimator
         let disableGasEstimation = gasEstimationOptions?.disableGasEstimation ?? false
 
-        let gasEstimator: ClientMiddlewareFn = if disableGasEstimation {
-            fallbackGasEstimator
-        } else {
-            { client, uoStruct, overrides in
-                uoStruct.callGasLimit = BigUInt(0)
-                uoStruct.preVerificationGas = BigUInt(0)
-                uoStruct.verificationGasLimit = BigUInt(0)
-
-                if overrides.paymasterAndData?.isEmpty == false {
-                    return try await fallbackGasEstimator(client, &uoStruct, overrides)
-                } else {
-                    return uoStruct
-                }
-            }
-        }
-        withGasEstimator(gasEstimator: gasEstimator)
-
         let feeDataGetter: ClientMiddlewareFn = if disableGasEstimation {
             fallbackFeeDataGetter
         } else {
@@ -94,11 +79,32 @@ extension AlchemyProvider {
         }
         withFeeDataGetter(feeDataGetter: feeDataGetter)
 
-        if disableGasEstimation {
-            return requestPaymasterAndData(provider: self, config: config) as! Self
+        let gasEstimator: ClientMiddlewareFn = if disableGasEstimation {
+            fallbackGasEstimator
         } else {
-            return requestGasAndPaymasterData(provider: self, config: config) as! Self
+            { client, uoStruct, overrides in
+                uoStruct.callGasLimit = BigUInt(0)
+                uoStruct.preVerificationGas = BigUInt(0)
+                uoStruct.verificationGasLimit = BigUInt(0)
+
+                if overrides.paymasterAndData?.isEmpty == false {
+                    return try await fallbackGasEstimator(client, &uoStruct, overrides)
+                } else {
+                    return uoStruct
+                }
+            }
         }
+        withGasEstimator(gasEstimator: gasEstimator)
+
+        let provider = if disableGasEstimation {
+            requestPaymasterAndData(provider: self, config: config) as! Self
+        } else {
+            requestGasAndPaymasterData(provider: self, config: config) as! Self
+        };
+
+        return provider.withMiddlewareRpcClient(
+            rpcClient: try AlchemyProvider.createRpcClient(config: ProviderConfig(chain: chain, connectionConfig: config.connectionConfig))
+        ) as! Self
     }
 }
 
@@ -109,20 +115,20 @@ extension AlchemyProvider {
 /// @param provider - the smart account provider to override to use the paymaster middleware
 /// @param config - the alchemy gas manager configuration
 /// @returns the provider augmented to use the paymaster middleware
-func requestPaymasterAndData(provider: AlchemyProvider, config: AlchemyGasManagerConfig) -> AlchemyProvider {
+func requestPaymasterAndData(provider: SmartAccountProvider, config: AlchemyGasManagerConfig) -> SmartAccountProvider {
     provider.withPaymasterMiddleware(
         dummyPaymasterDataMiddleware: { _, uoStruct, _ in
             uoStruct.paymasterAndData = dummyPaymasterAndData(chainId: provider.chain.id)
             return uoStruct
         },
-        paymasterDataMiddleware: { _, uoStruct, _ in
+        paymasterDataMiddleware: { client, uoStruct, _ in
             let entryPoint = try provider.getEntryPointAddress()
             let params = PaymasterAndDataParams(
                 policyId: config.policyId,
                 entryPoint: entryPoint.asString(),
                 userOperation: uoStruct.toUserOperationRequest()
             )
-            let alchemyClient = provider.rpcClient as! AlchemyClient
+            let alchemyClient = client as! AlchemyClient
             uoStruct.paymasterAndData = try await alchemyClient.requestPaymasterAndData(params: params).paymasterAndData
             return uoStruct
         }
@@ -137,23 +143,23 @@ func requestPaymasterAndData(provider: AlchemyProvider, config: AlchemyGasManage
 /// @param provider - the smart account provider to override to use the paymaster middleware
 /// @param config - the alchemy gas manager configuration
 /// @returns the provider augmented to use the paymaster middleware
-func requestGasAndPaymasterData(provider: AlchemyProvider, config: AlchemyGasManagerConfig) -> AlchemyProvider {
+func requestGasAndPaymasterData(provider: SmartAccountProvider, config: AlchemyGasManagerConfig) -> SmartAccountProvider {
     provider.withPaymasterMiddleware(
         dummyPaymasterDataMiddleware: { _, uoStruct, _ in
             uoStruct.paymasterAndData = dummyPaymasterAndData(chainId: provider.chain.id)
             return uoStruct
         },
-        paymasterDataMiddleware: { _, uoStruct, overrides in
+        paymasterDataMiddleware: { client, uoStruct, overrides in
             let userOperation = uoStruct.toUserOperationRequest()
             let feeOverride = FeeOverride(
-                maxFeePerGas: overrides.maxFeePerGas?.web3.hexString,
-                maxPriorityFeePerGas: overrides.maxPriorityFeePerGas?.web3.hexString,
-                callGasLimit: overrides.callGasLimit?.web3.hexString,
-                verificationGasLimit: overrides.verificationGasLimit?.web3.hexString,
-                preVerificationGas: overrides.preVerificationGas?.web3.hexString
+                maxFeePerGas: overrides.maxFeePerGas?.properHexString,
+                maxPriorityFeePerGas: overrides.maxPriorityFeePerGas?.properHexString,
+                callGasLimit: overrides.callGasLimit?.properHexString,
+                verificationGasLimit: overrides.verificationGasLimit?.properHexString,
+                preVerificationGas: overrides.preVerificationGas?.properHexString
             )
 
-            if let alchemyClient = provider.rpcClient as? AlchemyClient {
+            if let alchemyClient = client as? AlchemyClient {
                 let feeOverride: FeeOverride? = if feeOverride.isEmpty { nil } else { feeOverride }
                 let result = try await alchemyClient.requestGasAndPaymasterAndData(
                     params: PaymasterAndDataParams(

Sources/Alchemy/Provider/AlchemyProvider.swift

@@ -13,51 +13,30 @@ import Foundation
 public class AlchemyProvider: SmartAccountProvider {
     static private var rpcUrl: String = ""
 
-    static private func createRpcClient(config: AlchemyProviderConfig) throws -> Erc4337Client {
+    static internal func createRpcClient(config: ProviderConfig) throws -> Erc4337Client {
         guard let chain = SupportedChains[config.chain.id] else {
-            throw AlchemyError.unsupportedChain("Unsupported chain id: \(config.chain.id)")
+            throw ProviderError.unsupportedChain("Unsupported chain id: \(config.chain.id)")
         }
 
-        guard let rpcUrl = config.connectionConfig.rpcUrl ?? (chain.alchemyRpcHttpUrl.map { "\($0)/\(config.connectionConfig.apiKey ?? "")" }) else {
-            throw AlchemyError.rpcUrlNotFound("No rpcUrl found for chain \(config.chain.id)")
+        guard let rpcUrl = config.connectionConfig.rpcUrl ?? (chain.alchemyRpcHttpUrl.map {
+            let apiKey = config.connectionConfig.apiKey ?? ""
+            return apiKey.isEmpty ? $0 : "\($0)/\(apiKey)"
+        }) else {
+            throw ProviderError.rpcUrlNotFound("No rpcUrl found for chain \(config.chain.id)")
         }
 
         let headers = config.connectionConfig.jwt.map {
             ["Authorization": "Bearer \($0)"]
         } ?? [:]
-        let rpcClient = createAlchemyClient(url: rpcUrl, chain: config.chain, headers: headers)
+        let rpcClient = try createAlchemyClient(url: rpcUrl, chain: config.chain, headers: headers)
         self.rpcUrl = rpcUrl
 
         return rpcClient
     }
 
-    public init(entryPointAddress: EthereumAddress?, config: AlchemyProviderConfig) throws {
+    public init(entryPointAddress: EthereumAddress?, config: ProviderConfig) throws {
         let rpcClient = try AlchemyProvider.createRpcClient(config: config)
         try super.init(client: rpcClient, rpcUrl: nil, entryPointAddress: entryPointAddress, chain: config.chain, opts: config.opts)
         withGasEstimator(gasEstimator: alchemyFeeEstimator)
     }
-
-    public override func defaultGasEstimator(
-        client: Erc4337Client,
-        operation: inout UserOperationStruct,
-        overrides: UserOperationOverrides
-    ) async throws -> UserOperationStruct {
-        if (overrides.preVerificationGas != nil &&
-            overrides.verificationGasLimit != nil &&
-            overrides.callGasLimit != nil
-        ) {
-            operation.preVerificationGas = overrides.preVerificationGas
-            operation.verificationGasLimit = overrides.verificationGasLimit
-            operation.callGasLimit = overrides.callGasLimit
-        } else {
-            let request = operation.toUserOperationRequest()
-            let estimates = try await rpcClient.estimateUserOperationGas(request: request, entryPoint: getEntryPointAddress().asString())
-
-            operation.preVerificationGas = overrides.preVerificationGas ?? estimates.preVerificationGas
-            operation.verificationGasLimit = overrides.verificationGasLimit ?? estimates.verificationGasLimit
-            operation.callGasLimit = overrides.callGasLimit ?? estimates.callGasLimit
-        }
-
-        return operation
-    }
 }

Sources/Coinbase/Chain.swift

@@ -0,0 +1,26 @@
+//
+//  Copyright (c) 2025 aa-swift
+//
+//  This file is part of the aa-swift project: https://github.com/syn-mcj/aa-swift,
+//  and is released under the MIT License: https://opensource.org/licenses/MIT
+//
+
+import AASwift
+
+let SupportedChains: [Int64: Chain] = [
+    Chain.Base.id: Chain.Base,
+    Chain.BaseSepolia.id: Chain.BaseSepolia
+]
+
+extension Chain {
+    var coinbasePaymasterAndBundlerUrl: String? {
+        switch self {
+        case Chain.Base:
+            return "https://api.developer.coinbase.com/rpc/v1/base"
+        case Chain.BaseSepolia:
+            return "https://api.developer.coinbase.com/rpc/v1/base-sepolia"
+        default:
+            return nil
+        }
+    }
+}

Sources/Coinbase/Middleware/CoinbaseClient.swift

@@ -0,0 +1,13 @@
+//
+//  Copyright (c) 2025 aa-swift
+//
+//  This file is part of the aa-swift project: https://github.com/syn-mcj/aa-swift,
+//  and is released under the MIT License: https://opensource.org/licenses/MIT
+//
+
+import AASwift
+
+public protocol CoinbaseClient: Erc4337Client {
+    func getPaymasterData(params: PaymasterDataParams) async throws -> PaymasterAndData
+    func sponsorUserOperation(userOp: UserOperationRequest, entryPoint: String) async throws -> SponsoredUserOperation
+}