PROTOCOL SPECIFICATION
NoN Bond: Private Bonds by Commitment on Robinhood Chain
Scope. This document describes the protocol as deployed. Sections marked PLANNED are not live. Where the text and the published source differ, the source governs.
Abstract
NoN Bond lets a holder commit to an asset without publishing it. The holder's browser hashes the asset together with a random salt and a one-time key into a single SHA-256 commitment. The commitment reveals nothing about its inputs, yet the holder can later open it to one counterparty, who recomputes the hash and learns exactly one bit: the receipt matches or it does not. Commitments can be anchored on Robinhood Chain in a transaction from the holder's own wallet, carried as an ERC-721 token by the NonBondNFT collection, retired by publishing a nullifier, and passed to a new holder inside an AES-GCM package, after which the new holder re-cloaks under fresh key material. The protocol uses no zero-knowledge proofs, no trusted server and no custody. The $n0n token gates issuance of bond NFTs, funds a public holder vault, and is the fee currency of a planned Uniswap v4 hook. This paper specifies each component, states what is hidden and what is not, and lists the limitations of the current construction.
1Introduction and motivation
A public ledger makes ownership verifiable by making it observable. Every transfer, mint and contract call from an address is written once and readable forever, and any observer can join those records into a complete picture of what an address holds, when it acquired each position, and what it did next. The same transparency that lets anyone audit a balance lets anyone profile its owner.
Most privacy systems answer this with shielded pools and zero-knowledge proofs. Those systems are powerful and also heavy: they require trusted setups or large circuits, specialised provers, and a new transaction format. NoN Bond takes a narrower position. It does not hide value in transit and it does not hide the chain's own records. It gives a holder a way to state a position without revealing it, to prove that statement to a chosen party on demand, and to hand the statement on without the chain ever learning what was stated.
The primitive is the hash commitment, one of the oldest tools in cryptography. The contribution of this protocol is a complete, deployed workflow around it: key generation and storage in the browser, a receipt format for selective opening, an encrypted transfer package, an anchoring convention on Robinhood Chain, an ERC-721 contract that carries commitments and publishes nullifiers, and a token economy that funds the work. Each piece is small enough to read and check.
2Definitions
- Bond
- A statement about an asset, held privately by one party, represented in public only by its commitment. In the current release the asset is a free-text string chosen by the holder (for example a position, a ticker and size, or a reference). The protocol does not interpret it.
- Commitment
- The 32-byte SHA-256 digest of the asset, the salt and the key, as specified in Section 3. A commitment is the only part of a bond that may appear onchain.
- Receipt
- The opening of a commitment: the asset, the salt, the key and the commitment itself, as one JSON object. Whoever holds a receipt can recompute the commitment and therefore prove or verify the bond. The receipt is the bond's secret.
- Counterparty
- Any party to whom the holder chooses to open a bond. The counterparty receives one receipt and verifies it locally. Nothing about the opening is written to the chain.
- Nullifier
- A second SHA-256 digest derived from the same salt and key under a fixed domain prefix. Publishing it marks the bond as retired without revealing the asset or the commitment's opening. The construction follows the commitment and nullifier pattern used by Zcash [4].
- Holder
- The party whose browser generated the salt and key and who controls the receipt. On the NonBondNFT contract the holder is the address that owns the token.
3Construction
3.1Commitment scheme
All computation in this section runs in the holder's browser using the Web Crypto API. Nothing is sent to a server.
The separator U+241F is a Unicode symbol that does not occur in hex strings, which keeps the three fields unambiguous when concatenated. The asset is an arbitrary UTF-8 string, so the separator could in principle appear inside it; because salt and key have fixed lengths and a fixed alphabet, parsing from the right remains unambiguous. Both digests are 256 bits and are written as lowercase hex, prefixed with 0x when they appear onchain or in a receipt.
3.2Where each value lives
| VALUE | LOCATION | WHO CAN READ IT |
|---|---|---|
| asset, salt, key | Browser local storage on the holder's device | The holder, and anyone with access to that browser profile |
| receipt | Browser storage; copied out only when the holder exports it | The holder and each counterparty it is sent to |
| commitment C | Optionally the chain: an anchoring transaction (Section 6) or the NonBondNFT contract (Section 7) | Everyone, once published |
| nullifier N | The NonBondNFT contract, once the bond is retired | Everyone, once published |
| transfer package | Wherever the sender chooses to deliver it | Anyone who holds the package and the passphrase |
The site serves static files. It operates no database, holds no keys, and has no account system. If the browser profile is cleared, the receipts in it are gone and the corresponding commitments can no longer be opened.
4Proofs
4.1Selective opening
To prove a bond, the holder sends its receipt to one counterparty by any channel. The receipt opens that commitment and no other: a holder with many bonds reveals only the one they choose, and the counterparty learns nothing about the rest.
4.2One-bit verification
The counterparty pastes the receipt into /verify, or recomputes the hash with any SHA-256 implementation. The page parses the JSON, recomputes C' = SHA-256(asset ‖ SEP ‖ salt ‖ SEP ‖ key), and compares C' to the claimed commitment. The output is exactly one bit: verified: true or verified: false. Nothing is transmitted during verification.
4.3What a proof reveals
A verifying receipt proves that the sender holds the opening of that specific commitment, and it discloses the asset string to that counterparty in full. It does not by itself prove when the commitment was created or that it is anchored; for those properties the counterparty checks the anchoring transaction (Section 6) or the commitmentOf mapping on the collection (Section 7). It proves nothing about any other commitment the sender may hold.
5Transfer
5.1Transfer package
A bond changes hands by moving its receipt under encryption. The sender chooses a passphrase; the console derives a 256-bit AES key from it with PBKDF2 (HMAC-SHA-256, 100,000 iterations, a fresh 16-byte salt) and encrypts the receipt with AES-GCM under a fresh 12-byte IV. The result is a single string:
The package and the passphrase should travel by different channels. The protocol does not define a delivery channel; the package is plain text and can be sent over anything.
5.2Import and re-cloak
The recipient pastes the package and passphrase into the console. The console decrypts, checks that the embedded commitment matches SHA-256(asset ‖ SEP ‖ salt ‖ SEP ‖ key), and rejects the package if it does not. On success it immediately re-cloaks: it draws a new salt and key, computes a new commitment C2 for the same asset string, and stores the new receipt. The recipient never has to rely on the sender's key material from that point on.
5.3What a transfer does not do
A transfer does not retire the sender's original commitment. There is no registry that links C to C2, and a hash cannot be made to forget its opening. The sender's old receipt therefore still verifies after the transfer, until the sender discards it or, if the bond was minted, retires the token with its nullifier (Section 7.3). A counterparty who needs assurance that a bond has not also been retained or shown elsewhere must obtain that assurance by other means, for example by requiring the sender to retire the original token onchain. The protocol makes this explicit rather than implying a guarantee it cannot provide.
6Anchoring
A holder who wants a public, timestamped record that a commitment existed can anchor it. The console builds a transaction from the holder's wallet to the same address, with zero value and the commitment as the entire calldata:
The transaction calls no contract and moves no funds; it costs only gas. Once included, the block timestamp bounds when the commitment was known, and any party can later find the transaction by hash and compare its calldata to a receipt's commitment. Anchoring is optional and independent of the NFT collection. It links the commitment to the anchoring wallet, which is a deliberate trade: the holder gains a public timestamp and accepts that the wallet is seen to have published a hash (Section 9).
7Issuance: the bond NFT LIVE
The NonBondNFT contract carries commitments as ERC-721 tokens [6]. It was deployed on 2026-10-04 at 0x2DC6075F4a577FDc8ea6de0Ee0cCb2ECC3CeD4C4 with name NoN Bond and symbol n0nBOND. The source is published at /contracts/NonBondNFT.sol. The description below follows that source.
7.1State
non: the $n0n token address, set once in the constructor and immutable.commitmentOf(tokenId): the commitment a token carries.commitmentCloaked(commitment): true once a commitment has minted; a commitment can mint at most once.nullifierUsed(nullifier): true once a nullifier has been published; a nullifier can be used at most once.nextId,totalCloaked,totalRetired: counters. Token ids start at 1 and are sequential.
7.2Minting: cloakBond(bytes32 commitment)
The caller supplies a commitment. The function requires that the commitment is non-zero, that it has not been cloaked before, and that the caller's $n0n balance is greater than zero. It then assigns the next token id to the caller, records the commitment, and emits Transfer(0, caller, tokenId) and Cloaked(tokenId, commitment, caller). The contract does not verify that the caller knows the opening of the commitment; it accepts any 32-byte value that meets the three requirements. The holder gate is checked at mint time only; selling $n0n afterwards does not affect an existing token.
7.3Retiring: retire(uint256 tokenId, bytes32 nullifier)
Only the current owner of the token may call it. The function requires a non-zero nullifier that has not been used before, marks it used, deletes the token's commitment and approval, clears ownership, and emits Transfer(owner, 0, tokenId) and Retired(tokenId, nullifier). The console computes the nullifier as N = SHA-256("nullify" ‖ SEP ‖ salt ‖ SEP ‖ key) from the receipt. The contract itself does not check how the nullifier was derived; it enforces uniqueness and publishes the value. A published nullifier proves that a holder chose to retire that token without revealing which asset it stood for.
7.4Transfers and approvals
The contract implements ownerOf, balanceOf, approve, setApprovalForAll, transferFrom and both forms of safeTransferFrom with the ERC-721 receiver check, and reports support for ERC-165, ERC-721 and ERC-721 Metadata through supportsInterface. Transferring the token moves the commitment's onchain owner but does not move the receipt; a token transfer without a transfer package (Section 5) gives the new owner a token they cannot open.
7.5Onchain metadata
tokenURI is computed entirely onchain. It returns a base64-encoded JSON document containing the name NoN Bond #id, a fixed description, one attribute (commitment, the full 64-hex-character value) and an SVG image that shows the protocol mark and a shortened commitment. There is no external metadata server and no URI that can be changed later.
7.6Administration
The contract has no owner, no admin role, no pause function and no upgrade path. Nothing can be frozen, seized or reassigned by the project.
8Economics: $n0n
8.1Token
$n0n is an ERC-20 token at 0x82b2526cc11fef76c482b3b8161c493469eb3615 on Robinhood Chain (chain id 4663). It launched on 2026-10-03 on the Pons launchpad and bonded on 2026-10-04 into a Uniswap v4 pool. Total supply is 1,000,000,000 $n0n. Over 35M $n0n had been burned at the time of writing; the live figure is on the site. Within the protocol the token has three roles: it gates minting on the NonBondNFT collection (Section 7.2), it is the asset the holder vault distributes (Section 8.2), and it is the fee currency of the planned v4 hook (Section 8.3).
8.2Holder vault LIVE
The vault is a wallet, funded at the project's discretion, that pays the eighteen highest-weighted $n0n holders each cycle. Its rules, its balance, and every cycle's receipt are published at /vault.
| RULE | DEFINITION |
|---|---|
| Eligible set | The Top 18 holders ranked by weight at one snapshot block per cycle. Rank 19 and below receive nothing that cycle. |
| Weight | weight = amount x multiplier. The multiplier is 1.0x from day 0 of holding, 1.5x from day 7 and 2.0x from day 30. |
| Holding time | Computed FIFO from the token's Transfer logs. Tokens that leave a wallet are taken from its oldest lot; tokens received open a new lot at 1.0x and leave older lots untouched. |
| Budget | A percentage of the vault's ETH balance per cycle, capped per cycle and per address. Each receipt states the rule its cycle used. |
| Payment | The whole budget is spent on one $n0n purchase. The $n0n received is split among the eighteen in proportion to weight, one transfer each. |
| Receipts | Every cycle publishes its snapshot block, budget, purchase transaction and the eighteen transfer transactions. |
Funding is discretionary and can be zero. A cycle pays what the wallet holds under its rule that day. Nothing about the vault is a return, a rate or a promise.
8.3Uniswap v4 fee hook PLANNED
NonV4FeeHook is written and published at /contracts/NonV4FeeHook.sol. It is not deployed, and no fee is currently taken on $n0n swaps by this contract. Its logic, as written:
- It registers the
afterSwapandafterSwapReturnDeltapermissions and accepts calls only from the Uniswap v4 PoolManager [5]. - It applies only when $n0n is the output currency of the swap, that is, when the swap buys $n0n. Swaps that sell $n0n pay nothing to the hook.
- The fee is
FEE_BPS = 30, 0.30% of the $n0n output. - Of the fee,
BURN_BPS = 8000, 80%, is sent to the dead address0x…dEaD; the remaining 20% is sent to a prover fund address fixed at deployment. - It emits
FeeSettled(fee, burned, toProvers)and keepstotalBurnedandtotalToProverscounters.
Deploying a v4 hook requires an address whose low bits encode its permission flags. The published file mirrors the v4 types it touches so the logic can be read standalone; the production build compiles against v4-core and v4-periphery. Until a deployment is announced on the site with its address, this section describes intent, not behaviour.
9Security model and limitations
9.1What is hidden
- The asset string of a bond, from everyone except counterparties the holder chooses.
- The link between two commitments that stand for the same asset after a transfer.
- Which asset a retired token stood for; the nullifier reveals only that a retirement happened.
9.2What is not hidden
- Amounts are not hidden by the protocol. A commitment hides whatever is in the asset string, but the protocol does not shield token balances, swap sizes or NFT ownership. The $n0n balance of every address is public, and the vault publishes its Top 18.
- The funding wallet is visible. Anchoring a commitment or minting a bond NFT is an ordinary transaction from the holder's wallet. The chain records that this wallet published this hash at this time. Anyone can count a wallet's commitments and tokens.
- Timing is visible. Block timestamps of anchors, mints and retirements are public and can be correlated.
- Token ownership is visible. NonBondNFT is a standard ERC-721;
ownerOfand the Transfer log are public. - The asset is revealed in full to each counterparty. A proof is an opening, not a range or predicate proof. The counterparty can keep and forward the receipt.
9.3No zero-knowledge proofs
The protocol contains no ZK circuits. Every proof is a plaintext opening checked by recomputing a hash. This keeps the system auditable in a few hundred lines but rules out proving properties of a bond without disclosing it.
9.4Commitment assumptions
Hiding rests on the 32-byte key: an attacker who guesses an asset string still cannot confirm the guess without the key, and the key space is 2256. Binding rests on SHA-256 collision resistance [1]: a holder cannot produce two openings for one commitment. Both are standard assumptions for hash commitments. Randomness comes from crypto.getRandomValues; a browser with a defective random source weakens the scheme.
9.5Transfer does not revoke
As stated in Section 5.3, the sender's receipt remains a valid opening after a transfer. A sender who keeps it can still prove the original commitment. Recipients who require exclusivity should require the sender to retire the minted token, and should treat an unminted bond as a statement by its sender rather than an exclusive asset.
9.6Browser and device trust
The console, verifier and all key material run in the browser. The holder trusts the device, the browser, any extensions with page access, and the integrity of the files served from nonbond.trade at the time of use. A compromised device exposes every receipt in storage. Clearing site data destroys them. Users are responsible for backing up receipts they need.
9.7Transfer package strength
PBKDF2 at 100,000 iterations slows but does not prevent offline guessing of a weak passphrase by someone who obtains the package. Passphrases should be long and random, and the package and the passphrase should not travel together.
9.8Contract risk
No external audit has been performed on NonBondNFT or NonV4FeeHook. The contracts are short and the source is published, but unreviewed code can contain defects. The NFT contract does not check that a minter knows a commitment's opening, so a token proves only that someone holding $n0n chose to publish that value. There is no funded bug bounty at the time of writing; a bounty is listed as Planned in Section 10, and responsible disclosures are welcome through the project channels linked from the site.
10Roadmap PLANNED
Items in this section are intentions. None is live, none has a date, and any of them may change or be dropped. Delivery is announced on the site when it happens.
- Deployment of NonV4FeeHook on the $n0n pool with the split in Section 8.3, and publication of the prover fund address.
- Definition of the prover fund's disbursement rules.
- A bug bounty for the published contracts and the console.
- An external review of NonBondNFT and NonV4FeeHook.
- A receipt export format for offline backup, so that clearing a browser does not destroy bonds.
- An optional convention for linking a transfer to the retirement of the sender's token, so recipients can require exclusivity in one step.
AAppendix A: contract addresses and function selectors
| ITEM | VALUE | STATUS |
|---|---|---|
| Network | Robinhood Chain, chain id 4663 | live |
| $n0n token | 0x82b2526cc11fef76c482b3b8161c493469eb3615 | live, launched 2026-10-03 |
| NonBondNFT | 0x2DC6075F4a577FDc8ea6de0Ee0cCb2ECC3CeD4C4 | live, deployed 2026-10-04 |
| NonV4FeeHook | not deployed | planned |
cloakBond(bytes32) | selector 0xb6064305 | live |
retire(uint256,bytes32) | selector 0x3fc094cc | live |
| Mint calldata | 0xb6064305 ‖ C (32 bytes) | live |
| Retire calldata | 0x3fc094cc ‖ tokenId (32 bytes, left-padded) ‖ N (32 bytes) | live |
| Anchor calldata | 0x ‖ C, sent from the holder to the holder with zero value | live |
BAppendix B: receipt and package formats
B.1Receipt
B.2Transfer package
B.3Nullifier
References
- National Institute of Standards and Technology. Secure Hash Standard (SHS). FIPS PUB 180-4, 2015.
- M. Dworkin. Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC. NIST Special Publication 800-38D, 2007.
- K. Moriarty, B. Kaliski, A. Rusch. PKCS #5: Password-Based Cryptography Specification Version 2.1. RFC 8018, 2017.
- D. Hopwood, S. Bowe, T. Hornby, N. Wilcox. Zcash Protocol Specification, note commitments and nullifiers.
- Uniswap Labs. Uniswap v4 Core, hooks and the PoolManager.
- W. Entriken, D. Shirley, J. Evans, N. Sachs. ERC-721: Non-Fungible Token Standard. Ethereum Improvement Proposals, 2018.
Version history
| 1.0 | 2026-09-28 | Initial publication. |
| 1.1 | 2026-10-05 | $n0n bonded into a Uniswap v4 pool; NonBondNFT collection deployed; holder vault live with public receipts; security section expanded; appendices added. |
This document is informational. Risk, eligibility and the launch terms are set out in the Terms. Nothing here is financial advice.