LearnToEarn
15.3k Posts
LearnToEarn
Square Verified+Signals hub • Your risk • your call •Market News •Projects •Content Creator • Awarded Creator🏆 | X/Twitter: @LearnToEarn_K
Creator Awards 2024
Traders League Badge Expert
#BinanceTurns7 task 2
Open Trade
XAUT Holder
High-Frequency Trader
2.6 Years
152 Following
103.8K+ Followers
71.3K Liked
4 Badges
Posts
Portfolio
All
Quotes
Videos
Live
PINNED
I went back through the @Dusk documentation last night, specifically the section on their Succinct Attestation consensus. It’s a permissionless, committee-based proof-of-stake setup run by provisioners....anyone who locks at least 1000 DUSK as stake.
A stake is just the amount plus the block height it was included at. Eligibility isn’t immediate. There’s a maturity period calculated as M = 2 × epoch − (height mod epoch), and the epoch is currently 2160 blocks. Only after that maturity window, and if the amount meets the minimum, does the stake enter the deterministic sortition lottery that picks the block generator and the voting committees for each round.
The process itself runs in rounds and iterations. Each iteration has three steps: proposal (one provisioner is selected to put forward a candidate block), validation (a committee votes Valid, Invalid, or NoCandidate, needing a 2/3 supermajority for Valid or a simple majority for Invalid), and ratification (a fresh committee confirms the result). A round can go through up to 50 iterations before it fails.
What I’m still turning over is how the non-interactive sortition and the rotating committees actually affect long-term decentralization and the risk of committee capture. The fixed parameters....1000 DUSK minimum, 2160-block epochs, 50-iteration cap
....feel deliberate, but I couldn’t find a clear discussion of how they might be adjusted later or what governance process would control that.
Curious how others read the security assumptions around the voting committees and the maturity delay. Does the design feel robust to you, or are there edge cases I’m missing?
#dusk $DUSK
A stake is just the amount plus the block height it was included at. Eligibility isn’t immediate. There’s a maturity period calculated as M = 2 × epoch − (height mod epoch), and the epoch is currently 2160 blocks. Only after that maturity window, and if the amount meets the minimum, does the stake enter the deterministic sortition lottery that picks the block generator and the voting committees for each round.
The process itself runs in rounds and iterations. Each iteration has three steps: proposal (one provisioner is selected to put forward a candidate block), validation (a committee votes Valid, Invalid, or NoCandidate, needing a 2/3 supermajority for Valid or a simple majority for Invalid), and ratification (a fresh committee confirms the result). A round can go through up to 50 iterations before it fails.
What I’m still turning over is how the non-interactive sortition and the rotating committees actually affect long-term decentralization and the risk of committee capture. The fixed parameters....1000 DUSK minimum, 2160-block epochs, 50-iteration cap
....feel deliberate, but I couldn’t find a clear discussion of how they might be adjusted later or what governance process would control that.
Curious how others read the security assumptions around the voting committees and the maturity delay. Does the design feel robust to you, or are there edge cases I’m missing?
#dusk $DUSK
I went back through the @Dusk technical docs last night, specifically the sections on peer-to-peer communication and the Kadcast protocol. At first I was just skimming, but the more I read the more the design started clicking into place in a way that felt different from the usual gossip-based networks.
Kadcast sits on a Kademlia-style DHT and uses XOR distance to structure how messages move. Instead of flooding everything to random neighbors, nodes forward to a carefully chosen set of peers at increasing distances. That should cut a lot of redundant traffic and make latency more predictable. The docs also talk about how this naturally makes it harder to pinpoint the original sender, which feels relevant for a privacy-focused chain.
What I’m still turning over is the fault-tolerance part. When nodes drop or refuse to forward, the protocol is supposed to find alternative paths by updating routing tables. I can see how that works in theory, but I kept wondering how it behaves under sustained churn or targeted message-drop attacks. The paper mentions resilience and alternative paths, yet I couldn’t find hard numbers or detailed simulations on the worst-case scenarios.
On the governance and decentralization side, this kind of structured overlay seems to assume a reasonably healthy distribution of honest nodes. If a large share of the network ends up concentrated or coordinated, does the efficiency advantage turn into a liability? I’m not sure the docs fully close that loop.
Curious how others who’ve run nodes or dug into the code see the real-world trade-offs here. Does the privacy benefit from origin obfuscation hold up once you start looking at traffic analysis, or does it mainly help against casual observers?
@Dusk #dusk $DUSK
Kadcast sits on a Kademlia-style DHT and uses XOR distance to structure how messages move. Instead of flooding everything to random neighbors, nodes forward to a carefully chosen set of peers at increasing distances. That should cut a lot of redundant traffic and make latency more predictable. The docs also talk about how this naturally makes it harder to pinpoint the original sender, which feels relevant for a privacy-focused chain.
What I’m still turning over is the fault-tolerance part. When nodes drop or refuse to forward, the protocol is supposed to find alternative paths by updating routing tables. I can see how that works in theory, but I kept wondering how it behaves under sustained churn or targeted message-drop attacks. The paper mentions resilience and alternative paths, yet I couldn’t find hard numbers or detailed simulations on the worst-case scenarios.
On the governance and decentralization side, this kind of structured overlay seems to assume a reasonably healthy distribution of honest nodes. If a large share of the network ends up concentrated or coordinated, does the efficiency advantage turn into a liability? I’m not sure the docs fully close that loop.
Curious how others who’ve run nodes or dug into the code see the real-world trade-offs here. Does the privacy benefit from origin obfuscation hold up once you start looking at traffic analysis, or does it mainly help against casual observers?
@Dusk #dusk $DUSK
⚡ 𝐄𝐓𝐇 𝐇𝐎𝐋𝐃𝐈𝐍𝐆 𝐒𝐔𝐏𝐏𝐎𝐑𝐓! 𝐁𝐎𝐔𝐍𝐂𝐄 𝐖𝐀𝐓𝐂𝐇 🚀
$ETH is defending the support zone, keeping the short-term bullish setup in play. The key level to watch now is $1,900.
Entry: $1,863 – $1,885
TP1: $1,900
TP2: $1,920
SL: $1,863
R:R: 1:2
🔥 Break and hold above $1,900 could trigger the next leg higher.
DYOR $ETH
$ETH is defending the support zone, keeping the short-term bullish setup in play. The key level to watch now is $1,900.
Entry: $1,863 – $1,885
TP1: $1,900
TP2: $1,920
SL: $1,863
R:R: 1:2
🔥 Break and hold above $1,900 could trigger the next leg higher.
DYOR $ETH
⚡ 𝐁𝐓𝐂 𝐒𝐔𝐏𝐏𝐎𝐑𝐓 𝐓𝐄𝐒𝐓! 𝐁𝐎𝐔𝐍𝐂𝐄 𝐖𝐀𝐓𝐂𝐇 👀
$BTC is pulling back into a key support zone. If buyers defend this area, a short-term bounce toward the upside targets could develop.
Entry: $62,802 – $63,444
TP1: $64,010
TP2: $64,500
SL: $62,802
R:R: 1:2
🔥 Hold above $62,802 = bounce potential.
Break below it = setup invalidation.
DYOR
$BTC is pulling back into a key support zone. If buyers defend this area, a short-term bounce toward the upside targets could develop.
Entry: $62,802 – $63,444
TP1: $64,010
TP2: $64,500
SL: $62,802
R:R: 1:2
🔥 Hold above $62,802 = bounce potential.
Break below it = setup invalidation.
DYOR
$SKHYB is another tokenized-security product rather than a traditional cryptocurrency. It provides tokenized exposure to SK Hynix shares through Binance’s bStock framework. That makes the underlying company especially important when analyzing the asset. SK Hynix is a major semiconductor and memory-chip company, so factors such as AI infrastructure demand, HBM memory and the semiconductor cycle can influence the underlying equity. For me, the token is only one part of the analysis—the real fundamentals start with SK Hynix itself.
#SKHYB #RWA $SKHYB
#SKHYB #RWA $SKHYB
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
EDEN is associated with OpenEden, a project focused on bringing real-world assets, particularly U.S. Treasury exposure, on-chain. This puts it directly into the growing RWA narrative. What interests me isn't simply the token price it’s whether OpenEden can continue expanding its tokenized-asset ecosystem and create meaningful utility around EDEN. RWA projects need more than a good narrative; they need actual assets, users and sustainable demand. I’d keep those fundamentals in focus while watching the chart.
#EDEN #RWA $EDEN
#EDEN #RWA $EDEN
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$ROBO is connected to Fabric Protocol, which is building infrastructure around AI systems and autonomous machines. One of its key ideas is Proof of Robotic Work, linking real-world machine activity with blockchain-based verification and rewards. That gives ROBO a very specific AI-and-robotics thesis. But this is still an area where real adoption matters enormously. I’d want to see actual machines, developers and applications using the infrastructure before treating the narrative as proven. The technology story is interesting; execution will be the real test.
#ROBO #AI $ROBO
#ROBO #AI $ROBO
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$NOT , or Notcoin, became widely known through its Telegram-based viral distribution and its connection with the TON ecosystem. That helped it build a huge community, but the more difficult phase is always what comes after the initial hype. I’m interested in whether Notcoin can maintain meaningful user activity and develop lasting ecosystem utility. A strong community is valuable, but sustainable engagement matters more to me than a short-term price move. I’d watch liquidity, activity and ecosystem development closely.
#NOT #Notcoin $NOT
#NOT #Notcoin $NOT
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$GPS is the native token connected with GoPlus Security, a Web3 security infrastructure project focused on detecting and preventing risks across blockchain applications and assets. I find the thesis relevant because security becomes increasingly important as on-chain activity grows. But the key question for me is adoption. How much real demand is being generated for its security infrastructure, and how much of that demand translates into token utility? A green day is interesting, but usage and ecosystem growth are what I’d watch next.
#GPS #Web3 $GPS
#GPS #Web3 $GPS
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$SNDKB is another asset that needs some context before trading. It represents tokenized exposure to SanDisk shares through Binance’s bStock framework, rather than being a conventional cryptocurrency. That means the underlying equity is extremely important. Instead of looking only at the token chart, I’d also follow SanDisk’s business performance, semiconductor demand and broader equity-market conditions. Tokenization adds a new trading format, but it doesn't remove the fundamental risks of the underlying security.
#SNDKB #RWA $SNDKB
#SNDKB #RWA $SNDKB
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$ATM is quite different from the typical crypto projects on this list. It is Atlético de Madrid’s fan token within the Socios ecosystem. Its purpose is mainly fan engagement, including voting opportunities, rewards, experiences and exclusive content. It doesn’t represent ownership of the football club or a claim on its profits. So when I see a move in ATM, I look at it through a fan-token lens rather than treating it like a DeFi protocol. Sentiment, engagement and market liquidity matter here.
#ATM #FanToken $ATM
#ATM #FanToken $ATM
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$HOME is the token associated with DeFi App, a platform designed to bring multiple DeFi activities such as swaps, perpetuals and yield strategies into a simpler interface. What interests me here is the product angle. If the platform can make on-chain trading easier for users, that could support ecosystem growth. But a strong 24-hour move alone doesn’t prove that thesis. I’d watch user activity, liquidity and actual product adoption before becoming too confident about the token’s longer-term direction.
#HOME #DeFi $HOME
#HOME #DeFi $HOME
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$AVNT is tied to Avantis, a Base-based decentralized derivatives protocol offering leveraged markets across crypto and real-world assets. The token has utility within the ecosystem, including governance, staking and incentives. That makes the project interesting from a DeFi perspective, but I wouldn’t confuse protocol growth with guaranteed token appreciation. I’m more interested in whether trading activity, liquidity and user adoption continue to grow. Strong price action gets my attention, but sustainable usage is what I want to see behind it.
#AVNT #DeFi $AVNT
#AVNT #DeFi $AVNT
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$COTI has a more interesting thesis than simply being another crypto token. COTI V2 is focused on privacy-preserving computation and uses technologies such as Garbled Circuits to enable confidential smart-contract interactions. What I’m watching is adoption. Can developers actually build applications that need this level of privacy? Price momentum can bring attention, but real usage is what could validate the long-term thesis. I’d rather track ecosystem growth than make a decision based only on today’s percentage gain.
#COTI #Crypto $COTI
#COTI #Crypto $COTI
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
$SNXXB caught my attention because it isn’t a typical altcoin. It represents tokenized exposure to the Tradr 2X Long SNDK Daily ETF, giving leveraged exposure to SanDisk’s daily stock performance. That daily-reset structure is important: a “2X” product doesn’t simply mean double the long-term return of SNDK. With the strong move shown on the ranking, I’d be careful about chasing momentum. For me, the underlying SanDisk performance, volatility and daily leverage mechanics matter more than one green candle.
#SNXXB #RWA $SNXXB
#SNXXB #RWA $SNXXB
LearnToEarn
·
--
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
I went back through the documentation last night on the @Dusk transaction models and spent a few hours just trying to map how Moonlight and Phoenix actually fit together.
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
At first the distinction looked clean. Moonlight is the transparent, account-based side where each account keeps a public state that records its balance and nonce. Phoenix is the note-based shielded side: a note is structured around a recipient public key, a value v, and additional random scalars, with notes indexed inside a Merkle tree so a spender can prove inclusion without revealing the note itself. Spending requires a zero-knowledge proof and the publication of a nullifier so the network can reject double-spends. The docs also state that note values are bounded by 2^{64}-1.
Conversion paths between the two models (deposit into Phoenix notes, withdraw back to Moonlight accounts) are described, but I kept getting stuck on the exact security assumptions that hold during those hand-offs. The circuits are said to guarantee validity, yet I couldn’t find a clear statement on whether a single malformed conversion could affect the global nullifier set or the transparent balances that smart contracts rely on.
That raised a broader question for me about decentralization: if most value ends up living in Phoenix notes, how much practical governance power remains with the transparent account layer that contracts and oracles actually see?
Is the current circuit design and the 2^{64}-1 value bound considered final, or are there still open parameters around note generation, Merkle-tree depth, and nullifier uniqueness that the community is still iterating on?
Would appreciate any pointers from people who have gone deeper into the proofs.
#dusk $DUSK
🚨 𝐍𝐁𝐈𝐒𝐁 𝐁𝐔𝐋𝐋𝐈𝐒𝐇! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$NBISB is showing strong momentum with buyers pushing toward the key resistance at $260.00. A clean breakout could bring the next upside target into focus.
Entry: $208.00 – $250.50
TP1: $260.00
TP2: $270.00
SL: $200.00
R:R: 1:2
🔥 Break and hold above $260.00 could open the door for the next leg up.
$NBISB
$NBISB is showing strong momentum with buyers pushing toward the key resistance at $260.00. A clean breakout could bring the next upside target into focus.
Entry: $208.00 – $250.50
TP1: $260.00
TP2: $270.00
SL: $200.00
R:R: 1:2
🔥 Break and hold above $260.00 could open the door for the next leg up.
$NBISB
🚨 𝐐𝐍𝐓𝐁 𝐁𝐔𝐋𝐋𝐈𝐒𝐇! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐌𝐎𝐌𝐄𝐍𝐓𝐔𝐌 𝐁𝐔𝐈𝐋𝐃𝐈𝐍𝐆 🚀
$QNTB is showing strong upside momentum after a +25% surge. Buyers are pushing higher, and the next major test is around $72.89.
Entry: $55.60 – $70.96
TP1: $72.89
TP2: $75.00
SL: $55.60
R:R: 1:2
🔥 Break and hold above $72.89 could signal the next leg higher.
$QNTB
$QNTB is showing strong upside momentum after a +25% surge. Buyers are pushing higher, and the next major test is around $72.89.
Entry: $55.60 – $70.96
TP1: $72.89
TP2: $75.00
SL: $55.60
R:R: 1:2
🔥 Break and hold above $72.89 could signal the next leg higher.
$QNTB
🚨 𝐏𝐑𝐎𝐌 𝐁𝐔𝐋𝐋𝐈𝐒𝐇! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐈𝐒 𝐒𝐓𝐈𝐋𝐋 𝐀𝐋𝐈𝐕𝐄 🚀
$PROM is showing strong momentum after a powerful breakout. Buyers are still defending the move, but the key is holding the entry zone.
Entry: $1.934 – $2.641
TP1: $3.627
TP2: $3.800
SL: $1.934
R:R: 1:2
🔥 A clean break and hold above $3.627 could open the way for another strong leg higher.
Watch the confirmation before entering.
$PROM
$PROM is showing strong momentum after a powerful breakout. Buyers are still defending the move, but the key is holding the entry zone.
Entry: $1.934 – $2.641
TP1: $3.627
TP2: $3.800
SL: $1.934
R:R: 1:2
🔥 A clean break and hold above $3.627 could open the way for another strong leg higher.
Watch the confirmation before entering.
$PROM
$ETH is slowly finding its footing again after the recent weakness. What catches my attention is how buyers are defending the lower zone instead of allowing price to keep sliding. The recovery may still be developing, but momentum is starting to shift.
The key level I’m watching is $1,925. If ETH breaks above it and holds, this recovery could turn into another bullish leg toward $1,940.
📍Entry: $1,860 – $1,889
🎯TP1: $1,925
🎯TP2: $1,940
🛑SL: $1,860
⚖️Risk:Reward: 1:2
I’m not chasing the first green candles. Let ETH confirm the breakout and show that buyers are ready to carry the move higher.
$ETH
The key level I’m watching is $1,925. If ETH breaks above it and holds, this recovery could turn into another bullish leg toward $1,940.
📍Entry: $1,860 – $1,889
🎯TP1: $1,925
🎯TP2: $1,940
🛑SL: $1,860
⚖️Risk:Reward: 1:2
I’m not chasing the first green candles. Let ETH confirm the breakout and show that buyers are ready to carry the move higher.
$ETH
Log in to explore more content