NoN Bond

PROTOCOL SPECIFICATION

NoN Bond: Private Bonds by Commitment on Robinhood Chain

VERSION
1.1
DATE
October 2026
NETWORK
Robinhood Chain, chain id 4663
TOKEN
$n0n
0x82b2526cc11fef76c482b3b8161c493469eb3615
COLLECTION
NonBondNFT (n0nBOND)
0x2DC6075F4a577FDc8ea6de0Ee0cCb2ECC3CeD4C4

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.

// key material salt = 16 random bytes, hex encoded (32 characters) key = 32 random bytes, hex encoded (64 characters) // commitment, SEP is the single character U+241F C = SHA-256( UTF-8( asset ‖ SEP ‖ salt ‖ SEP ‖ key ) ) // nullifier, same material under a fixed domain prefix N = SHA-256( UTF-8( "nullify" ‖ SEP ‖ salt ‖ SEP ‖ key ) )

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.

Figure 1: the asset, salt and key are hashed in the browser into one commitment; only the commitment may leave the device. HOLDER'S BROWSER asset salt (16 B) key (32 B) SHA-256 commitment C 0x… 32 bytes, the only public value receipt = { commitment, salt, key, asset } stays in browser storage
Figure 1. Commitment flow. The asset and two random secrets are hashed once in the holder's browser. The digest can be published; the inputs cannot be recovered from it.

3.2Where each value lives

VALUELOCATIONWHO CAN READ IT
asset, salt, keyBrowser local storage on the holder's deviceThe holder, and anyone with access to that browser profile
receiptBrowser storage; copied out only when the holder exports itThe holder and each counterparty it is sent to
commitment COptionally the chain: an anchoring transaction (Section 6) or the NonBondNFT contract (Section 7)Everyone, once published
nullifier NThe NonBondNFT contract, once the bond is retiredEveryone, once published
transfer packageWherever the sender chooses to deliver itAnyone 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.

Figure 2: the holder sends one receipt to one counterparty; the counterparty recomputes the hash and gets a single true or false. HOLDER receipt of bond C receipt of bond C2 (kept) one receipt is sent, others never leave any channel COUNTERPARTY, /verify SHA-256 C' == C ? true false revealed: the asset string of this one bond not revealed: any other bond, any key reuse, any history
Figure 2. Prove and open. The counterparty's own browser recomputes the digest and compares it. The answer is a single bit.

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:

nonxfer1.<base64 pbkdf2Salt>.<base64 iv>.<base64 ciphertext> plaintext = JSON { asset, salt, key, h } // h is the commitment without 0x kdf = PBKDF2-HMAC-SHA-256, 100 000 iterations, 16-byte salt cipher = AES-256-GCM, 12-byte IV, 128-bit tag

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.

Figure 3: the receipt is sealed in an encrypted package, the recipient decrypts it, verifies it and re-cloaks under a fresh salt and key; the old commitment remains valid. SENDER receipt (C) PBKDF2 + AES-GCM C still verifies until discarded or retired nonxfer1.… package + passphrase RECIPIENT decrypt, check C new salt, new key receipt (C2) no onchain link exists between C and C2
Figure 3. Transfer and re-cloak. The receipt moves inside an encrypted package; the recipient derives an unrelated commitment. The sender's commitment is not invalidated by the transfer itself.

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:

eth_sendTransaction { from: holder to: holder // self-transaction value: 0x0 data: 0x<C> // 32 bytes, the commitment }

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

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.

RULEDEFINITION
Eligible setThe Top 18 holders ranked by weight at one snapshot block per cycle. Rank 19 and below receive nothing that cycle.
Weightweight = 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 timeComputed 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.
BudgetA percentage of the vault's ETH balance per cycle, capped per cycle and per address. Each receipt states the rule its cycle used.
PaymentThe whole budget is spent on one $n0n purchase. The $n0n received is split among the eighteen in proportion to weight, one transfer each.
ReceiptsEvery 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:

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

9.2What is not hidden

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.

AAppendix A: contract addresses and function selectors

ITEMVALUESTATUS
NetworkRobinhood Chain, chain id 4663live
$n0n token0x82b2526cc11fef76c482b3b8161c493469eb3615live, launched 2026-10-03
NonBondNFT0x2DC6075F4a577FDc8ea6de0Ee0cCb2ECC3CeD4C4live, deployed 2026-10-04
NonV4FeeHooknot deployedplanned
cloakBond(bytes32)selector 0xb6064305live
retire(uint256,bytes32)selector 0x3fc094cclive
Mint calldata0xb6064305 ‖ C (32 bytes)live
Retire calldata0x3fc094cc ‖ tokenId (32 bytes, left-padded) ‖ N (32 bytes)live
Anchor calldata0x ‖ C, sent from the holder to the holder with zero valuelive

BAppendix B: receipt and package formats

B.1Receipt

{ "commitment": "0x<64 hex>", // C "salt": "<32 hex>", // 16 random bytes "key": "<64 hex>", // 32 random bytes "asset": "<utf-8 string>" } // valid iff SHA-256(asset ‖ U+241F ‖ salt ‖ U+241F ‖ key) == commitment

B.2Transfer package

nonxfer1 . base64(pbkdf2Salt[16]) . base64(iv[12]) . base64(ciphertext) key = PBKDF2(passphrase, pbkdf2Salt, 100000, SHA-256) -> AES-256 ciphertext = AES-GCM(key, iv, UTF-8(JSON { asset, salt, key, h })) // h is the commitment C without the 0x prefix // a package whose decrypted h != SHA-256(asset ‖ SEP ‖ salt ‖ SEP ‖ key) is rejected

B.3Nullifier

N = SHA-256( UTF-8( "nullify" ‖ U+241F ‖ salt ‖ U+241F ‖ key ) )

 References

  1. National Institute of Standards and Technology. Secure Hash Standard (SHS). FIPS PUB 180-4, 2015.
  2. M. Dworkin. Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC. NIST Special Publication 800-38D, 2007.
  3. K. Moriarty, B. Kaliski, A. Rusch. PKCS #5: Password-Based Cryptography Specification Version 2.1. RFC 8018, 2017.
  4. D. Hopwood, S. Bowe, T. Hornby, N. Wilcox. Zcash Protocol Specification, note commitments and nullifiers.
  5. Uniswap Labs. Uniswap v4 Core, hooks and the PoolManager.
  6. W. Entriken, D. Shirley, J. Evans, N. Sachs. ERC-721: Non-Fungible Token Standard. Ethereum Improvement Proposals, 2018.

Version history

1.02026-09-28Initial publication.
1.12026-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.