Open-Sourcing the Solana Transaction Decoder

Parsing Solana transaction data is crucial for building a powerful tool for projects and developers.

Solana transaction parsing is the process of analyzing and interpreting the data contained within a Solana transaction. This process is crucial for understanding the flow of funds, identifying potential security vulnerabilities, and optimizing transaction efficiency. By delving into the intricacies of Solana transactions, developers can gain valuable insights into how transactions are structured and executed on the blockchain.

At its core, transaction parsing involves breaking down the transaction data into its fundamental components, allowing for a detailed examination of each element. This not only helps in debugging and development but also plays a vital role in ensuring the security and reliability of transactions. In this section, we will explore the various aspects of Solana transaction parsing, shedding light on its importance and practical applications.

Building a powerful tool for projects and developers

At deBridge, we've been building for Solana for almost a year now and developed a set of internal development tools that we plan to gradually open-source to all Solana builders. Today, we're thrilled to open-source the first Transaction Parser for Solana, giving developers a tool to easily read and decode transactions into a human-friendly format. You can find the Parser on GitHub here.

Solana transactions are defined through ABI, a program interface that determines the transaction structure, including the sequence of arguments and the way a transaction is encoded. Before being sent to the blockchain, transactions are serialized and packed as binary instructions data, which is difficult to read.

In the past, to restore the arguments of any instruction out of the instruction data, developers needed to manually write the code or carefully decode it.

Instruction data parsing is needed to debug transactions, read on-chain data, create analytics, cross-chain interactions, and much more. We have developed a framework that enables the decoding of arbitrary Solana instructions based on Interface Definition Language (IDL) or using a custom parsing scheme.

With our newly open-sourced Solana Transaction Parser, every developer has now the ability to inspect the contents of a serialized message for debugging and development in the Solana ecosystem. Let's dive into the details and explain how to get started.

Intro to Anchor

The Anchor project implements all the low-level components you need to parse transactions (instructions processor, arguments serialization, etc) but all the programs written with Anchor consume more computation resources than a program written without this framework. Furthermore, Anchor makes interaction with on-chain programs easy since low-level instructions preparations are performed by Anchor typescript client using IDL. IDL is a file generated during contract compilation that contains a list of instructions with needed args (including their types) and accounts, similar to EVM ABI.

Transaction Structure and Components

A Solana transaction consists of several key components, each playing a critical role in the execution of the transaction. Understanding these components is essential for effective parsing and analysis. Let’s break down the main elements:

• Transaction Message: This is the core of the transaction, containing the instructions and data necessary for execution. It specifies what actions need to be performed and which accounts are involved.
• Transaction Format: This refers to the specific structure and encoding of the transaction data. It defines how the transaction is serialized and packed, ensuring that it can be correctly interpreted by the Solana network.
• Transaction Size: This is the total size of the transaction, including all instructions and data. The size of a transaction can impact its processing time and fees, making it an important factor to consider.

By understanding the transaction structure and components, developers can effectively parse and analyze Solana transactions, gaining insights into their execution and potential areas for optimization.

Parsing instructions using IDL

Typescript SDK allows us to easily serialize/deserialize instructions using IDL, but we need to perform some common steps such as: initialize instruction coder, try to decode instruction, check if decoding succeeds, prepare list of decoded accounts and set correct types. These are clearly tasks that should be automated.

This is exactly what we’ve built for you at deBridge! Now, you can easily initialize the parser using IDL and program ID. Let’s dive into how it works step-by-step:

Printing parsed will emit something like this:

CPI and Transaction Execution

Cross-Program Invocation (CPI) is a powerful feature in the Solana ecosystem that allows a proxy contract to take some arguments, modify them, and call another contract with the provided args. This capability is crucial for transaction execution, as it enables seamless interaction between different programs and contracts on the Solana blockchain.

When parsing transactions, it is essential to consider CPI and its role in transaction execution. This involves analyzing the transaction data to identify CPI calls, understanding the arguments and modifications made, and tracing the flow of execution between contracts. By doing so, developers can gain a comprehensive understanding of how transactions are processed and ensure that all interactions are correctly validated and executed.

CPI

What if we want to use a proxy contract that will take some arguments, modify them, and call another contract with provided args using Cross Program Invocation (CPI)?

We can extract args passed to the proxy contract from the transaction dump but we need transaction processing results to get CPI data. Let’s set the parse CPI flag to true and check what’s going on during a Jupiter swap.

9W959DqEETiGZocYWCQPaJ6sBmUzgfxXfqGeTEdp3aQP is an Orca (Whirlpool) address, so this instruction looks like “Orca Swap”. Let's try to reverse-engineer this instruction and write a custom parser. The data structure looks like [instruction id (u8), value 1 (u64 little endian), value 2 (u64 little endian)], and accounts are similar to the Jupiter variant. The custom parser looks like this:

Let’s add a custom parser and try to parse the same transaction.

The Parse result looks much better.

Now it looks like an explorer variant but is available from the code:

Logs

Solana allows you to emit logs during execution. You may want to process these logs after transaction finalization for monitoring purposes. Let’s assume that we need to extract all logs emitted by Cykura’s SwapCallback. We just extract the transaction from the chain and then call a function called parseLogs which emits logs with its context.

Filtering logs by programId and log messages is simple:

And it emits everything we need during the process!

Comprehensive and human-friendly tooling can be a real growth catalyst for any blockchain ecosystem, giving developers a way to navigate ever-changing architectures. By building and open-sourcing the Solana Transaction Parser, we’re thrilled to be able to start contributing to Solana’s tooling stack, and hopefully, give developers and projects a useful new tool in their arsenal!

Example Use Case: Simple SOL Transfer

A simple SOL transfer is a fundamental example of a Solana transaction. In this scenario, a user initiates a transaction to transfer a certain amount of SOL from their account to another account. Let’s break down the components involved in parsing this transaction:

• Transaction Message: This would contain the instruction to transfer SOL, including the sender and recipient accounts, and the amount of SOL being transferred. It specifies the action to be performed and the parties involved.
• Transaction Format: This would specify the encoding and structure of the transaction data. It ensures that the transaction is correctly serialized and can be interpreted by the Solana network.
• Transaction Size: This would be the total size of the transaction, including all instructions and data. The size can impact the transaction’s processing time and fees.

By parsing this transaction, we can gain insights into the flow of funds, identify potential security vulnerabilities, and optimize transaction efficiency. This practical example highlights the importance of understanding transaction data and its implications.

Security Considerations

Solana transaction parsing raises several security considerations that developers must address to ensure secure and reliable parsing and analysis. Key considerations include:

• Data Integrity: Ensuring the accuracy and integrity of the transaction data is crucial for secure parsing. Any discrepancies or tampering with the data can lead to incorrect interpretations and potential vulnerabilities.
• Data Confidentiality: Protecting sensitive information, such as account balances and transaction data, is essential for maintaining confidentiality. Developers must implement measures to safeguard this information during the parsing process.
• CPI Security: Understanding the security implications of CPI calls and ensuring that they are properly validated and executed is critical for secure transaction execution. Developers must be vigilant in verifying the authenticity and correctness of CPI interactions.

By considering these security aspects, developers and analysts can ensure that their Solana transaction parsing solutions are secure, reliable, and efficient, ultimately contributing to the robustness of the Solana ecosystem.

Website | deSwap | Docs | Discord | GitHub | Twitter | Telegram