# What is Solaxy? **Solaxy** is a high-performance, zk-enabled Layer 2 rollup built on top of the Solana blockchain. It is designed to scale Solana’s throughput while preserving the speed, security, and composability that developers and users expect from the Solana ecosystem. At its core, Solaxy moves execution off-chain while settling securely on Solana Layer 1. This design allows it to offer: * **Higher throughput** * **Lower latency** * **Reduced transaction costs** * **Improved developer experience** By integrating with the **Sovereign SDK** and running the **Solana Virtual Machine (SVM)** within a **zero-knowledge virtual machine (zkVM)**, Solaxy combines Solana’s native tooling with modern scaling techniques used in Ethereum’s L2 ecosystem. The ecosystem is powered by the native token $SOLX. *** #### Why It Matters Solana’s ecosystem has experienced rapid growth - but with it comes increased network load, congestion, and occasional reliability issues. Solaxy helps solve these challenges by introducing a modular execution layer that: * Processes transactions off-chain in a rollup environment * Publishes proofs and data to Solana L1 for finality and security * Bridges $SOLX seamlessly between Solana, Solaxy, and Ethereum. *** #### Built for Developers Solaxy supports Solana-native development out of the box. Developers can: * Deploy existing SVM-based programs without rewriting code * Use familiar tools like `solana-cli` and `@solana/web3.js` * Tap into higher throughput environments for complex or high-frequency applications Whether you're building DeFi protocols, games, or consumer apps - Solaxy lets you scale on Solana without compromise. # Why Solaxy? Solana is one of the fastest and most efficient blockchains - but as demand grows, so do the challenges of scalability, reliability, and cost-efficiency. Solaxy was built to address these head-on. Here’s why Solaxy matters: *** #### 1. **Scalability Without Compromise** Solaxy massively increases throughput by moving execution off-chain. It leverages rollup architecture and zkVM-based proof systems to compress and batch transactions, reducing load on Solana L1 while still settling there securely. > This means more users, more transactions, and more apps - without clogging the base layer. *** #### 2. **Native Developer Experience** Unlike other L2s that require custom tooling or rewriting smart contracts, Solaxy is fully **SVM-compatible**. You can build using the same tools you're already familiar with: * `solana-cli` * `@solana/web3.js` * Anchor *** #### 3. **Secure, Transparent Settlement** Solaxy publishes transaction data and validity proofs directly to Solana L1. This ensures: * Transparent data availability * Secure state transitions * Verifiable settlement logic via zk or optimistic proofs Security is not bolted on - it’s built-in. *** #### 4. **Cross-Chain by Design** Solaxy uses Hyperlane to enable seamless bridging between Solana, Solaxy, and Ethereum. This makes it easy to move assets and liquidity across ecosystems. *** #### 5. **Modular and Future-Proof** By building on the Sovereign SDK and supporting zero-knowledge virtual machines like SP1 by Succinct, Solaxy is prepared to adapt quickly: * Support for new proof systems * More flexible DA layers (e.g. Celestia) * Custom appchains and execution environments *** In short, **Solaxy unlocks scalable, developer-friendly rollups on Solana - without sacrificing speed, security, or composability.** It’s built for where Solana is going, not just where it is today. # Key Features Solaxy combines cutting-edge rollup architecture with native Solana compatibility to deliver a next-generation Layer 2 experience. Here are the core features that set Solaxy apart: *** #### 🚀 **High Throughput & Low Latency** Solaxy’s off-chain execution allows it to process thousands of transactions per second, significantly surpassing the throughput limitations of Solana L1. Finality is quick, with users experiencing near-instant confirmations. *** #### 🔁 **Full SVM Compatibility** Solaxy supports the **Solana Virtual Machine (SVM)** natively inside a [**zkVM** (SP1 by Succinct)](https://blog.succinct.xyz/introducing-sp1/), allowing developers to: * Deploy existing Solana smart contracts with no code changes * Use standard Solana libraries and tooling * Build high-performance apps without leaving the Solana ecosystem *** #### 🧠 **Modular zk-Rollup Architecture** Solaxy leverages a modular rollup framework, allowing independent scaling and evolution of: * Execution (via [Sovereign SDK](https://github.com/Sovereign-Labs/sovereign-sdk)) * Data Availability (Solana and Celestia) * Settlement (to Solana L1) * Bridging (via Hyperlane) This makes Solaxy flexible, future-proof, and capable of integrating next-gen infrastructure as it matures. *** #### 🔒 **Secure Settlement on Solana L1** Solaxy commits transaction data and proofs to Solana Layer 1, ensuring: * Transparent state verification * Strong censorship resistance * Trustless interoperability Security is guaranteed by Solana’s battle-tested consensus and validator set. *** #### 🌉 **Cross-Chain Bridging** Powered by **Hyperlane**, Solaxy enables asset transfers between: * Solana ↔ Solaxy ↔ Ethereum This makes Solaxy a key interoperability layer, allowing liquidity to move across ecosystems. *** #### 🧪 **Dev-Friendly Testnet & Tooling** Solaxy offers: * Public testnet access * Explorer and RPC nodes * CLI support * Web3 JS support * Bridge * Faucet Everything is designed to get developers building fast, with minimal friction. *** #### 🔄 **Optimistic + ZK Mode Support** Solaxy’s architecture supports both **optimistic rollups** and **zk-proofs**, giving it flexibility based on application needs and infrastructure readiness. *** These features combine to make Solaxy a powerful scaling layer for the next generation of Solana-based apps - from DeFi to games, infra, and beyond. # FAQ #### ❓ What is Solaxy? Solaxy is a high-performance Layer 2 rollup built on Solana. It scales the network by executing transactions off-chain while settling securely on Solana Layer 1. It supports Solana-native tooling and is compatible with the Solana Virtual Machine (SVM). *** #### ❓ How does Solaxy scale Solana? Solaxy increases throughput by bundling transactions off-chain and committing them to Solana L1 in compressed batches. This reduces load on the base layer and improves performance without sacrificing security. *** #### ❓ Is Solaxy a zk-rollup or optimistic rollup? Solaxy is **modular** - it currently supports optimistic rollup logic and is integrating zk-proof support using the SP1 zero-knowledge virtual machine. Over time, it will support both modes depending on use case and infrastructure maturity. *** #### ❓ What’s the difference between Solaxy and Solana? Solaxy is a **Layer 2** rollup that runs on top of Solana. It executes transactions off-chain and publishes data and proofs to Solana L1. Solana remains the source of truth, while Solaxy provides scalability and better UX. *** #### ❓ Can I deploy existing Solana programs on Solaxy? Yes. Solaxy supports the Solana Virtual Machine (SVM) natively, so you can use existing programs and tooling without rewriting code. *** #### ❓ How do I use the Solaxy bridge? You can access the bridge at . It supports transferring assets across Sol <> Solx <> Eth. *** #### ❓ What chains does Solaxy support bridging to? * **Solana ↔ Solaxy** * **Ethereum ↔ Solaxy** * **Solana ↔ Ethereum** *** #### ❓ Is there a token? Yes. Solaxy will have a native token, **$SOLX**, which will be used for transaction fees. *** #### ❓ Where can I track development progress? You can follow Dev Updates on our website or join the community on X (Twitter) and Telegram for real-time updates. # Rollup Architecture Solaxy is a modular Layer 2 rollup that runs off-chain execution while anchoring security and finality to Solana Layer 1. Its architecture is designed for performance, flexibility, and compatibility with Solana-native tooling. *** #### 🧱 Core Components **1. Sequencer** The sequencer is responsible for ordering and bundling transactions. Solaxy uses a **deterministic sequencer** that ensures consistent execution and minimizes latency. **2. Execution Layer** Solaxy runs **Solana smart contracts** inside a **zkVM**, specifically the **SP1 zero-knowledge virtual machine by Succinct**. This allows existing SVM-based programs to execute inside a scalable rollup without code changes. **3. State Transition Function** This is the core logic that determines how transactions modify the system’s state. Solaxy has implemented a robust state transition function that mirrors Solana’s execution semantics, ensuring compatibility and reliability. *** #### 🔁 Off-Chain Execution & On-Chain Settlement Solaxy processes transactions off-chain to achieve higher throughput and lower costs. Once a batch of transactions is processed, the rollup: 1. Generates a **proof of correctness** 2. Publishes **transaction data + proof** to Solana L1 3. Commits the new **state root** on-chain This preserves security while offloading computation from Solana L1. *** #### 📦 Data Availability Solaxy supports modular data availability layers: * **Primary:** Solana L1 (for production-grade security) * **Optional:** Celestia (for bandwidth-optimized configurations) DA ensures that anyone can independently verify the current rollup state. *** #### 🌉 Bridging Layer Solaxy integrates with **Hyperlane** to power permissionless, modular cross-chain messaging. The bridge connects: * **Solana ↔ Solaxy** * **Ethereum ↔ Solaxy** * **Solana ↔ Ethereum** The bridging layer supports native asset transfers and message passing between ecosystems. *** ⚙️ Modular Design via Sovereign SDK Solaxy is built using the [**Sovereign SDK**](https://github.com/Sovereign-Labs/sovereign-sdk), which enables: * Plug-and-play data availability layers * Configurable sequencing & settlement logic * zkVM integration This makes Solaxy highly composable and adaptable for the future of rollup infrastructure on Solana. # Sequencer & zkVM Integration Solaxy’s rollup architecture is built around two foundational components: 1. A **deterministic sequencer** that orders transactions off-chain 2. A **zkVM** (zero-knowledge virtual machine) that executes transactions and generates verifiable proofs Together, they enable Solaxy to scale Solana while preserving trustlessness and performance. *** #### ⚙️ Sequencer: Fast, Ordered, and Secure The **sequencer** is the engine that drives transaction flow on Solaxy. It is responsible for: * Ordering incoming transactions deterministically * Batching them into rollup blocks * Producing a clear state transition trail * Minimizing latency and front-running risks **Benefits of the Sequencer:** * **Predictable block production** * **Fast confirmations (soft confirmations supported)** * **Modular control over transaction inclusion and ordering** * **Future-proofed for proposer-builder separation and MEV protection** *** #### 🧠 zkVM: Verifiable Execution via SP1 To scale securely, Solaxy integrates the [**SP1 zkVM** developed by Succinct Labs](https://blog.succinct.xyz/introducing-sp1/). This virtual machine is capable of: * Running Solana smart contracts (via the Solana Virtual Machine) * Executing off-chain while maintaining cryptographic verifiability * Producing **zero-knowledge proofs** of valid state transitions This means every transaction executed off-chain can be proven correct - and those proofs can be verified on-chain. **What’s Inside the zkVM?** * Native support for **SVM bytecode** * Integration with the **Sovereign SDK** * Modular backends for future proof system upgrades * Designed for compatibility with Solana tools (e.g. `solana-cli`, `@solana/web3.js`) *** #### 🧪 Soft Confirmations To improve UX during testing and development, Solaxy supports **soft confirmations** - a feature where the sequencer provides early confirmation of transaction validity before full rollup settlement. This allows: * Faster frontend responsiveness * Better user feedback loops * Flexible tradeoffs between speed and finality *** #### 🔄 Sync Between Sequencer & zkVM The sequencer and zkVM work in tandem: 1. The sequencer receives and orders transactions. 2. The zkVM executes them off-chain and generates a proof. 3. The result - proof + new state root - is published to Solana L1. 4. The state root becomes the canonical on-chain snapshot. This flow ensures: * **Speed from off-chain execution** * **Security from on-chain verification** * **Trustless coordination between users, apps, and validators** # Data Availability **Data Availability (DA)** is a critical part of any rollup system. It ensures that all the transaction data behind a rollup’s state changes is publicly accessible - allowing anyone to verify the rollup’s correctness and reconstruct the current state. Without secure DA, a rollup could claim a new state root without revealing how it got there - making it impossible to independently verify or challenge. *** #### How Solaxy Handles DA Solaxy uses a **modular data availability layer**, giving it the flexibility to balance security, performance, and cost depending on the environment. **Primary DA Layer: Solana L1** For production and high-trust environments, Solaxy publishes transaction data and proofs directly to **Solana Layer 1**. This inherits the strong security guarantees of Solana’s consensus and validator set. Benefits: * Secure, censorship-resistant data storage * Transparent and verifiable by anyone * Long-term archival persistence *** **Optional DA Layer: Celestia** For performance testing, alternative configurations, or cost-sensitive applications, Solaxy can optionally publish data to **Celestia**, a dedicated modular DA network. Benefits: * Lightweight DA layer optimized for throughput * Lower publishing costs for large data batches * Separation of execution and data roles *** #### DA Modes in Solaxy Solaxy supports multiple DA strategies: * **Inline Posting (to Solana L1):** Data is posted alongside proofs during settlement. * **External Posting (e.g. Celestia - Not implemented yet):** Data is committed to a secondary layer with references anchored on Solana L1. In both cases, Solaxy ensures: * All necessary transaction data is retrievable * Validators, light clients, and users can independently verify rollup behavior *** #### Future DA Enhancements Solaxy’s modular architecture will allow support for additional DA layers and innovations, such as: * **Shared DA markets** * **Erasure-coded storage** * **Reed-Solomon fallback proofs** * **Fraud-proof-based DA guarantees** This flexibility allows Solaxy to evolve alongside the broader modular blockchain ecosystem. # Bridging Mechanism Solaxy is built with interoperability in mind. One of its key features is the ability to **bridge assets and data across multiple blockchains**, enabling seamless liquidity flow between Solaxy, Solana, and Ethereum networks. To achieve this, Solaxy integrates with **Hyperlane**, a modular, permissionless interoperability protocol. *** #### How the Solaxy Bridge Works? Solaxy’s bridging system enables users to transfer native assets between chains. Here’s how the process works at a high level: 1. **Lock** assets on the source chain (e.g., Solana). 2. **Message** is passed via Hyperlane, a trust-minimized relayer protocol. 3. **Mint or release** equivalent assets on the destination chain (e.g., Solaxy). 4. Users can **redeem** and return assets in reverse with full transparency. This enables: * Native asset transfers * Cross-chain protocol interaction * Composability across ecosystems *** #### Powered by Hyperlane Hyperlane brings several key benefits to Solaxy’s bridge system: * **Permissionless**: Any application can integrate with the bridge. * **Modular**: Supports new chains and messaging logic without refactoring. * **Secure**: Validator set is fully configurable. *** Solaxy’s bridge is more than just a connector - it’s a core piece of cross-chain infrastructure designed for scale, security, and composability. # Solaxy Network **Solaxy Network** is the Layer 2 infrastructure that powers fast, scalable, and secure decentralized applications on top of Solana. While Solaxy is built as a zk-rollup protocol under the hood, it's also a **full-stack product ecosystem** designed to deliver real utility to both developers and end-users. *** #### 🔧 What is the Solaxy Network? At its core, the Solaxy Network is: * A **zk-rollup** that runs Solana smart contracts off-chain and settles on Solana Layer 1. * A **developer platform** offering SVM compatibility, fast confirmations, and a familiar toolchain. * A **cross-chain execution layer** with seamless bridging to Solana, Solaxy and Ethereum. * A **production-ready rollup stack** integrated with Hyperlane, Sovereign SDK, and SP1 zkVM. It’s everything you expect from a modern L2 - but native to Solana. *** #### 🚀 Who is it for? Solaxy Network is designed for: * **Developers** building DeFi, gaming, or high-throughput applications that need more scalability than Solana L1 can offer. * **Projects** looking to bridge liquidity or deploy multi-chain smart contracts. * **End users** who want fast, low-fee transactions and a consistent experience across chains. *** #### 🧱 Core Components Solaxy Network includes: * **Rollup Node Infrastructure**: Validates and sequences transactions off-chain * **Bridge Interface**: Transfers assets between Solana, Solaxy, and Ethereum * **Block Explorer**: Provides visibility into rollup activity and state * **Testnet Environment**: Open to developers for experimentation and feedback * **Public RPCs & APIs**: For permissionless app and frontend integration *** #### 🌐 Live Network (Testnet) Solaxy Testnet is currently live and supports: * Bridging via * SVM-compatible contract deployment using RPC endpoint in [Access Information](/developer-resources/access-information) * Explorer at * Testnet Faucet at Mainnet launch will follow successful audits, performance validation, and community readiness. *** #### 🛠 Built With Solaxy Network integrates a range of modular components: * **Sovereign SDK**: Rollup framework for SVM execution and modular design * **SP1 zkVM**: Zero-knowledge virtual machine for provable computation * **Hyperlane**: Interoperability protocol for trustless bridging * **Solana L1**: Final settlement and data availability layer *** #### 🌉 Ecosystem Vision Solaxy isn’t just a scaling solution - it’s a **foundational layer** for the next wave of cross-chain applications. By making Solana-native tooling available in a rollup environment and bridging it to Ethereum, Solaxy becomes the hub for high-performance, multi-chain development. # Bridge The **Solaxy Bridge** enables fast and secure transfers of assets between Solana, Ethereum and Solaxy. This bridge is a core part of Solaxy’s cross-chain architecture, allowing users and applications to move tokens across ecosystems and interact with rollup-based smart contracts using familiar assets like $**SOLX**. *** #### 🔁 Current Status The bridge is live and allows: * **Solana Devnet → Solaxy Testnet** transfers for Devnet SOL * **Solaxy Testnet → Solana Devnet** transfers for Devnet SOL * Ethereum **→ Solana** transfers for $SOLX * Solana **→ Ethereum** transfers for $SOLX Users can bridge at

Solaxy Bridge UI

*** The Solaxy Bridge is the gateway to a modular, composable, and fully connected cross-chain future - with Solaxy at the center. # Block Explorer The **Solaxy Block Explorer** provides a real-time view of all activity on the Solaxy rollup network. It’s a key tool for both developers and users to monitor transactions, inspect contract activity, and understand the internal mechanics of the rollup. 🔗 **Explorer:**

Solaxy Explorer UI

*** #### 🔍 What Can You Do with the Explorer? * **View transactions** across Solaxy * **Track blocks**, gas usage, and sequencing order * **Inspect rollup state roots** and block metadata * **Debug smart contract behavior** * **Monitor bridging activity** *** #### 🧱 Key Features * **Transaction Search**: Look up by signature, block, or account. * **Block Detail Pages**: See block number, timestamp, transaction count, and rollup metadata. * **Address Pages**: View balances and history for accounts deployed on Solaxy. * **Bridge Transactions**: Track $SOLX transfers in and out of Solaxy. *** #### ⚙️ Built for Developers The explorer is designed to be a **developer-first tool**, giving clear insights into: * Rollup behavior and performance * Contract deployment and invocation * Block timing and sequencing * Data publication and settlement checkpoints *** The block explorer helps make Solaxy transparent, verifiable, and easy to interact with - whether you're a developer, user, validator, or researcher. # Testnet Faucet To help developers and testers interact with the Solaxy Testnet, we've provided a **Testnet Faucet** that distributes free $**SOLX (Testnet)** for use on **Solaxy network**. This $SOLX is for testing only and has no real-world value. The $SOLX can be used on Solaxy Testnet for: * Test transfers * Interact with test dApps * Deploy smart contracts 🔗 **Testnet Faucet:**

Solaxy Faucet UI

*** #### 🛠 How to Use It 1. Go to the Testnet Faucet 2. Paste your **Solana Devnet wallet address** (e.g. Backpack, Phantom) 3. Request funds *** #### 💡 Notes * You must connect a wallet that supports Solana Testnet (we recommend **Backpack**) * Faucet funds are limited to prevent abuse * If the faucet is down, try again later or ask in the Solaxy community channels for help # Neptoon **Neptoon** is the official decentralized exchange (DEX) of the Solaxy network - a high-performance, rollup-native trading platform optimized for speed, scalability, and the memecoin-driven energy of the Solana ecosystem. Neptoon is designed to be the core liquidity hub for all assets launched and bridged into the Solaxy Layer 2. 🔗 Neptoon: [https://neptoon.solaxy.io](https://neptoon.solaxy.io/)
Solaxy’s mission is to scale Solana through a zk-rollup architecture - and Neptoon completes that vision by offering a native trading layer for the tokens that power this new ecosystem. Unlike traditional Solana DEXs, Neptoon operates entirely on the Solaxy rollup, meaning: * **Ultra-low gas fees** * **Frictionless trading** * **Instant settlement** * **No L1 congestion impact** *** ### 🔁 What Can You Do on Neptoon? * **Swap tokens** on the Solaxy rollup with near-zero fees * **Provide liquidity** and earn LP fees * **Trade Igniter-launched tokens** immediately after their bonding curves complete # Igniter **Igniter** is the official **token launchpad** of the Solaxy network - a seamless, rollup-native platform that empowers anyone to create and launch tokens directly on Solaxy Layer 2. It’s built to serve creators, communities, and founders launching the next wave of meme coins, utility tokens, and ecosystem assets - all with the performance and scalability of the Solaxy rollup. 🔗Igniter: [https://igniter.solaxy.io](https://igniter.solaxy.io/)
### 🚀 Why Igniter? Solaxy’s vision is to scale Solana with a fully compatible zk-rollup. Igniter brings this vision to life by unlocking **permissionless token creation** at a new level of speed, simplicity, and affordability. Forget expensive deployments and slow launch flows - Igniter gives you: * A streamlined token creation interface * A built-in bonding curve model for initial liquidity * Instant access to Neptoon once your market cap reaches **1M $SOLX** Igniter is designed to make launching a token as easy as minting an NFT.\ \ After every token on Igniter graduates, the collected 1M SOLX is used in following manner: * 200k SOLX is burnt forever * 700k SOLX is put in the Neptoon LP * 100k SOLX is sent back to the creator as a reward. Further, to make sure builders stay motivated and aligned long-term we are introducing vesting:\ **6% of the total token supply will now vest to the project creator over 12 months, releasing monthly.** *** ### ⚙️ Key Features * **Token creation** directly on Solaxy Layer 2 * **Bonding curve mechanics** to bootstrap liquidity and discover price * **Automatic integration with Neptoon DEX** after reaching 1M $SOLX market cap * **Wallet compatibility** with the Solaxy Wallet and standard Solana tools * **Near-zero gas fees** and no L1 congestion risk *** ### 🔄 Launch Flow Overview 1. Connect your wallet 2. Create your token (name, supply, metadata) 3. Launch 4. Once your token hits 1M $SOLX market cap → automatically routed into **Neptoon** for open trading *** ### 🧪 Built for Builders, Degens & Meme Lords Whether you’re shipping a serious ecosystem utility token or launching the next viral meme coin, **Igniter gives you a high-performance, low-friction platform** to go live - without waiting for centralized approvals or dealing with L1 traffic. *** Igniter is more than a launchpad - it’s the **ignition system** of the Solaxy ecosystem.\ Fuel your token. Launch your vision. # Wallet **Solaxy Wallet** is the official browser extension wallet purpose-built for the Solaxy Layer 2 network. It offers a smooth and fast experience for trading, transfers, token launches, and interacting with dApps across the rollup - fully aligned with Solaxy’s zk-powered architecture. 🔗 Get it now:
### 🌌 Why Solaxy Wallet? While standard Solana-compatible wallets work with Solaxy, the **Solaxy Wallet** is designed specifically to support the unique needs of rollup-native users: * Native support for Solaxy rollup assets * Optimized for low-latency transactions * Seamless interactions with Neptoon, Igniter, and bridging * Simplified UX for L2 token management It’s the go-to wallet for builders, traders, and users who want the best experience on Solaxy. *** # Access Information You can use the information below to access the Solaxy network:
KeyValue
Devnet RPC URLhttps://devnet.rpc.solaxy.io
Devnet Faucethttps://faucet.solaxy.io
Mainnet RPC URLhttps://mainnet.rpc.solaxy.io
# Running a Solaxy Rollup Node Updated: 20 Feb, 2026 This guide explains how to download, configure, and run the `svm-rollup` binary to operate a Solaxy rollup node connected to the Celestia data availability layer. Running a node allows participants to support network infrastructure, maintain state replication, and prepare for validator participation as the network expands. #### 💻 Hardware Requirements For reliable rollup node performance, the following specifications are recommended: * **CPU:** 16 vCPUs * **Memory:** 32 GiB RAM * **Storage:** 1 TB disk These specifications ensure stable syncing, transaction processing, and state management under sustained network activity. #### 📦 System Prerequisites Supported environment: * **Linux x86\_64** (Ubuntu 24.04 or compatible) Install required system dependencies: ```bash sudo apt update sudo apt install -y build-essential cmake pkg-config libudev-dev ``` #### ⬇️ Download the Rollup Binary The latest Solaxy rollup binary bundle is distributed through a stable release endpoint. Download the binary and genesis state: ```bash curl -LO https://download.solaxy.io/solaxy/svm-rollup.tar.gz curl -LO https://download.solaxy.io/solaxy/state_export.svmd ``` #### 📂 Extract the Bundle Unpack the release archive and place the genesis state file in the appropriate directory: ```bash tar -xzf svm-rollup-latest.tar.gz cp state_export.svmd svm-rollup/genesis/state_export.svmd cd svm-rollup ``` After extraction, the directory structure will resemble: ``` svm-rollup/ svm-rollup # Rollup binary config.toml # Rollup configuration genesis/ # Genesis configuration and state ``` #### ⚙️ Configuration Provide your own configuration on how to access the Celestia network, by modifying the `da` section in the `config.toml` . You **must** configure the following fields: * `rpc_url` * `grpc_url` * `signer_private_key` #### 🪙 Wallet for prover rewards Configure the wallet you want to receive rewards on in the `config.toml` file. In the `proof_manager` section, the `prover_address` key, and also in the `sequencer` section the `rollup_address` key - both should point to your preferred wallet address.\ \ **Note:** The address must exist on the rollup and be funded in order to post the required bond. Current bond values: * Sequencer minimum registration bond: `10,000` SOLX lamports. * Current genesis prover bond: `200,000` SOLX lamports. * A new community operator is **not** pre-funded in genesis, so you need SOLX on your rollup address before registering. * Hold enough TIA to submit blobs to Celestia #### ▶️ Start the Rollup Node Launch the rollup node: ```bash export SOV_PROVER_MODE=skip ./svm-rollup --da-layer celestia --rollup-config-path config.toml --genesis-paths genesis ``` The node will begin syncing and connecting to the Celestia data availability layer. #### 🔎 Verify Node Operation Once the node is running, verify connectivity via the RPC endpoint: {% code overflow="wrap" %} ```bash curl -s http://localhost:8899/rpc -X POST \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["SysvarC1ock11111111111111111111111111111111",{"encoding":"jsonParsed"}]}' ``` {% endcode %} A valid JSON response confirms the node is operational and serving RPC requests. #### 🌐 Network Context The Solaxy rollup operates as a modular Layer 2 built using the Sovereign SDK and secured by Celestia for data availability. Running a node contributes to: * Network resilience * State replication * Infrastructure decentralization * Validator readiness As validator participation expands, this rollup node setup forms the foundation for broader community-operated infrastructure. # Using Solana Code The Solaxy rollup is completely SVM compatible. So any smart contracts/code written for Solana can be deployed as it is on Solaxy Layer. Developers can choose to write code in accordance with [official Solana docs](https://solana.com/docs) and deploy it on Solaxy right away using the [Access Information](/developer-resources/access-information). # Using Custom Code Developers are free to deploy their decentralized applications on the Solaxy layer using exact same tools and frameworks as in Native Solana. However, we have curated some examples to get you started. # RPC Client Setup To initialize your client, please pass in the URL in [Access Information](/developer-resources/access-information). * Client Template 
pub(crate) struct SampleClient {
      rpc: WsClient,
      node_client: NodeClient,
  }

  impl SampleClient {
      pub(crate) async fn new(rpc_addr: String, rest_addr: String) -> Self {
          let rpc_socket: SocketAddr = rpc_addr.parse().unwrap();
          let rpc = WsClientBuilder::default()
              .build(&format!("ws://127.0.0.1:{}", rpc_socket.port()))
              .await
              .unwrap();

          let rest_socket: SocketAddr = rest_addr.parse().unwrap();
          let node_client =
              NodeClient::new_unchecked(&format!("<http://127.0.0.1>:{}", rest_socket.port()));

          Self { rpc, node_client }
      }

      pub(crate) async fn svm_query_state(&self) -> anyhow::Result<String> {
          self.rpc
              .request("queryModuleState", rpc_params![])
              .await
              .map_err(|e| anyhow!("Failed to query SVM state: {e}"))
      }

      #[allow(dead_code)]
      pub(crate) async fn svm_get_slot(&self) -> anyhow::Result<u64> {
          self.rpc
              .request("getSlot", rpc_params![])
              .await
              .map_err(|e| anyhow!("Failed to get slot: {e}"))
      }

      pub(crate) async fn svm_get_account_info(&self, pubkey: Pubkey) -> anyhow::Result<Account> {
          let res: Response<Option<UiAccount>> = self
              .rpc
              .request("getAccountInfo", rpc_params![pubkey])
              .await
              .map_err(|e| anyhow!("Failed to get account info: {e}"))?;
          res.value
              .ok_or_else(|| anyhow!("Failed to get account info"))?
              .decode()
              .ok_or_else(|| anyhow!("Failed to decode account info"))
      }

      pub(crate) async fn svm_get_account_balance(&self, pubkey: Pubkey) -> anyhow::Result<u64> {
          self.rpc
              .request("getBalance", rpc_params![pubkey])
              .await
              .map_err(|e| anyhow!("Failed to get account balance: {e}"))
      }

      pub(crate) async fn svm_get_latest_blockhash(&self) -> anyhow::Result<Hash> {
          self.rpc
              .request("getLatestBlockhash", rpc_params![])
              .await
              .map_err(|e| anyhow!("Failed to get blockhash: {e}"))
      }

      pub(crate) async fn svm_send_transaction(&self, tx: &Transaction) -> anyhow::Result<Hash> {
          let raw_tx = serialize_and_encode(tx, UiTransactionEncoding::Base58)?;
          self.rpc
              .request("sendTransaction", rpc_params![raw_tx])
              .await
              .map_err(|e| anyhow!("Failed to send transaction: {e}"))
      }

      pub(crate) async fn get_minimum_balance_for_rent_exemption(
          &self,
          data_len: usize,
      ) -> anyhow::Result<u64> {
          self.rpc
              .request("getMinimumBalanceForRentExemption", rpc_params![data_len])
              .await
              .map_err(|e| anyhow!("Failed to get rent balance: {e}"))
      }

      pub(crate) async fn get_fee_for_message(&self, message: Message) -> anyhow::Result<u64> {
          self.rpc
              .request("getFeeForMessage", rpc_params![message])
              .await
              .map_err(|e| anyhow!("Failed to get fee for message: {e}"))
      }

      pub(crate) async fn simulate_call_message(
          &self,
          transactions: &[Transaction],
      ) -> anyhow::Result<u64> {
          let raw_txs = transactions
              .iter()
              .map(|tx| borsh::to_vec(tx).expect("Failed to serialize transaction"))
              .collect();

          let msg = svm::call::CallMessage {
              transactions: raw_txs,
          };

          let user = TestUser::<SvmRollupSpec>::generate_with_default_balance();

          let partial_transaction: PartialTransaction =
              sov_rollup_apis::PartialTransaction::<SvmRollupSpec> {
                  sender_pub_key: user.private_key().pub_key(),
                  details: sov_modules_api::transaction::TxDetails {
                      max_priority_fee_bips: PriorityFeeBips::ZERO,
                      max_fee: TEST_DEFAULT_MAX_FEE,
                      gas_limit: None,
                      chain_id: config_chain_id(),
                  },
                  encoded_call_message: <RT as EncodeCall<SVM<SvmRollupSpec>>>::encode_call(msg),
                  gas_price: None,
                  sequencer: None,
                  generation: 0,
              }
              .try_into()
              .unwrap();

          let simulation_result = self
              .node_client
              .client
              .simulate(&SimulateBody {
                  body: partial_transaction,
              })
              .await
              .map_err(|e| anyhow!("Failed to simulate call message: {e}"))?
              .data
              .clone()
              .unwrap();

          let simulation_result_parsed: SimulateExecutionContainer<SvmRollupSpec> =
              simulation_result.try_into()?;

          let tx_consumption = simulation_result_parsed
              .apply_tx_result
              .transaction_consumption;
          let base_fee = tx_consumption.base_fee_value();
          let priority_fee = tx_consumption.priority_fee();
          Ok(base_fee.0 + priority_fee.0)
      }

      pub(crate) async fn get_total_fee_for_transaction(
          &self,
          transaction: &Transaction,
      ) -> anyhow::Result<u64> {
          let call_message_gas_fee_estimate =
              self.simulate_call_message(&[transaction.clone()]).await?;
          let svm_gas_fee_estimate = self
              .get_fee_for_message(transaction.message.clone())
              .await?;
          Ok(call_message_gas_fee_estimate + svm_gas_fee_estimate)
      }
  }
* Initializing the Client 
let client = TestClient::new(config.rpc.rpc_addr, config.rpc.rest_addr).await;
# Transferring SOL * Creating an Account 
use std::time::Duration;

  use anyhow::anyhow;
  use jsonrpsee::tracing::debug;
  use solana_program::system_program;
  use solana_sdk::{
      account::Account,
      signature::{Keypair, Signer},
  };
  use tokio::time::sleep;

  use crate::{client::TestClient, SLEEP_DURATION_SECONDS};

  /// Prepares a Solana transaction for a create_account instruction.
  /// Returns a base58-encoded string representation of the prepared transaction.
  pub fn prepare_new_account_transaction(
      payer: &Keypair,
      new_account: &Keypair,
      rent: u64,
      blockhash: Hash,
  ) -> Transaction {
      let instruction = system_instruction::create_account(
          &payer.pubkey(),
          &new_account.pubkey(),
          rent,
          0,
          &system_program::id(),
      );

      Transaction::new_signed_with_payer(
          &[instruction],
          Some(&payer.pubkey()),
          &[payer, new_account],
          blockhash,
      )
  }

  pub(crate) async fn create_account(
      client: &TestClient,
      payer: &Keypair,
      new_account: &Keypair,
      amount: u64,
  ) -> anyhow::Result<()> {
      debug!("Create new account");
      // Get initial balance
      let payer_initial_balance = client
          .svm_get_account_balance(payer.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get payer's initial balance: {e}"))?;

      // Get latest blockhash
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let create_acc_tx =
          prepare_new_account_transaction(payer, new_account, amount, latest_blockhash);

      let total_gas_fee_estimate = client
          .get_total_fee_for_transaction(&create_acc_tx)
          .await
          .map_err(|e| anyhow!("Failed to get total fee estimate for transaction: {e}"))?;

      let tx_hash = client
          .svm_send_transaction(&create_acc_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      // Wait for transactions to process and persist changes
      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      // Check accounts and balances
      // Check payer's post balance
      let payer_post_balance = client
          .svm_get_account_balance(payer.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get payer's post balance: {e}"))?;
      let expected_balance = payer_initial_balance - amount - total_gas_fee_estimate;

      // Check new account's post balance
      let new_acc_balance = client
          .svm_get_account_balance(new_account.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get new account's balance: {e}"))?;

      // Check new account's info
      let new_acc_info = client
          .svm_get_account_info(new_account.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to retrieve new account: {e}"))?;
      let new_acc_key = new_account.pubkey();

      Ok(())
  }
* Transferring SOL 
/// Prepares a Solana transaction for a transfer instruction.
  /// Returns a base58-encoded string representation of the prepared transaction.
  pub fn prepare_sol_transfer_transaction(
      payer: &Keypair,
      receiver: &Pubkey,
      lamports: u64,
      blockhash: Hash,
  ) -> Transaction {
      let instruction = system_instruction::transfer(&payer.pubkey(), receiver, lamports);
      Transaction::new_signed_with_payer(&[instruction], Some(&payer.pubkey()), &[payer], blockhash)
  }

  pub(crate) async fn transfer_sol(
      client: &TestClient,
      sender: &Keypair,
      receiver: &Keypair,
      amount: u64,
  ) -> anyhow::Result<()> {
      // Get initial balances
      let sender_initial_balance = client
          .svm_get_account_balance(sender.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get sender's initial balance: {e}"))?;
      let receiver_initial_balance = client
          .svm_get_account_balance(receiver.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get receiver's initial balance: {e}"))?;

      // Get latest blockhash
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      // Send and publish transaction
      let sol_transfer_tx =
          prepare_sol_transfer_transaction(sender, &receiver.pubkey(), amount, latest_blockhash);

      let total_gas_fee_estimate = client
          .get_total_fee_for_transaction(&sol_transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to get total fee estimate for transaction: {e}"))?;

      let tx_hash = client
          .svm_send_transaction(&sol_transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      // Wait for transactions to process and persist changes
      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      // Check balances post transfer
      // Check sender's post balance
      let sender_post_balance = client
          .svm_get_account_balance(sender.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get sender's post balance: {e}"))?;

      // Check receiver's post balance
      let receiver_post_balance = client
          .svm_get_account_balance(receiver.pubkey())
          .await
          .map_err(|e| anyhow!("Failed to get receiver's post balance: {e}"))?;

      Ok(())
  }
# Minting + Burning SPL Tokens SPL tokens are Solana’s fungible token standard, and they can be thought of as the equivalent of ERC20s in Ethereum. * Create Mint 
pub(crate) async fn create_mint(client: &TestClient, payer: &Keypair) -> anyhow::Result<Keypair> {
      let mint_account = Keypair::new();

      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let rent_balance = client
          .get_minimum_balance_for_rent_exemption(Mint::LEN)
          .await
          .map_err(|e| anyhow!("Failed to get a rent exempt balance: {e}"))?;

      let create_mint_account = solana_sdk::system_instruction::create_account(
          &payer.pubkey(),
          &mint_account.pubkey(),
          rent_balance,
          Mint::LEN as u64,
          &spl_token::id(),
      );

      let initialize_mint = spl_token::instruction::initialize_mint(
          &spl_token::id(),
          &mint_account.pubkey(),
          &payer.pubkey(), // mint authority
          None,
          0,
      )
      .map_err(|e| anyhow!("Failed to create initialize mint instruction: {e}"))?;

      let create_mint_tx = Transaction::new_signed_with_payer(
          &[create_mint_account, initialize_mint],
          Some(&payer.pubkey()),
          &[payer, &mint_account],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&create_mint_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let mint_acc_info = client
          .svm_get_account_info(mint_account.pubkey())
          .await
          .map_err(|e| anyhow!("Mint account should exist after transaction: {e}"))?;

      // Deserialize the mint account data
      let mint_data = Mint::unpack(&mint_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack mint account data: {e}"))?;

      Ok(mint_account)
  }
* Create Associated Token Account 
pub(crate) async fn create_associated_token_account(
      client: &TestClient,
      payer: &Keypair,
      target_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
  ) -> anyhow::Result<()> {
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let create_ata = spl_associated_token_account::instruction::create_associated_token_account(
          &payer.pubkey(),
          target_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let create_ata_tx = Transaction::new_signed_with_payer(
          &[create_ata],
          Some(&payer.pubkey()),
          &[&payer],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&create_ata_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let ata_pubkey = get_associated_token_address_with_program_id(
          target_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let ata_acc_info = client.svm_get_account_info(ata_pubkey).await.map_err(|e| {
          anyhow!("Failed to retrieve associated token account after transaction: {e}")
      })?;

      Ok(())
  }
* Mint Tokens 
pub(crate) async fn transfer_tokens(
      client: &TestClient,
      payer: &Keypair,
      sender: &Keypair,
      receiver_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let sender_key = sender.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let sender_ata_pubkey = get_associated_token_address_with_program_id(
          &sender_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let receiver_ata_pubkey = get_associated_token_address_with_program_id(
          receiver_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let sender_ata_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_ata_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      // Get initial balances for tests
      let initial_sender_tokens = sender_token_account_data.amount;
      let initial_receiver_tokens = receiver_token_account_data.amount;

      let transfer = spl_token::instruction::transfer_checked(
          &spl_token::id(),
          &sender_ata_pubkey,
          mint_account_pubkey,
          &receiver_ata_pubkey,
          &sender_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create transfer checked instruction: {e}"))?;

      let transfer_tx = Transaction::new_signed_with_payer(
          &[transfer],
          Some(&payer.pubkey()),
          &[&payer, &sender],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let sender_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      Ok(())
  }
* Transfer Tokens 
pub(crate) async fn transfer_tokens(
      client: &TestClient,
      payer: &Keypair,
      sender: &Keypair,
      receiver_account_pubkey: &Pubkey,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let sender_key = sender.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let sender_ata_pubkey = get_associated_token_address_with_program_id(
          &sender_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let receiver_ata_pubkey = get_associated_token_address_with_program_id(
          receiver_account_pubkey,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let sender_ata_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;
      debug!("Sender's token account data:: {sender_token_account_data:?}");

      let receiver_ata_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_ata_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;
      debug!("Receiver's token account data: {receiver_token_account_data:?}");

      // Get initial balances for tests
      let initial_sender_tokens = sender_token_account_data.amount;
      let initial_receiver_tokens = receiver_token_account_data.amount;

      let transfer = spl_token::instruction::transfer_checked(
          &spl_token::id(),
          &sender_ata_pubkey,
          mint_account_pubkey,
          &receiver_ata_pubkey,
          &sender_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create transfer checked instruction: {e}"))?;

      let transfer_tx = Transaction::new_signed_with_payer(
          &[transfer],
          Some(&payer.pubkey()),
          &[&payer, &sender],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&transfer_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let sender_acc_info = client
          .svm_get_account_info(sender_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {sender_ata_pubkey}: {e}"))?;
      let sender_token_account_data = TokenAccount::unpack(&sender_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack sender's token account data: {e}"))?;

      let receiver_acc_info = client
          .svm_get_account_info(receiver_ata_pubkey)
          .await
          .map_err(|e| anyhow!("Failed to retrieve account {receiver_ata_pubkey}: {e}"))?;
      let receiver_token_account_data = TokenAccount::unpack(&receiver_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack receiver's token account data: {e}"))?;

      Ok(())
  }
* Burn Tokens 
pub(crate) async fn burn_tokens(
      client: &TestClient,
      payer: &Keypair,
      target_account: &Keypair,
      mint_account_pubkey: &Pubkey,
      amount: u64,
  ) -> anyhow::Result<()> {
      let target_key = target_account.pubkey();
      let latest_blockhash = client
          .svm_get_latest_blockhash()
          .await
          .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

      let target_ata_pubkey = get_associated_token_address_with_program_id(
          &target_key,
          mint_account_pubkey,
          &spl_token::id(),
      );

      let target_acc_info = client
          .svm_get_account_info(target_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {target_ata_pubkey}: {e}"))?;
      let target_token_account_data = TokenAccount::unpack(&target_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack token account data: {e}"))?;
      debug!("Target's token account data:: {target_token_account_data:?}");

      let initial_target_tokens = target_token_account_data.amount;

      let burn = spl_token::instruction::burn_checked(
          &spl_token::id(),
          &target_ata_pubkey,
          mint_account_pubkey,
          &target_key,
          &[],
          amount,
          0,
      )
      .map_err(|e| anyhow!("Failed to create burn tx: {e}"))?;

      let burn_tx = Transaction::new_signed_with_payer(
          &[burn],
          Some(&payer.pubkey()),
          &[&payer, &target_account],
          latest_blockhash,
      );

      let tx_hash = client
          .svm_send_transaction(&burn_tx)
          .await
          .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
          .to_string();

      sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

      let target_acc_info = client
          .svm_get_account_info(target_ata_pubkey)
          .await
          .map_err(|e| anyhow!("failed to retrieve account {target_ata_pubkey}: {e}"))?;
      let target_token_account_data = TokenAccount::unpack(&target_acc_info.data)
          .map_err(|e| anyhow!("Failed to unpack token account data: {e}"))?;

      Ok(())
  }
# Deploying Programs To deploy the programs please use the RPC method. TPU clients are not supported.\ Use the following command if using Anchor: `anchor deploy -- --use-rpc` or `solana program deploy --use-rpc` \ Alternatively, it can be done with Rust: {% code overflow="wrap" %} ```rust pub(crate) async fn deploy_program( client: &TestClient, payer: &Keypair, bytecode: &[u8], ) -> anyhow::Result { let program_keypair = Keypair::new(); let program_pubkey = program_keypair.pubkey(); let program_data_pubkey = get_program_data_address(&program_pubkey); let latest_blockhash = client .svm_get_latest_blockhash() .await .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?; let buffer_lamports = client .get_minimum_balance_for_rent_exemption( bytecode.len() + UpgradeableLoaderState::size_of_buffer_metadata(), ) .await .map_err(|e| anyhow!("Failed to get a rent exempt balance: {e}"))?; let deploy_txs = create_deploy_program_transactions( payer, &program_keypair, payer, bytecode.to_vec(), buffer_lamports, latest_blockhash, ) .map_err(|e| anyhow!("Failed to initialize transactions for program deployment: {e}"))?; for tx in deploy_txs { let tx_hash = client .svm_send_transaction(&tx) .await .map_err(|e| anyhow!("Failed to send a transaction: {e}"))? .to_string(); } sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await; let program_account = client .svm_get_account_info(program_pubkey) .await .map_err(|e| anyhow!("Failed to retrieve a program account: {e}"))?; let program_account_data: UpgradeableLoaderState = bincode::deserialize(&program_account.data) .map_err(|e| anyhow!("Failed to deserialize program account data: {e}"))?; if let UpgradeableLoaderState::Program { programdata_address, } = program_account_data { assert_eq!( programdata_address, program_data_pubkey, "Expected programdata_address from program account's metadata to match \ program_data_pubkey derived for program's pubkey" ); } let program_data_account = client .svm_get_account_info(program_data_pubkey) .await .map_err(|e| anyhow!("Failed to retrieve a program data account: {e}"))?; let program_data_account_metadata: UpgradeableLoaderState = bincode::deserialize( &program_data_account.data[..UpgradeableLoaderState::size_of_programdata_metadata()], ) .map_err(|e| anyhow!("Failed to deserialize program data account metadata: {e}"))?; if let UpgradeableLoaderState::ProgramData { upgrade_authority_address, .. } = program_data_account_metadata { let authority = upgrade_authority_address .expect("Expected program data account to have a program authority"); } Ok(program_keypair) } ``` {% endcode %} # Using Solana CLI The rollup adheres to the Solana RPC spec so you can use `solana-cli` to interact with the RPC. First step is to install the `solana-cli` if you haven’t already - you can do this by following the guide at . After you have set up the tools, you can send requests like the following: {% code overflow="wrap" %} ```bash solana --url "https://devnet.rpc.solaxy.io" account 2MCVmcuUcREwQKDS3HazuYctkkbZV3XRMspM5eLWRZUV ``` {% endcode %} If you have a keypair on your machine and would like to fund it on the rollup, you can do so by requesting an airdrop using the following command: {% code overflow="wrap" %} ```bash solana --url "https://devnet.rpc.solaxy.io" airdrop 0.00025 ``` {% endcode %} The 6h maximum airdrop amount is `250,000` lamports (or 0.00025 SOL) per account. # Using Solana Web3.js Install it via `npm`. ```bash npm install --save @solana/web3.js@1 ``` Send SOL from one account to another. {% code overflow="wrap" %} ```tsx const { Keypair, Transaction, SystemProgram, LAMPORTS_PER_SOL, } = require("@solana/web3.js"); let fromKeypair = Keypair.generate(); let toKeypair = Keypair.generate(); let transaction = new Transaction(); transaction.add( SystemProgram.transfer({ fromPubkey: fromKeypair.publicKey, toPubkey: toKeypair.publicKey, lamports: LAMPORTS_PER_SOL, }), ); ``` {% endcode %} Request an airdrop. {% code overflow="wrap" %} ```tsx let keypair = web3.Keypair.generate(); let payer = web3.Keypair.generate(); let connection = new web3.Connection("https://devnet.rpc.solaxy.io"); let airdropSignature = await connection.requestAirdrop( payer.publicKey, web3.LAMPORTS_PER_SOL, ); await connection.confirmTransaction({ signature: airdropSignature }); ``` {% endcode %} See additional information on the [docs page](https://solana.com/docs/clients/javascript). # Official Links ### Project * **Website:** * **Twitter (X):** * **Telegram Community:** [https://t.me/solaxyrollup](https://t.me/solaxytoken) * **Whitepaper**: * **CoinMarketCap**: * **CoinGecko**: ### $SOLX Token * Ethereum Ξ * [Contract Address](https://etherscan.io/token/0xe0B7AD7F8F26e2b00C8b47b5Df370f15F90fCF48) * [Liquidity Lock](https://app.uncx.network/lockers/univ3/chain/1/address/0x7e75b6876a9fee811ec67b55385ba5a1491d11f3/lock/0xfd235968e65b0990584585763f837a5b5330e6de953) * [Uniswap](https://app.uniswap.org/#/swap?outputCurrency=0xe0B7AD7F8F26e2b00C8b47b5Df370f15F90fCF48) * [DexScreener](https://dexscreener.com/ethereum/0x7E75b6876a9feE811EC67B55385BA5A1491D11f3) * [DexTools](https://www.dextools.io/app/en/ether/pair-explorer/0x7e75b6876a9fee811ec67b55385ba5a1491d11f3?t=1750693876672) * Solana ◎ * [Contract Address](https://solscan.io/token/Cf2LnRpmcUxY8qkAyiaaPpgAtUHgzkH3tPhMAevE9zLg) * [Liquidity Lock](https://solana.uncx.network/lockers/cp-swap/FBePpA9ZuAxQm6HqGi8ZvG7cj8utoRRmgSmpj5xnENN5/lock/UNCXdvMRxvz91g3HqFmpZ5NgmL77UH4QRM4NfeL4mQB-15?wallet=3kRny76Lr5MuJGFWrDkx6s2BuC3f8JW6tArZZNNZ7gDy) * [Raydium](https://raydium.io/swap/?inputMint=sol\&outputMint=Cf2LnRpmcUxY8qkAyiaaPpgAtUHgzkH3tPhMAevE9zLg) * [DexScreener](https://dexscreener.com/solana/fbeppa9zuaxqm6hqgi8zvg7cj8utorrmgsmpj5xnenn5) * [DexTools](https://www.dextools.io/app/en/solana/pair-explorer/FBePpA9ZuAxQm6HqGi8ZvG7cj8utoRRmgSmpj5xnENN5?t=1750688898061) * [BirdEye](https://birdeye.so/token/Cf2LnRpmcUxY8qkAyiaaPpgAtUHgzkH3tPhMAevE9zLg?chain=solana)