Synapse SAP SDK v0.4.2: Full SAP Transaction Decoding from Raw RPC Data
v0.4.2 introduces a new parsing layer that turns raw RPC data into fully structured SAP transactions, including instructions, CPI calls, and events, in a single step.
If you’ve ever worked with raw Solana RPC data, you know how messy it gets.
A single transaction can include multiple instructions, inner CPI calls, logs, and events. Understanding what actually happened often means writing your own parsing logic on top of everything.
With v0.4.2, we wanted to remove that friction.
This release introduces a new parsing layer that lets you take raw transaction data and turn it into something you can actually work with.
What Changed
Instead of dealing with fragmented data, you can now reconstruct a full SAP transaction in one go.
Instructions, accounts, inner CPI calls, events — all decoded into structured output.
No stitching together multiple tools, no guessing from logs.
One Call, Full Context
At the center of this release is: parseSapTransactionComplete
It does what the name suggests. You pass in the transaction data and get back the full picture:
- decoded instructions with arguments
- resolved accounts
- reconstructed inner instructions
- extracted protocol events
Everything in one place, ready to use.
Built for Real Workloads
Most of the time, you’re not parsing one transaction, you’re parsing thousands.
That’s why this release also adds: parseSapTransactionBatch
So you can process pages of transactions cleanly inside indexers, workers, or ingestion pipelines without building extra layers around it.
Seeing What Actually Happened
A lot of important logic happens inside CPI calls, but they’re usually hard to follow.
With: decodeInnerInstructions
you can now reconstruct those inner calls with full account context. This makes it much easier to understand how a transaction actually executed, not just what was called at the top level.
Works With What You Already Have
Not every system works with the same input format, so the parser doesn’t force one approach.
You can use it depending on what you already have:
- Full transaction response → parseSapInstructionsFromTransaction
- Instruction list → parseSapInstructionsFromList
- Full decode (everything included) → parseSapTransactionComplete
No need to reshape your pipeline just to use it.
Handles Modern Solana Transactions
v0.4.2 supports:
- Legacy transactions
- Versioned (v0) transactions
- Address lookup tables
So it works with the way transactions are actually being built today.
Events, Without Extra Work
Events are extracted directly from logs and returned alongside instructions.
No separate parsing step, no additional tooling.
Runs Anywhere
The parser is completely stateless.
No RPC calls, no hidden dependencies. You pass the data and the Anchor coder, and it just works.
That makes it easy to run in:
- backend services
- cron jobs
- indexers
- offline processing pipelines
Access Through the Client
If you’re already using the SDK client, the parser is available via:
client.parser
So you can use it in a more structured way without changing how you interact with the SDK.
Subpath Import
You can also import only the parser:
@oobe-protocol-labs/synapse-sap-sdk/parser
Keeps things lightweight if you only need decoding.
Why This Matters
If you’re building anything on top of SAP, understanding transactions is not optional.
Until now, that meant extra work.
With v0.4.2, that layer is handled for you.
You get clean, structured data out of raw transactions, ready to plug into indexers, analytics, or agent systems.
Synapse SAP SDK: https://github.com/OOBE-PROTOCOL/synapse-sap-sdk
Update Released by Steve - Blog created by Solking