Upgrade engine toolkit to 1.0.0

App/BabylonWallet.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -239,8 +239,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/radixdlt/swift-engine-toolkit",
       "state" : {
-        "revision" : "4ded56afc8a8a55ffeadbdce16dbb5789ab4d664",
-        "version" : "0.12.1-293dd4c"
+        "branch" : "add_final_classes",
+        "revision" : "7a26ed178eaf0cb842276e1b6aa8d7a4b614713c"
       }
     },
     {

Package.swift

@@ -1035,7 +1035,7 @@ package.addModules([
 		dependencies: [
 			"Cryptography",
 			.product(name: "EngineToolkit", package: "swift-engine-toolkit") {
-				.package(url: "https://github.com/radixdlt/swift-engine-toolkit", exact: "0.12.1-293dd4c")
+				.package(url: "https://github.com/radixdlt/swift-engine-toolkit", branch: "add_final_classes")
 			},
 		],
 		tests: .no

Sources/Core/SharedModels/Assets/AccountPortfolio.swift

@@ -342,41 +342,3 @@ extension [AccountPortfolio.NonFungibleResource.NonFungibleToken.NFTData] {
 		self[.claimAmount]?.decimal
 	}
 }
-
-extension AccountPortfolio.NonFungibleResource.NonFungibleToken {
-	enum CodingKeys: CodingKey {
-		case id
-		case name
-		case description
-		case keyImageURL
-		case metadata
-		case stakeClaimAmount
-		case claimEpoch
-		case canBeClaimed
-	}
-
-	public init(from decoder: Decoder) throws {
-		let container = try decoder.container(keyedBy: CodingKeys.self)
-
-		try self.init(
-			id: .init(nonFungibleGlobalId: container.decode(String.self, forKey: .id)),
-			name: container.decodeIfPresent(String.self, forKey: .name),
-			description: container.decodeIfPresent(String.self, forKey: .description),
-			keyImageURL: container.decodeIfPresent(URL.self, forKey: .keyImageURL),
-			metadata: container.decode([AccountPortfolio.Metadata].self, forKey: .metadata),
-			stakeClaimAmount: container.decodeIfPresent(BigDecimal.self, forKey: .stakeClaimAmount),
-			canBeClaimed: container.decode(Bool.self, forKey: .canBeClaimed)
-		)
-	}
-
-	public func encode(to encoder: Encoder) throws {
-		var container = encoder.container(keyedBy: CodingKeys.self)
-		try container.encode(id.asStr(), forKey: .id)
-		try container.encodeIfPresent(name, forKey: .name)
-		try container.encodeIfPresent(description, forKey: .description)
-		try container.encodeIfPresent(keyImageURL, forKey: .keyImageURL)
-		try container.encode(metadata, forKey: .metadata)
-		try container.encodeIfPresent(stakeClaimAmount, forKey: .stakeClaimAmount)
-		try container.encode(canBeClaimed, forKey: .canBeClaimed)
-	}
-}

Sources/EngineKit/Codable/NonFungibleGlobalID+Codable.swift

@@ -0,0 +1,15 @@
+import EngineToolkit
+import Foundation
+
+extension NonFungibleGlobalId: Codable {
+	public func encode(to encoder: Encoder) throws {
+		var container = encoder.singleValueContainer()
+		try container.encode(asStr())
+	}
+
+	public convenience init(from decoder: Decoder) throws {
+		let container = try decoder.singleValueContainer()
+		let raw = try container.decode(String.self)
+		try self.init(nonFungibleGlobalId: raw)
+	}
+}

Sources/EngineKit/HashableExtensions.swift

@@ -425,8 +425,8 @@ extension EngineToolkit.Address: Hashable {
 // MARK: - TransactionIntent + Hashable
 extension TransactionIntent: Hashable {
 	public static func == (lhs: EngineToolkit.Intent, rhs: EngineToolkit.Intent) -> Bool {
-		lhs.header() == rhs.header() &&
-			lhs.manifest() == rhs.manifest()
+		lhs.header() == rhs.header()
+			&& lhs.manifest() == rhs.manifest()
 	}
 
 	public func hash(into hasher: inout Hasher) {
@@ -438,10 +438,10 @@ extension TransactionIntent: Hashable {
 // MARK: - ExecutionAnalysis + Hashable
 extension ExecutionAnalysis: Hashable {
 	public static func == (lhs: ExecutionAnalysis, rhs: ExecutionAnalysis) -> Bool {
-		lhs.feeLocks == rhs.feeLocks &&
-			lhs.feeSummary == rhs.feeSummary &&
-			lhs.transactionTypes == rhs.transactionTypes &&
-			lhs.reservedInstructions == rhs.reservedInstructions
+		lhs.feeLocks == rhs.feeLocks
+			&& lhs.feeSummary == rhs.feeSummary
+			&& lhs.transactionTypes == rhs.transactionTypes
+			&& lhs.reservedInstructions == rhs.reservedInstructions
 	}
 
 	public func hash(into hasher: inout Hasher) {
@@ -467,17 +467,17 @@ extension FeeLocks: Hashable {
 // MARK: - FeeSummary + Hashable
 extension FeeSummary: Hashable {
 	public static func == (lhs: FeeSummary, rhs: FeeSummary) -> Bool {
-		lhs.executionCost == rhs.executionCost &&
-			lhs.finalizationCost == rhs.finalizationCost &&
-			lhs.royaltyCost == rhs.royaltyCost &&
-			lhs.storageExpansionCost == rhs.storageExpansionCost
+		lhs.executionCost == rhs.executionCost
+			&& lhs.finalizationCost == rhs.finalizationCost
+			&& lhs.royaltyCost == rhs.royaltyCost
+			&& lhs.storageExpansionCost == rhs.storageExpansionCost
 	}
 
 	public func hash(into hasher: inout Hasher) {
-		hasher.combine(self.executionCost)
-		hasher.combine(self.finalizationCost)
-		hasher.combine(self.royaltyCost)
-		hasher.combine(self.storageExpansionCost)
+		hasher.combine(executionCost)
+		hasher.combine(finalizationCost)
+		hasher.combine(royaltyCost)
+		hasher.combine(storageExpansionCost)
 	}
 }
 
@@ -559,6 +559,15 @@ extension TransactionType: Hashable {
 			hasher.combine(resourcePreferenceChanges)
 			hasher.combine(defaultDepositRuleChanges)
 			hasher.combine(authorizedDepositorsChanges)
+		case let .stakeTransaction(stakes: stakes):
+			hasher.combine("stakeTransaction")
+			hasher.combine(stakes)
+		case let .unstakeTransaction(unstakes: unstakes):
+			hasher.combine("unstakeTransaction")
+			hasher.combine(unstakes)
+		case let .claimStakeTransaction(claims: claims):
+			hasher.combine("claimStakeTransaction")
+			hasher.combine(claims)
 		}
 	}
 }
@@ -665,6 +674,82 @@ extension DecimalSource: Hashable {
 	}
 }
 
+// MARK: - StakeInformation + Hashable
+extension StakeInformation: Hashable {
+	public static func == (lhs: StakeInformation, rhs: StakeInformation) -> Bool {
+		lhs.fromAccount == rhs.fromAccount
+			&& lhs.validatorAddress == rhs.validatorAddress
+			&& lhs.stakeUnitResource == rhs.stakeUnitResource
+			&& lhs.stakeUnitAmount == rhs.stakeUnitAmount
+			&& lhs.stakedXrd == rhs.stakedXrd
+	}
+
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(fromAccount)
+		hasher.combine(validatorAddress)
+		hasher.combine(stakeUnitResource)
+		hasher.combine(stakeUnitAmount)
+		hasher.combine(stakedXrd)
+	}
+}
+
+// MARK: - UnstakeInformation + Hashable
+extension UnstakeInformation: Hashable {
+	public static func == (lhs: UnstakeInformation, rhs: UnstakeInformation) -> Bool {
+		lhs.fromAccount == rhs.fromAccount
+			&& lhs.stakeUnitAddress == rhs.stakeUnitAddress
+			&& lhs.stakeUnitAmount == rhs.stakeUnitAmount
+			&& lhs.validatorAddress == rhs.validatorAddress
+			&& lhs.claimNftResource == rhs.claimNftResource
+			&& lhs.claimNftLocalId == rhs.claimNftLocalId
+			&& lhs.claimNftData == rhs.claimNftData
+	}
+
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(fromAccount)
+		hasher.combine(stakeUnitAddress)
+		hasher.combine(stakeUnitAmount)
+		hasher.combine(validatorAddress)
+		hasher.combine(claimNftResource)
+		hasher.combine(claimNftLocalId)
+		hasher.combine(claimNftData)
+	}
+}
+
+// MARK: - UnstakeData + Hashable
+extension UnstakeData: Hashable {
+	public static func == (lhs: UnstakeData, rhs: UnstakeData) -> Bool {
+		lhs.name == rhs.name
+			&& lhs.claimEpoch == rhs.claimEpoch
+			&& lhs.claimAmount == rhs.claimAmount
+	}
+
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(name)
+		hasher.combine(claimEpoch)
+		hasher.combine(claimAmount)
+	}
+}
+
+// MARK: - ClaimStakeInformation + Hashable
+extension ClaimStakeInformation: Hashable {
+	public static func == (lhs: ClaimStakeInformation, rhs: ClaimStakeInformation) -> Bool {
+		lhs.fromAccount == rhs.fromAccount
+			&& lhs.validatorAddress == rhs.validatorAddress
+			&& lhs.claimNftResource == rhs.claimNftResource
+			&& lhs.claimNftLocalIds == rhs.claimNftLocalIds
+			&& lhs.claimedXrd == rhs.claimedXrd
+	}
+
+	public func hash(into hasher: inout Hasher) {
+		hasher.combine(fromAccount)
+		hasher.combine(validatorAddress)
+		hasher.combine(claimNftResource)
+		hasher.combine(claimNftLocalIds)
+		hasher.combine(claimedXrd)
+	}
+}
+
 // MARK: - MetadataValue + Hashable
 extension MetadataValue: Hashable {
 	public static func == (lhs: MetadataValue, rhs: MetadataValue) -> Bool {

Sources/EngineKit/ReviewedTransaction.swift

@@ -184,6 +184,8 @@ extension TransactionType {
 					authorizedDepositorsChanges: authorizedDepositorsChanges.mapKeys(AccountAddress.init(validatingAddress:))
 				)
 			))
+		case .stakeTransaction, .unstakeTransaction, .claimStakeTransaction:
+			return .nonConforming
 		}
 	}
 }