LearnToEarn

I went back through the Dusk whitepaper last night, especially the sections on incentives, transactions, and Moonlight, and I found the design more nuanced than I first expected.

The consensus side uses 64 committee credits, with voting power weighted by credits. Quorum needs 2/3 for Valid, while Invalid, NoCandidate or NoQuorum can pass with 1/2 + 1. Rolling finality also caught my attention: if a block has two previous non-attested iterations, it needs 2×2 = 4 consecutive attested or confirmed blocks to become confirmed.

The incentive model is interesting too. Block rewards are split 80% to the generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% itself includes a fixed 70% plus a variable 10% tied to included votes. I can see why this exists: higher-iteration generators could otherwise benefit from earlier iterations failing.

On transactions, Moonlight is account-based and transparent, with public balances and a nonce for replay protection. Phoenix takes the UTXO route and uses ZK proofs and nullifiers for privacy.

What I’m still wondering is whether the 80/10/10 structure creates enough incentive for broad participation, and how decentralization behaves when stake concentration determines committee credits.

How does the community view these trade-offs?


#dusk $DUSK @Dusk

I went back through the Dusk whitepaper last night, especially the sections on incentives, transactions, and Moonlight, and I found the design more nuanced than I first expected.

The consensus side uses 64 committee credits, with voting power weighted by credits. Quorum needs 2/3 for Valid, while Invalid, NoCandidate or NoQuorum can pass with 1/2 + 1. Rolling finality also caught my attention: if a block has two previous non-attested iterations, it needs 2×2 = 4 consecutive attested or confirmed blocks to become confirmed.

The incentive model is interesting too. Block rewards are split 80% to the generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% itself includes a fixed 70% plus a variable 10% tied to included votes. I can see why this exists: higher-iteration generators could otherwise benefit from earlier iterations failing.

On transactions, Moonlight is account-based and transparent, with public balances and a nonce for replay protection. Phoenix takes the UTXO route and uses ZK proofs and nullifiers for privacy.

What I’m still wondering is whether the 80/10/10 structure creates enough incentive for broad participation, and how decentralization behaves when stake concentration determines committee credits.

How does the community view these trade-offs?


#dusk $DUSK @Dusk

I went back through the TermMax pre-mine documentation last night, trying to map out exactly how the TMX allocation is supposed to work once mainnet is live.

The core idea seems straightforward on the surface: 1 billion TMX total supply, with a portion set aside for monthly campaigns that start on day one of mainnet. Eligible participants fall into two groups....people holding fixed-rate PT tokens (bought on the lending page or via vault deposits) and order makers who provide liquidity through range or custom limit orders. Rewards accumulate continuously during each campaign window and stay non-transferable until TGE, when they convert 1:1.

What I kept circling back to is the APY calculation language. It references a $50 million daily volume and TVL figure, then distributes TMX based on prior-day deposits. I’m still unclear whether that volume assumption is a hard parameter baked into the smart contracts or just an illustrative example. If the actual matched volume comes in much lower or higher, does the effective rate scale linearly, or is there a cap or floor that isn’t spelled out here?

On the governance side, the note that points (Kudos) from the earlier Term Structure protocol are “under discussion” for conversion into TermMax rewards left me with more questions than answers. Who decides the conversion ratio, and is that decision on-chain or off-chain? The disclaimer also reserves the right to adjust the pre-mine timeline if it benefits the platform. That flexibility is practical, but it raises the usual decentralization trade-off: how much control remains with the team versus token holders after TGE?

Curious how others are reading the eligibility and claiming mechanics. Does the current design create any obvious concentration risks for early order makers versus passive PT holders?

#termmax @TermMax

I went back through the Dusk whitepaper last night, especially the sections on incentives, transactions, and Moonlight, and I found the design more nuanced than I first expected.

The consensus side uses 64 committee credits, with voting power weighted by credits. Quorum needs 2/3 for Valid, while Invalid, NoCandidate or NoQuorum can pass with 1/2 + 1. Rolling finality also caught my attention: if a block has two previous non-attested iterations, it needs 2×2 = 4 consecutive attested or confirmed blocks to become confirmed.

The incentive model is interesting too. Block rewards are split 80% to the generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% itself includes a fixed 70% plus a variable 10% tied to included votes. I can see why this exists: higher-iteration generators could otherwise benefit from earlier iterations failing.

On transactions, Moonlight is account-based and transparent, with public balances and a nonce for replay protection. Phoenix takes the UTXO route and uses ZK proofs and nullifiers for privacy.

What I’m still wondering is whether the 80/10/10 structure creates enough incentive for broad participation, and how decentralization behaves when stake concentration determines committee credits.

How does the community view these trade-offs?


#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the TermMax docs last night, specifically the TMX utility and risk sections. Total supply is fixed at 1B, with Community at 150M (15%). Initial circulation sits around 20%.

The part that stuck with me is how $TMX holders can stake for sTMX (protocol FT tokens denominated in TMX) or LP it on something like PancakeSwap. Staking rewards can come from the Community allocation plus a slice of Treasury funds. Those Treasury inflows are supposed to come from trading fees on FT/XT tokens, protocol fees on borrowing, liquidation fees, and other sources. It looks like a way to tie long-term holders to actual protocol revenue, but I’m still unclear how much of the Treasury actually flows to stakers versus other uses.

Enhanced governance rights for stakers include adjusting market risk parameters and curator whitelisting. That raises questions about how decentralized the process really is once live. On the risk side, they openly list smart-contract risk (audits, competitions, monitoring, and bounties notwithstanding), dual-oracle dependency that could still fail, network congestion, price volatility, liquidity risk, regulatory uncertainty, and competition from other fixed-rate protocols.

I’m left wondering how the dual-oracle setup handles edge cases in practice, and whether the enhanced governance for sTMX holders meaningfully shifts control or mostly refines parameters set by the team. Anyone who’s dug into the contracts or fee flows how do you read the sustainability of the Treasury-to-staker path?

#termmax @TermMax

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the TermMax docs last night, specifically the TMX utility and risk sections. Total supply is fixed at 1B, with Community at 150M (15%). Initial circulation sits around 20%.

The part that stuck with me is how $TMX holders can stake for sTMX (protocol FT tokens denominated in TMX) or LP it on something like PancakeSwap. Staking rewards can come from the Community allocation plus a slice of Treasury funds. Those Treasury inflows are supposed to come from trading fees on FT/XT tokens, protocol fees on borrowing, liquidation fees, and other sources. It looks like a way to tie long-term holders to actual protocol revenue, but I’m still unclear how much of the Treasury actually flows to stakers versus other uses.

Enhanced governance rights for stakers include adjusting market risk parameters and curator whitelisting. That raises questions about how decentralized the process really is once live. On the risk side, they openly list smart-contract risk (audits, competitions, monitoring, and bounties notwithstanding), dual-oracle dependency that could still fail, network congestion, price volatility, liquidity risk, regulatory uncertainty, and competition from other fixed-rate protocols.

I’m left wondering how the dual-oracle setup handles edge cases in practice, and whether the enhanced governance for sTMX holders meaningfully shifts control or mostly refines parameters set by the team. Anyone who’s dug into the contracts or fee flows how do you read the sustainability of the Treasury-to-staker path?

#termmax @TermMax

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the TermMax docs last night, specifically the TMX utility and risk sections. Total supply is fixed at 1B, with Community at 150M (15%). Initial circulation sits around 20%.

The part that stuck with me is how $TMX holders can stake for sTMX (protocol FT tokens denominated in TMX) or LP it on something like PancakeSwap. Staking rewards can come from the Community allocation plus a slice of Treasury funds. Those Treasury inflows are supposed to come from trading fees on FT/XT tokens, protocol fees on borrowing, liquidation fees, and other sources. It looks like a way to tie long-term holders to actual protocol revenue, but I’m still unclear how much of the Treasury actually flows to stakers versus other uses.

Enhanced governance rights for stakers include adjusting market risk parameters and curator whitelisting. That raises questions about how decentralized the process really is once live. On the risk side, they openly list smart-contract risk (audits, competitions, monitoring, and bounties notwithstanding), dual-oracle dependency that could still fail, network congestion, price volatility, liquidity risk, regulatory uncertainty, and competition from other fixed-rate protocols.

I’m left wondering how the dual-oracle setup handles edge cases in practice, and whether the enhanced governance for sTMX holders meaningfully shifts control or mostly refines parameters set by the team. Anyone who’s dug into the contracts or fee flows how do you read the sustainability of the Treasury-to-staker path?

#termmax @TermMax

I went back through the Dusk documentation last night, and I came away more interested in the design questions than technical claims.

The first thing that clicked was the split between Moonlight and Phoenix. Moonlight is account-based, with a public key, nonce and balance, while Phoenix uses UTXOs as “notes” inside a Merkle tree. Moonlight transaction fields include from, to, value, nonce, deposit, data, gas_limit, gas_price and signature, with maximum gas calculated as gas_limit × gas_price.

Phoenix gets interesting. It uses the Jubjub curve, with public keys (A,B), secret keys (a,b), and a view key (a,B). The note structure includes type, com, enc, npk, R and encsender. The one-time note key is derived as npk = H(rA)G + B, while the spending key is nsk = H(aR) + b.

I’m still trying to understand the trust boundary around ZK proof generation and delegated scanning. The documentation says third parties can generate proofs or scan using view keys without getting spending authority, but where are the failure points?

And with nullifiers, recent Merkle roots, and gas handled inside the proof, how does this behave under adversarial network conditions? Which parts are decentralized, and which assumptions should users scrutinize?

#dusk $DUSK @Dusk

I went back through the TermMax docs last night, specifically the TMX utility and risk sections. Total supply is fixed at 1B, with Community at 150M (15%). Initial circulation sits around 20%.

The part that stuck with me is how $TMX holders can stake for sTMX (protocol FT tokens denominated in TMX) or LP it on something like PancakeSwap. Staking rewards can come from the Community allocation plus a slice of Treasury funds. Those Treasury inflows are supposed to come from trading fees on FT/XT tokens, protocol fees on borrowing, liquidation fees, and other sources. It looks like a way to tie long-term holders to actual protocol revenue, but I’m still unclear how much of the Treasury actually flows to stakers versus other uses.

Enhanced governance rights for stakers include adjusting market risk parameters and curator whitelisting. That raises questions about how decentralized the process really is once live. On the risk side, they openly list smart-contract risk (audits, competitions, monitoring, and bounties notwithstanding), dual-oracle dependency that could still fail, network congestion, price volatility, liquidity risk, regulatory uncertainty, and competition from other fixed-rate protocols.

I’m left wondering how the dual-oracle setup handles edge cases in practice, and whether the enhanced governance for sTMX holders meaningfully shifts control or mostly refines parameters set by the team. Anyone who’s dug into the contracts or fee flows how do you read the sustainability of the Treasury-to-staker path?

#termmax @TermMax