Adamant

Privacy by default. Verifiable by anyone. Governed by no one.

[Adamant @AdamantProtocol]

Adamant update : it's been a minute.

Quick recap of where we are:

The L1 is deep in build. Privacy-default by design, post-quantum sigs, built to handle real volume. Bytecode verifier shipped. Runtime is ~93% complete. Phase 6 (privacy layer) is next, then mainnet.

But the protocol on its own isn't the point. The point is what people actually use.

So here's what Adamant is becoming:

Chain → privacy-default settlement layer
Bridges → bring assets from BTC, ETH, stablecoins onto Adamant
Device → hardware-secured phone-form-factor purpose-built for sending, spending, saving crypto without the friction

Ledger but usable. Saga but built around a chain designed for it. Cash-like UX backed by hardware-grade security.

Crypto today is two worlds — the technical underground and the apps that copy banks. Neither is what people actually want. The real merge of crypto and everyday life needs both the rails and the device.

That's what we're building. Years of work ahead. Heads down.

More soon.

[Adamant @AdamantProtocol]

@despondent103 Going to take a while loads happening in the background!

[Adamant @AdamantProtocol]

Adamant update : it's been a minute.

Quick recap of where we are:

The L1 is deep in build. Privacy-default by design, post-quantum sigs, built to handle real volume. Bytecode verifier shipped. Runtime is ~93% complete. Phase 6 (privacy layer) is next, then mainnet.

But the protocol on its own isn't the point. The point is what people actually use.

So here's what Adamant is becoming:

Chain → privacy-default settlement layer
Bridges → bring assets from BTC, ETH, stablecoins onto Adamant
Device → hardware-secured phone-form-factor purpose-built for sending, spending, saving crypto without the friction

Ledger but usable. Saga but built around a chain designed for it. Cash-like UX backed by hardware-grade security.

Crypto today is two worlds — the technical underground and the apps that copy banks. Neither is what people actually want. The real merge of crypto and everyday life needs both the rails and the device.

That's what we're building. Years of work ahead. Heads down.

More soon.

[Adamant @AdamantProtocol]

Adamant has two halves.

The chain decentralised, privacy-default, post-quantum. No investors, no central control. That's not a marketing line; it's the design. Infrastructure that belongs to no one.

The hardware + software a purpose-built device for crypto. Self-custody by default. Multi-chain by design. Adamant-settled. Bridged to BTC, ETH, stablecoins.

Two halves, one mission: bring crypto out of the technical underground and into something people actually use.

The chain doesn't take investment. The product side does that's where execution lives.

Open for conversations.

[Adamant @AdamantProtocol]

Getting closer to the finish line 🏁

[Adamant @AdamantProtocol]

We are still building behind the scenes for the people asking been a lot going on, some exciting developments are happening!

[Adamant @AdamantProtocol]

Adamant update.
The site. Adamant Protocol is rebuilt as a working hub.

Five doors route from the home page: use ADM, run a node, build on it, audit it, understand it.

/start is the protocol in five steps with diagrams.

/network is a full block-explorer scaffold search, blocks, per-transaction pages with the public-view vs view-key-disclosure split, validator detail with cohort markers, the two-regime mempool inspector (threshold encryption at N≥15, time-lock VDF below), burn-to-mint registry, Genesis NFT registry.

/developers has the JSON-RPC reference, the Adamant Move walkthrough, run-a-node with config.toml, view-key encoding, ML-KEM-768 stealth-address derivation, per-source-chain burn-tx format.

/security publishes audit progress per primitive, the signing-key roster with Ed25519 + ML-DSA fingerprints, reproducible-build SHA-256s.

/tokenomics has the validator-APR calculator, the slashing-condition catalog, the multi-dimensional fee market.

/roadmap lists five stages with entry conditions, not calendar dates.

The protocol. The reference implementation is public, Rust, Apache 2.0: <https://t.co/KgzCrRYwLQ>. Ten crates.

Phases 1–5 complete: foundation, cryptographic primitives, transactions and lifecycle, AVM verifier with the cross-module rule walker.

Phase 5/6 AVM Runtime is ~93% (bytecode dispatch, multi-dimensional gas accounting, transaction-boundary integration).

Phase 7 consensus and networking foundations is now active.

Today's track:
· Binary quadratic form arithmetic

· Class-group composition and fast squaring (Cohen 5.4.7 / 5.4.8)

· Hash-to-class-group element via Tonelli–Shanks

· Wesolowski VDF — evaluate, prove, verify

· Time-lock envelope encryption (§3.8.8)

· Threshold-mempool regime hysteresis (§3.6, §8.4)

· ML-DSA-87 added as opt-in post-quantum signature variant alongside ML-DSA-65

Whitepaper amended in lockstep — §3.8.6, §3.8.7, §3.8.8, §6.2.1.9, §7.0, §7.2.2 Pallas, §7.3 value-commitments all landed today.

Pre-launch. Specification phase. The chain self-activates the moment seven Node Runners are simultaneously registered, stake-eligible, and online.

The whitepaper is the source of truth. The code implements it. The site reads from both.

[Adamant @AdamantProtocol]

You’re right even with the rules fixed at genesis, users still have to trust that:

• the burn proofs (light-client verification of BTC/ETH burns) work as written.

• the mint logic executes correctly.

• and validators continue enforcing the exact same code long-term.

That trust surface exists in every chain. The difference Adamant tries to make is removing any single party who can quietly change those rules later.

There’s no foundation, no admin keys, and no on-chain governance.

The only way the protocol ever changes is if every node operator individually opts in Bitcoin-style.

The burn-to-mint and mint logic are part of the immutable genesis rules (Section 10.2).

Once the chain is live, the code is the law, and anyone can audit or run a node to verify it.

You’re correct that incentives can shift over time. The design assumes that people who already burned real value and staked as validators have skin in the game to keep the rules intact. If that assumption breaks, the chain slows or stalls no hidden team wallet steps in to “fix” it.

That’s the real trade-off of credible neutrality. It’s not that trust disappears completely. It’s that you only have to trust the open-source code and the collective incentives of the people running nodes not a small group with special powers.

Curious what you think breaks first too.

Happy to dive into any specific part of the spec if you want.

[Adamant @AdamantProtocol]

Where the burn goes.
Getting this question a lot, so worth answering plainly.

1. The external value you burn (BTC, ETH, USDT, USDC) goes nowhere.

You burn it to a verifiably unspendable address on its source chain the Bitcoin null address, Ethereum's 0x000...dead, the equivalent on Tron and Ethereum for stablecoins.

The chain sees the cryptographic proof of burn and mints ADM to your Adamant address. Your burned crypto is permanently destroyed. No foundation receives it. No developer wallet receives it. No treasury holds it. It is gone, mathematically, forever.

There is no party on the receiving end of the burn. That's the entire point — it's how the chain bootstraps without a foundation collecting funds.

2. The ADM you receive is minted from the genesis pool.

A fixed pool of 100,000,000 ADM exists at protocol launch, partitioned 70M for burns and 30M for validator block rewards. When you burn, ADM is minted to you from the burn-allocated 70M sub-counter at the rate of 20 ADM per USD-equivalent burned. The pool drains as people burn and as validators earn. No new ADM appears outside this mechanism during the launch phase.

3. ADM you stake stays yours.

Staking doesn't transfer ADM anywhere. It locks ADM in your address as a behaviour bond slashable for misbehaviour, otherwise still owned by you, returned (subject to the 28-day unbonding window) when you exit. No staking pool, no validator escrow contract holding your funds, no third party ever takes custody.

4. What happens if the pool isn't fully claimed.

The launch phase ends when the pool is fully drained or, at latest, five years from genesis whichever comes first. If the five-year cap is reached with ADM still unclaimed in either sub-counter, the unclaimed ADM is destroyed. Not redistributed. Not held in reserve. Not allocated to validators or to anyone else. The unclaimed portion of the pool simply ceases to exist.
This preserves the no-insider-allocation property. No party gains from low launch-phase participation. The chain's circulating supply at the end of the launch phase is exactly what was claimed during it nothing more.

After the launch phase, the protocol's perpetual issuance schedule takes over (4% of supply Y1-5, 3% Y6-10, 2% Y11-20, 1% perpetual thereafter), paying validators continuously while transaction fees burn supply back. The expected long-term equilibrium is rough supply stability with mild deflationary pressure under sustained usage.

Spec: §10.2 of the whitepaper at https://t.co/lnd7xF6oJL covers all of this in detail.

https://t.co/z6KszxIg4z

[Adamant @AdamantProtocol]

@Mark_Onchain Fair point that’s a real risk in any fair-launch design without a foundation or team wallet seeding liquidity.

You’re right that early burners have to choose to provide LP instead of just holding or staking.

The protocol doesn’t force it, subsidize it, or coordinate it. That’s deliberate.

Here’s how the economics actually play out (straight from the whitepaper):

• Burners already put real skin in the game (BTC/ETH/stablecoins burned at market rates).

They minted ADM because they want the chain to exist and be useful.

• Validator block rewards (30% of the genesis pool) keep minting more ADM over time, creating natural selling pressure from people who want to realize gains or fund ops.

• If early LPs don’t show up, the pools stay shallow → slower price discovery and adoption.

The chain still runs, burn-to-mint stays open, and validators keep earning.

It just grows more slowly until real utility pulls in more participants. It’s not “behavioral coordination under incentives” in the usual VC-premine sense.

It’s pure market behavior: people who already committed capital decide whether providing liquidity makes sense for them. If enough of them don’t, the bootstrap takes longer. That’s the fair-launch trade-off.

No hidden backstop, no team liquidity to paper over it. Just the market deciding.

[Adamant @AdamantProtocol]

How does the first DEX on Adamant actually get liquidity when everything starts with burn-to-mint?

Here’s the exact economic bootstrap from the whitepaper (no team pre-seed, no foundation wallet):

1. Burn-to-mint is the only initial supply path (70% of the fixed 100M ADM genesis pool).

Anyone burns BTC, ETH, USDT or USDC on their original chain → Adamant’s on-chain light client verifies it → protocol instantly mints ADM to your address at fixed public rates.

2. Economics in action:

• Early burners now hold real ADM (they paid market value in BTC/ETH/stablecoins).

• They use part of it to stake the minimum (1,000 ADM) and become validators.

• Once 7 validators are live → the chain self-activates automatically. No coordination, no insiders.

The other 30% of the genesis pool is released gradually as validator block rewards — so more ADM flows out naturally over time.

3. DEX liquidity forms organically:

Early ADM holders (burners + validators earning rewards) can now provide liquidity to a community-deployed native DEX (Adamant Move smart contract).

They pair their ADM with bridged USDC/ETH/etc.

Result: Real economic skin-in-the-game liquidity from day one.

More burns → more circulating ADM → deeper pools → more trading → more confidence.

Pure market-driven bootstrap.
Full details (Section 10.2 + 8.1).

[Adamant @AdamantProtocol]

Adamant whitepaper key design choices:

• Credible neutrality (no foundation/premine/admin keys) + privacy by default + 50k+ TPS on residential fiber + phone-verifiable history via recursive Halo 2

• Dual-regime encrypted mempool (threshold encryption + time-lock VDF bootstrap)

• Hybrid post-quantum crypto (ML-DSA signatures + ML-KEM stealth addresses)

• Permissionless prover market + validator fallback for guaranteed proofs

• Protocol-enforced mutability declarations on every object/contract

• Dynamic FCFS validator set with transferable slots + multi-tier participation

• Genesis pool: 70% public burn-to-mint + 30% validator rewards

• Adamant Move bytecode with mandatory privacy/mutability metadata + native verifier

[Adamant @AdamantProtocol]

Thanks @MerginDorn! Appreciate the kind words on the native account abstraction + linear types + shielded-by-default combo.

The full Adamant Move dialect specs (Sui-Move substrate + protocol extensions for mutability declarations, shielded/transparent annotations, privacy primitives, bytecode metadata, verifier rules, etc.) are already in the whitepaper Section 6 covers the language and execution model in detail.

https://t.co/D5k2Ha2sx3

Here is also the GitHub for the project itself and how far we are.

https://t.co/a70gQsg65q

Reference implementation (Rust, Apache 2.0) is actively being developed and will evolve together with the spec. Excited to share more as it ships! 🚀

[Adamant @AdamantProtocol]

Every account on Adamant is a smart account from day one.

No EOA vs contract split.
Full account abstraction native.

Adamant Move brings:
• Linear types & resource safety (no accidental fund loss)

• Object-centric model with explicit mutability

• Privacy by default via shielded functions

This is next-gen smart contracts. 👇 #AdamantProtocol

[Adamant @AdamantProtocol]

Four ways to participate in Adamant Protocol, Two staked roles secure the chain. Two permissionless markets serve it.

Anyone can join either market without permission and without stake you can take a staked role by simply meeting the floor.

Node Runner → Consensus participant (STAKED)

Node Watcher → Attestation, DA sampling, fraud detection (STAKED)

Prover → Recursive proof generation (PERMISSIONLESS)

Service Node → Light-client infrastructure (PERMISSIONLESS)

Hardware requirements, compensation details, and set sizes in the graphic

Full specs & whitepapers here:

→ https://t.co/PVXJVo664Y

→ https://t.co/9ecwYVL3gW

Which role are you picking? Drop it below

#AdamantProtocol #Blockchain

[Adamant @AdamantProtocol]

@cap_tzzz https://t.co/cZgiWzM1cZ

this is the specific section that talks about this.

[Adamant @AdamantProtocol]

Good question. Short version: nobody decides.

The protocol detects it cryptographically. Three categories of slashable offence, each defined in the

spec:1. Equivocation (100% slash)

Signing two different votes for the same round. The chain catches this automatically both signatures end up on-chain, both signed by the same key, both for the same round but with different content. Cryptographic proof, no human judgement involved. This is the only offence that takes 100% of stake because it's the only one that actively attacks consensus.

2. Liveness failure (0.5% slash + removal from active set)

Failing to participate in consensus for more than 2 consecutive epochs while in the active set. The chain measures this automatically your validator either signed off on the rounds in the window or it didn't. ~72 seconds offline triggers it.

3. False attestation (witness-specific) A Node Watcher signing an attestation that's contradicted by the cryptographic state of the chain. Other witnesses can submit a fraud proof showing the attestation was false; if the proof verifies, the false attester is slashed.The key thing: none of these involve a foundation, a multisig, a governance vote, or anyone's judgement. Each is detectable from the chain's own state. The protocol verifies the proof, executes the slash. Same way Bitcoin doesn't need anyone to decide if a block hash meets the difficulty target the math either checks out or it doesn't.What's NOT slashable: being slow, having low uptime that's still above the threshold, holding minority opinions, running unpopular software, anything subjective.

The protocol has no concept of "this validator was being annoying" because there's no entity to make that call.

Spec is in §8.1.5 of the whitepaper at https://t.co/lnd7xF6oJL if you want the formal definitions.

[Adamant @AdamantProtocol]

why am i building this, the problem isnt one bank or one government. its that whoever is in charge can change the rules whenever they want. banks freeze you. foundations dilute you. platforms ban you. every system that touches money eventually builds a way for someone with power to do something to someone without it, bitcoin fixed money. nobody can change bitcoin. but you cant build on it, ethereum let you build. but the foundation has changed the rules five times since 2015.

you shouldnt have to pick

so i made adamant. a chain you can build on where the rules cant be changed by anyone. including me. no foundation no premine no admin keys.

7 validators come online and it runs. after that i have no more power over it than you do. thats the point.