Coming soon
NLN Mirage: your own mainnet fork, hosted for you
NLN Mirage is a hosted Solana network simulator from NoLimitNodes, coming soon. You get your own isolated Mirage behind your usual RPC key. It forks mainnet on demand from our own nodes, so you can set any balance, move the clock, profile a transaction and test against real state, from the dashboard or with special RPC calls. It is +$250/mo on Pro, Ultra and Max, it is included in Enterprise, and it shares your plan’s requests per second.
- Your own isolated mainnet fork, behind your usual RPC key
- Change anything in the dashboard or with special RPC calls
- +$250/mo, included in Enterprise, sharing your plan’s requests per second
- Pulled by this send0
- Downloaded in advance0
- Held in your Mirage0
Send a transaction to begin.
The 11 accounts a swap on a real pool touches
- Your walletsigner and payer
- Your USDC accountsource token account
- Your SOL accountdestination token account
- The poolpool state
- Vault Athe pool’s first token
- Vault Bthe pool’s second token
- The swap programprogram
- The token programprogram
- The system programprogram
- The fee accountprotocol fee
- The price oracleprice feed
A sample of mainnet drawn as squares, not to scale. The accounts in each scenario are an illustration of a typical one; yours will differ. A fresh Mirage holds none of them until something touches them.
01The problem
Testing on Solana asks you to choose
Real state is on mainnet, where every try costs real funds and nothing can be undone. Everywhere else, the state is something you have to build. Pick what you need to test and see what each way asks of you.
I need to
A local test validator
Takes effort
Clone the pool’s accounts yourself
A public test network
Doesn’t fit
Different pools, different liquidity
Mainnet itself
Takes effort
Real, and it spends real funds
NLN Mirage
Fits
The real pool, fetched as you use it
- Fits
- Takes effort
- Doesn’t fit
All five needs, in a table
| Need | A local test validator | A public test network | Mainnet itself | NLN Mirage |
|---|---|---|---|---|
| Test a swap against a real pool | A local test validatorClone the pool’s accounts yourself. Takes effort. | A public test networkDifferent pools, different liquidity. Doesn’t fit. | Mainnet itselfReal, and it spends real funds. Takes effort. | NLN MirageThe real pool, fetched as you use it. Fits. |
| Start with any balance | A local test validatorAirdrop it or set it. Fits. | A public test networkFaucets are limited. Takes effort. | Mainnet itselfYou can’t give yourself funds. Doesn’t fit. | NLN MirageSet any balance, in the dashboard or a call. Fits. |
| Try a program upgrade before it ships | A local test validatorLoad it, then rebuild the state around it. Takes effort. | A public test networkDeploy it to a separate network. Takes effort. | Mainnet itselfShip it and find out. Doesn’t fit. | NLN MirageDeploy it over a fork of the real state. Fits. |
| Reproduce a bug against real accounts | A local test validatorClone every account involved. Takes effort. | A public test networkThe accounts aren’t the same ones. Doesn’t fit. | Mainnet itselfYou can’t change anything to test a fix. Doesn’t fit. | NLN MirageFork, then change one thing at a time. Fits. |
| Let a whole team test the same state | A local test validatorEach person runs their own copy. Takes effort. | A public test networkShared with every other user. Takes effort. | Mainnet itselfShared with everyone. Doesn’t fit. | NLN MirageOne endpoint for your team, yours alone. Fits. |
How we read it: a general description of each way, not of any one product. “Fits” means it does the job without extra work.
02How it works
Create it, connect, send, and it fills in
Five steps, and you can go through them yourself. The picture changes with each one, and the list under it says the same in words.
Step 5 of 5. Accounts pulled: 11
Send the same transaction again and nothing more is pulled: those accounts are already in your Mirage.
03Change anything
Change anything, from the dashboard or a call
Every change you can make is a form in the dashboard and a special RPC call to your Mirage, and they do the same thing. Pick one, change the fields and watch the call and the result follow.
In the dashboard
Or from code, the same change
curl "$MIRAGE_URL" \ -H "x-api-key: $NLN_API_KEY" \ -H "content-type: application/json" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "mirage_setAccount", "params": ["7xKdq2FaWallet", { "lamports": 10000000000000 }]}'What changed
| What | Before | After you apply |
|---|---|---|
| Wallet balance | 1.25 SOL | — |
The call names are the plan and are confirmed at launch. The wallet and account names are made up, and so are the balances shown before the change.
04Profile
See what a transaction would do, without doing it
Profile a transaction and your Mirage simulates it without committing anything, then hands back the compute units, the logs and the accounts it would change. Tag each run, change the code, profile again, and compare.
- Transfer in4,700
- Transfer out4,700
- Read the price9,800
Logs, tag before-fix
Program swap invoke [1]Program log: route 2 hopsProgram log: price readProgram swap consumed 134900 of 200000 compute unitsProgram swap successAccounts it would change
| Account | Before | After |
|---|---|---|
| Your USDC account | 5,000.00 | 4,000.00 |
| Your SOL account | 1.2500 | 6.1830 |
| The pool’s vault A | 812,440.00 | 813,440.00 |
Profiled, not sent: your Mirage keeps none of these changes.
The instructions, compute units, logs and balances here are made up to show the shape of a profile. Nothing was run.
05The clock
Move the clock, and wait for nothing
A vesting grant that unlocks over a year would take a year to test. In your Mirage you move the clock to the day you care about, pause it where it is, and put it back to the start when you are done.
- Day0
- Released0%
The last call
{ "method": "mirage_resetNetwork", "params": [] }The clock only moves forward, so a day earlier than now is refused. Resetting your Mirage starts it over. The grant is a made-up example.
06The calls
Twenty-eight special calls, in seven families
Everything above, and the rest, is a call you can send to your Mirage. Your Mirage also speaks the full Solana RPC API and WebSocket subscriptions, so your existing code and tools keep working. Search the calls or choose a family.
Showing 28 of 28.
mirage_setAccountSet an account’s balance, data, owner or executable flag.
State
mirage_setTokenAccountSet a token account’s balance, delegate, state or authorities.
State
mirage_setSupplySet the supply figures the network reports.
State
mirage_cloneProgramAccountCopy a program, with its data, to another address.
State
mirage_setProgramAuthorityChange or remove a program’s upgrade authority.
State
mirage_writeProgramWrite program data in chunks, at an offset you choose.
State
mirage_registerScenarioRegister a set of account overrides to apply at a slot.
State
mirage_timeTravelMove the clock forward to a time, slot or epoch. It never goes back.
Clock
mirage_pauseClockFreeze the clock where it is.
Clock
mirage_resumeClockLet the clock run again.
Clock
mirage_profileTransactionSimulate a transaction without committing it and get compute units, logs and account changes.
Profiling
mirage_getProfileResultsByTagGet every profile you saved under a tag.
Profiling
mirage_getTransactionProfileGet the profile of one transaction, by signature or id.
Profiling
mirage_getLocalSignaturesList the latest signatures sent to your Mirage.
Profiling
mirage_resetAccountPut an account back to mainnet’s version, with the accounts it owns if you like.
Fork control
mirage_resetNetworkPut your whole Mirage back to how it started.
Fork control
mirage_offlineAccountStop an account being fetched from mainnet, so your version stays.
Fork control
mirage_exportSnapshotExport the accounts in your Mirage, with filters.
Fork control
mirage_streamAccountFeed one account into your Mirage as if it were streaming.
Fork control
mirage_streamAccountsFeed several accounts in at once.
Fork control
mirage_getStreamedAccountsList the accounts you are streaming.
Fork control
mirage_registerIdlRegister a program’s IDL so its accounts and instructions decode.
Program IDLs
mirage_getActiveIdlGet the IDL registered for a program.
Program IDLs
mirage_getConfidentialBalanceRead the decrypted balances of a confidential token account.
Confidential transfers
mirage_deriveConfidentialKeysDerive the keys for confidential transfers from a signature.
Confidential transfers
mirage_enableCheatcodeTurn special calls back on.
Control
mirage_disableCheatcodeTurn special calls off for a session, for a shared Mirage you want kept as it is.
Control
mirage_getInfoRead information about your Mirage.
Control
These names are the plan. The final names are confirmed at launch.
07Your endpoint
Your endpoint, with the key you already have
Your Mirage gets an HTTP and a WebSocket endpoint, and you reach both with the same RPC key as your plan. It forks from our own nodes, so there is no second key to bring and nothing to configure on our side.
- HTTP endpoint
- https://YOUR_MIRAGE_ENDPOINT
- WebSocket endpoint
- wss://YOUR_MIRAGE_ENDPOINT
- Header
- x-api-key, the same key as your plan
- Forks from
- Our own mainnet nodes
- Holds
- 41 accounts, the ones your tests have touched
Connect to it
export MIRAGE_URL="https://YOUR_MIRAGE_ENDPOINT"
curl "$MIRAGE_URL" \ -H "x-api-key: YOUR_API_KEY" \ -H "content-type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"getBalance","params":["YOUR_WALLET"]}'import { Connection } from "@solana/web3.js"
const connection = new Connection("https://YOUR_MIRAGE_ENDPOINT", { httpHeaders: { "x-api-key": process.env.NLN_API_KEY! },})
const balance = await connection.getBalance(wallet)from solana.rpc.api import Client
client = Client( "https://YOUR_MIRAGE_ENDPOINT", extra_headers={"x-api-key": "YOUR_API_KEY"},)
balance = client.get_balance(wallet)curl "$MIRAGE_URL" \ -H "x-api-key: YOUR_API_KEY" \ -H "content-type: application/json" \ -d '{ "jsonrpc": "2.0", "id": 1, "method": "mirage_setAccount", "params": ["YOUR_WALLET", { "lamports": 10000000000000 }]}'The same key
Send your usual x-api-key header. The key that works for your RPC works for your Mirage.
No RPC key to bring
Your Mirage reads mainnet from our own nodes, so it needs nothing from you to fork.
Standard RPC, plus the calls
Your existing code runs as it is. The special calls are extra methods on the same endpoint.
The host is a placeholder: the real one is the one we give you. The samples are illustrative, and the account counts are made up.
08Requests and isolation
One limit, shared with the rest of your plan
Your Mirage has no second limit to manage. Requests you send to it count against your plan’s requests per second, the same as the rest of your traffic. Choose a plan, then how much of your traffic goes to your Mirage.
- Your Mirage: 80 requests a second
- The rest of your traffic: 120 requests a second
Pro: 200 requests a second in all.
The split is only an example of how one limit is shared. You do not set a split: it is one limit.
Yours alone
Each customer gets their own isolated Mirage. What you change in yours is never seen by anyone else, and you never see theirs. Change an account in yours and see.
Changed in yours: 0. Changed in everyone else’s: 0.
09Side by side
Three ways to test, side by side
None of them is wrong. They answer different needs, so here is what each gives you and asks of you. The first two describe the kind of tool, not any one product.
| Topic | A local test validator | A public test network | NLN Mirage |
|---|---|---|---|
| Where the state comes from | A local test validatorAn empty ledger, plus whatever you clone in | A public test networkIts own separate state and programs | NLN MirageMainnet, fetched as you use it |
| Who runs it | A local test validatorYou | A public test networkThe network | NLN MirageWe do, behind your endpoint |
| Real programs and liquidity | A local test validatorOnly what you copy in | A public test networkSeparate from mainnet’s | NLN MirageThe real accounts |
| Changing and resetting | A local test validatorRestart it | A public test networkNot yours to reset | NLN MirageChange in the dashboard or by call, reset an account or the whole Mirage |
| Sharing with a team | A local test validatorEveryone runs their own | A public test networkShared with every user | NLN MirageOne endpoint for your team, isolated from other customers |
| What it costs | A local test validatorYour machine and your time | A public test networkFree, with limited faucets | NLN Mirage+$250/mo (included in Enterprise), within your plan’s request rate |
10What it is for
What teams use it for
Five jobs, each with the calls it leans on. Every one starts from real accounts, because that is where a Mirage starts.
- 01
Test a swap against real liquidity
Fund a wallet, set a token balance and send your swap through the real pool, without spending anything.
mirage_setAccountmirage_setTokenAccountmirage_profileTransaction - 02
Rehearse a liquidation bot
Move an oracle or the clock until a position is underwater, then see whether your bot gets there first.
mirage_setAccountmirage_timeTravelmirage_getLocalSignatures - 03
Check an upgrade before it ships
Deploy the new version over a fork of the real state and run the transactions that matter against it.
mirage_writeProgrammirage_setProgramAuthoritymirage_cloneProgramAccount - 04
Test a wallet or app with any balance
Give a test account whatever it needs, in any token, and put it back when the test is over.
mirage_setTokenAccountmirage_resetAccountmirage_resetNetwork - 05
Audit a protocol against real state
Profile each path, export a snapshot of what it touched and share one Mirage with the whole review.
mirage_profileTransactionmirage_exportSnapshotmirage_registerIdl - 06
Yours
Whatever you need to test against real state. Tell us the first thing you would try.
Email us your use
11Getting started
From a plan to a fork, in three steps
- 1
Add NLN Mirage to your plan
It is +$250/mo on top of Pro, Ultra and Max, and included in Enterprise. It opens when it launches. Email us and we will tell you.
- 2
Create your Mirage
In the dashboard. You get an HTTP endpoint and a WebSocket endpoint, both reached with your usual RPC key.
- 3
Point your tests at it
Change the endpoint your tests send to, then set up the world with the dashboard or the special calls.
NLN Mirage: questions
Not here? Email [email protected] or talk to sales.
What is NLN Mirage?
NLN Mirage is a hosted Solana network simulator from NoLimitNodes, coming soon. You get your own isolated Mirage behind your usual RPC key. It forks mainnet on demand from our own nodes, so you can test against real state, from the dashboard or with special RPC calls.
How is it different from a local test validator?
A local test validator starts empty, and you copy in the accounts you need. A Mirage starts as mainnet and fetches an account the first time something touches it, so there is no snapshot to download and nothing to run. We host it, and you reach it by endpoint.
Where does the data come from?
From our own nodes. Your Mirage fetches an account from mainnet the first time something touches it, then holds it, so a second send pulls nothing more. You bring no RPC key to make that happen.
Do I need a second key?
No. You use the same RPC key as your plan, sent as the x-api-key header, the same as on your other endpoints.
What does it cost?
+$250/mo on Pro, Ultra and Max, and included in Enterprise. It shares your plan’s requests per second, so there is no second limit to manage.
Does it count against my requests per second?
Yes. Requests to your Mirage count against the same requests per second as the rest of your traffic on your plan.
Is my Mirage private?
Yes. Each customer gets their own isolated Mirage. The changes you make in yours are never seen by anyone else, and you never see theirs.
What can I change?
Balances, token accounts, account data, programs, program authorities, supply and the clock, and you can reset an account or your whole Mirage. You do it in the dashboard or with the special calls, which do the same thing. There are twenty-eight calls in seven families, all listed on this page.
Does it support the full Solana RPC API and WebSocket?
Yes. Your Mirage speaks the full Solana RPC API and WebSocket subscriptions as well as the special calls, so your existing code and tools keep working against it.
When can I get it?
NLN Mirage is coming soon. We have not set a date to publish here. Email [email protected] and we will tell you when it opens.
NLN Mirage is coming soon.
Your own mainnet fork, hosted for you, behind the key you already have. +$250/mo, included in Enterprise, sharing your plan’s requests per second.
Questions first? Email [email protected] or talk to sales.