❌

Normal view

There are new articles available, click to refresh the page.
Before yesterdayMain stream

Verifiable DeFi Is Catching On. Case Studies: Robin Markets, Tradable.

✇Coinmonks
By: Arnab Kar (DC)
21 July 2026 at 09:55

Confidential decentralized finance (DeFi) has always been one of the best use cases for Oasis’s privacy stack. The industry’s first and only production-ready confidential EVM, Sapphire, was, however, only half the solution for trustless applications to ensure user data is sovereign and secured by default.

On-chain runtime can only take you so far, especially when processing huge datasets or sensitive information is concerned. Oasis has crossed that hurdle now with runtime off-chain logic ROFL in production. This framework runs off-chain compute inside a Trusted Execution Environment (TEE) before handing over the result to Sapphire for on-chain storage and finalization.

As Sapphire and ROFL enable verifiable privacy at scale, thereby counteracting the trust bottleneck, several projects have aligned themselves with Oasis to integrate this privacy layer for their products. Here, I will outline two examples that offer a glimpse into the future where confidential DeFi unfolds as verifiable private DeFi of tomorrow, uplifting user experience.

Robin Markets & verifiable yield with trustless oracle

Prediction markets are an interesting spin-off of the DeFi space, and Polymarket is undeniably one of the biggest players. Here, users can bet on real-world scenarios and outcomes, from elections to sports to just anything that involves Yes/No decisions. They can buy YES or NO tokens that are essentially tokenised positions in the market. The potentially lucrative returns attract not only crypto-native but also mainstream users, and at any given time, hundreds of millions in positions are open.

Funds locked with idle positions

The prediction market sounds fun and simple to engage with but has an inherent problem. When a user buys those YES or NO tokens, the time taken to resolve the position may range from a few hours to a few days to a few months. And until resolution, the funds are locked in the position, sitting idle, and with zero benefit to the asset owner.

Robin Markets proposes to solve this inefficient situation.

Users can trade and stake the YES or NO tokens, and earn passive income. It works like this.

  • Robin Markets pairs the YES and NO tokens
  • Then finds a YES staker and a NO staker on the same market
  • Next pulls the underlying USDC collateral from Polymarket
  • Finally routes it into viable DeFi yield strategies

With this scenario, both the YES and NO stakers stay in the market with their open positions untouched, while the collateral helps earn them APY.

Yield distribution mechanism

Users earning from idle positions is good news, but the yield distribution scenario is challenging. At the resolution point, one position wins, and the other loses. But the yield accumulated during the lifecycle of the positions is not equivalent for the opposing parties, representing variable risks.

It is improbable that the YES and NO stakers split the risk and the position 50:50, so the yield payout also cannot be an even distribution. Splitting the yield at the final resolved price is also inaccurate, as it will nullify the changing positions during the lifecycle of the staking period.

Time-weighted average, or TWAP, is used to solve this dilemma. This mechanism tracks the average price of both the YES and NO positions during the lifecycle of the staking period before calculating yield distribution. Robin Markets has a trustless oracle server to access the price history from Polymarket. It then uses TWAP to process the yield calculation, and signs the results on-chain. Any update on the yield in the staking vault only applies when a valid signature is verified from the oracle.

Oasis role

The trustless oracle runs on ROFL, executing the whole process of price fetching, TWAP computation, and result sign-off inside a secure enclave. No part of the process is visible, accessible, or modifiable by Robin Markets or any third parties. Also, since on-chain verification of signature must accompany any update, it ensures the oracle data remains in sync with the current chain state.

The verifiable-by-design computation and tamper-proof oracle reports ensure there are no trust gaps in the mechanism, letting users avail a first for yield on locked prediction-market positions.

Tradable & verifiable market intelligence

DeFi is the go-to web3 use case for many, but the market reality of retail traders versus institutions and professional traders shows a huge and unfair gap. While institutions benefit from reading and interpreting on-chain flows, liquidity conditions, and real-time market sentiments, professional traders have access to high-grade tools, automations, and data analysis and insights.

The Tradable platform and its SenseAI tool help plug this imbalance. With automated trading enabled and a personalised AI portfolio assistant to help, users other than traditional heavy hitters can also make the most of the market opportunities.

As an autonomous agent, SenseAI reads the market 24x7, bringing institutional feeds and insights to retail. It involves simultaneous access to three layers.

  • Macro structures like dominance trends and ETF flows
  • Network health like wallet data and capital inflows/ outflows
  • Market sentiment like fear/ greed cycles, narrative buildup, and trajectory

With institutional-grade intelligence on their fingertips, average users can use the opportunity to translate market trends and signals into potentially high-return crypto portfolios.

The mechanics of SenseAI

SenseAI, as a market intelligence tool, differs from most similar solutions that produce information overload by dumping too much raw data, with users unable to decide how to interpret the signals or what to do next. Instead, it runs a process that combines reasoned output from strategy, research, and analysis.

As a result, SenseAI is involved in context building to decide what matters and when, data access and processing, and using all this to analyse signals and infer the best foot forward. Two key components of the process are divergence and confluence.

Divergence is where the tool can flag the fragility of a network even when the price pumps and no apparent weakness is visible or predicted by price action. Confluence is where the tool can read signal over narrative so that liquidity and on-chain activity expansion is validated as real strength rather than mere hype.

Every insight is encrypted, verified, and paid on-chain, yet the whole process feels like a normal web request.

Oasis role

Market analysis, especially using autonomous agents, needs integrity, and that trust must be earned. The mechanism should be tamper-proof, and there should also be no bias for or against any crypto assets. Running inside ROFL, SenseAI ensures confidential compute on the Tradable virtual chain on Aurora. With remote attestation securing the tool’s mechanism, it is safe from any manipulation by the operator, and the user prompts also stay confidential.

Like any other AI tool, memory is the eternal pain point. As user interactions grow, memory also grows, branches, and needs constant access for context. The storage problem is solved by putting the entire memory, comprising messages and context, in an encrypted file on Autonomys Auto Drive. So, the confidential on-chain smart contract gatekeeps and proves any conversation that happens; Auto Drive stores the conversation content, and only the user, holding the keys, can access and read it.

Currently, SenseAI is in testnet mode, where usage by the community provides the information layer for the tool. After mainnet rollout on Aurora and enabling of live token payments, it will be integrated into the Tradable platform as the verifiable market intelligence for individual traders.

Final words

Robin Markets and Tradable’s SenseAI showcase how next-gen confidential DeFi evolves alongside AI agents. Integrating Oasis’s tech stack like ROFL underlines the value of off-chain compute and verifiable privacy.

What is your take on these projects? Let’s hit the comments section.
Also, explore Oasis’s in-house private DeFi solution, Privana, or how the protocol can help build and deploy verifiable agents.

Originally published at https://dev.to on July 21, 2026.

Verifiable DeFi Is Catching On. Case Studies: Robin Markets, Tradable. was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

When An Engineering Education Doesn’t Teach You How To Really Make Anything

✇Hackaday
By: Jenny List
7 July 2026 at 13:00

In the sweltering temperatures of an unusually hot European heatwave, I found myself having a chat with  a friend of mine from my university days. After discussing the health of his cat who had solved the problem of a fur coat on a hot day by flattening himself out on the concrete floor in the coolest place in the house, we moved on to tech matters. We’ve known each other for not far short of four decades, so this is familiar territory for us. The problems that come with taking a prototype to manufacturing, a process which even the most seasoned of engineers can slip up on.

The Difference Between Making, And Making For Manufacture

If you’ve ever taken a project and replicated it, you will know the progression. If you’re making five or ten widgets, you can debug and rework as needed, tweak things, and get things going. If you’re making more then this, the process consumes a greater proportion of your time, until a point at which manufacture becomes impractical. Maybe that’s around fifty boards, sometimes more or less.

A picture of a printed circuit board covered with components, with a red ring drawn round a reworked part.
This rework on the SHA2017 badge was caused by counterfeit parts rather than bad design, but the work it created was very costly for the team.

The skill a professional engineer picks up here is designing for manufacture. It’s something I picked only progressively over the years, and learned with a bang when I became peripherally involved in the production of electronic conference badges. You learn to be much more exact in your PCB design to avoid those reworks and bodge wires, you pick your parts with much greater care, and pay far more attention to power supplies, decoupling, thermal issues, impedances, and ground isolation. Something that works has to become something that always works, first time. You go from having several spins of the prototype PCB to having maybe a couple, and you reach a point at which you can order 5000 boards and have less than 50 of them that need attention. My friend describes himself as more of a software expert than hardware, but he’s learned this process over the decades far more than I have.

One comment he made hit the mark so well that it prompted me to start writing this: that when hiring recent graduates they would design things that could not be volume manufactured, while the new hire apprentices’ designs could. This fit so well with our common experience when we came through an engineering education that it posed the question, were we failed by it? We both attended the University of Hull, on England’s north-east coast, but this isn’t specific to Hull or even our generation as the problem of inadequate preparation applies to so many other institutions. Last year I talked about a couple of young engineers wrestling with an analagous experience here in the 2020s, and they were a long way from the Humber.

Do Universities Secretly See Their Job As Training More Academics?

A brick-and-concrete university building, a lawn and paved path in the foreground.
Hull University Electronic Engineering Department, where I learned most of what I know about electronics (except how to make things for manufacture). Hullian111, CC BY-SA 4.0.

My overwhelming memory of my degree course was shared by my friend, that about half of it was composed of useful stuff, and the other half of it was either trying to teach you to be an electronic engineering academic like the people delivering the lectures, or a course that seemed only to be there because they had someone who could teach it.

My Achilies’ heel was the mathematics, something I was later told improved in later years when the engineering department wrested its students away from the maths department. We had a very small amount of practical work, including simple transistor circuits, digital logic using real 74-series chips, laying out a PCB using crêpe paper tape on acetate film, and oddly considering it was outdated even in the early 1990s, wire-wrapping.

It’s easy to sit here and say that a university course teaches too much theory and not enough practice, but the fact is that universities aren’t there to teach you to solder. Indeed, while it’s a super-useful thing to be able to do and I’d urge every electronic engineer to learn it, soldering your own projects is not what makes you an engineer. Instead there has to be an exploration of where the boundary lies between the theoretical and the practical, and education should straddle that line rather than stay only on one side of it. It’s in deciding where that straddling point stops that the key lies.

There are university courses that manage that boundary by splitting it entirely. They combine time in industry with time studying, and a student on one of those courses would in theory learn the skills of a real-world engineer in their work placements. There are also industry sponsorship schemes placing students into industrial environments, but they are so few and the competition for them so fierce, that they might as well not exist for most students. Even the world of hackerspaces which gives the students a rare chance to mix with professional engineers in their off-time, is actively discouraged by universities. For a student in a full-time, study-based course, the challenge comes in how to bridge that gap into real-world manufacturing despite all these challenges, and learn something useful without the luxury of a real-world environment.

Torturing The Students With Diabolical Designs

The temptation for most courses is to start yet another group project. A team of six students are tasked with getting something working together, and learn stuff. The trouble with group projects though is that they either completely don’t work like our early 1990s assignment to make a telephone exchange from a Transputer link adapter chip, or a few participants end up doing all the hard work like my two young friends mentioned earlier. Group projects are inexpensive for an institution, but they look better than they really are.

An excerpt from the datasheet for the NXP BAX23 dual switching diode, showing the three different pinout options for the same package.
Component pinouts like this one from the NXP BAV23 datasheet are a spectacularly evil trick to play on an unsuspecting student.

The hardware hacker world has been marked by a series of epochs, as new technologies bring with them a flowering of creativity. There’s one of those that I think has the potential to delover something impossible back in the 1990s when I was a student, and allow individual students to learn the art of manufacture without a group project in sight. I’m talking about inexpensive PCB manufacture, which allows multiple spins of a design to be completed with a bearable wait, and for not a lot of money.

So if I wanted to teach a bunch of students about designing for manufacture, I’d give them a ready made small project in software form, as EDA files, and as a BOM with a board assembly house. Of course, the project would be fatally flawed but fixable with probably two or maybe three spins, but I wouldn’t tell them that. Instead their first task would be to send the files off and receive a ready-made PCB, or if I was feeling charitable I could give them that first spin ready-made, and tell them to get on with it.

I would throw everything I could at this unfortunate design, a wrong-but-plausible footprint, badly thought out earthing, an accidental oscillator, and all the really annoying things which we’ve all in our time found. I am sure you could think of more diabolical but superficially plausible features. Their task would involve diagnosing the board and redesigning it before sending the files off to the assembly house. A week later they’d have that next spin, they’d have to hunt down any remaining bugs and repeat it all, and so on. I learned this process with my friends in the making of an event badge for 5,000 people, and I think it’s possible that you could learn it as a single trainee engineer with a much smaller board.

It may be unfair to throw all that is wrong with engineering education at the door of universities, even though it’s certain that there are some extremely low hanging fruit. But arriving in the workplace completely lacking an essential skill is perhaps the point at which something should be said. The question is, when it comes to designing for manufacture, is anyone listening?

Junior Developers Write Code — Senior Engineers Design Outcomes

✇Coinmonks
By: Satyajeet Bansode
6 July 2026 at 01:52

Your code works.

That is the problem.

It runs. It passes tests. It gets merged. And yet, three months later, someone rewrites it. Six months later, it becomes a production issue. One year later, nobody wants to touch it.

This is the uncomfortable truth no one tells early in a developer career.

Writing code is not the job.

Designing outcomes is.

Early in a career, success feels simple. A ticket comes in. You write a function. You fix a bug. You see green checks. You feel productive.

That feeling is addictive.

But it is also misleading.

Because the real world does not reward code. It rewards impact.

A junior developer asks:
“What should I write?”

A senior engineer asks:
“What problem are we actually solving?”

That one shift changes everything.

Take a simple example.

A junior developer might implement an API like this:

@GetMapping("/user/{id}")
public User getUser(int id) {
    return repo.findById(id).get();
}

It works. It returns data. Done.

A senior engineer looks at the same requirement and sees something else entirely.

What happens if the user does not exist?

What about latency?

What about caching?

What about abuse?

What about future scale?

The code becomes:

@GetMapping("/user/{id}")
public ResponseEntity<User> getUser(int id) {
    User u = cache.get(id);
    if (u == null) {
        u = repo.findById(id).orElse(null);
        if (u != null) cache.put(id, u);
    }
    return (u != null) ? ok(u) : notFound();
}

Still simple. Still readable.

But now it reflects thought.

That is the difference. Not complexity. Not cleverness. Thought.

Junior developers optimize for completion.

Senior engineers optimize for consequences.

Before writing a single line, a senior engineer maps the system in their head.

Something like this:

Client
  |
  v
API Layer
  |
  v
Service Logic
  |
  v
Database
  |
  v
External Services

But they do not stop there.

They ask:

Where will this break?

Where will this slow down?

Where will this be abused?

Where will this need to evolve?

That is how outcomes are designed.

There is also a hard truth that stings a bit.

More code does not mean more value.

In fact, the best engineers often write less code.

Because they remove unnecessary work before it begins.

A junior developer might build a feature in five days.

A senior engineer might spend two days questioning it, then solve it in one.

Or decide it should not be built at all.

That is not laziness. That is leverage.

Another difference shows up during incidents.

When production breaks, junior developers search for the bug.

Senior engineers search for the system failure.

A null pointer is not the problem.

The absence of validation is.

A timeout is not the problem.

The lack of retries, backoff, or circuit breaking is.

A crash is not the problem.

The lack of observability is.

Senior engineers think in layers.

They design systems that fail gracefully, not systems that hope to never fail.

Let us talk about ownership.

Junior developers often feel ownership over code.

Senior engineers feel ownership over outcomes.

If a feature fails in production, it does not matter who wrote it.

It matters that it failed.

This mindset changes behavior.

Documentation improves.

Monitoring gets added.

Edge cases are considered.

Communication becomes clearer.

Because the goal is no longer to finish work.

The goal is to make things work in the real world.

So how does someone make this shift?

Not by learning another framework.

Not by memorizing more syntax.

But by asking better questions.

Before writing code, pause and ask:

What happens if this grows 10x?

What happens if this fails at midnight?

Who depends on this?

What is the simplest version that solves the real problem?

And most importantly:

Is this even the right problem to solve?

There is a moment in every developer’s journey where things click.

You stop thinking in methods.

You start thinking in systems.

You stop chasing tickets.

You start shaping outcomes.

That is when growth accelerates.

That is when people trust your decisions, not just your code.

Writing code is a skill.

Designing outcomes is a responsibility.

One gets you started.

The other makes you indispensable.

If your code works, that is good.

If your system works under pressure, that is engineering.

And that is the difference that separates a developer from an engineer.

Junior Developers Write Code — Senior Engineers Design Outcomes was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Piano Escapement Migrates to Drum Kit

✇Hackaday
By: Bryan Cockfield
29 June 2026 at 16:00

For as popular as the piano is in music studios, homes, and schools, it almost defies logic. Compared to a guitar, harmonica, or drum set, pianos are incredibly complex machines that can have somewhere on the order of 8,000 moving parts in a case that can easily weigh hundreds of pounds and which often responds quite poorly to seasonal changes in temperature and humidity. But for putting up with all of these downsides, musicians are rewarded with an instrument that uniquely responds to touch, style, and emotion. A big reason for that is that mechanical complexity, and [Super Valid Designs] is attempting to bring that design to a drum set.

Compared to the complex machinery that connects the movement of a piano’s key to its hammer striking a string, a kick drum pedal is much simpler. It can only bounce off of the drum or get “buried” where the beater remains pressed up against the drum after hitting it. [Super Valid Designs] wanted something with a bit more finesse and control, so he first 3D printed a mechanism that throws the beater towards the drum head and then disconnects it mechanically from the pedal, so that it rebounds even if the pedal stays depressed. The next steps were more difficult, which involved making sure the mechanism reset itself in a repeatable way, without making too much noise of its own. This involved trying out a few different ideas and printing a massive amount of subtly different linkages, but in the end he’s left with a machine that nearly replicates all of the parts of a piano’s escapement,

The end goal of this project wasn’t simply to reproduce piano mechanisms on a drum set, though. [Super Valid Designs] hopes to make a kick drum that’s much smaller than those found in traditional kits, and since smaller drums respond poorly when the beater remains on or near the drum after striking it, a mechanism like this will dramatically improve the performance of the smaller drum and help reduce the requirement for perfect technique. And, maybe in 50 years or so, these types of escapements will take over the drumming world just like the piano escapement took over keyboards after its invention in the 1700s. Some simpler piano actions have been built before, but the complexity seems to be a requirement for all of the tasks they need to do whether its for a piano or a drum.

❌
❌