BranchesTags

Repository files navigation

Grat

Rust 1.77Next.js 16TS 5Docs

Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.

Features

  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.

Architecture

Grat is organized as a modular monorepo:

  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.

Tech Stack

  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)

Quick Start

  1. Prerequisites:

    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.

  2. Clone and Prepare:

    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install

  3. Build from Source:

    cargo build --release

  4. Run the CLI:

    ./target/release/grat decode <tx-hash>

Documentation

For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds. Complete guide to all Grat commands. Deep dive into the 3-tier diagnostic engine. Real-world walkthroughs and optimization tips.

Use Cases

Debugging Failed Transactions

Instantly understand why a mainnet transaction failed without redeploying or adding print statements.

Resource Optimization

Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.

Regression Testing

Export failed transactions as standalone test cases to ensure bugs are permanently resolved.

Authorization Type Detection

Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.

Supported Types

TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).

Detection Logic

Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:

  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.

SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.

Report Fields

Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:

{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}

The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.

Contributing

We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Empowering Soroban developers with clear, actionable diagnostics.

About

Soroban transaction debugger

prism-ddf93e61.mintlify.app/docs/introduction

Resources

Readme

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Grat
Rust 1.77Next.js 16TS 5Docs
Grat is a developer tool that makes Soroban smart contract errors easy to understand. It takes raw, cryptic error codes from failed transactions and turns them into plain English explanations with suggested fixes. It also lets developers replay past transactions step by step to see exactly what went wrong and why, so they can find and fix the problem in seconds instead of guessing.
Features
  • Instant Error Decoding: Decodes Soroban host errors into plain English with suggested fixes.
  • Contract-Specific Resolution: Cross-references WASM metadata to resolve custom error codes (e.g., #3 → InsufficientBalance).
  • Execution Trace Replay: Replays transactions against historical ledger state for deep inspection.
  • Resource Profiling: Identifies budget hotspots and expensive host function calls.
  • Time-Travel Debugging: Supports breakpoints, step-through execution, and "what-if" re-simulation.
  • Multi-Interface Support: Available via Rust CLI, VS Code Extension, and a Web Application.
  • Authorization Type Detection: Distinguishes Ed25519 account signatures from Smart Wallet (contract) authorizations and surfaces the relevant address or contract ID.
Architecture
Grat is organized as a modular monorepo:
  • Core Library (crates/core): The shared Rust engine for decoding, replaying, and debugging.
  • CLI (crates/cli): Powerful command-line interface for terminal-native diagnostics.
  • WASM (crates/wasm): Core logic compiled to WASM for client-side web integration.
  • Web App (apps/web): Interactive Next.js 16 dashboard for shareable debug sessions.
  • Server (apps/server): Async task processor and WebSocket server for trace streaming.
Tech Stack
  • Core Engine: Rust (edition 2021)
  • Blockchain: Stellar Soroban SDK (v21)
  • Web Frontend: Next.js 16, React 19, TypeScript 5
  • WASM Processing: wasmparser & wasm-pack
  • CLI Framework: Clap & Ratatui (TUI)
Quick Start
  1. Prerequisites:
    • Rust 1.77 or higher.
    • Node.js 20 or higher.
    • pnpm installed.
  2. Clone and Prepare:
    git clone https://github.com/grat-soroban/grat.git
cd Grat
pnpm install
  3. Build from Source:
    cargo build --release
  4. Run the CLI:
    ./target/release/grat decode <tx-hash>
Documentation
For full technical specifications, architecture deep-dives, and API references, visit our Live Documentation.

Get up and running in under 60 seconds.
Complete guide to all Grat commands.
Deep dive into the 3-tier diagnostic engine.
Real-world walkthroughs and optimization tips.

Use Cases
Debugging Failed Transactions
Instantly understand why a mainnet transaction failed without redeploying or adding print statements.
Resource Optimization
Profile contract execution to identify expensive storage reads or CPU-heavy host function calls before deploying to mainnet.
Regression Testing
Export failed transactions as standalone test cases to ensure bugs are permanently resolved.
Authorization Type Detection
Grat automatically identifies the kind of authorization used in each Soroban transaction and includes this information in every diagnostic report.
Supported Types
TypeAddress PrefixDescription
Ed25519G...Classic Stellar account signing with its ed25519 key pair.
Smart WalletC...Deployed contract implementing custom signature verification (e.g., multi-sig, passkeys).
Detection Logic
Detection is based on the ScAddress variant inside each SorobanAddressCredentials entry:
  • ScAddress::Account(...) → Ed25519 — a standard Stellar account.
  • ScAddress::Contract(...) → Smart Wallet — a deployed contract acting as an authorizer.
SourceAccount credentials (where the transaction's own source account implicitly authorizes the entry) are not typed because they carry no separate address.
Report Fields
Each decoded DiagnosticReport includes an auth_entries array with one entry per authorization found in the transaction:
{
"auth_entries": [
{
"auth_type": "Ed25519",
"address": "GABC...XYZ"
},
{
"auth_type": "Smart Wallet",
"address": "CABC...XYZ",
"contract_id": "CABC...XYZ"
}
]
}
The existing auth_signatures field (hex-encoded ed25519 signature bytes) is preserved unchanged for backward compatibility.
Contributing
We welcome contributions! Please see CONTRIBUTING.md for detailed guidelines.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Empowering Soroban developers with clear, actionable diagnostics.
About
Soroban transaction debugger
prism-ddf93e61.mintlify.app/docs/introduction
Resources
Readme
Code of conduct
Code of conduct
Contributing
Contributing
Security policy
Security policy
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages