[ABW-1316] Split out signing and submission from TransactionClient, introduce Signing feature (prepares for signing w Ledger)

Package.swift

@@ -63,7 +63,7 @@ package.addModules([
 	.feature(
 		name: "AssetTransferFeature",
 		dependencies: [
-			"TransactionSigningFeature",
+			.product(name: "ComposableArchitecture", package: "swift-composable-architecture"),
 		],
 		tests: .yes()
 	),
@@ -249,6 +249,17 @@ package.addModules([
 		],
 		tests: .yes()
 	),
+	.feature(
+		name: "SigningFeature",
+		featureSuffixDroppedFromFolderName: true,
+		dependencies: [
+			"TransactionClient",
+			"FactorSourcesClient",
+			"Profile",
+			"UseFactorSourceClient",
+		],
+		tests: .no
+	),
 	.feature(
 		name: "SplashFeature",
 		dependencies: [
@@ -262,19 +273,11 @@ package.addModules([
 		dependencies: [
 			"GatewayAPI",
 			"TransactionClient",
+			"SigningFeature",
+			"SubmitTransactionClient",
 		],
 		tests: .yes()
 	),
-	.feature(
-		name: "TransactionSigningFeature",
-		dependencies: [
-			"GatewayAPI",
-			"GatewaysClient",
-			"TransactionClient",
-		],
-		tests: .yes()
-	),
-
 ])
 
 // MARK: - Clients
@@ -374,6 +377,7 @@ package.addModules([
 		dependencies: [
 			"FactorSourcesClient",
 			"ProfileStore",
+			"AccountsClient",
 		],
 		tests: .yes()
 	),
@@ -384,6 +388,7 @@ package.addModules([
 			"EngineToolkitClient",
 			"GatewayAPI",
 			"GatewaysClient", // getCurrentNetworkID
+			"SubmitTransactionClient",
 			"TransactionClient",
 		],
 		tests: .yes()
@@ -555,18 +560,25 @@ package.addModules([
 		],
 		tests: .yes()
 	),
+	.client(
+		name: "SubmitTransactionClient",
+		dependencies: [
+			"EngineToolkitClient",
+			"GatewayAPI",
+		],
+		tests: .no
+	),
 	.client(
 		name: "TransactionClient",
 		dependencies: [
 			"AccountsClient",
 			"AccountPortfoliosClient",
 			"CacheClient",
-			"EngineToolkitClient",
 			"FactorSourcesClient",
-			"GatewayAPI",
-			"GatewaysClient",
 			"SecureStorageClient",
+			"EngineToolkitClient",
 			"UseFactorSourceClient",
+			"GatewayAPI",
 		],
 		tests: .yes()
 	),
@@ -575,6 +587,7 @@ package.addModules([
 		dependencies: [
 			"Profile",
 			"Cryptography",
+			"FactorSourcesClient",
 			"SecureStorageClient",
 		],
 		tests: .no

Sources/Clients/CacheClient/CacheClient+Interface.swift

@@ -118,3 +118,14 @@ extension CacheClient {
 		case entryLifetimeExpired
 	}
 }
+
+extension CacheClient {
+	@Sendable
+	public func clearCacheForAccounts(_ accounts: Set<AccountAddress>) {
+		if !accounts.isEmpty {
+			accounts.forEach { self.removeFile(.accountPortfolio(.single($0.address))) }
+		} else {
+			self.removeFolder(.accountPortfolio(.all))
+		}
+	}
+}

Sources/Clients/EngineToolkitClient/EngineToolkitClient+Interface.swift

@@ -12,6 +12,7 @@ public struct EngineToolkitClient: Sendable, DependencyKey {
 	public var compileTransactionIntent: CompileTransactionIntent
 	public var compileSignedTransactionIntent: CompileSignedTransactionIntent
 	public var compileNotarizedTransactionIntent: CompileNotarizedTransactionIntent
+	public var decompileTransactionIntentRequest: DecompileTransactionIntentRequest
 
 	public var deriveOlympiaAdressFromPublicKey: DeriveOlympiaAdressFromPublicKey
 
@@ -68,6 +69,8 @@ extension EngineToolkitClient {
 	public typealias GenerateTransactionReview = @Sendable (AnalyzeManifestWithPreviewContextRequest) throws -> AnalyzeManifestWithPreviewContextResponse
 
 	public typealias DecodeAddressRequest = @Sendable (String) throws -> DecodeAddressResponse
+
+	public typealias DecompileTransactionIntentRequest = @Sendable (EngineToolkitModels.DecompileTransactionIntentRequest) throws -> DecompileTransactionIntentResponse
 }
 
 // MARK: - AccountAddressesInvolvedInTransactionRequest

Sources/Clients/EngineToolkitClient/EngineToolkitClient+Live.swift

@@ -48,6 +48,9 @@ extension EngineToolkitClient {
 			compileNotarizedTransactionIntent: {
 				try engineToolkit.compileNotarizedTransactionIntentRequest(request: $0).get()
 			},
+			decompileTransactionIntentRequest: {
+				try engineToolkit.decompileTransactionIntentRequest(request: $0).get()
+			},
 			deriveOlympiaAdressFromPublicKey: {
 				try engineToolkit.deriveOlympiaAddressFromPublicKeyRequest(
 					request: .init(network: .mainnet, publicKey: $0.intoEngine())

Sources/Clients/EngineToolkitClient/EngineToolkitClient+Test.swift

@@ -15,6 +15,7 @@ extension EngineToolkitClient: TestDependencyKey {
 		compileTransactionIntent: { _ in .init(compiledIntent: [0xDE, 0xAD]) },
 		compileSignedTransactionIntent: { _ in .init(bytes: [0xDE, 0xAD]) },
 		compileNotarizedTransactionIntent: { _ in .init(compiledIntent: [0xDE, 0xAD]) },
+		decompileTransactionIntentRequest: { _ in throw NoopError() },
 		deriveOlympiaAdressFromPublicKey: { _ in throw NoopError() },
 		generateTXID: { _ in "deadbeef" },
 		accountAddressesNeedingToSignTransaction: { _ in [] },
@@ -31,6 +32,7 @@ extension EngineToolkitClient: TestDependencyKey {
 		compileTransactionIntent: unimplemented("\(Self.self).compileTransactionIntent"),
 		compileSignedTransactionIntent: unimplemented("\(Self.self).compileSignedTransactionIntent"),
 		compileNotarizedTransactionIntent: unimplemented("\(Self.self).compileNotarizedTransactionIntent"),
+		decompileTransactionIntentRequest: unimplemented("\(Self.self).decompileTransactionIntentRequest"),
 		deriveOlympiaAdressFromPublicKey: unimplemented("\(Self.self).deriveOlympiaAdressFromPublicKey"),
 		generateTXID: unimplemented("\(Self.self).generateTXID"),
 		accountAddressesNeedingToSignTransaction: unimplemented("\(Self.self).accountAddressesNeedingToSignTransaction"),

Sources/Clients/FactorSourcesClient/FactorSourcesClient+Interface.swift

@@ -8,19 +8,22 @@ public struct FactorSourcesClient: Sendable {
 	public var addPrivateHDFactorSource: AddPrivateHDFactorSource
 	public var checkIfHasOlympiaFactorSourceForAccounts: CheckIfHasOlympiaFactorSourceForAccounts
 	public var addOffDeviceFactorSource: AddOffDeviceFactorSource
+	public var getSigningFactors: GetSigningFactors
 
 	public init(
 		getFactorSources: @escaping GetFactorSources,
 		factorSourcesAsyncSequence: @escaping FactorSourcesAsyncSequence,
 		addPrivateHDFactorSource: @escaping AddPrivateHDFactorSource,
 		checkIfHasOlympiaFactorSourceForAccounts: @escaping CheckIfHasOlympiaFactorSourceForAccounts,
-		addOffDeviceFactorSource: @escaping AddOffDeviceFactorSource
+		addOffDeviceFactorSource: @escaping AddOffDeviceFactorSource,
+		getSigningFactors: @escaping GetSigningFactors
 	) {
 		self.getFactorSources = getFactorSources
 		self.factorSourcesAsyncSequence = factorSourcesAsyncSequence
 		self.addPrivateHDFactorSource = addPrivateHDFactorSource
 		self.checkIfHasOlympiaFactorSourceForAccounts = checkIfHasOlympiaFactorSourceForAccounts
 		self.addOffDeviceFactorSource = addOffDeviceFactorSource
+		self.getSigningFactors = getSigningFactors
 	}
 }
 
@@ -31,6 +34,28 @@ extension FactorSourcesClient {
 	public typealias AddPrivateHDFactorSource = @Sendable (PrivateHDFactorSource) async throws -> FactorSourceID
 	public typealias CheckIfHasOlympiaFactorSourceForAccounts = @Sendable (NonEmpty<OrderedSet<OlympiaAccountToMigrate>>) async -> FactorSourceID?
 	public typealias AddOffDeviceFactorSource = @Sendable (FactorSource) async throws -> Void
+	public typealias GetSigningFactors = @Sendable (NetworkID, NonEmpty<Set<Profile.Network.Account>>) async throws -> SigningFactors
+}
+
+public typealias SigningFactors = NonEmpty<OrderedSet<SigningFactor>>
+
+// MARK: - SigningFactor
+public struct SigningFactor: Sendable, Hashable {
+	public let factorSource: FactorSource
+	public let signers: NonEmpty<Set<Signer>>
+	public init(factorSource: FactorSource, signers: NonEmpty<Set<Signer>>) {
+		self.factorSource = factorSource
+		self.signers = signers
+	}
+
+	public struct Signer: Sendable, Hashable {
+		public let account: Profile.Network.Account
+		public let factorInstancesRequiredToSign: Set<FactorInstance>
+		public init(account: Profile.Network.Account, factorInstancesRequiredToSign: Set<FactorInstance>) {
+			self.account = account
+			self.factorInstancesRequiredToSign = factorInstancesRequiredToSign
+		}
+	}
 }
 
 extension FactorSourcesClient {

Sources/Clients/FactorSourcesClient/FactorSourcesClient+Test.swift

@@ -15,14 +15,16 @@ extension FactorSourcesClient: TestDependencyKey {
 		factorSourcesAsyncSequence: unimplemented("\(Self.self).factorSourcesAsyncSequence"),
 		addPrivateHDFactorSource: unimplemented("\(Self.self).addPrivateHDFactorSource"),
 		checkIfHasOlympiaFactorSourceForAccounts: unimplemented("\(Self.self).checkIfHasOlympiaFactorSourceForAccounts"),
-		addOffDeviceFactorSource: unimplemented("\(Self.self).addOffDeviceFactorSource")
+		addOffDeviceFactorSource: unimplemented("\(Self.self).addOffDeviceFactorSource"),
+		getSigningFactors: unimplemented("\(Self.self).getSigningFactors")
 	)
 
 	public static let noop = Self(
 		getFactorSources: { throw NoopError() },
 		factorSourcesAsyncSequence: { AsyncLazySequence([]).eraseToAnyAsyncSequence() },
 		addPrivateHDFactorSource: { _ in throw NoopError() },
 		checkIfHasOlympiaFactorSourceForAccounts: { _ in nil },
-		addOffDeviceFactorSource: { _ in }
+		addOffDeviceFactorSource: { _ in },
+		getSigningFactors: { _, _ in throw NoopError() }
 	)
 }

Sources/Clients/FactorSourcesClientLive/FactorSourcesClient+Live.swift

@@ -1,3 +1,4 @@
+import AccountsClient
 import ClientPrelude
 import FactorSourcesClient
 import ProfileStore
@@ -72,12 +73,98 @@ extension FactorSourcesClient: DependencyKey {
 					return nil // failure
 				}
 			},
-			addOffDeviceFactorSource: addOffDeviceFactorSource
+			addOffDeviceFactorSource: addOffDeviceFactorSource,
+			getSigningFactors: { _, accounts in
+				@Dependency(\.accountsClient) var accountsClient
+
+				let allFactorSources = try await getFactorSources()
+
+				final class SigningFactorRef {
+					let factorSource: FactorSource
+					var signers: [Profile.Network.Account.ID: SignerRef] = [:]
+					init(factorSource: FactorSource, signers: [Profile.Network.Account.ID: SignerRef] = [:]) {
+						self.factorSource = factorSource
+						self.signers = signers
+					}
+
+					final class SignerRef {
+						let account: Profile.Network.Account
+						var factorInstancesRequiredToSign: Set<FactorInstance>
+						init(account: Profile.Network.Account, factorInstancesRequiredToSign: Set<FactorInstance> = .init()) {
+							self.account = account
+							self.factorInstancesRequiredToSign = factorInstancesRequiredToSign
+						}
+
+						func valueType() -> SigningFactor.Signer {
+							.init(account: account, factorInstancesRequiredToSign: factorInstancesRequiredToSign)
+						}
+					}
+
+					func valueType() throws -> SigningFactor {
+						guard let signersNonEmpty = NonEmpty<Set<SigningFactor.Signer>>(rawValue: Set(self.signers.values.map { $0.valueType() })) else {
+							throw SignersUnexpectedlyEmpty()
+						}
+						return .init(factorSource: factorSource, signers: signersNonEmpty)
+					}
+				}
+
+				var signingFactors: [FactorSourceID: SigningFactorRef] = [:]
+
+				for account in accounts {
+					switch account.securityState {
+					case let .unsecured(unsecuredEntityControl):
+						let factorInstance = unsecuredEntityControl.genesisFactorInstance
+						let id = factorInstance.factorSourceID
+						guard let factorSource = allFactorSources[id: id] else {
+							assertionFailure("Bad! factor source not found")
+							throw FactorSourceNotFound()
+						}
+						let outerRef = signingFactors[id, default: SigningFactorRef(factorSource: factorSource)]
+						let innerRef = outerRef.signers[account.id, default: .init(account: account)]
+						innerRef.factorInstancesRequiredToSign.insert(factorInstance)
+						outerRef.signers[account.id] = innerRef
+						signingFactors[id] = outerRef
+					}
+				}
+
+				guard let signersNonEmpty = try SigningFactors(
+					rawValue: OrderedSet(uncheckedUniqueElements: signingFactors.values.map { try $0.valueType() }.sorted())
+				) else {
+					throw FailedToFindSigners()
+				}
+				return signersNonEmpty
+			}
 		)
 	}
 
 	public static let liveValue = Self.live()
 }
 
+// MARK: - SignersUnexpectedlyEmpty
+struct SignersUnexpectedlyEmpty: Error {}
+
+// MARK: - FailedToFindSigners
+struct FailedToFindSigners: Error {}
+
 // MARK: - FactorSourceAlreadyPresent
 struct FactorSourceAlreadyPresent: Swift.Error {}
+
+// MARK: - FactorSourceNotFound
+struct FactorSourceNotFound: Swift.Error {}
+
+// MARK: - SigningFactor + Comparable
+extension SigningFactor: Comparable {
+	public static func < (lhs: Self, rhs: Self) -> Bool {
+		lhs.factorSource.kind.signingOrder < rhs.factorSource.kind.signingOrder
+	}
+}
+
+extension FactorSourceKind {
+	fileprivate var signingOrder: Int {
+		switch self {
+		case .ledgerHQHardwareWallet: return 0
+		case .device: return 1
+		default: return 1000
+		}
+	}
+}

Sources/Clients/FaucetClient/FaucetClient+Live.swift

@@ -1,7 +1,10 @@
 import ClientPrelude
+import Cryptography
 import EngineToolkitClient
+import EngineToolkitModels
 import GatewayAPI
 import GatewaysClient
+import SubmitTransactionClient
 import TransactionClient
 
 let minimumNumberOfEpochsPassedForFaucetToBeReused = 1
@@ -41,18 +44,36 @@ extension FaucetClient: DependencyKey {
 			await isAllowedToUseFaucetIfSoGetEpochs(accountAddress: accountAddress) != nil
 		}
 
+		/// This function can ONLY sign transaction which does not spend funds or otherwise require
+		/// auth, since we use an ephemeral key pair
 		@Sendable func signSubmitTX(manifest: TransactionManifest) async throws {
 			@Dependency(\.transactionClient) var transactionClient
+			@Dependency(\.engineToolkitClient) var engineToolkitClient
+			@Dependency(\.submitTXClient) var submitTXClient
 
-			let signSubmitTXRequest = SignManifestRequest(
-				manifestToSign: manifest,
-				makeTransactionHeaderInput: .default
+			let networkID = await gatewaysClient.getCurrentNetworkID()
+
+			let ephemeralNotary = Curve25519.Signing.PrivateKey()
+
+			let builtTransactionIntentWithSigners = try await transactionClient.buildTransactionIntent(
+				.init(
+					networkID: networkID,
+					manifest: manifest,
+					selectNotary: { _ in
+						.init(notary: .ephemeralPublicKey(.eddsaEd25519(ephemeralNotary.publicKey)), notaryAsSignatory: true)
+					}
+				)
 			)
 
-			let _ = try await transactionClient
-				.signAndSubmitTransaction(signSubmitTXRequest)
-				.asyncFlatMap(transform: transactionClient.getTransactionResult)
-				.get()
+			let transactionIntent = builtTransactionIntentWithSigners.intent
+			let compiledIntent = try engineToolkitClient.compileTransactionIntent(transactionIntent)
+
+			let notarized = try await transactionClient.notarizeTransaction(.init(intentSignatures: [], compileTransactionIntent: compiledIntent, notary: .curve25519(ephemeralNotary)))
+
+			let txID = notarized.txID
+			_ = try await submitTXClient.submitTransaction(.init(txID: txID, compiledNotarizedTXIntent: notarized.notarized))
+
+			try await submitTXClient.hasTXBeenCommittedSuccessfully(txID)
 		}
 
 		let getFreeXRD: GetFreeXRD = { faucetRequest in