Introduce Sargon: Radix Engine Toolkit (RET) removed

.xcode-version

@@ -1 +1 @@
-15.0.1
+15.2

RadixWallet.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,4 +1,5 @@
 {
+  "originHash" : "afe728646c91bd6674f4d8d6eb1692b8a79001f355d20f9465ca2f3750ced870",
   "pins" : [
     {
       "identity" : "anycodable",
@@ -108,6 +109,15 @@
         "version" : "11.6.4"
       }
     },
+    {
+      "identity" : "sargon",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/radixdlt/sargon",
+      "state" : {
+        "revision" : "84d016d098552f47bd4e35900db9dda662aa2960",
+        "version" : "0.5.3"
+      }
+    },
     {
       "identity" : "screenshotpreventing-ios",
       "kind" : "remoteSourceControl",
@@ -176,8 +186,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/apple/swift-collections.git",
       "state" : {
-        "branch" : "main",
-        "revision" : "b2c7faa198164f3d928b1ceec9ce373e22febb96"
+        "revision" : "94cf62b3ba8d4bed62680a282d4c25f9c63c2efb",
+        "version" : "1.1.0"
       }
     },
     {
@@ -234,15 +244,6 @@
         "revision" : "db33f4084304e2ef47c8b4d2949f0eb286f95b90"
       }
     },
-    {
-      "identity" : "swift-engine-toolkit",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/radixdlt/swift-engine-toolkit",
-      "state" : {
-        "branch" : "1.0.12_update",
-        "revision" : "4cf2edc92a430d4f59547d405e4c2c4bc5c912fe"
-      }
-    },
     {
       "identity" : "swift-identified-collections",
       "kind" : "remoteSourceControl",
@@ -415,5 +416,5 @@
       }
     }
   ],
-  "version" : 2
+  "version" : 3
 }

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+Interface.swift

@@ -44,38 +44,34 @@ extension AccountPortfoliosClient {
 			@Dependency(\.cacheClient) var cacheClient
 
 			let changedAccounts: [Profile.Network.Account.EntityAddress]?
-			let resourceAddressesToRefresh: [Address]?
+			let poolAddressesToRefresh: [PoolAddress]?
 			do {
-				let manifest = intent.manifest()
+				let manifest = intent.manifest
 
 				let involvedAccounts = try await transactionClient.myInvolvedEntities(manifest)
 				changedAccounts = involvedAccounts.accountsDepositedInto
 					.union(involvedAccounts.accountsWithdrawnFrom)
 					.map(\.address)
 
-				let involvedAddresses = manifest.extractAddresses()
+				let involvedPoolAddresses = manifest.involvedPoolAddresses
 				/// Refresh the resources if an operation on resource pool is involved,
 				/// reason being that contributing or withdrawing from a resource pool modifies the totalSupply
-				if involvedAddresses.contains(where: \.key.isResourcePool) {
+				if !involvedPoolAddresses.isEmpty {
 					/// A little bit too aggressive, as any other resource will also be refreshed.
 					/// But at this stage we cannot determine(without making additional calls) the pool unit related fungible resource
-					resourceAddressesToRefresh = involvedAddresses
-						.filter { $0.key == .globalFungibleResourceManager || $0.key.isResourcePool }
-						.values
-						.flatMap(identity)
-						.compactMap { try? $0.asSpecific() }
+					poolAddressesToRefresh = involvedPoolAddresses
 				} else {
-					resourceAddressesToRefresh = nil
+					poolAddressesToRefresh = nil
 				}
 			} catch {
 				loggerGlobal.warning("Could get transactionClient.myInvolvedEntities: \(error.localizedDescription)")
 				changedAccounts = nil
-				resourceAddressesToRefresh = nil
+				poolAddressesToRefresh = nil
 			}
 
-			if let resourceAddressesToRefresh {
-				for item in resourceAddressesToRefresh {
-					cacheClient.removeFile(.onLedgerEntity(.resource(item.asGeneral)))
+			if let poolAddressesToRefresh {
+				for item in poolAddressesToRefresh {
+					cacheClient.removeFile(.onLedgerEntity(.address(.pool(item))))
 				}
 			}
 

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+Live.swift

@@ -71,7 +71,7 @@ extension AccountPortfoliosClient: DependencyKey {
 			await state.setRadixGateway(gateway)
 			if forceRefresh {
 				for accountAddress in accountAddresses {
-					cacheClient.removeFolder(.onLedgerEntity(.account(accountAddress.asGeneral)))
+					cacheClient.removeFolder(.init(address: accountAddress))
 				}
 			}
 
@@ -130,7 +130,7 @@ extension AccountPortfoliosClient: DependencyKey {
 		@Sendable
 		func fetchAccountPortfolio(_ accountAddress: AccountAddress, _ forceRefresh: Bool) async throws -> AccountPortfolio {
 			if forceRefresh {
-				cacheClient.removeFolder(.onLedgerEntity(.account(accountAddress.asGeneral)))
+				cacheClient.removeFolder(.init(address: accountAddress))
 			}
 
 			let account = try await onLedgerEntitiesClient.getAccount(accountAddress)

RadixWallet/Clients/AccountPortfoliosClient/AccountPortfoliosClient+State.swift

@@ -13,7 +13,7 @@ extension AccountPortfoliosClient {
 
 	/// Internal state that holds all loaded portfolios.
 	actor State {
-		typealias TokenPrices = [ResourceAddress: RETDecimal]
+		typealias TokenPrices = [ResourceAddress: Decimal192]
 		let portfoliosSubject: AsyncCurrentValueSubject<Loadable<[AccountAddress: AccountPortfolio]>> = .init(.loading)
 		var tokenPrices: TokenPrices = [:]
 

RadixWallet/Clients/AccountsClient/AccountsClient+Interface.swift

@@ -139,3 +139,10 @@ extension AccountsClient {
 		try await saveVirtualAccounts([account])
 	}
 }
+
+// FIXME: Delete this TEMPORARY bridge, once Wallet uses Sargon Profile!
+extension AccountsClient {
+	public func fromSargon(_ sargonAccount: Sargon.Account) async throws -> Profile.Network.Account {
+		try await getAccountByAddress(sargonAccount.address)
+	}
+}

RadixWallet/Clients/CacheClient/CacheClient+Interface.swift

@@ -69,16 +69,85 @@ extension CacheClient {
 	}
 }
 
+extension Address {
+	fileprivate func filesystemFolderPath(rootName folderRoot: String) -> String {
+		switch self {
+		case let .account(accountAddress):
+			"\(folderRoot)/accounts/\(accountAddress.address)"
+		case .resource:
+			"\(folderRoot)/resources"
+		case .pool:
+			"\(folderRoot)/resourcePools"
+		case .validator:
+			"\(folderRoot)/validators"
+		case .component:
+			"\(folderRoot)/componentAddress"
+		default:
+			"\(folderRoot)/generic"
+		}
+	}
+
+	fileprivate func filesystemFilePath(folderPath filesystemFolderPath: String) -> String {
+		switch self {
+		case .account:
+			"\(filesystemFolderPath)/details"
+		case let .resource(resourceAddress):
+			"\(filesystemFolderPath)/\(resourceAddress.address)"
+		case let .pool(poolAddress):
+			"\(filesystemFolderPath)/\(poolAddress.address)"
+		case let .validator(validatorAddress):
+			"\(filesystemFolderPath)/\(validatorAddress.address)"
+		case let .component(componentAddress):
+			"\(filesystemFolderPath)/\(componentAddress.address)"
+		default:
+			"\(filesystemFolderPath)/\(self.address)"
+		}
+	}
+}
+
 extension CacheClient {
 	public enum Entry: Equatable {
+		public init(address: some AddressProtocol) {
+			self = .onLedgerEntity(.init(address: address))
+		}
+
 		public enum OnLedgerEntity: Hashable {
-			case account(Address)
-			case resource(Address)
-			case resourcePool(Address)
-			case validator(Address)
-			case genericComponent(Address)
+			case address(Address)
+
+			public init(address: some AddressProtocol) {
+				self = .address(address.embed())
+			}
+
 			case nonFungibleData(NonFungibleGlobalId)
-			case nonFungibleIdPage(accountAddress: Address, resourceAddress: Address, pageCursor: String?)
+			case nonFungibleIdPage(
+				accountAddress: AccountAddress,
+				resourceAddress: ResourceAddress,
+				pageCursor: String?
+			)
+
+			var filesystemFilePath: String {
+				switch self {
+				case let .address(address):
+					return address.filesystemFilePath(folderPath: filesystemFolderPath)
+				case let .nonFungibleData(nonFungibleGlobalId):
+					return "\(filesystemFolderPath)/\(nonFungibleGlobalId.description)"
+				case let .nonFungibleIdPage(_, resourceAddress, pageCursor):
+					let file = "nonFungibleIds-" + resourceAddress.address + (pageCursor.map { "-\($0)" } ?? "")
+					return "\(filesystemFolderPath)/\(file)"
+				}
+			}
+
+			var filesystemFolderPath: String {
+				let folderRoot = "OnLedgerEntity"
+				switch self {
+				case let .address(address):
+					return address.filesystemFolderPath(rootName: folderRoot)
+				case .nonFungibleData:
+					return "\(folderRoot)/nonFungiblesData"
+				case let .nonFungibleIdPage(accountAddress, _, _):
+					return "\(folderRoot)/accounts/\(accountAddress.address)"
+				}
+			}
 		}
 
 		case onLedgerEntity(OnLedgerEntity)
@@ -92,70 +161,38 @@ extension CacheClient {
 		var filesystemFilePath: String {
 			switch self {
 			case let .onLedgerEntity(entity):
-				switch entity {
-				case .account:
-					return "\(filesystemFolderPath)/details"
-				case let .resource(resourceAddress):
-					return "\(filesystemFolderPath)/\(resourceAddress.address)"
-				case let .resourcePool(resourcePoolAddress):
-					return "\(filesystemFolderPath)/\(resourcePoolAddress.address)"
-				case let .validator(validatorAddress):
-					return "\(filesystemFolderPath)/\(validatorAddress.address)"
-				case let .genericComponent(componentAddress):
-					return "\(filesystemFolderPath)/\(componentAddress.address)"
-				case let .nonFungibleData(nonFungibleGlobalId):
-					return "\(filesystemFolderPath)/\(nonFungibleGlobalId.asStr())"
-				case let .nonFungibleIdPage(_, resourceAddress, pageCursor):
-					let file = "nonFungibleIds-" + resourceAddress.address + (pageCursor.map { "-\($0)" } ?? "")
-					return "\(filesystemFolderPath)/\(file)"
-				}
+				entity.filesystemFilePath
 			case let .networkName(url):
-				return "\(filesystemFolderPath)/networkName-\(url)"
+				"\(filesystemFolderPath)/networkName-\(url)"
 			case let .dAppRequestMetadata(definitionAddress):
-				return "\(filesystemFolderPath)/DappRequestMetadata-\(definitionAddress)"
+				"\(filesystemFolderPath)/DappRequestMetadata-\(definitionAddress)"
 			case let .rolaDappVerificationMetadata(definitionAddress):
-				return "\(filesystemFolderPath)/RolaDappVerificationMetadata-\(definitionAddress)"
+				"\(filesystemFolderPath)/RolaDappVerificationMetadata-\(definitionAddress)"
 			case let .rolaWellKnownFileVerification(url):
-				return "\(filesystemFolderPath)/RolaWellKnownFileVerification-\(url)"
+				"\(filesystemFolderPath)/RolaWellKnownFileVerification-\(url)"
 			case let .tokenPrices(currency):
-				return "\(filesystemFolderPath)/prices-\(currency.rawValue)"
+				"\(filesystemFolderPath)/prices-\(currency.rawValue)"
 			case let .dateOfFirstTransaction(address):
-				return "\(filesystemFolderPath)/account-\(address.address)"
+				"\(filesystemFolderPath)/account-\(address.address)"
 			}
 		}
 
 		var filesystemFolderPath: String {
 			switch self {
 			case let .onLedgerEntity(entity):
-				let folderRoot = "OnLedgerEntity"
-				switch entity {
-				case let .account(accountAddress):
-					return "\(folderRoot)/accounts/\(accountAddress.address)"
-				case .resource:
-					return "\(folderRoot)/resources"
-				case .resourcePool:
-					return "\(folderRoot)/resourcePools"
-				case .validator:
-					return "\(folderRoot)/validators"
-				case .genericComponent:
-					return "\(folderRoot)/genericComponents"
-				case .nonFungibleData:
-					return "\(folderRoot)/nonFungiblesData"
-				case let .nonFungibleIdPage(accountAddress, _, _):
-					return "\(folderRoot)/accounts/\(accountAddress.address)"
-				}
+				entity.filesystemFolderPath
 			case .networkName:
-				return "NetworkName"
+				"NetworkName"
 			case .dAppRequestMetadata:
-				return "DappRequestMetadata"
+				"DappRequestMetadata"
 			case .rolaDappVerificationMetadata:
-				return "RolaDappVerificationMetadata"
+				"RolaDappVerificationMetadata"
 			case .rolaWellKnownFileVerification:
-				return "RolaWellKnownFileVerification"
+				"RolaWellKnownFileVerification"
 			case .tokenPrices:
-				return "TokenPrices"
+				"TokenPrices"
 			case .dateOfFirstTransaction:
-				return "DateOfFirstTransaction"
+				"DateOfFirstTransaction"
 			}
 		}
 

RadixWallet/Clients/DeviceFactorSourceClient/DeviceFactorSourceClient+Interface.swift

@@ -123,7 +123,7 @@ struct IncorrectSignatureCountExpectedExactlyOne: Swift.Error {}
 extension DeviceFactorSourceClient {
 	public func signUsingDeviceFactorSource(
 		signerEntity: EntityPotentiallyVirtual,
-		hashedDataToSign: some DataProtocol,
+		hashedDataToSign: Data,
 		purpose: SigningPurpose
 	) async throws -> SignatureOfEntity {
 		@Dependency(\.factorSourcesClient) var factorSourcesClient