Sattar Chaqer

ALL TP HITS

Go go lets go join here guys

TP 1 HITS

I used to think consensus was mostly about choosing the next block.

Dusk made me look at it differently.

With Succinct Attestation, a candidate block has to move through multiple stages before it becomes the new tip.

First comes Proposal, where a randomly selected provisioner generates and broadcasts a candidate block.

Then Validation. A committee checks the candidate against the current chain and votes on whether it is valid.

But Dusk doesn’t stop there.

A separate committee handles Ratification, voting on the result of the validation stage.

That separation is what caught my attention.

The network isn’t simply asking, “Do we have a block?”

It is asking whether the block is valid, whether that validation reached quorum, and whether another committee agrees with that outcome.

Only after successful ratification is the candidate accepted as the new tip.

That’s a very different way to think about consensus.

@Dusk $DUSK #dusk

What Reward Splitting Rules a Staking Contract Can Actually Set
‎
‎Spent the afternoon tracing what a staking contract on Dusk is actually allowed to configure and i expected a fairly narrow set of options. it isn't narrow.
‎
‎Dusk's own documentation on Stake Abstraction confirms contracts can implement arbitrary reward splitting rules routing a portion of rewards to referrers affiliates or operators entirely at the contract's own discretion. that's not a fixed protocol level percentage. that's a genuinely open configuration space.$BTR
‎
‎thats the part that stuck.
‎
‎give up protocol enforced simplicity in exchange for letting whoever deploys the contract decide how rewards actually get divided among the people using it. no standard split gets imposed from above.$TAC
‎
‎But hold up i want to be precise about what i actually know here. Dusk names Sozu as the example of this pattern in practice an automated staking pool. What i haven't found documented anywhere is Sozu's current deployment status mainnet live testnet only or something in between. i won't guess at that.@Dusk
‎
‎Kept coming back to what this actually enables regardless of Sozu's specific status referral driven staking services operator fee models affiliate programs all technically possible without needing Dusk itself to build any of them.#dusk
‎
‎So does open reward splitting create genuinely useful staking products or does it just shift the trust question from does Dusk's protocol treat me fairly to does this specific contract's operator treat me fairly?$DUSK

Privacy isn’t just about hiding the amount.

What I found interesting in Phoenix is that it also tries to make transactions harder to connect.

Phoenix uses notes stored in a Merkle tree. Each note has its own note public key.

Instead of using the same public key again and again Phoenix creates a one time note public key for each note.

That stood out to me because reusing the same identifier could make it easier to connect different transactions to the same user.$GRASS

The whitepaper says this one time key is designed to provide unlinkability between transactions.$UAI

There’s another part I found interesting.

The recipient can use a view key to check whether a note belongs to them while the secret key needed to spend that note can only be derived using their full secret key.

So the privacy idea here isn’t simply hide everything.

It’s more about controlling what can be connected publicly.

That made me look at Phoenix differently.

A private transaction is one thing.

Making it harder for someone to look at several transactions and connect them together is another.

And honestly that second part might be just as important.

@Dusk $DUSK #dusk

What matters most for privacy?

Sending every blockchain message to everyone sounds safe. It also sounds incredibly wasteful.

That’s what made Kadcast interesting when I went through Dusk’s whitepaper.

Dusk uses Kadcast to broadcast blocks transactions and consensus votes. Instead of simply flooding every neighboring node with the same message Kadcast organizes nodes using ideas from Kademlia.

Each node keeps routing information grouped into buckets based on the XOR distance between node IDs.

Then the propagation gets more selective.

A node forwards a message to selected peers at increasing XOR distances. Those peers continue the process creating a structured cascade across the network.

Kadcast also uses multicast trees. A message starts with nearby peers which then pass it toward nodes farther away in the network. This lets the network cover its nodes with fewer relays instead of repeatedly sending the same information through unnecessary paths.$TUT

That distinction caught my attention because blockchain networking can become expensive when every node keeps forwarding everything to every neighbor.

The point isn’t just making messages move quickly.

It is reducing redundant transmissions while maintaining reliable and timely propagation.

I like this because it shows that blockchain performance isn’t only about consensus or block production.$PUMP

The network has to move information efficiently too.

Sometimes the smarter design isn’t sending more messages.

It’s knowing which nodes actually need to receive them.

@Dusk $DUSK #dusk

What makes Kadcast efficient?

The market is bringing some interesting names again. $TRUMP $BEAT Both are getting plenty of attention on the chart. At this point I’m just trying to figure out how everyone finds these moves before I do.

I used to think a failed smart contract call was basically just an error.

But the more I looked at DuskVM the more interesting the failure path became.

Before execution gets underway Dusk checks things like the sender’s balance signature and nonce. If those basic conditions fail the transaction doesn’t get to execute normally.

But what happens when something goes wrong during execution?

That’s the part I find more important.

A smart contract can make state changes while running but a failed call doesn’t simply leave those changes sitting there. The state changes from that failed execution are not committed.

So you don’t end up with a contract stuck halfway between its old state and an incomplete new one.

Gas matters here too. Contract execution consumes gas which means failure isn’t just about whether the final result was successful. There are still execution resources involved along the way.

That made me rethink what safe execution actually means.

It isn’t only about making successful transactions work.

It’s also about having predictable behavior when execution fails.

For financial applications that distinction matters. A system handling valuable assets needs to know what happens when the expected path breaks.

Sometimes the most important part of a smart contract isn’t what happens when everything goes right.

It’s what the network does when it doesn’t.

@Dusk $DUSK #dusk

What matters most when calls fail?

The market really knows how to make you look twice. $PEOPLE $ENA

Both showing some serious strength on the chart.

I’m starting to think the real skill is not finding the movers it’s finding them before they move.

I used to think building directly on a blockchain’s native environment was automatically the better option.

Then I looked closer at DuskVM.

DuskVM gives developers direct access to Dusk’s Layer 1 environment. Smart contracts can use Dusk specific primitives and interact closely with the network’s native capabilities.

That sounds like an obvious advantage until you look at the other side.

Building directly on Dusk also means working with tooling designed specifically for DuskVM. Developers coming from established ecosystems may already be comfortable with familiar languages frameworks and development workflows.

So there is a real trade off.

You get closer access to the L1 but you also move further away from the tooling you already know.

That made me think about DuskVM differently.

The question isn’t simply whether Dusk’s native execution environment is powerful.

It’s whether access to Dusk’s own primitives is valuable enough for developers to accept a more specialized development experience.

For applications that need capabilities closely tied to Dusk’s architecture that trade off could make sense.

But for developers who mainly want familiar tools and workflows the learning curve may matter just as much as the technology itself.

Infrastructure isn’t only about what developers can build.

It’s also about what they’re willing to learn to build it.

@Dusk $DUSK #dusk

What matters more for developers?

The market keeps finding new names to surprise me. $BOME $RE

Both are getting plenty of attention on the chart.

At this point, I’m not even asking which one will move next I’m just trying to spot it before everyone else.

I used to think adding an EVM to a blockchain was mainly about making development easier.

But looking deeper into Dusk I started seeing it differently.

Dusk has two execution environments DuskVM and DuskEVM. And they seem to solve two different developer problems.

DuskVM is the native environment. Smart contracts can be written in Rust and compiled to WebAssembly giving developers a way to build directly within Dusk’s L1 architecture.

DuskEVM takes a different approach.

It gives developers coming from Ethereum a more familiar environment with support for Solidity Vyper and established EVM tooling.

That distinction matters more than I initially thought.

A developer who wants to work closely with Dusk’s native architecture can use DuskVM.

But someone who already knows Solidity and has spent years using Ethereum development tools doesn’t necessarily want to learn an entirely different environment just to start experimenting with Dusk.

So I don’t see DuskVM and DuskEVM as competing with each other.

They are more like two entry points into the same network.

One is native to Dusk.

The other makes the ecosystem more accessible to developers coming from the EVM world.

Now I’m more curious about the harder question.

Can Dusk attract both groups of developers without making its execution architecture feel fragmented?

@Dusk $DUSK #dusk

Which Dusk environment interests you more?

The chart is getting interesting $BTW $VELVET

These two are definitely stealing some attention from the market.

And of course I’m here discovering them after the move started.

A blockchain can look perfectly orderly when everything is working. The interesting part is what happens when it doesn’t.

What caught my attention in Dusk is that the network doesn’t simply assume every block will arrive on time or that every provisioner will always be reachable.

Delayed or lost messages can cause multiple candidate blocks to reach consensus in the same round creating a fork. Dusk’s fallback procedure normally resolves this by selecting the candidate from the lowest iteration. A higher iteration block can therefore be reverted if a lower iteration candidate later reaches consensus.

But there’s a deeper fallback.

If enough consecutive iterations fail because provisioners are offline or isolated Dusk can enter emergency mode. Normal step timeouts are disabled and iterations continue until a candidate block reaches quorum. Multiple open iterations can run at the same time increasing the chance of reaching consensus although that also creates a higher possibility of forks.

That made me think about consensus differently.

The real test of a network isn’t only how it behaves when everything goes right.

It’s what happens when communication breaks down.

For financial infrastructure having defined behavior for those messy conditions may be just as important as achieving fast consensus under normal conditions.

@Dusk $DUSK #dusk

What matters most during failures?

The market is cooking today

$CLO
$1000RATS
$ACE

Three names suddenly showing up on my radar.

I swear, crypto has a talent for making you discover the move after it already started.

Now I’m watching closely.

I keep noticing one problem in DeFi that gets overlooked: the rate you borrow at can change while your strategy is still running.

Floating borrowing and lending rates move with market conditions. That creates uncertainty. A borrower can face higher repayment costs while a lender’s expected return can change as rates move.

@TermMax approaches this differently.

Its model uses fixed borrowing and lending rates for defined maturities. In simple terms you can know the rate and know when the position ends.

That changes the planning equation.

For borrowers a fixed rate makes the repayment cost more predictable over the agreed period.

For lenders the fixed structure can make returns easier to understand and plan around.

And I think the maturity date is the part people underestimate.

Knowing the rate alone tells you how much.

Knowing the rate plus the maturity tells you how much for how long.

That distinction matters when building a strategy.

TermMax isn’t simply changing how DeFi lending works. It is addressing the uncertainty created by constantly moving rates and giving both sides clearer terms from the start.

That’s why fixed rate DeFi is worth watching.

#TermMax

What matters most in lending?

Another day, another pair making the chart look interesting.

$EDEN +27.59%
$ACE +27.08%

Both are quietly putting in a solid move today. Meanwhile, I’m just watching and wondering which one I should’ve noticed earlier.

I used to think Dusk’s committee selection was simply more stake = more chances.

It’s more nuanced than that.

Dusk uses deterministic extraction to select provisioners with selection frequency proportional to stake.

Each eligible provisioner receives credits based on a pseudorandom score and those credits determine who gets selected for consensus roles.

The interesting part?

The process is deterministic but future selections are difficult to predict.

Dusk uses SHA3 with inputs including the previous block’s seed, the current round and step, and the credit being assigned.

The seed then changes with every block.

There’s also a balancing mechanism I found interesting.

After a provisioner receives a credit its weight is reduced by 1 DUSK for the next selection.

So the system isn’t simply:

Biggest stake → permanent influence.

Instead it combines stake weight deterministic randomness and changing selection weights.

The result is a committee selection process where stake matters but knowing who gets selected next isn’t straightforward.

And for a network designed around financial infrastructure that unpredictability matters.

@Dusk $DUSK #dusk

What shapes Dusk selection most?

The gainers list is getting interesting again.

$GPS +57.86%
$ACE +39.51%

Both are having a pretty good day while I’m here wondering why I always notice these moves after they happen.

A blockchain transaction is often described as either confirmed or not. Dusk’s consensus model makes that answer more nuanced.

A block can move through four states accepted attested confirmed and final. Each stage represents a different level of confidence about whether that block can still be replaced.

An accepted block has a success attestation but it can still be replaced by a lower iteration block with a success attestation. An attested block has a success attestation and all previous iterations have failed so it cannot be replaced by a lower iteration block.

Then comes confirmed. At this stage the block is unlikely to be replaced although an ancestor could still be replaced. That makes confirmed different from final.

A final block goes one step further it is confirmed and its parent is final. According to the documentation a final block cannot be replaced under any circumstances.

That distinction is easy to overlook because confirmed and final are often treated as the same thing. Dusk makes the progression explicit.

For financial applications knowing exactly when a block becomes irreversible is not a small detail. It can affect when a settlement can truly be treated as finished.

@Dusk $DUSK #dusk

When is a block truly final?