View fee breakdown and change fee tip

Sources/Clients/FaucetClient/FaucetClient+Live.swift

@@ -58,6 +58,7 @@ extension FaucetClient: DependencyKey {
 					networkID: networkID,
 					manifest: manifest,
 					message: .none,
+					makeTransactionHeaderInput: .default,
 					isFaucetTransaction: true,
 					ephemeralNotaryPublicKey: ephemeralNotary.publicKey
 				)

Sources/Clients/TransactionClient/Models/TransactionFailure.swift

@@ -31,8 +31,6 @@ extension TransactionFailure {
 		switch self {
 		case let .failedToPrepareForTXSigning(error), let .failedToPrepareTXReview(.failedSigning(error)):
 			switch error {
-			case .failedToFindAccountWithEnoughFundsToLockFee:
-				return (errorKind: .failedToFindAccountWithEnoughFundsToLockFee, message: error.errorDescription)
 			case .failedToGetEpoch, .failedToLoadNotaryAndSigners, .failedToLoadNotaryPublicKey, .failedToLoadSignerPublicKeys, .failedToParseTXItIsProbablyInvalid:
 				return (errorKind: .failedToPrepareTransaction, message: error.errorDescription)
 			}
@@ -110,7 +108,6 @@ extension TransactionFailure {
 		case failedToLoadNotaryAndSigners
 		case failedToLoadNotaryPublicKey
 		case failedToLoadSignerPublicKeys
-		case failedToFindAccountWithEnoughFundsToLockFee
 
 		public var errorDescription: String? {
 			switch self {
@@ -124,8 +121,6 @@ extension TransactionFailure {
 				return "Failed to load signer public keys"
 			case .failedToLoadNotaryAndSigners:
 				return "Failed to load notary and signers"
-			case .failedToFindAccountWithEnoughFundsToLockFee:
-				return "Failed to find an account with enough funds to lock fee"
 			}
 		}
 	}

Sources/Clients/TransactionClient/Models/TransactionModels.swift

@@ -146,7 +146,7 @@ public struct BuildTransactionIntentRequest: Sendable {
 		manifest: TransactionManifest,
 		message: Message,
 		nonce: Nonce = .secureRandom(),
-		makeTransactionHeaderInput: MakeTransactionHeaderInput = .default,
+		makeTransactionHeaderInput: MakeTransactionHeaderInput,
 		isFaucetTransaction: Bool = false,
 		ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey
 	) {
@@ -198,7 +198,6 @@ public struct ManifestReviewRequest: Sendable {
 	public let manifestToSign: TransactionManifest
 	public let message: Message
 	public let nonce: Nonce
-	public let feeToAdd: BigDecimal
 	public let makeTransactionHeaderInput: MakeTransactionHeaderInput
 	public let ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey
 
@@ -207,76 +206,224 @@ public struct ManifestReviewRequest: Sendable {
 		message: Message,
 		nonce: Nonce,
 		makeTransactionHeaderInput: MakeTransactionHeaderInput = .default,
-		feeToAdd: BigDecimal,
 		ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey = Curve25519.Signing.PrivateKey().publicKey
 	) {
 		self.manifestToSign = manifestToSign
 		self.message = message
 		self.nonce = nonce
-		self.feeToAdd = feeToAdd
 		self.makeTransactionHeaderInput = makeTransactionHeaderInput
 		self.ephemeralNotaryPublicKey = ephemeralNotaryPublicKey
 	}
 }
 
-// MARK: - FeePayerCandiate
-public struct FeePayerCandiate: Sendable, Hashable, Identifiable {
+// MARK: - FeePayerCandidate
+public struct FeePayerCandidate: Sendable, Hashable, Identifiable {
 	public let account: Profile.Network.Account
 	public let xrdBalance: BigDecimal
 	public typealias ID = Profile.Network.Account.ID
 	public var id: ID { account.id }
 }
 
-// MARK: - AddFeeToManifestOutcome
-public enum AddFeeToManifestOutcome: Sendable, Equatable {
-	case includesLockFee(AddFeeToManifestOutcomeIncludesLockFee)
-	case excludesLockFee(AddFeeToManifestOutcomeExcludesLockFee)
-}
-
-// MARK: - AddFeeToManifestOutcomeIncludesLockFee
-public struct AddFeeToManifestOutcomeIncludesLockFee: Sendable, Equatable {
-	public let manifestWithLockFee: TransactionManifest
-	public let feePayerSelectionAmongstCandidates: FeePayerSelectionAmongstCandidates
-}
-
-// MARK: - AddFeeToManifestOutcomeExcludesLockFee
-public struct AddFeeToManifestOutcomeExcludesLockFee: Sendable, Equatable {
-	public let manifestExcludingLockFee: TransactionManifest
-	public let feePayerCandidates: NonEmpty<IdentifiedArrayOf<FeePayerCandiate>>
-	public let feeNotYetAdded: BigDecimal
-}
-
 // MARK: - TransactionToReview
 public struct TransactionToReview: Sendable, Equatable {
 	public let analyzedManifestToReview: ExecutionAnalysis
-	public let addFeeToManifestOutcome: AddFeeToManifestOutcome
 	public let networkID: NetworkID
+	public let feePayerSelectionAmongstCandidates: FeePayerSelectionAmongstCandidates
 }
 
 // MARK: - FeePayerSelectionAmongstCandidates
 public struct FeePayerSelectionAmongstCandidates: Sendable, Hashable {
-	public enum Selection: Sendable, Hashable {
-		case selectedByUser
-		case auto
-	}
-
-	public let selected: FeePayerCandiate
+	public var selected: FeePayerCandidate?
 	/// contains `selected`
-	public let candidates: NonEmpty<IdentifiedArrayOf<FeePayerCandiate>>
-
-	public let fee: BigDecimal
-
-	public let selection: Selection
+	public let candidates: NonEmpty<IdentifiedArrayOf<FeePayerCandidate>>
+	public var transactionFee: TransactionFee
 
 	public init(
-		selected: FeePayerCandiate,
-		candidates: NonEmpty<IdentifiedArrayOf<FeePayerCandiate>>,
-		fee: BigDecimal,
-		selection: Selection
+		selected: FeePayerCandidate?,
+		candidates: NonEmpty<IdentifiedArrayOf<FeePayerCandidate>>,
+		transactionFee: TransactionFee
 	) {
 		self.selected = selected
 		self.candidates = candidates
-		self.fee = fee
-		self.selection = selection
+		self.transactionFee = transactionFee
+	}
+}
+
+// MARK: - TransactionFee
+public struct TransactionFee: Hashable, Sendable {
+	/// FeeSummary after transaction was analyzed
+	let feeSummary: FeeSummary
+
+	/// FeeLocks after transaction was analyzed
+	let feeLocks: FeeLocks
+
+	/// The calculaton mode
+	public var mode: Mode
+
+	public init(feeSummary: FeeSummary, feeLocks: FeeLocks, mode: Mode) {
+		self.feeSummary = feeSummary
+		self.feeLocks = feeLocks
+		self.mode = mode
+	}
+
+	public init(executionAnalysis: ExecutionAnalysis) throws {
+		let feeSummary: FeeSummary = try .init(
+			executionCost: .init(executionAnalysis.feeSummary.executionCost),
+			finalizationCost: .init(executionAnalysis.feeSummary.finalizationCost),
+			storageExpansionCost: .init(executionAnalysis.feeSummary.storageExpansionCost),
+			royaltyCost: .init(executionAnalysis.feeSummary.royaltyCost)
+		)
+
+		let feeLocks: FeeLocks = try .init(
+			nonContingentLock: .init(executionAnalysis.feeLocks.lock),
+			contingentLock: .init(executionAnalysis.feeLocks.contingentLock)
+		)
+
+		self.init(
+			feeSummary: feeSummary,
+			feeLocks: feeLocks,
+			mode: .normal(.init(feeSummary: feeSummary, feeLocks: feeLocks))
+		)
+	}
+}
+
+extension TransactionFee {
+	/// Calculates the totalFee for the transaction based on the `mode`
+	public var totalFee: TotalFee {
+		switch mode {
+		case let .normal(normalCustomization):
+			let maxFee = normalCustomization.total
+			let minFee = maxFee.clampedDiff(feeLocks.contingentLock)
+			return .init(min: minFee, max: maxFee)
+		case let .advanced(advancedCustomization):
+			return .init(min: advancedCustomization.total, max: advancedCustomization.total)
+		}
+	}
+
+	public mutating func toggleMode() {
+		switch mode {
+		case .normal:
+			mode = .advanced(.init(feeSummary: feeSummary))
+		case .advanced:
+			mode = .normal(.init(feeSummary: feeSummary, feeLocks: feeLocks))
+		}
+	}
+
+	public var isNormalMode: Bool {
+		if case .normal = mode {
+			return true
+		}
+		return false
+	}
+}
+
+extension TransactionFee {
+	enum PredefinedFeeConstants {
+		/// 15% margin is added here to make up for the ambiguity of the transaction preview estimate)
+		static let networkFeeMultiplier: BigDecimal = 0.15
+
+		// TODO: Add WalletFees table. Which is yet to be determined.
+	}
+
+	public enum Mode: Hashable, Sendable {
+		case normal(NormalFeeCustomization)
+		case advanced(AdvancedFeeCustomization)
+	}
+
+	public struct FeeSummary: Hashable, Sendable {
+		public let executionCost: BigDecimal
+		public let finalizationCost: BigDecimal
+		public let storageExpansionCost: BigDecimal
+		public let royaltyCost: BigDecimal
+
+		public var total: BigDecimal {
+			executionCost + finalizationCost + storageExpansionCost + royaltyCost
+		}
+
+		public init(
+			executionCost: BigDecimal,
+			finalizationCost: BigDecimal,
+			storageExpansionCost: BigDecimal,
+			royaltyCost: BigDecimal
+		) {
+			self.executionCost = executionCost
+			self.finalizationCost = finalizationCost
+			self.storageExpansionCost = storageExpansionCost
+			self.royaltyCost = royaltyCost
+		}
+	}
+
+	public struct FeeLocks: Hashable, Sendable {
+		let nonContingentLock: BigDecimal
+		let contingentLock: BigDecimal
+
+		public init(nonContingentLock: BigDecimal, contingentLock: BigDecimal) {
+			self.nonContingentLock = nonContingentLock
+			self.contingentLock = contingentLock
+		}
+	}
+
+	public struct AdvancedFeeCustomization: Hashable, Sendable {
+		private let networkFee: BigDecimal
+
+		public let feeSummary: FeeSummary
+		public var paddingFee: BigDecimal
+		public var tipPercentage: BigDecimal
+
+		public var tipAmount: BigDecimal {
+			(tipPercentage / 100) * networkFee
+		}
+
+		public var total: BigDecimal {
+			feeSummary.total + paddingFee + tipAmount
+		}
+
+		public init(feeSummary: FeeSummary) {
+			self.feeSummary = feeSummary
+			// The networkFee is used to derive the base PaddingFee as well the tipAmount
+			self.networkFee = feeSummary.executionCost + feeSummary.finalizationCost
+			self.paddingFee = networkFee * PredefinedFeeConstants.networkFeeMultiplier
+			self.tipPercentage = .zero
+		}
+	}
+
+	public struct NormalFeeCustomization: Hashable, Sendable {
+		public let networkFee: BigDecimal
+		public let royaltyFee: BigDecimal
+		public let total: BigDecimal
+
+		public init(networkFee: BigDecimal, royaltyFee: BigDecimal) {
+			self.networkFee = networkFee
+			self.royaltyFee = royaltyFee
+			self.total = networkFee + royaltyFee
+		}
+
+		public init(feeSummary: FeeSummary, feeLocks: FeeLocks) {
+			var networkFee = feeSummary.executionCost + feeSummary.finalizationCost + feeSummary.storageExpansionCost
+			networkFee += networkFee * PredefinedFeeConstants.networkFeeMultiplier
+			let remainingNonContingentLock = feeLocks.nonContingentLock.clampedDiff(networkFee)
+
+			self.init(
+				networkFee: networkFee.clampedDiff(feeLocks.nonContingentLock),
+				royaltyFee: feeSummary.royaltyCost.clampedDiff(remainingNonContingentLock)
+			)
+		}
+	}
+
+	public struct TotalFee: Hashable, Sendable {
+		let min: BigDecimal
+		let max: BigDecimal
+
+		public var lockFee: BigDecimal {
+			// We always lock the max amount
+			max
+		}
+
+		public var displayedTotalFee: String {
+			if max > min {
+				return "\(min.format()) - \(max.format()) XRD"
+			}
+			return "\(max.format()) XRD"
+		}
 	}
 }

Sources/Clients/TransactionClient/TransactionClient+Interface.swift

@@ -5,8 +5,6 @@ import FactorSourcesClient
 
 // MARK: - TransactionClient
 public struct TransactionClient: Sendable, DependencyKey {
-	public var lockFeeBySearchingForSuitablePayer: LockFeeBySearchingForSuitablePayer
-	public var lockFeeWithSelectedPayer: LockFeeWithSelectedPayer
 	public var getTransactionReview: GetTransactionReview
 	public var buildTransactionIntent: BuildTransactionIntent
 	public var notarizeTransaction: NotarizeTransaction
@@ -16,9 +14,6 @@ public struct TransactionClient: Sendable, DependencyKey {
 
 // MARK: TransactionClient.SignAndSubmitTransaction
 extension TransactionClient {
-	public typealias LockFeeBySearchingForSuitablePayer = @Sendable (TransactionManifest, _ fee: BigDecimal) async throws -> AddFeeToManifestOutcome
-	public typealias LockFeeWithSelectedPayer = @Sendable (TransactionManifest, _ fee: BigDecimal, _ payer: AccountAddress) async throws -> TransactionManifest
-
 	public typealias GetTransactionReview = @Sendable (ManifestReviewRequest) async throws -> TransactionToReview
 	public typealias BuildTransactionIntent = @Sendable (BuildTransactionIntentRequest) async throws -> TransactionIntentWithSigners
 	public typealias NotarizeTransaction = @Sendable (NotarizeTransactionRequest) async throws -> NotarizeTransactionResponse
@@ -34,48 +29,29 @@ extension DependencyValues {
 	}
 }
 
-// MARK: - AddInstructionToManifestLocation
-public enum AddInstructionToManifestLocation: Sendable, Hashable {
-	case first
-	public static let lockFee: Self = .first
-}
-
-// MARK: - AddInstructionToManifestRequest
-public struct AddInstructionToManifestRequest: Sendable, Hashable {
-	public let instruction: Instruction
-	public let manifest: TransactionManifest
-	public let location: AddInstructionToManifestLocation
-	public init(
-		instruction: Instruction,
-		to manifest: TransactionManifest,
-		at location: AddInstructionToManifestLocation
-	) {
-		self.instruction = instruction
-		self.manifest = manifest
-		self.location = location
-	}
-}
-
 extension TransactionClient {
 	public struct PrepareForSigningRequest: Equatable, Sendable {
 		public let nonce: Nonce
 		public let manifest: TransactionManifest
 		public let message: Message
-		public let feePayer: Profile.Network.Account
+		// Optional, as there might not be any fee
+		public let feePayer: Profile.Network.Account?
 		public let networkID: NetworkID
 		public let purpose: SigningPurpose
 
 		public var compiledIntent: [UInt8]? = nil
 		public let ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey
+		public let transactionHeader: MakeTransactionHeaderInput
 
 		public init(
 			nonce: Nonce,
 			manifest: TransactionManifest,
 			message: Message,
 			networkID: NetworkID,
-			feePayer: Profile.Network.Account,
+			feePayer: Profile.Network.Account?,
 			purpose: SigningPurpose,
-			ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey
+			ephemeralNotaryPublicKey: Curve25519.Signing.PublicKey,
+			transactionHeader: MakeTransactionHeaderInput
 		) {
 			self.nonce = nonce
 			self.manifest = manifest
@@ -84,6 +60,7 @@ extension TransactionClient {
 			self.feePayer = feePayer
 			self.purpose = purpose
 			self.ephemeralNotaryPublicKey = ephemeralNotaryPublicKey
+			self.transactionHeader = transactionHeader
 		}
 	}