feat: add ethSignTransactionAndSendByCadence

Author: lmcmz

Package.resolved

@@ -16,7 +16,7 @@ let package = Package(
     ],
     dependencies: [
         .package(url: "https://github.com/kishikawakatsumi/KeychainAccess", from: "4.2.2"),
-        .package(url: "https://github.com/Outblock/flow-swift", .revisionItem("0d72e52bca7e8c6aeb4b594b9a31b1f35af770fb")),
+        .package(url: "https://github.com/Outblock/flow-swift", .revisionItem("013e8537d1c9654c6be3c9c673fbdcb13ce62ffa")),
         .package(url: "https://github.com/trustwallet/wallet-core", .upToNextMajor(from: "4.3.2")),
     ],
     targets: [

Package.swift

@@ -0,0 +1,81 @@
+//
+//  EVMModels.swift
+//  FlowWalletKit
+//
+
+import Foundation
+import Flow
+
+/// Represents supported EVM chains (Flow EVM plus custom extensions).
+public enum EVMChain: Equatable {
+    case flowMainnet
+    case flowTestnet
+    case custom(UInt64)
+
+    /// Numeric chain ID.
+    public var chainId: UInt64 {
+        switch self {
+        case .flowMainnet: return 747
+        case .flowTestnet: return 545
+        case let .custom(id): return id
+        }
+    }
+
+    /// Encoded chain ID for WalletCore signing input.
+    public var chainIdData: Data {
+        var value = chainId
+        var bytes: [UInt8] = []
+        repeat {
+            bytes.insert(UInt8(value & 0xff), at: 0)
+            value >>= 8
+        } while value > 0
+        return Data(bytes)
+    }
+
+    /// Whether this chain is Flow EVM (mainnet/testnet).
+    public var isFlowEVM: Bool {
+        switch self {
+        case .flowMainnet, .flowTestnet:
+            return true
+        default:
+            return false
+        }
+    }
+
+    /// Corresponding Flow chain ID when applicable (nil for non-Flow EVM).
+    public var flowChainID: Flow.ChainID? {
+        switch self {
+        case .flowMainnet:
+            return .mainnet
+        case .flowTestnet:
+            return .testnet
+        case .custom:
+            return nil
+        }
+    }
+}
+
+/// Result model for submitting an EVM transaction via Flow.
+public struct FlowEVMSubmitResult {
+    public let flowTxId: String
+    public let evmTxId: String
+
+    public init(flowTxId: String, evmTxId: String) {
+        self.flowTxId = flowTxId
+        self.evmTxId = evmTxId
+    }
+}
+
+public extension Flow.ChainID {
+    /// Map Flow network to its corresponding EVM chain when available.
+    var evmChain: EVMChain? {
+        switch self {
+        case .mainnet:
+            return .flowMainnet
+        case .testnet:
+            return .flowTestnet
+        default:
+            return nil
+        }
+    }
+}

iOS/FlowWalletKit/Sources/Wallet/EVMModels.swift

@@ -6,6 +6,7 @@
 //
 
 import Foundation
+import Flow
 import WalletCore
 
 // MARK: - Support EOA
@@ -72,7 +73,7 @@ extension Wallet {
         guard let publicKey = PublicKey.recover(signature: normalizedSignature, message: digest) else {
             throw FWKError.invalidEthereumSignature
         }
-		let address = AnyAddress(publicKey: publicKey, coin: .ethereum)
+        let address = AnyAddress(publicKey: publicKey, coin: .ethereum)
         return address.description
     }
 
@@ -82,7 +83,7 @@ extension Wallet {
         var signingInput = input
         signingInput.privateKey = try key.ethPrivateKey(index: index)
         defer { signingInput.privateKey = Data() }
-	    var output: EthereumSigningOutput = AnySigner.sign(input: signingInput, coin: .ethereum)
+        var output: EthereumSigningOutput = AnySigner.sign(input: signingInput, coin: .ethereum)
         let transactionHash = Hash.keccak256(data: output.encoded)
         output.preHash = transactionHash
         return output
@@ -131,4 +132,83 @@ extension Wallet {
         }
         return ethereumKey
     }
+
+    /// Sends an EOA-signed Ethereum transaction to Flow EVM through Cadence.
+    /// - Parameters:
+    ///   - account: Flow account used as proposer/payer/authorizer.
+    ///   - rlpEncodedTransaction: Signed Ethereum transaction payload.
+    ///   - coinbaseAddr: EOA coinbase address.
+    /// - Returns: Flow transaction ID after submission.
+	public func ethSendSignedTransactionByCadence(chainId: Flow.ChainID = .mainnet,
+												  account: Flow.Address,
+												  rlpEncodedTransaction: Data,
+												  coinbaseAddr: String,
+												  signers: [FlowSigner],
+												  payer: Flow.Address? = nil
+    ) async throws -> Flow.ID {
+        try await flow.runEVMTransaction(
+            chainID: chainId,
+            proposer: account,
+            payer: payer ?? account,
+            rlpEncodedTransaction: Array(rlpEncodedTransaction),
+            coinbaseAddress: coinbaseAddr,
+            signers: signers
+        )
+    }
+
+    /// Sign an Ethereum transaction (WalletCore input) and submit it to Flow EVM via Cadence.
+    /// Returns both the Flow transaction ID and the EVM transaction hash.
+    /// - Parameters:
+    ///   - chain: Flow EVM chain (mainnet/testnet only).
+    ///   - input: Unsigned Ethereum signing input; chainId is set automatically based on `chain`.
+    ///   - fromAddress: Expected EOA sender/coinbase; must match the wallet's derived address for `index`.
+    ///   - signers: Flow signers (proposer/authorizers/payer).
+    ///   - flowAddress: Optional Flow address for proposer/payer; defaults to the first signer address.
+    ///   - payer: Optional custom payer; defaults to proposer.
+    ///   - index: HD derivation index for EVM key (defaults to 0).
+    /// - Returns: `FlowEVMSubmitResult` containing Flow tx id and EVM tx hash (0x-prefixed).
+    public func ethSignTransactionAndSendByCadence(
+        chain: EVMChain = .flowMainnet,
+        input: EthereumSigningInput,
+        fromAddress: String,
+        signers: [FlowSigner],
+        flowAddress: Flow.Address? = nil,
+        payer: Flow.Address? = nil,
+        index: UInt32 = 0
+    ) async throws -> FlowEVMSubmitResult {
+        guard case .key = type else {
+            throw FWKError.invaildWalletType
+        }
+        guard !signers.isEmpty else {
+            throw FWKError.emptySignKey
+        }
+
+        var signingInput = input
+        signingInput.chainID = chain.chainIdData
+        guard let fromAddr = AnyAddress(string: fromAddress, coin: .ethereum) else {
+            throw FWKError.invaildEVMAddress
+        }
+        let derivedAddr = try ethAddress(index: index)
+        guard fromAddr.description.lowercased() == derivedAddr.lowercased() else {
+            throw FWKError.invaildEVMAddress
+        }
+
+        let signed = try ethSignTransaction(signingInput, index: index)
+        guard let flowChainID = chain.flowChainID else {
+            throw FWKError.unsupportedEVMChain
+        }
+        guard let proposer = flowAddress ?? signers.first?.address else {
+            throw FWKError.emptyFlowAddress
+        }
+        let flowTxId = try await ethSendSignedTransactionByCadence(
+            chainId: flowChainID,
+            account: proposer,
+            rlpEncodedTransaction: signed.encoded,
+            coinbaseAddr: fromAddr.description,
+            signers: signers,
+            payer: payer ?? proposer
+        )
+        let flowTxIdString = String(describing: flowTxId)
+        return FlowEVMSubmitResult(flowTxId: flowTxIdString, evmTxId: signed.txIdHex())
+    }
 }

iOS/FlowWalletKit/Sources/Wallet/Wallet+EOA.swift

@@ -79,6 +79,10 @@ public enum FWKError: String, Error, CaseIterable, CustomStringConvertible {
     /// Invalid EVM address
     /// Thrown when an unknown or invalid EVM address is provided
     case invaildEVMAddress
+    /// Empty FLowAddress
+    case emptyFlowAddress
+    /// Unsupported EVM chain for Flow submission
+    case unsupportedEVMChain
 
     // MARK: - Authentication Errors