The Modern Testing Interface for Solana Smart Contracts
Kizen transforms the way developers interact with Solana programs by providing a comprehensive, browser-based environment for exploring, testing, and debugging smart contracts. Think Postman, but purpose-built for the Solana ecosystem—where the complexity of blockchain development meets the simplicity of a clean, intuitive interface.
Testing Solana programs has traditionally been a fragmented, time-consuming ordeal. Developers juggle multiple tools: CLI commands for deployment, custom scripts for transaction building, separate utilities for PDA derivation, and manual RPC calls for state inspection. Each test requires context switching, environment setup, and often, writing throwaway code just to validate a single instruction.
The iteration cycle becomes painfully slow. Make a change. Rebuild. Redeploy. Write a new test script. Execute. Debug. Repeat. This friction doesn't just waste time—it discourages thorough testing and limits collaboration, especially when onboarding new team members who need to understand program behavior without diving into implementation details.
Kizen collapses this entire workflow into a single, unified interface. Upload your IDL file once, and the entire program interface becomes immediately explorable and testable. No local environment configuration. No deployment scripts. No boilerplate code. Just pure, streamlined interaction with your Solana programs across any network—mainnet, testnet, or devnet.
IDL-First Architecture: Your Anchor IDL is the single source of truth. Kizen automatically parses program interfaces, instruction schemas, account requirements, and PDA seed configurations to generate a complete testing environment dynamically.
Zero Configuration: From the moment you upload an IDL, every instruction becomes executable. Accounts are validated, PDAs are automatically derived when possible, and transactions are constructed with full type safety—no setup required.
Network Agnostic: Test against any Solana cluster with a simple configuration change. Switch between devnet for development, testnet for staging, and mainnet for production validation without changing a single line of code.
Persistent State: Every interaction is tracked. Transaction history, program configurations, and project settings are stored in a robust PostgreSQL database, enabling you to revisit past tests, audit transaction flows, and collaborate with team confidence.
Kizen is built on a modern, performant stack designed for real-time blockchain interaction:
- Frontend Framework: Next.js 16 with React 19, leveraging server-side rendering and React Server Components for optimal performance
- UI System: Shadcn/ui components with Radix UI primitives, providing accessible, composable interfaces
- Styling: Tailwind CSS with dark mode support via next-themes
- Blockchain Integration: Solana Web3.js and Coral-XYZ Anchor libraries for program interaction
- Wallet Adapter: Solana wallet adapter supporting multiple wallet providers
- Database: PostgreSQL with Prisma ORM, utilizing connection pooling and query acceleration
- Authentication: Clerk for secure, passwordless user authentication
- State Management: React hooks with server actions for optimistic updates
The data model is designed around collaborative project management:
User (Clerk-backed authentication)
├── Projects (workspace containers)
├── IdlFiles (uploaded program interfaces)
├── Transactions (execution history)
└── ProjectSettings (network configurations)
Each project maintains isolated settings for RPC endpoints, commitment levels, preflight checks, and retry policies. This enables teams to work on multiple programs simultaneously with different network configurations.
The heart of Kizen is its sophisticated IDL parser that transforms Anchor's JSON schema into an interactive testing interface:
Instruction Analysis: Each instruction is decomposed into its discriminator, accounts, and arguments. The parser identifies signers, mutable accounts, and optional parameters automatically.
Account Classification: Accounts are categorized into three types:
- Signers: Automatically populated with the connected wallet's public key
- Standard Accounts: Require manual input or use pre-defined addresses from the IDL
- PDA Accounts: Derived automatically using seed configurations
PDA Derivation: The most powerful feature—Kizen recursively resolves PDA seeds, handling constant strings, account references, and argument dependencies. The derivation engine:
- Identifies all PDA accounts in an instruction
- Analyzes seed dependencies (constants, account paths, argument paths)
- Recursively derives PDAs when dependencies are satisfied
- Falls back to manual input for unresolvable seeds
- Uses the program ID as the authority for
findProgramAddresscalls
This means developers can execute complex instructions with nested PDAs without manually computing addresses.
When executing an instruction, Kizen follows a sophisticated transaction construction flow:
- Method Resolution: The Anchor program interface is loaded, and the target instruction method is retrieved
- Account Population: Accounts are resolved in order:
- Signers are auto-filled with wallet public key
- Standard accounts use user input or IDL defaults
- PDAs are derived using the recursive seed resolution algorithm
- Argument Type Conversion: String inputs are converted to appropriate Anchor types:
- Numbers become BN (BigNumber) instances
- Booleans are parsed from string values
- Complex types are JSON-parsed and validated
- PublicKeys are constructed from base58 strings
- Transaction Construction: Anchor builds the transaction instruction with proper account metadata and serialized data
- Execution: The transaction is sent via the connected wallet with project-specific settings (commitment level, preflight, max retries)
- Persistence: On success, transaction details are stored with signature, status, program metadata, and timestamp
Each project maintains granular network configurations:
- RPC URL: Customizable endpoint supporting public RPCs or private node access
- Commitment Level: Processed, confirmed, or finalized transaction verification
- Skip Preflight: Option to bypass simulation for faster execution
- Max Retries: Configurable retry policy for transaction confirmation
These settings apply globally to all program interactions within a project, enabling consistent testing behavior across different network conditions.
Upload a compiled IDL and watch Kizen dissect every instruction, account relationship, and error code. The parser understands Anchor's type system, including enums, structs, and nested account definitions, presenting them in a clean, hierarchical view.
PDA accounts are notorious for their complexity. Kizen automatically discovers PDA seed configurations from the IDL and derives addresses on-the-fly. When seeds reference other accounts or instruction arguments, the UI intelligently updates derived addresses as you input data.
Each instruction gets a purpose-built form with typed inputs. String fields, number fields, boolean toggles, and public key inputs are generated automatically. Account requirements are clearly labeled—signers highlighted, writable accounts indicated, optional fields marked.
Connect any Solana wallet and execute instructions directly from the browser. Transactions are constructed using Anchor's high-level API, ensuring proper serialization and account ordering. Results appear instantly with Solana Explorer and Solscan links for deep inspection.
Every transaction is recorded with full context: signature, program ID, instruction name, status, and timestamp. The history view provides at-a-glance status indicators and direct links to on-chain explorers for verification.
Switch between clusters seamlessly. Configure custom RPC endpoints for private nodes, test against different commitment levels, and adjust transaction policies without code changes.
Organize multiple programs into logical projects. Each project maintains its own IDL library, transaction history, and network settings, enabling parallel work on different contracts or different networks.
With persistent storage and user authentication, Kizen is built for teams. Share project configurations, review transaction histories collaboratively, and onboard new developers instantly by simply granting access to a project.
- Create Account: Sign in with Clerk authentication (supports email, social logins)
- Create Project: Initialize a new workspace with a descriptive name
- Upload IDL: Drop your
target/idl/program.jsonfile into the interface - Configure Network: Select mainnet, testnet, or devnet, or provide a custom RPC URL
- Select Program: Choose from uploaded IDL files in the project sidebar
- Browse Instructions: View all available instructions with their accounts and arguments
- Connect Wallet: Link your Solana wallet (Phantom, Solflare, etc.)
- Fill Instruction: Input required arguments and account addresses
- Signer accounts auto-populate with your wallet
- PDA accounts derive automatically when possible
- Standard accounts require manual input
- Execute Transaction: Send the transaction with one click
- View Results: See transaction status, signature, and explorer links immediately
- Review History: Access the transactions tab to audit all past executions
The beauty of Kizen is the speed of iteration. After modifying your program:
- Rebuild your program:
anchor build - Upload the new IDL to Kizen
- Immediately test new instructions or modified interfaces
No deployment necessary during development. No test scripts to update. No environment variables to manage.
Traditional testing requires writing JavaScript/TypeScript test files for every scenario. With Kizen, these tests become interactive form submissions. Change a parameter, click send, see results. The feedback loop compresses from minutes to seconds.
Explorers show what happened. Kizen lets you make it happen. While explorers are read-only, Kizen provides write access to program instructions with proper validation and user-friendly interfaces.
Building a frontend for every program is expensive and repetitive. Kizen generates the interface automatically from the IDL, providing 80% of the functionality teams need without writing a single line of frontend code.
Anchor tests are perfect for CI/CD and automated validation. Kizen complements them by providing manual, exploratory testing for edge cases, debugging production issues, and demonstrating program functionality to non-technical stakeholders.
During active development, use Kizen as your primary testing interface. Upload IDLs after each build, test instruction behavior against devnet, and validate state changes without writing test harnesses.
QA engineers can test program functionality without understanding Rust or Anchor. Upload an IDL, follow test scenarios, and verify behavior across different account states and input combinations.
When mainnet contracts behave unexpectedly, use Kizen to replay transactions with different parameters. Test against production state using mainnet RPC, and validate fixes before redeployment.
New team members can explore program capabilities immediately. Hand them an IDL, show them Kizen, and they understand the program interface without reading implementation code.
Showcase smart contract functionality to investors, auditors, or partners. Execute real transactions on testnet with clear, visual feedback that non-technical audiences can follow.
Before building frontend integrations, validate instruction behavior and account relationships in Kizen. Confirm PDA derivations, test error conditions, and document expected transaction flows.
Kizen performs runtime type validation on all instruction arguments, ensuring that numeric types don't overflow, public keys are valid base58 strings, and complex types match expected schemas. This catches errors before transactions reach the chain.
Using React Server Actions with optimistic updates, the interface remains responsive even during transaction confirmation. Status indicators update immediately, then reconcile with on-chain state once finalized.
Database queries utilize Prisma's connection pooling with the @prisma/adapter-pg extension, ensuring low-latency reads even under high load. The schema is optimized with proper indexes on foreign keys and query-heavy fields.
The entire interface is mobile-responsive, allowing developers to test programs from tablets or even smartphones—useful for quick checks or demonstrations on the go.
Full dark mode implementation using CSS variables and next-themes, reducing eye strain during extended testing sessions and matching developer preferences.
While Kizen is fully functional today, the vision extends further:
- Account State Viewer: Fetch and deserialize on-chain account data to inspect program state
- Event Log Parsing: Capture and decode program logs and events emitted during instruction execution
- Instruction Batching: Compose multiple instructions into a single transaction for complex operations
- Environment Variables: Store frequently used addresses (tokens, authorities) as project-level constants
- Custom Instruction Templates: Save pre-filled instruction forms as templates for repeated testing scenarios
- Collaboration Features: Add comments to transactions, share projects with team members, and track who executed what
- CI/CD Integration: Provide API endpoints for automated testing pipelines
- Native Error Decoding: Parse program errors using IDL error codes and display human-readable messages
Kizen doesn't just make Solana testing easier—it reimagines what testing should be. By eliminating the friction between thought and execution, developers spend less time on tooling and more time on logic. By centralizing program interaction into a single interface, teams move faster and collaborate better.
The Solana ecosystem needs tools that match the sophistication of its technology. Anchor brought high-level abstractions to smart contract development. Kizen brings those same abstractions to smart contract testing. It's the missing piece in the modern Solana development workflow—and once you use it, you'll wonder how you ever tested programs without it.
This is Solana testing, evolved.
- Node.js 20+
- pnpm (or npm/yarn)
- PostgreSQL database
- Clerk account for authentication
- Solana wallet browser extension
# Clone the repository
git clone https://github.com/yourusername/kizen.git
cd kizen
# Install dependencies
pnpm install
# Configure environment variables
cp .env.example .env
# Add your DATABASE_URL and CLERK credentials
# Run database migrations
pnpm prisma migrate dev
# Start the development server
pnpm devNavigate to http://localhost:3000, create an account, and start testing.
Kizen: Because smart contract testing shouldn't require a PhD in tooling.