LearnToEarn
16k Publicaciones
LearnToEarn
Verificado Plus de Binance SquareSignals 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
Abrir trade
Holder de XAUT
Traders de alta frecuencia
2.6 año(s)
213 Siguiendo
103.9K+ Seguidores
71.7K+ Me gusta
4 Insignias
Publicaciones
Cartera
Todo
Citas
Videos
Live
PINNED
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
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
PINNED
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
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
🧨 𝐁𝐓𝐂 𝐂𝐎𝐍𝐒𝐎𝐋𝐈𝐃𝐀𝐓𝐈𝐍𝐆! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$BTC is moving in a tight range, with buyers and sellers battling around the current zone. The key level to watch is $65,058.
Entry: $64,027 – $64,334
TP1: $65,058
TP2: $65,500
SL: $64,027
🔥 Break and hold above $65,058 could open the door for the next leg higher.
$BTC
$BTC is moving in a tight range, with buyers and sellers battling around the current zone. The key level to watch is $65,058.
Entry: $64,027 – $64,334
TP1: $65,058
TP2: $65,500
SL: $64,027
🔥 Break and hold above $65,058 could open the door for the next leg higher.
$BTC
LearnToEarn
·
--
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
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
🚨 𝐕𝐄𝐋𝐕𝐄𝐓 +𝟐𝟕% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$VELVET is showing strong momentum after a +27% surge, with buyers now approaching the key resistance at $0.6996.
Entry: $0.4722 – $0.6355
TP1: $0.6996
TP2: $0.7200
SL: $0.4722
🔥 Break and hold above $0.6996 could open the door for the next leg higher.
$VELVET is showing strong momentum after a +27% surge, with buyers now approaching the key resistance at $0.6996.
Entry: $0.4722 – $0.6355
TP1: $0.6996
TP2: $0.7200
SL: $0.4722
🔥 Break and hold above $0.6996 could open the door for the next leg higher.
LearnToEarn
·
--
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
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
🚨 𝐁𝐓𝐂 𝐇𝐎𝐋𝐃𝐈𝐍𝐆 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$BTC is holding its recent gains, with buyers defending the current zone. The key level to watch now is $65,058.
Entry: $64,027 – $64,414
TP1: $65,058
TP2: $65,500
SL: $64,027
🔥 Break and hold above $65,058 could open the door for the next leg higher.
$BTC
$BTC is holding its recent gains, with buyers defending the current zone. The key level to watch now is $65,058.
Entry: $64,027 – $64,414
TP1: $65,058
TP2: $65,500
SL: $64,027
🔥 Break and hold above $65,058 could open the door for the next leg higher.
$BTC
LearnToEarn
·
--
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
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
🚨 𝐁𝐓𝐖 +𝟑𝟏% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$BTW is showing strong momentum after a +31% surge, with buyers now approaching the key resistance at $0.4788.
Entry: $0.3500 – $0.4697
TP1: $0.4788
TP2: $0.5000
SL: $0.3500
🔥 Break and hold above $0.4788 could open the door for the next leg higher.
$BTW
$BTW is showing strong momentum after a +31% surge, with buyers now approaching the key resistance at $0.4788.
Entry: $0.3500 – $0.4697
TP1: $0.4788
TP2: $0.5000
SL: $0.3500
🔥 Break and hold above $0.4788 could open the door for the next leg higher.
$BTW
LearnToEarn
·
--
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
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
🚨 𝐀𝐂𝐄 +𝟑𝟕% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$ACE is showing strong momentum after a +37% surge, with buyers now approaching the key resistance at $0.2516.
Entry: $0.1488 – $0.2167
TP1: $0.2516
TP2: $0.2600
SL: $0.1488
🔥 Break and hold above $0.2516 could open the door for another strong upside move.
$ACE is showing strong momentum after a +37% surge, with buyers now approaching the key resistance at $0.2516.
Entry: $0.1488 – $0.2167
TP1: $0.2516
TP2: $0.2600
SL: $0.1488
🔥 Break and hold above $0.2516 could open the door for another strong upside move.
LearnToEarn
·
--
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
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
⚡ 𝐏𝐀𝐗𝐆 𝐃𝐈𝐏𝐏𝐈𝐍𝐆! 𝐒𝐔𝐏𝐏𝐎𝐑𝐓 𝐖𝐀𝐓𝐂𝐇 👀
$PAXG is pulling back toward the key support zone. If buyers defend $4,354, a bounce toward the upside targets could come into focus.
Entry: $4,354 – $4,362
TP1: $4,430
TP2: $4,450
SL: $4,354
🔥 Hold above $4,354 = bounce potential.
Break below it = setup invalidation.
$PAXG
$PAXG is pulling back toward the key support zone. If buyers defend $4,354, a bounce toward the upside targets could come into focus.
Entry: $4,354 – $4,362
TP1: $4,430
TP2: $4,450
SL: $4,354
🔥 Hold above $4,354 = bounce potential.
Break below it = setup invalidation.
$PAXG
LearnToEarn
·
--
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
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
🚨 𝐀𝐋𝐏𝐈𝐍𝐄 +𝟐𝟐% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$ALPINE is showing strong momentum after a +22% surge, with buyers now approaching the key resistance at $0.433.
Entry: $0.307 – $0.385
TP1: $0.433
TP2: $0.450
SL: $0.307
🔥 Break and hold above $0.433 could open the door for the next leg higher. $ALPINE
$ALPINE is showing strong momentum after a +22% surge, with buyers now approaching the key resistance at $0.433.
Entry: $0.307 – $0.385
TP1: $0.433
TP2: $0.450
SL: $0.307
🔥 Break and hold above $0.433 could open the door for the next leg higher. $ALPINE
LearnToEarn
·
--
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
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
🚨 𝐀𝐂𝐄 +𝟐𝟐% 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$ACE is holding strong after a +22% move, with buyers now approaching the key resistance at $0.2376.
Entry: $0.1488 – $0.2176
TP1: $0.2376
TP2: $0.2500
SL: $0.1488
🔥 Break and hold above $0.2376 could open the door for the next leg higher.
$ACE
$ACE is holding strong after a +22% move, with buyers now approaching the key resistance at $0.2376.
Entry: $0.1488 – $0.2176
TP1: $0.2376
TP2: $0.2500
SL: $0.1488
🔥 Break and hold above $0.2376 could open the door for the next leg higher.
$ACE
LearnToEarn
·
--
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
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
🚨 𝐄𝐓𝐇 𝐇𝐎𝐋𝐃𝐈𝐍𝐆 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$ETH is holding its recent gains, with buyers now testing the path toward the key resistance at $1,923.
Entry: $1,885 – $1,913
TP1: $1,923
TP2: $1,940
SL: $1,885
🔥 Break and hold above $1,923 could open the door for the next leg higher. $ETH
$ETH is holding its recent gains, with buyers now testing the path toward the key resistance at $1,923.
Entry: $1,885 – $1,913
TP1: $1,923
TP2: $1,940
SL: $1,885
🔥 Break and hold above $1,923 could open the door for the next leg higher. $ETH
LearnToEarn
·
--
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
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
🚀 𝐁𝐓𝐂 𝐁𝐔𝐋𝐋𝐈𝐒𝐇! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🔥
$BTC is holding a strong bullish structure, with buyers now approaching the key resistance at $65,058.
Entry: $63,979 – $64,838
TP1: $65,058
TP2: $65,500
SL: $63,979
🔥 Break and hold above $65,058 could open the door for the next leg higher.$BTC
$BTC is holding a strong bullish structure, with buyers now approaching the key resistance at $65,058.
Entry: $63,979 – $64,838
TP1: $65,058
TP2: $65,500
SL: $63,979
🔥 Break and hold above $65,058 could open the door for the next leg higher.$BTC
LearnToEarn
·
--
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
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
🚨 𝐑𝐀𝐓𝐒 +𝟑𝟏% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$1000RATS is showing strong momentum after a +31% move, with buyers approaching the key resistance at $0.05552.
Entry: $0.03939 – $0.05384
TP1: $0.05552
TP2: $0.05800
SL: $0.03939
🔥 Break and hold above $0.05552 could open the door for the next leg higher.
$1000RATS is showing strong momentum after a +31% move, with buyers approaching the key resistance at $0.05552.
Entry: $0.03939 – $0.05384
TP1: $0.05552
TP2: $0.05800
SL: $0.03939
🔥 Break and hold above $0.05552 could open the door for the next leg higher.
LearnToEarn
·
--
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
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
🚨 𝐎𝐏𝐍 +𝟏𝟗% 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$OPN is showing solid momentum after a +19% move, with buyers approaching the key resistance at $0.0628.
Entry: $0.0511 – $0.0613
TP1: $0.0628
TP2: $0.0640
SL: $0.0511
🔥 Break and hold above $0.0628 could open the door for the next leg higher.$OPN
$OPN is showing solid momentum after a +19% move, with buyers approaching the key resistance at $0.0628.
Entry: $0.0511 – $0.0613
TP1: $0.0628
TP2: $0.0640
SL: $0.0511
🔥 Break and hold above $0.0628 could open the door for the next leg higher.$OPN
LearnToEarn
·
--
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
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
🚨 𝐒𝐎𝐗𝐒𝐁 +𝟐𝟐% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$SOXSB is showing strong momentum after a +22% move, with buyers now testing the key resistance at $45.88.
Entry: $37.07 – $45.31
TP1: $45.88
TP2: $47.00
SL: $37.07
🔥 Break and hold above $45.88 could open the door for the next leg higher.$SOXSB
$SOXSB is showing strong momentum after a +22% move, with buyers now testing the key resistance at $45.88.
Entry: $37.07 – $45.31
TP1: $45.88
TP2: $47.00
SL: $37.07
🔥 Break and hold above $45.88 could open the door for the next leg higher.$SOXSB
LearnToEarn
·
--
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
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
🚨 𝐀𝐂𝐄 +𝟐𝟐% 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$ACE is holding strong after a +22% move, with buyers now testing the key resistance at $0.2206.
Entry: $0.1488 – $0.2185
TP1: $0.2206
TP2: $0.2300
SL: $0.1488
🔥 Break and hold above $0.2206 could open the door for the next leg higher.$ACE
$ACE is holding strong after a +22% move, with buyers now testing the key resistance at $0.2206.
Entry: $0.1488 – $0.2185
TP1: $0.2206
TP2: $0.2300
SL: $0.1488
🔥 Break and hold above $0.2206 could open the door for the next leg higher.$ACE
LearnToEarn
·
--
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
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 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
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
🚀 𝐁𝐓𝐂 𝐁𝐔𝐋𝐋𝐈𝐒𝐇! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🔥
$BTC is showing strong bullish momentum, with buyers pushing toward the next resistance zone. The key level now is $64,610 for continuation.
Entry: $63,295 – $64,200
TP1: $64,610
TP2: $65,000
SL: $63,295
🔥 Break and hold above $64,610 could open the door for the next leg higher.$BTC
$BTC is showing strong bullish momentum, with buyers pushing toward the next resistance zone. The key level now is $64,610 for continuation.
Entry: $63,295 – $64,200
TP1: $64,610
TP2: $65,000
SL: $63,295
🔥 Break and hold above $64,610 could open the door for the next leg higher.$BTC
LearnToEarn
·
--
I went back through the Dusk documentation last night, and the incentive section made me slow down and read it twice.
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
🚨 𝐑𝐄𝐃 +𝟐𝟔% 𝐒𝐔𝐑𝐆𝐄! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$RED is showing strong momentum after a +26% move. Buyers are pushing toward the key resistance at $0.1148, making this the level to watch.
Entry: $0.0823 – $0.1069
TP1: $0.1148
TP2: $0.1200
SL: $0.0823
🔥 Break and hold above $0.1148 could open the door for the next leg higher.
$RED
$RED is showing strong momentum after a +26% move. Buyers are pushing toward the key resistance at $0.1148, making this the level to watch.
Entry: $0.0823 – $0.1069
TP1: $0.1148
TP2: $0.1200
SL: $0.0823
🔥 Break and hold above $0.1148 could open the door for the next leg higher.
$RED
LearnToEarn
·
--
I went back through the Dusk documentation last night, and the incentive section made me slow down and read it twice.
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
🚨 𝐆𝐏𝐒 𝐇𝐎𝐋𝐃𝐈𝐍𝐆 𝐆𝐀𝐈𝐍𝐒! 𝐁𝐑𝐄𝐀𝐊𝐎𝐔𝐓 𝐖𝐀𝐓𝐂𝐇 🚀
$GPS is holding its recent gains, with buyers still defending the current zone. The key level to watch is $0.01752 for a potential continuation.
Entry: $0.01107 – $0.01667
TP1: $0.01752
TP2: $0.01850
SL: $0.01107
🔥 Break and hold above $0.01752 could open the door for the next leg higher.
$GPS
$GPS is holding its recent gains, with buyers still defending the current zone. The key level to watch is $0.01752 for a potential continuation.
Entry: $0.01107 – $0.01667
TP1: $0.01752
TP2: $0.01850
SL: $0.01107
🔥 Break and hold above $0.01752 could open the door for the next leg higher.
$GPS
LearnToEarn
·
--
I went back through the Dusk documentation last night, and the incentive section made me slow down and read it twice.
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
What I first understood as a simple validator reward is more nuanced. Block rewards come from newly minted DUSK and transaction fees, with 80% going to the block generator, 10% to the voting committee, and 10% to Dusk. The generator’s 80% is split into a fixed 70% and a variable 10%, where the variable part depends on votes included in the block certificate. Voter rewards are based on credits, so voting power and incentives are closely connected.
That raised a question for me: does rewarding higher-credit voters strengthen participation, or could it gradually concentrate influence among already-strong provisioners?
The security side is also interesting. Minor faults can lead to suspension and soft slashing, while major faults such as invalid blocks, double voting, or conflicting blocks can trigger hard slashing.
Then I reached transactions. Dusk uses two models: Moonlight, an account-based model with public keys, and Phoenix, a UTXO-based model using ZK proofs for privacy. The contrast is clear, but I’m still wondering how these two models affect long-term decentralization and governance in practice.
How do you view the trade-off between voter credits, penalties, and decentralization?
@Dusk #dusk $DUSK
Inicia sesión para explorar más contenidos