What MagnoPrivate does
Three things, in the order you would use them:
- Inspects a token. You paste a mint address and the app reads the mint account from the network: supply, decimals, who can mint or freeze, which Token-2022 extensions are active, whether metadata can change, and the largest token accounts when the network endpoint serves them.
- Quotes and prepares a public swap. The app asks Jupiter’s onchain router for a route, assembles one transaction from the route’s raw instructions, simulates that exact transaction, checks its structure, and shows you the result before your wallet is involved.
- Follows the transaction. After you sign, the app tracks the signature until the network gives a final answer and writes a receipt from the transaction’s own balance records.
It is non-custodial. There is no account, no deposit and no server-side key. The server cannot sign or move anything; it prepares unsigned transactions and relays reads.
What is live
The table below is produced by this deployment when it probes its own network endpoint and quote provider. It is the same data the landing page and the app show.
Token inspection
Live
Reads mint accounts, authorities, extensions and largest accounts from the network.
Executable quotes
Live, limited
Routed by Jupiter’s onchain router. Running without a provider key, so requests are rate limited.
Public swap
Live, limited
You review and sign each swap in your wallet. The transaction is visible on-chain.
Private batch execution
In development
No batch service, custody or privacy mechanism is deployed. Orders cannot be submitted.
Platform fee
Not offered
MagnoPrivate charges no fee. Network and route costs are shown before you sign.
Platform token
Not offered
There is no MagnoPrivate token. None is needed to use the product.
Solana mainnet · network identity verified · checked 09:32:27 UTC
No audit has been performed. MagnoPrivate deploys no on-chain program of its own: swaps execute through Jupiter’s deployed aggregator program. The project is not affiliated with Solana, Jupiter or any wallet, and there is no MagnoPrivate token.
Public and private execution
Public swap: available
Public swap — transaction activity is visible on-chain. A public swap is an ordinary Solana transaction. Anyone can see the wallet that signed it, the tokens and amounts, the venues it went through and the time. The app labels this mode “Public swap” everywhere and never describes it as private.
A public swap is immediate: it executes at the market price within your slippage tolerance, or it fails. It is not a limit order, and saving a preference does not create an order. Nothing is monitored or executed after you leave the page.
Private batch: in development
Private batches are in development. The switch in the trading panel shows this and submits nothing. A private batch needs infrastructure that does not exist yet: an order protocol, a custody or escrow model, a batch service, a settlement mechanism and a privacy mechanism whose guarantees can be stated precisely. Until those exist and have been reviewed, the mode stays off. The design and its privacy assumptions are written down below so they can be examined before anything is built on them.
Supported tokens and routes
Routing uses Jupiter’s Swap API V2, router path (/build): onchain venues only, raw instructions, no Jupiter swap fee. A token can be traded when the router finds a route for the pair at the size you ask for.
- Many newly launched tokens have no route, or none at a given size. The app then shows “No supported execution route is available.” and offers nothing else.
- Both SPL Token and Token-2022 mints are read. A token that is non-transferable or paused cannot be swapped, and the app says so.
- A token with a transfer fee can be swapped; the fee is withheld by the token program and the app warns about it.
- Quotes and swaps need Solana mainnet. On devnet the app inspects tokens and nothing more.
- Balances are read from your wallet’s associated token account for each mint, which is where wallets and routers keep tokens by default. Tokens held in a non-standard token account are not counted.
Token inspection
Inspection validates, in order: that the text is a 32-byte base58 address; that an account exists there; that it is owned by the SPL Token or Token-2022 program; and that it is a mint rather than a token account or a multisig.
Then it reports facts, each stated as a fact:
- “Mint authority enabled.” or “disabled”, and the same for the freeze authority.
- Token-2022 extensions: transfer fee, permanent delegate, transfer hook, non-transferable, default frozen accounts, pausable, mint close authority, confidential transfers, interest-bearing and scaled display amounts.
- “Metadata can be updated.” when the name and symbol can still change.
- The twenty largest token accounts, grouped by owner, with owners that are program addresses marked as such.
- Market figures from Jupiter’s token index, labelled with their source and age.
Limits of inspection
- There is no safety score and no “safe” label. Authority checks cannot tell you that a token is safe, and a clean list has preceded many losses.
- The largest accounts are token accounts, not people. One owner can hold several accounts; a pool or a bonding curve is an owner too. It is never presented as a holder distribution.
- Shared public RPC endpoints refuse largest-account queries. The report then says “Holder distribution unavailable.”
- Inspection reads the token program’s account. It does not review the team, contracts outside the token program, or liquidity that can be withdrawn.
Untrusted metadata
Names, symbols and descriptions are written by whoever created the token. They are stripped of control and direction-override characters and shortened before display. A token’s metadata file is fetched by the server only over https, only from a public address checked at connection time, with a size and time limit, and never follows more than two redirects. Images named by a token are never loaded; icons come only from the token index’s own image host, through this site.
Quotes and slippage
- Amounts are integers. Token amounts are converted to raw units with integer arithmetic and are never passed through floating point.
- Minimum received. For a quoted output and a tolerance in basis points, the minimum is the quoted output times (10,000 − tolerance) ÷ 10,000, rounded down. The swap program enforces it on-chain: if the swap would deliver less, the transaction fails.
- Quotes expire. A quote can be acted on for 30 seconds. After that the app asks you to refresh, and the old figures cannot be reviewed.
- Changing an input invalidates the quote. A quote belongs to one pair, one amount, one tolerance and one wallet. Change any of them and the previous answer is discarded.
- What you review is what you sign. Pressing “Review swap” prepares a fresh transaction. The figures on the review screen belong to that transaction. If they are worse than the quote you saw by more than 0.1%, you are told and must accept the new figures explicitly.
Checks before you sign
The server assembles the transaction from the router’s instructions and compiles it against lookup tables read from the chain. Before your wallet sees it, two things happen.
Structure
The same checks run on the server and again in your browser, on the bytes that will be handed to the wallet:
- Your wallet is the fee payer and the only signer.
- Only the expected programs are called: compute budget, system, the two token programs, the associated token program and Jupiter’s aggregator.
- There is exactly one swap instruction, and it is authorised by your wallet.
- The priority price is at or below this deployment’s ceiling of 2,000,000 micro-lamports per compute unit.
- SOL moves only into your own wrapped-SOL account, and never more than the amount you entered.
- Token accounts are opened for your wallet only, at their standard addresses.
- There are no direct token transfers, approvals or authority changes.
Simulation
The exact message is simulated on the network. The simulated balance changes must show your wallet receiving at least the minimum and spending no more than you entered. A failed simulation blocks signing. If the network cannot simulate, the review says so and asks before continuing.
After signing
The signed transaction is compared with the reviewed one. Identical bytes pass. If a wallet has appended its own guard instructions, every reviewed instruction must still be present and unchanged and the additions must be of a known kind; anything else stops the process and nothing is sent.
These checks cover what the transaction format exposes. They cannot see inside the route itself; that is what the simulation and the on-chain minimum are for.
Fees
- Network fee: 5,000 lamports per signature, paid to the network.
- Priority fee: the router’s estimate, capped at 2,000,000 micro-lamports per compute unit. The review shows the most it can cost.
- Route cost: price impact and the trading fees of the venues on the route are inside the quoted output. The router path adds no Jupiter swap fee.
- Account rent: the first time your wallet receives a token, a token account is opened and a rent deposit is locked in it. It is yours and returns when the account is closed.
- Platform fee: none. No fee instruction is added and no fee account is passed to the router. If a fee is ever introduced, its rate and recipient will be shown before signing, documented here and printed on receipts.
There is no platform token, no staking, no rewards and no revenue sharing.
Confirmation and receipts
A signature returned by a wallet is not a confirmation. Each transaction moves through explicit states:
- Awaiting signature: your wallet is showing the transaction. Nothing has been sent.
- Submitted: the network has the signature. Not yet proof that it landed.
- Confirmed, then finalized: the block that holds it has been voted on, then made final.
- Failed: it ran and was rejected, for example by the slippage limit. Nothing was exchanged; the network fee was paid.
- Expired: its blockhash ran out and, after repeated checks, the network has no record of it.
- Confirmation unknown: the network could not be asked. The app says so and keeps asking; it does not guess.
While a transaction is unconfirmed and its blockhash is still valid, the app re-sends the same signed bytes. That cannot execute it twice. It never builds or signs a replacement on its own.
A receipt distinguishes the quoted output from the settled one. The settled amount is derived from the confirmed transaction’s balance records. If it cannot be derived, the receipt prints “Unavailable” rather than repeating the quote.
The planned batch mechanism
Status: design only. Private batches are in development. Nothing in this section is deployed, and no order can be submitted.
The idea is a batch that clears at one price. Orders that are compatible with each other are matched internally, so they do not move the market against one another, and only the unmatched remainder is routed to a liquidity venue.
- Eligible orders enter a batch.
- Compatible buys and sells are matched.
- Remaining volume routes to supported liquidity.
- Settlement results become available for review.
Matching does not eliminate price impact: the remainder still trades on a venue and pays what that venue charges. It does not guarantee a fill either: an order whose limit is not met sits the batch out. A batch interval (for example 15 seconds) would be a schedule, not a settlement guarantee.
Rules of the reference engine
The matching rules are implemented as a pure function in this repository, with tests, so the arithmetic can be examined before any infrastructure exists:
- Order terms: pair, side, input amount, limit price, minimum fill, whether partial fills are allowed, slippage tolerance for the routed remainder, expiry, and a nonce. The signed message binds all of them to one wallet and one network.
- Eligibility: wrong network or pair, a bad signature, an expired order, a reused nonce or a cancellation before the cutoff removes an order. A cancellation after the cutoff is too late for that batch.
- Price: one clearing price per batch, taken from a supported venue’s reference price when the batch closes. A buy takes part only if its limit is at or above it, a sell only at or below.
- Priority: the smaller side fills completely. The larger side fills by better limit first, then earlier arrival, then order id, so the result does not depend on the order in which orders are processed.
- Remainder: routed per order, only if the venue’s price respects both the order’s limit and its tolerance.
- Partial fills: an all-or-nothing order, or one with a minimum fill, is removed entirely when the batch cannot satisfy it, and the batch is matched again without it.
- Rounding: every conversion rounds in favour of the pool. An order is never filled if rounding would push it past its limit. Leftover units are counted as dust and reported.
- Fees: taken from each order’s output at a stated rate, zero by default, and included in the accounting.
- Failed settlement: a batch settles as a whole or not at all. On failure every input is returned, no fee is charged and the nonces are released so the orders can enter a later batch.
The engine asserts three invariants: no order spends more than it authorised; no fill is outside the order’s limit; and for each asset, what came in equals what went out plus refunds, fees and dust.
Try the rules
| Order | Side | Amount in | Limit price | Partial fill | Result | Matched | Routed | Received | Refunded | Remove |
|---|---|---|---|---|---|---|---|---|---|---|
| A | quote | Filled | 500 | 0 | 250 base | 0 | ||||
| B | quote | Partly filled | 100 | 0 | 50 base | 200 | ||||
| C | quote | Not filledthe clearing price does not meet its limit | 0 | 0 | 0 base | 200 | ||||
| D | base | Filled | 180 | 0 | 360 quote | 0 | ||||
| E | base | Filled | 120 | 0 | 240 quote | 0 | ||||
| F | base | Not filledthe clearing price does not meet its limit | 0 | 0 | 0 quote | 90 |
- Sent to the venue
- 0 quote · 0 base
- Rounding dust
- 0 quote · 0 base
- Every unit accounted for
- Yes: in = out + refunds + fees + dust, for both assets
What still has to exist
- An order submission protocol with signature verification and replay protection on the server and on-chain.
- A custody or escrow model: where funds sit between submission and settlement, and who can move them.
- A batch service with durable storage, scheduling and recovery after a failure.
- An on-chain settlement program, reviewed and audited, and rules for refunds when settlement fails.
- A privacy mechanism with guarantees that can be stated and checked.
No financial program will be deployed to mainnet without an explicit decision, a review and an audit.
Privacy assumptions
Today
There is no privacy feature. A public swap reveals, on a public ledger, the wallet, the tokens, the amounts, the venues and the time. This site sees the requests your browser makes to it (for example which mint you inspect or quote); it does not store them, and it has no accounts to tie them to.
What a private batch would have to state before it can be called private
- What is hidden: at most, an order’s size, side and limit between submission and settlement.
- From whom: from other traders and from observers of the public ledger during that window. Not necessarily from the operator.
- What becomes public at settlement: settlement is an on-chain transaction. The net amounts that move, the venue leg and the participating accounts are visible unless the settlement design specifically prevents it.
- What the operator can see: in a server-run batch, the operator sees every order in clear. That is a trust assumption, and it would be stated as one.
- What is retained: which order data is stored, for how long, and who can read it.
- Linkability: whether a deposit and a later withdrawal can be linked by amount, timing or address. If they can, the design does not hide who traded.
Two things are not privacy on their own. A private database on a server does not make anything private on-chain. A hash commitment hides an order’s contents until it is revealed, but not that the order exists, who posted it or what is settled afterwards. MagnoPrivate does not use custom cryptography and does not claim any proof system.
Local data
Three things are stored in your browser’s local storage, and nowhere else:
- Settings: default slippage tolerance, quote refresh interval, block explorer and motion preference.
- Watchlist: the mint addresses you saved.
- Activity: a receipt for each swap signed from this browser.
They do not follow you to another device and are not sent to a server. Settings → Local data clears them. Clearing history removes receipts from this device; the transactions stay on-chain. The signed bytes of a transaction are held in memory only while it is being followed and are never written to storage.
Running your own copy
The repository’s README has the full setup. In short: Node 22 or later and pnpm; copy .env.example to .env.local; run pnpm install and pnpm dev.
- NEXT_PUBLIC_SOLANA_CLUSTER: the network. This deployment runs on Solana mainnet.
- SOLANA_RPC_URL: a server-side RPC endpoint. This deployment reads from mainnet.helius-rpc.com.
- JUPITER_API_KEY: optional. Without it, quotes run on Jupiter’s keyless tier, which is rate limited. This deployment has no key configured.