Succinctness & Lightning, Neptune's killer app?

You open a program, it downloads and verified the latest block which takes less than a second. You are then synced to the chain.

You immediately get an address that you can send NPT to. Once you’ve sent NPT to that address from e.g. an exchange, the program automatically opens up a lightning channel.

This takes up one to two block times to be mined, so 5–20 minutes with the current block time. The opening of this channel only happens once, on each device.

Once the channel is open, you can send NPT, or other assets, everywhere in the world, instantaneously. Because of succinct block validation, program is a full node. And it is simultaneously a lightning wallet. Money can be sent immediately after the program is opened, even if the device was turned off.

To be clear, this application has not been programmed yet. But this is what Neptune’s technology can offer once succinctness has been activated.

Some challenges arise from this vision:

  1. on-ramp: How do people buy their first NPT?
  2. channel closure: If the wallet is not always online, how does it react if the counterparty to the lightning channel maliciously closes the channel in their favor? I think it’ll have to outsource this preventive channel closure somehow.
1 Like

I’m optimistic that the on-ramp issue will resolve itself as adoption grows and the UX improves. A larger user base will drive more demand, attracting more services and liquidity through CEXs, DEXs, and other channels. In that sense, adoption and accessibility can reinforce each other.

Related to this topic, web-based payment plugins could be an interesting area to explore once succinct nodes are live. Making it easy to pay with NPT and ensuring there are services that accept it will be important for unlocking more use cases for Neptune.

1 Like

The only people I’ve seen offering a non-custodial yet consistently working lightning experience - because they integrate into their apps their own lightning channels services - are Phoenix and Zeus wallets (although Zeus is far more advanced and their own lightning channel service is optional).

The downside of the seamlessness is that these companies (Phoenix always, and Zeus if you use their channel service) can track your transactions (although it’s still far more private than fiat as you have no-KYC, can use VPN, can regularly create new wallets, etc.)

A great way to grasp lightning (and all the PITAs involved with it) is to setup Zeus wallet, skip their own channel service, manually purchase lightning channels on lnbig.com, lnode.io, etc., and hook these channels into your Zeus wallet. This is the PITA required under the hood to have inbound capacity of lightning-BTC. (Turning just an L1-BTC deposit into a lightning channel gives you only a channel with outbound capacity.)

Yes, but only if the other party somehow obtained inbound capacity of lightning-NPT. We could count that as the 3rd challenge.

As a starter, the NPT community could (e.g. after a community funding) offer a website where lightning-NPT channels can be purchased/rented.

2 Likes

Privacy on BTC lightning is basically:

  • So-called good sender privacy (because in-between hop node does not expose from-node to the to-node). So AFAIK the sender privacy assumes a decentralized enough network. Sadly this is not the case with lightning-BTC as most lightning traffic goes through the big Zeus/Phoenix/Aqua/etc. services AFAIK.
  • Bad receiver privacy (because receiver exposes node ID).
  • When interfacing lightning-BTC ↔ L1-BTC one is of course inevitably dealing with crappy L1-BTC privacy.

If somehow NPT can offer lightning with even better privacy characteristics than lightning-BTC, yes it’s a true killer app indeed. We’re headed for a 10,000 USD/NPT price :fire: :rocket: at least if this feat can be pulled off.

2 Likes

Great post. I’ve been sketching exactly this as an elastOS capsule, and I think it answers both of your open challenges.

The idea: NEAR Intents UX, without the leaks. NEAR Intents nailed the UX (one signature, any chain), but intents go to solvers in clear, settlement sits in a public verifier contract, and every swap links to one fixed account. Run the same flow on the elastOS Runtime with Neptune as the settlement layer and it becomes private end to end:

  1. The user signs an intent with a one-time DID and seals it to 3–5 chosen solver DIDs. It is never broadcast.
  2. Solvers answer with DID-signed quotes over the P2P carrier, and the user picks one.
  3. The user locks NPT in a Neptune HTLC lock script (preimage of H, or refund after time T).
  4. The solver locks BTC, ETH or USDC under the same H with a shorter timeout.
  5. The user claims the solver’s asset, revealing the preimage, and the solver then claims the NPT. Payment notices go off-chain to DIDs.

Nobody can steal; worst case a solver’s funds sit until the timeout.

Why the elastOS Runtime. The app is a sandboxed WASM capsule with no ports, no domains and no keys. A native neptune provider holds the keys, wallet and STARK proving, and the capsule only gets scoped, expiring capability tokens. Peers find each other by DID over the carrier, never by URL, the node runs with --no-incoming, and messages are already sealed with hybrid ML-KEM-768 + X25519. That matches Neptune’s “nothing visible” model: hidden amounts and parties on-chain, and no IPs, domains or fixed identities around it.

How it maps to your two challenges:

  • On-ramp. Private intent swaps are the on-ramp: USDC or BTC to NPT through a solver and an HTLC, with no exchange account. The first NPT that funds the channel can come straight from a swap.
  • Channel closure while offline. The watchtower becomes a DID service, for example the user’s own always-on elastOS Home node. No domain and no third party, just a peer the wallet trusts by DID.

And with succinctness, the provider checks the chain itself: it takes the tip from any DID peer and verifies one block’s recursive proof, so a lying peer gets caught. Swaps and Lightning channels both rest on hashlocks and timelocks, so one HTLC lock script serves both.

Honest limits: the other chain’s leg is public and timing can link the two locks, a solver sees the amount (but not who sent it), outbound connections expose IPs to peers and relays, and coin upkeep still follows new blocks until succinctness is live.