ashley mason

Yoo

[ashley mason @_ashholee_]

@SimonWheaton @m477lander Yeah, that’s probably the cleanest fix tbh. Slots for ordering, timestamps for time. No reason every integrator should be doing their own conversion.

[ashley mason @_ashholee_]

@death_jokes @m477lander Same honestly 😂 30 slots just feels like 12 seconds at this point. That’s exactly why these assumptions are so easy to miss.

[ashley mason @_ashholee_]

@TreyCrocket @m477lander Yeah lol, that’s the sneaky part. Nothing looks broken until the timing starts biting you.

[ashley mason @_ashholee_]

@kaju1official @m477lander Yeah, that’s the part people can easily miss. The rule still says 30 slots, but what 30 slots actually means in real time has changed. Worth checking all those assumptions before the next step.

[ashley mason @_ashholee_]

@slurpewp @m477lander Yeah, that’s the part that bugs me. If the oracle already knows both, why make every app figure out the clock conversion themselves? That’s how the little inconsistencies creep in.

[ashley mason @_ashholee_]

@Smokefly @m477lander Really?

[ashley mason @_ashholee_]

@Chloe_Kaia_ @m477lander Yeahh true 💯

[ashley mason @_ashholee_]

@tinnna0731 @m477lander Yeah 😂 the chain sped up, but the assumptions are still living in the old timeline. That mismatch is where the sneaky stuff starts.

[ashley mason @_ashholee_]

@syafri_soekamti @m477lander Exactly “free speed” sounds great until you realize the liquidation clock got faster too.

[ashley mason @_ashholee_]

@EliasQuinn8449 @m477lander Yeah, that’s the sneaky part. Everything can look fine on paper while the timing assumption is quietly getting worse.

[ashley mason @_ashholee_]

@mccreamies @m477lander Exactly. Faster slots mean less real-time cushion, so liquidations can come knocking sooner than people expect 😭

[ashley mason @_ashholee_]

@trinitymorgan23 @m477lander Yeah, exactly. The slot number looks the same, but each one has way less time to breathe now 😭

[ashley mason @_ashholee_]

@LuLualexq @m477lander Free speedrun to liquidation, love that for us. Definitely not the kind of “performance upgrade” anyone asked for.

[ashley mason @_ashholee_]

@EliasQuinn8449 @m477lander Exactly 😂 slots and seconds can coexist just fine. It’s the “400ms forever” assumption that deserves the side-eye.

[Matt lander @m477lander]

Solana won my network poll, so I took the hint and spent some time looking through the latest network changes.

the obvious headline is SIMD-0525: the 350ms slot target is now live. Faster slots and the shorter blockhash window have already been covered. I wanted to see what this changes higher up the stack, so I went through the proposal, docs and public protocol code.

What I hadn't seen discussed much is what happens one layer above it:: the chain clock moved, while some app logic still reads time through the old 400ms assumption

The SIMD warns about this directly. anything measured in slots now covers less real time, and programs that treat slot distance as wall-clock time may need an update Static SDK constants also stay unchanged for now.

@switchboardxyz's Solana tutorial gave me the cleanest example:

`.max_age(30)` rejects data older than 30 slots and describes that as roughly 12 seconds..

At the 350ms target, those 30 slots are nominally 10.5 seconds. At 200ms, 6 seconds.

Same code. Same parameter. Different risk policy.

Switchboard is doing exactly what it says. If you meant 30 slots, the rule still does exactly what you asked. If you meant roughly 12 seconds, you don't have 12 seconds anymore.

I checked @kamino's public kLend code and found the same handoff. The path starts with Switchboard's last update slot, uses DEFAULT_MS_PER_SLOT to manufacture a timestamp, then checks that against a max age in seconds. the SDK constant is still 400ms, so against the 350ms target the nominal age comes out 14.3% higher.

At the 200ms target, it would read as 2x older than it really is. A 30-second policy would trip after roughly 15 seconds of wall time, without anyone changing the policy.

The deeper problem isn't the number 400. It's that a risk check silently translates between two clocks. And this is why "just use `Clock::unix_timestamp`" isn't the whole fix. the current time is in seconds, but this oracle update starts in slots Both sides of the check still need to speak the same clock

No exploit claim here. The bias is conservative: valid data can look stale sooner. This is an availability risk, not a direct value-extraction path. The important part is that the handoff exists in real code.

This is exactly why I keep banging on about the full execution path. The network can report the right slot. The oracle can report the right update. The check can run exactly as written. the final behavior still changes at the handoff between protocol time and real time.

This actually makes me like @Solana's staged rollout more. A faster clock is good infra, and every gate gives builders a real checkpoint to catch these assumptions before 200ms.

Before the next gate, grep for every `max_age`, staleness check, cooldown, retry and timeout expressed in slots. Did you mean slots or seconds?

@bw_solana, should apps stop converting between the two entirely: slots for protocol ordering, timestamped data for wall-clock policy? And if so, what should an oracle expose so apps never have to manufacture that timestamp themselves?

SIMD-0525:
https://t.co/GRZMxPDlti

Switchboard example:
https://t.co/HYhQE7X4Yw

SDK constant:
https://t.co/QtzmoQQItE

Public code example:
https://t.co/EFJ2bXV7NB
https://t.co/xm1gTjQEPc

[ashley mason @_ashholee_]

@Chloe_Kaia_ @m477lander Yeah, exactly. If I have to approve every single payment, what’s the agent actually doing? The sweet spot is giving it enough freedom while keeping the important guardrails in place.

[ashley mason @_ashholee_]

@Smokefly @m477lander Exactly. Limits can control what an agent does, but proving the action was actually intended by the user is a whole different problem. That’s where the real trust layer comes in.

[ashley mason @_ashholee_]

@swagsarah14 @m477lander Yeah, I’m with you on that. Keeping the final say with the local wallet gives the user more control and keeps the intent check closer to the actual signer.