Add decompile TransactionMessage (MessageV0 only)

Author: maxim-v-ideasoft

Sources/SolanaSwift/Models/Message/IMessage.swift

@@ -4,8 +4,8 @@ public protocol IMessage {
     var version: TransactionVersion { get }
     var header: MessageHeader { get }
     var recentBlockhash: String { get }
+    var staticAccountKeys: [PublicKey] { get }
 
     func serialize() throws -> Data
-
-    var staticAccountKeys: [PublicKey] { get }
+    func getAccountKeys(addressLookupTableAccounts: [AddressLookupTableAccount]) throws -> MessageAccountKeys
 }

Sources/SolanaSwift/Models/Message/LegacyMessage.swift

@@ -60,6 +60,10 @@ public struct Message: IMessage, Equatable {
 
         return data
     }
+    
+    public func getAccountKeys(addressLookupTableAccounts: [AddressLookupTableAccount]) throws -> MessageAccountKeys {
+        .init(staticAccountKeys: staticAccountKeys)
+    }
 
     static func from(data: Data) throws -> Message {
         var data = data

Sources/SolanaSwift/Models/Message/VersionedMessage.swift

@@ -24,6 +24,28 @@ public enum VersionedMessage: Equatable {
         case let .v0(message): return message
         }
     }
+    
+    public var header: MessageHeader {
+        value.header
+    }
+    
+    public var compiledInstructions: [MessageCompiledInstruction] {
+        switch self {
+        case .legacy:
+            // need update
+            return []
+        case .v0(let value):
+            return value.compiledInstructions
+        }
+    }
+    
+    public var staticAccountKeys: [PublicKey] {
+        value.staticAccountKeys
+    }
+    
+    public var recentBlockhash: BlockHash {
+        value.recentBlockhash
+    }
 
     public mutating func setRecentBlockHash(_ blockHash: BlockHash) {
         switch self {
@@ -35,4 +57,8 @@ public enum VersionedMessage: Equatable {
             self = .v0(messageV0)
         }
     }
+    
+    public func getAccountKeys(addressLookupTableAccounts: [AddressLookupTableAccount]) throws -> MessageAccountKeys {
+        try value.getAccountKeys(addressLookupTableAccounts: addressLookupTableAccounts)
+    }
 }

Sources/SolanaSwift/Models/Transaction/TransactionMessage.swift

@@ -1,18 +1,74 @@
 import Foundation
 
 public struct TransactionMessage {
-    var instructions: [TransactionInstruction]
-    var recentBlockhash: String
-    var payerKey: PublicKey
+    public var instructions: [TransactionInstruction]
+    public var recentBlockhash: String
+    public var payerKey: PublicKey
 
     public init(instructions: [TransactionInstruction], recentBlockhash: String, payerKey: PublicKey) {
         self.instructions = instructions
         self.recentBlockhash = recentBlockhash
         self.payerKey = payerKey
     }
 
-    // TODO: implement
-    // static func decompile() {}
+    public static func decompile(message: VersionedMessage, addressLookupTableAccounts: [AddressLookupTableAccount]) throws -> Self {
+        let header = message.header
+        let compiledInstructions = message.compiledInstructions
+        let recentBlockhash = message.recentBlockhash
+        
+        let numRequiredSignatures = header.numRequiredSignatures
+        let numReadonlySignedAccounts = header.numReadonlySignedAccounts
+        let numReadonlyUnsignedAccounts = header.numReadonlyUnsignedAccounts
+        
+        let numWritableSignedAccounts = numRequiredSignatures - numReadonlySignedAccounts
+        guard numWritableSignedAccounts > 0 else {
+            throw TransactionMessageError.invalidHeader
+        }
+        
+        let numWritableUnsignedAccounts = message.staticAccountKeys.count - numRequiredSignatures - numReadonlyUnsignedAccounts
+        guard numWritableUnsignedAccounts >= 0 else {
+            throw TransactionMessageError.invalidHeader
+        }
+        
+        guard let accountKeys = try? message.getAccountKeys(addressLookupTableAccounts: addressLookupTableAccounts) else {
+            throw TransactionMessageError.noAccountKeys
+        }
+        
+        guard let payerKey = accountKeys[0] else {
+            throw TransactionMessageError.noPayerKey
+        }
+        
+        var instructions: [TransactionInstruction] = []
+        for compiledIx in compiledInstructions {
+            var keys: [AccountMeta] = []
+            for keyIndex in compiledIx.accountKeyIndexes {
+                guard let pubkey = accountKeys[Int(keyIndex)] else {
+                    throw TransactionMessageError.keyNotFound
+                }
+                
+                let isSigner = keyIndex < numRequiredSignatures
+                let isWritable: Bool
+                if isSigner {
+                    isWritable = keyIndex < numWritableSignedAccounts
+                } else if keyIndex < accountKeys.staticAccountKeys.count {
+                    isWritable = Int(keyIndex) - numRequiredSignatures < numWritableUnsignedAccounts
+                } else {
+                    let writableCount = accountKeys.accountKeysFromLookups!.writable.count
+                    isWritable = Int(keyIndex) - accountKeys.staticAccountKeys.count < writableCount
+                }
+                
+                keys.append(AccountMeta(publicKey: pubkey, isSigner: isSigner, isWritable: isWritable))
+            }
+            
+            guard let programId = accountKeys[Int(compiledIx.programIdIndex)] else {
+                throw TransactionMessageError.programIdNotFound
+            }
+            
+            instructions.append(TransactionInstruction(keys: keys, programId: programId, data: compiledIx.data))
+        }
+        
+        return TransactionMessage(instructions: instructions, recentBlockhash: recentBlockhash, payerKey: payerKey)
+    }
 
     public func compileToLegacyMessage() throws -> Message {
         try Transaction(
@@ -34,3 +90,11 @@ public struct TransactionMessage {
         )
     }
 }
+
+public enum TransactionMessageError: Error, Equatable {
+    case invalidHeader
+    case noAccountKeys
+    case noPayerKey
+    case keyNotFound
+    case programIdNotFound
+}