Menu

AI Generator

AI Image Generator AI Icon Generator AI TTS Generator

Browse All Tools

Web3 & Blockchain

Ethereum Address Checksum Crypto Unit Converter BIP39 Mnemonic Generator Multi-chain Address Validator Wallet Address Format Converter Wei / Gwei / Ether Converter ABI Decoder & Encoder Function Selector Lookup Calldata Decoder Solana Lamports Converter Solana Address Validator Bech32 Address Converter Cosmos IBC Denom Parser EIP-712 Typed Data Builder Event Log Decoder Anchor IDL Decoder CosmWasm Schema Validator NFT Metadata Builder Token Decimals Calculator Merkle Tree Generator

JSON

JSON Formatter JSON Diff JSON Flattener JSON to TypeScript JSON to CSV JSON to YAML JSON to XML JSON to SQL JSON to Markdown JSON to JSON Schema JSON to Python JSON to Go JSON to Java JSON to C#

CSV

CSV to JSON CSV Converter CSV Formatter CSV Validator CSV Diff CSV to HTML Table

YAML

YAML to JSON YAML Formatter YAML Validator YAML Diff YAML to TypeScript YAML to .env YAML Converter Kubernetes Validator Docker Compose Validator

XML

XML to JSON XML Validator XML Converter XML Formatter XML Diff XPath Tester

Development

Regex Tester cURL to Code SQL Formatter Markdown Preview Markdown to HTML HTML to Markdown CSS Minifier HTML Minifier JavaScript Minifier Code Diff Viewer JSON Schema Validator Chmod Calculator Number Base Converter Mock Data Generator

Crypto & Security

Hash Generator HMAC Generator Checksum Calculator Bcrypt Hash AES Encrypt / Decrypt TOTP Generator RSA Key Pair Generator Ed25519 Key Generator

Encode/Decode

Base64 Encoder & Decoder URL Encoder & Decoder Base64 Encoder Base64 Decoder URL Encoder URL Decoder

Converters

Color Converter Timestamp Converter HEX to RGB Converter Color Palette Generator PX / REM / EM Converter Aspect Ratio Calculator DPI / PPI Calculator

Web & SEO

JWT Decoder URL Parser HTML Entity Escape Slug Generator Meta Tag Generator Schema Markup Generator CSS Box-shadow Generator

Image & Media

Image to Base64 Base64 to Image Image Compressor Image Resizer Image Format Converter Favicon Generator SVG Optimizer Image Color Picker Placeholder Image Generator Image EXIF Viewer

Network & API

Subnet Calculator IP Address Lookup HTTP Header Parser User Agent Parser JSONPath Tester

Generators

QR Code Generator Password Generator UUID Generator Random Number Generator

Text

Case Converter Word Counter Lorem Ipsum Generator Markdown Table Generator

Utilities

Crontab Generator Time Zone Converter HTTP Status Codes Text Statistics Docker Run to Compose

Blog About FAQ Contact

Privacy Policy Terms of Service Cookie Settings

Loading...

Please wait while we prepare your tools

</>

BeautiCode

Free developer tools. Client-side processing. Your data never leaves your browser.

Tools

JSON Tools
CSV Tools
All Tools

Resources

Blog
About
FAQ
Contact

Legal

Privacy Policy
Terms of Service
Cookie Settings

© 2025 BeautiCodeYour data never leaves your browser

Anchor IDL Decoder

Paste a Solana Anchor IDL JSON and inspect instructions, accounts, types, errors, and PDA seeds interactively.

Anchor IDL (JSON)

Introduction

Anchor programs on Solana publish an IDL — a JSON description of every instruction, account layout, custom type, and error code. Reading a raw IDL in a text editor is tedious: nested enums, account metadata, and PDA seeds quickly sprawl across hundreds of lines. This decoder parses the IDL and presents each section behind a collapsible summary so you can drill into exactly what you need.

The tool is schema-only. It does not fetch live account data or call an RPC — it renders whatever IDL you paste. A built-in sample escrow IDL is included so you can explore the UI without a Solana dev setup.

How to Use

Paste the contents of target/idl/<program>.json into the editor, or click Sample.
Click Decode. A summary card shows instruction, account, type, and error counts.
Expand an instruction to see its account list (with signer/mut flags and PDA seeds) and argument types.
Expand an account or type to see its struct fields or enum variants.

Examples

Example 1: Instruction with PDA seeds

Input

"initialize": {
  "accounts": [{
    "name": "escrow",
    "pda": { "seeds": [
      { "kind": "const",
        "value": "escrow" },
      { "kind": "account",
        "path": "initializer" }
    ]}
  }],
  "args": [
    { "name": "amount", "type": "u64" }
  ]
}

Output

initialize
  Accounts:
    escrow [mut]
      seeds:
        const: "escrow"
        account → initializer
  Args:
    amount : u64

Example 2: Account struct with mixed types

Input

"Escrow": {
  "type": {
    "kind": "struct",
    "fields": [
      { "name": "owner",
        "type": "publicKey" },
      { "name": "amount",
        "type": "u64" },
      { "name": "note",
        "type": { "option": "string" } }
    ]
  }
}

Output

Escrow  struct
  owner  : publicKey
  amount : u64
  note   : Option<string>

Example 3: Enum type

Input

"Status": {
  "type": {
    "kind": "enum",
    "variants": [
      { "name": "Open" },
      { "name": "Cancelled" },
      { "name": "Completed" }
    ]
  }
}

Output

Status  enum
  Open
  Cancelled
  Completed

Deep Dive into the Anchor Framework

Discriminators and account constraints

Anchor prepends an 8-byte discriminator to every account and every instruction payload. For accounts, the discriminator is the first 8 bytes of sha256("account:<AccountName>"); for instructions, it is the first 8 bytes of sha256("global:<instruction_name>"). The runtime uses the discriminator to reject mis-typed data before deserialisation, which makes Anchor accounts resilient against someone passing a structurally similar account of a different type. Account constraints declared with #[account(...)] (seeds, bump, mut, has_one, close) run during every instruction entry.

PDA seeds and Cross-Program Invocation

PDA seeds in an IDL carry three kinds: const for literal bytes, arg for values drawn from the instruction's arguments, and accountfor another account's public key bytes. Reproducing a PDA off-chain requires feeding the correct seed array and program ID into findProgramAddress. Cross-Program Invocation (CPI) lets one program call another's instruction while preserving the outer signer set via invoke_signed, and the IDL records which accounts are expected on the inner call.

Error code conventions

Anchor emits errors as Custom(n) codes where n starts at 6000 for user errors and leaves lower numbers for framework-level failures (constraint violations, missing accounts, discriminator mismatches). The error array in the IDL maps each custom code to a name and human message, so pasting the IDL here turns a raw Custom(6007) RPC response into a readable explanation.

Real-world Integration

Integrating a third-party Solana contract typically starts by downloading its IDL JSON from target/idl/ or from an on-chain IDL account. Paste the file here to see the full instruction surface without opening a terminal. The decoder surfaces the discriminator bytes, PDA seed structure, and error table in one view, which makes it easier to write a client wrapper in TypeScript or Rust without skipping edge cases. Pair this with the Solana address validator to confirm that a PDA derived off-chain from the seed spec actually reports as off-curve before hard-coding it into your client.

When debugging a failed transaction, the RPC returns a Custom(n)code that on its own tells you nothing. The IDL's error array resolves Custom(6007) to, for example, InsufficientVaultBalance with a descriptive message. Before updating the account state, look up the rent impact by pasting the expected allocation size into the lamport converter to see the rent-exempt minimum for the account, so the top-up amount in the retry transaction is correct on the first attempt.

For code-generation workflows — typed clients for browsers, mobile SDKs, or server daemons — the decoder gives a quick sanity check that the IDL you are about to feed into Anchor's TypeScript generator is well-formed and complete. Missing PDA seeds on older Anchor versions, unexpected events fields, and typeless arguments all show up immediately, letting you fix the IDL upstream rather than debugging generated client code after the fact.

Key Features

Section counts: at-a-glance instruction / account / type / error counts in the summary card.
Instruction drill-down: every instruction lists its ordered accounts (with signer / mut flags) and typed argument list.
PDA seeds: seed arrays are expanded into const, arg, and account entries when the IDL embeds them.
Struct & enum layouts: accounts and custom types render as labelled field or variant lists; complex types use a readable Vec<T> / Option<T> form.
Error table: error codes, names, and messages are shown in a compact grid for quick lookup against a Custom(n) RPC response.
Client-side: IDLs stay in the browser — nothing is uploaded.

Frequently Asked Questions

Which Anchor versions are supported?

The viewer reads the fields that have been stable since Anchor 0.25 and carried forward through 0.29 / 0.30: instructions, accounts, types, errors, plus optional pda.seeds. Newer additions (events, metadata) are accepted but not rendered.

What does signer and mut on an account mean?

signer marks an account whose keypair must sign the transaction. mut marks an account whose data or lamports can change. Both flags are carried straight from the IDL.

How do I compute the PDA address from the seeds shown?

PDA addresses are derived with findProgramAddress(seeds, programId) using @solana/web3.js. const seeds are byte strings, arg seeds come from an instruction argument, accountseeds resolve to another account's public key. The hashing must be done with the correct program ID.

Why don't I see PDA seeds for all my accounts?

Older Anchor versions did not serialise the pda field into the IDL. Recompiling with a modern Anchor CLI (0.29+) and the --idl flag will populate it.

Does the tool decode account data bytes?

No. For live account buffers, use Anchor's AccountsCoder or the REST endpoint of a Solana indexer. This tool focuses on the schema itself.

Related Tools

Ethereum Address Checksum

Convert Ethereum addresses to EIP-55 checksum format and validate integrity.

Crypto Unit Converter

Convert between ETH, Wei, Gwei, BTC, and Satoshi units.

BIP39 Mnemonic Generator

Generate and validate BIP39 mnemonic seed phrases (12/24 words).

Multi-chain Address Validator

Auto-detect and validate addresses across BTC, ETH, SOL, Cosmos, and more.

Wallet Address Format Converter

Convert between EVM hex and Bech32 address formats for dual-chain wallets.

Wei / Gwei / Ether Converter

Convert between Wei, Gwei, and Ether with decimal precision.

ABI Decoder & Encoder

Decode and encode Solidity function call data against an ABI.

Function Selector Lookup

Resolve 4-byte function selectors to Solidity function signatures.

Calldata Decoder

Decode transaction input data into function and arguments.

Solana Lamports Converter

Convert between lamports and SOL with precise arithmetic.

Solana Address Validator

Validate Solana Base58 addresses and detect program IDs or PDAs.

Bech32 Address Converter

Convert between Cosmos Bech32 prefixes (cosmos1…, osmo1…).

Cosmos IBC Denom Parser

Parse IBC denom hashes back to channel, port, and base denom.

EIP-712 Typed Data Builder

Build EIP-712 typed data payloads for wallet signing.

Event Log Decoder

Decode ERC-20 / ERC-721 event logs by Topic0 and ABI fragment.

CosmWasm Schema Validator

Validate CosmWasm contract schemas against sample payloads.

NFT Metadata Builder

Build NFT metadata JSON for ERC-721, ERC-1155, and Metaplex.

Token Decimals Calculator

Convert raw token units to human amounts per token decimals.

Merkle Tree Generator

Build Merkle root and inclusion proofs from an airdrop list.