The latest update from OISY Wallet, version 1.4.6, brings in a set of features designed to streamline daily crypto transactions without weighing down users with clutter or confusion. It’s less of a facelift and more of a polish job—one that focuses on fine-tuning the experience while expanding its reach across chains.

Support for Polygon is now baked in, which means native POL, USDC, and USDT are all good to go. This makes OISY even more versatile, stepping further into the multi-chain future. For users juggling stablecoins or hopping between chains, this update knocks down a few more walls.

One of the more subtle but meaningful upgrades is the smart send flow. OISY now remembers recently used addresses and flags anything unfamiliar. It’s a small addition that carries a lot of weight, especially in a space where a mistyped address can send assets into a digital void. By surfacing recently interacted-with wallets and giving a clear heads-up when something’s new, OISY adds a layer of reassurance without introducing friction.

The ICPSwap integration adds some automatic muscle to every transaction. Users get the best available swap offers by default, but the option to make manual adjustments remains. It’s not trying to be a black box; it’s just doing the legwork for you upfront, while keeping the driver’s seat unlocked.

On the interface side, the activity page has finally caught up with expectations. It now scrolls cleanly and loads progressively—something that sounds basic, but for power users flipping through transaction history, makes a noticeable difference. Combined with crisper fee displays and cleaned-up filters, the experience is more coherent. Buttons behave, data loads without tantrums, and filters feel like they were placed with intention.

Another new guest at the party is XTC, which now enjoys full token support. And for users working with euro-denominated assets, there’s vEUR, accompanied by a subtle but fresh Euro-stars background. It’s the kind of visual touch that doesn’t overwhelm the interface, but quietly signals that the token’s profile has grown.

There’s also better visibility for pending conversions, specifically for ‘ck’ tokens. These now show up in the activity log even before they fully land, and their values are accurately reflected. For anyone juggling conversions and watching balances across canisters, this saves some guesswork. It’s also one more way OISY tries to reduce the number of “wait, where did that go?” moments.

The wallet’s UI tweaks aren’t dramatic, but they’re deliberate. Fee displays are clearer, and filters are more responsive. There’s also the kind of bug fixing that doesn’t make headlines but keeps everything from wobbling under pressure.

The 1.4.6 update isn’t about changing direction. It’s about sticking to the path and making sure the pavement is smooth. The wallet continues to do what it set out to do—supporting a wide set of tokens across multiple chains, giving users control without overwhelming them, and keeping the day-to-day operations tidy.

There’s an obvious interest in making the app friendly for repeat users. The new address memory feature is one example of that, helping reduce errors and speed up transactions. The improved activity page is another. It’s an interface made with the understanding that crypto isn’t just something people check once in a while; it’s something they use like email or banking.

Polygon support brings in a large and active base, while still preserving OISY’s commitment to other networks. The ICPSwap integration is a good indicator of how OISY is quietly looking for ways to make smart decisions in the background, without being pushy.

These kinds of updates reflect a developer team that’s more interested in quality-of-life improvements than flash. That means focusing on the smaller frictions—slow loads, clunky filters, missing tokens—and smoothing them out. It’s work that rarely gets fanfare, but adds up to a better product over time.

For those keeping score, the combination of new token support (XTC, vEUR), enhanced transaction previews, and deeper chain compatibility ticks off several frequently requested features. None of them is flashy on its own, but together they show a wallet that’s listening closely to what users need.

The addition of visual cues like the Euro-stars backdrop for vEUR hints at a willingness to keep the interface personal and recognisable. The same goes for context-aware warnings during sends. These aren’t features that will go on marketing posters, but they’re the kind that users remember when things go wrong—or, more accurately, when they don’t.

Crypto wallets walk a fine line between control and convenience. Too much automation, and users feel boxed in. Too little, and it feels like a command-line interface wrapped in colours. OISY’s recent update doesn’t tip too far in either direction. It gives more options to those who want them, without demanding technical gymnastics. It’s also a quiet nudge that OISY is growing without trying to become a bloated control panel.

The pending conversion display for ck tokens fills a gap that previously led to uncertainty. By acknowledging what’s incoming—even if it’s not fully processed yet—OISY reduces mental overhead. The user doesn’t have to keep tabs in a separate tracker or refresh obsessively. It’s visible, it’s valued, and it behaves predictably.

With the current crypto wallet scene becoming increasingly noisy and fragmented, OISY’s update feels more like someone quietly reorganising your messy desk while you’re at lunch. You come back, and everything’s where it should be—with some new tools thrown in.

The update also shows how far things have come from the early days when wallets were rigid, feature-sparse, and indifferent to usability. Now, there’s an expectation that these tools behave like polished apps rather than experimental side-projects. OISY is clearly chasing that standard, and hitting more marks with each release.

There’s no bombast in version 1.4.6, but there is confidence. Confidence in the way new features are introduced, how they’re tucked into the interface without yelling for attention, and how they build on each other instead of cluttering things up.

Crypto users want wallets that don’t need a manual. They want clarity without compromise. This update brings a little more of that. It makes everyday tasks faster, decisions easier, and mistakes rarer.

As other products continue to chase new buzzwords and try to reinvent the wheel, OISY is doing the less glamorous but far more important work: making the wheel turn more smoothly. One feature at a time.

CycleOps has just flipped the switch on a new way to launch and manage Internet Computer canisters, and it comes with a sleek dashboard, an intuitive flow, and an absolute refusal to rely on complicated command-line guesswork. Developers can now spin up smart contracts in seconds without touching a CLI. The days of double-checking command syntax, hunting through docs for flags, or dealing with errors that are vaguely threatening and entirely unhelpful may be on the way out. CycleOps is giving developers the digital equivalent of a big red launch button.

It’s the kind of move that makes sense if you’ve ever worked with canisters on the Internet Computer. Creating and deploying them isn’t impossible through command-line tools, but it can be tedious, error-prone, and off-putting for developers who simply want to ship fast and iterate freely. CycleOps steps into that gap, streamlining the process into three easy steps: pick a subnet, set a cycle balance, and assign controllers. After that, you’re good to go. A new canister is live—no friction, no fuss.

Behind this simplicity is a clear goal: to take the repetitive overhead out of launching and managing smart contracts. By offering pre-defined subnet options—whether you’re aiming for low-latency execution, larger storage, fiduciary compliance, or compatibility with a specific fleet—you get to align your canister’s environment with its actual workload. It’s a small touch, but one that shows an awareness of the diverse needs across decentralised applications.

Once the canister is launched, the dashboard becomes your control room. Everything that used to be buried in CLI commands is now available with clicks: start or stop a canister on demand, edit who controls it, change operational thresholds, take snapshots, and restore state. If something goes wrong, live log tailing is built right in—no more jumping between terminals or logging tools.

The core idea behind CycleOps is about putting control back into the hands of developers, without making them wrestle with infrastructure. This isn’t a full-stack platform trying to do everything. Instead, it’s laser-focused on making canister lifecycle management fast, easy, and error-resistant. Whether you’re deploying a brand new app or just need to push a small upgrade to a microservice, the process is now significantly less painful.

What used to be a potential stumbling block for teams new to the Internet Computer ecosystem could now be one of its selling points. It removes that early developer friction, especially for those coming from traditional cloud services where dashboards and automation are the norm. A UI-first approach makes the Internet Computer ecosystem more accessible to devs who might not want to dive into command lines just to get started.

CycleOps also fits nicely into team workflows. By allowing multiple controllers to be added at the point of launch, collaborative development is better supported from the beginning. There’s no need to update configs manually after the fact. Everything that matters is frontloaded into the process, reducing post-launch overhead and keeping developers focused on building features instead of wrangling tools.

There’s something refreshingly direct about the way the CycleOps team has structured the dashboard. Instead of building a tool that tries to predict what users might need, they’ve simply made the fundamentals more approachable. The interface doesn’t overcomplicate things. There’s no unnecessary abstraction or branding flourish—it’s just practical, clean, and geared for people who want to get things done.

That attention to practical use cases extends to features like state snapshots and log tailing. These might sound minor, but for teams running canisters in production, they can be a lifeline. Rolling back to a known state after a failed update or bug is far easier with snapshots. Live logs can catch issues before users even notice them. All of this adds up to a smoother devops experience that’s likely to be appreciated across both small indie teams and larger organisations building on the Internet Computer.

The name “CycleOps” feels more apt now than ever—it’s truly about operations management through the lens of cycle economics. Since canisters require cycles to function, setting the initial balance at the launch stage avoids a common pain point: running out of cycles too soon or over-provisioning. Developers can make informed decisions right from the beginning, optimising both performance and cost.

Although it’s still early days for the dashboard, the approach is promising. There’s plenty of scope for future improvements—automated alerts, tighter integration with CI/CD pipelines, or expanded role-based access—but what’s here already addresses a core set of needs in a straightforward way. It doesn’t try to be everything; it just tries to be useful.

There’s a quiet confidence in that approach. While other platforms aim to be flashy or overly complex in their offering, CycleOps keeps things grounded. It knows its audience and delivers tools that respect their time. By hiding the rough edges of canister deployment and giving back visibility and control through a clean interface, it makes the whole process feel a lot more human.

That matters more than it might seem. Developers are at their most productive when they’re not distracted by tools. They need things to work without surprises, errors, or unnecessary hurdles. CycleOps delivers on that front by removing friction without removing control. It simplifies, but it doesn’t dumb down.

The growing interest in Internet Computer as a platform for building decentralised apps means this kind of tooling couldn’t come at a better time. Developers are hungry for tools that let them iterate quickly, deploy confidently, and recover from failure gracefully. CycleOps checks those boxes in a way that feels intuitive and developer-first.

As the platform matures, having more tools like CycleOps will be crucial for keeping the barrier to entry low while maintaining the high standards of decentralisation and performance that the Internet Computer ecosystem is aiming for. This dashboard isn’t just a quality-of-life upgrade—it’s a key step in making serious development on ICP accessible to more people.

CycleOps is now live and ready for action. If you’re building on the Internet Computer and have ever found yourself copy-pasting commands from docs, wrestling with dfx, or manually updating configs after launch, this dashboard is probably what you’ve been waiting for. It’s the kind of upgrade that makes things smoother without adding noise, and it’s likely to become a go-to tool for developers serious about scaling on-chain.

With its no-fuss launch process, built-in state controls, and live log visibility, CycleOps delivers a smarter way to manage canisters. One that’s less about ceremony, and more about shipping. And if it helps you avoid yet another late-night debugging session, that’s a win worth logging.

The Internet Computer is drawing the curtains on one of its longest-running backend flows. Developers who rely on the ledger_notify method for minting cycles are now being asked to shift to a more efficient and robust alternative. The legacy path, once the standard for creating or topping up canisters using ICP tokens, is now marked for deprecation. This marks a technical turning point for many within the ecosystem, particularly those operating at the infrastructure level.

The existing process works in two steps: an initial ICP transfer to a subaccount tied to the Cycles Minting Canister (CMC), followed by a separate notify() call to the Ledger. The memo in the transaction determines whether it’s a request to create a canister or top up an existing one. Once this second step is triggered, the Ledger performs a chain of checks and forwards the transaction details to the CMC, which then mints cycles based on the ICP/XDR rate and completes the operation.

While this model has served the community well, it carries a few serious drawbacks. The coupling between the Ledger and downstream canister calls means the Ledger has to wait for responses from the CMC—or even other subnetworks. If those downstream systems hang or become unresponsive, the Ledger is left holding open contexts, which interferes with upgrades and puts the entire flow at risk. This issue isn’t theoretical; it has already created challenges for the ecosystem’s upgrade agility.

There’s also the matter of deduplication. To prevent replay attacks or accidental double usage, the Ledger only keeps track of past notify() calls for a 24-hour window. If a notification doesn’t come through successfully within that short timeframe, the underlying ICP tokens can’t be re-used or recovered unless a manual fix is applied. It’s not hard to imagine how this could affect developers working across time zones or with limited automation.

Even worse, if the response from a notify call is lost—for example, due to frontend failure or poor network conditions—there’s no recovery path. The Ledger doesn’t store the result, so users can’t later find out what happened to their canister creation or top-up. In short, the system has too many single points of failure and too little room for error.

That’s where the new cmc_notify flow comes in. The process kicks off in the same way—transferring ICP tokens to a designated CMC subaccount—but now skips the Ledger as an intermediary in the notification step. Instead, users directly interact with the CMC via one of two new endpoints: notify_create_canister() for new canisters, and notify_top_up_canister() for replenishing existing ones.

This change alters the architecture in meaningful ways. Since the Ledger is no longer involved in downstream calls, its role becomes cleaner, reducing upgrade risks and improving overall reliability. The CMC, now in charge of its own deduplication, retains records for up to a million transactions, well beyond the previous 24-hour limit. If something goes wrong—like a lost network response—the user can simply try again with the same transaction index and get the original result.

The shift also brings more power to developers. When creating a new canister, they can now specify the subnet type or even pick a specific subnet. They can also define initial settings right from the start. This gives teams much-needed control during deployment, especially in production environments.

Switching to the new system is simple, technically speaking. Developers currently using ledger_notify just need to swap out the notify call to point to one of the two new CMC methods. No other part of the ICP transfer process needs to change. That said, developers should act quickly—there’s a firm removal date on the horizon. The notify() endpoint is scheduled to be permanently disabled at the end of June. After that, any integration still relying on the legacy path will stop working.

To ease this transition, the ICP team is taking a proactive approach. The Ledger’s notify() endpoint now logs the principal of each caller. This way, the team can try to identify and reach out directly to anyone still relying on the old flow. It’s an unusual but necessary move, driven by the goal of reducing friction and avoiding disruption for developers who might otherwise miss the announcement.

Those still using ledger_notify are being asked to confirm their status and provide an estimated migration timeline. If there are any blockers—be it a lack of engineering time, dependency on third-party libraries, or just confusion about how to proceed—the ICP team is open to support. Several developers have already begun the migration, and early feedback indicates that the process is straightforward and the benefits are real.

While this might seem like a low-level infrastructure change, it has broader implications for the stability and scalability of the Internet Computer. By removing dependencies between key canisters and allowing more graceful handling of delays or outages, the network is making itself more robust. It’s the kind of detail that won’t make headlines outside developer circles, but within the community, it’s a major quality-of-life improvement.

As decentralised systems continue to mature, these types of incremental updates—replacing tightly-coupled flows with more modular ones—play a big part in long-term resilience. The success of the cmc_notify transition will likely shape how future improvements to ICP infrastructure are rolled out. For now, the focus is on getting everyone off the old flow before it vanishes for good.

Anyone using ledger_notify and yet to begin the migration is encouraged to flag it publicly or contact the team. With only a few weeks left before the legacy route is removed entirely, preparation is key. The change is already live and ready for use, and those who’ve switched say it’s a clear upgrade in terms of control and reliability.

Developers who take the time now to transition will likely face fewer headaches in the months to come. And for a platform as complex and interconnected as the Internet Computer, fewer headaches means more time building—and less time untangling backend flows that no longer fit the way the network runs.

ICP Racer has quietly rolled onto Telegram, inviting crypto users to test their price instincts in a game that’s part prediction, part fast-paced fun. Built on the Internet Computer Protocol (ICP), this new mini app brings price guessing into your chat window — and throws in a points system, a multiplier for streaks, and a referral boost to keep things moving.

At its core, ICP Racer asks a simple question: will the price of ICP go up or down? Players tap “Moon” for up or “Doom” for down, and if they’re right, they collect 10 points. Get on a roll — six wins in a row — and the game starts multiplying those points. The idea is clean, quick, and designed to fit into a Telegram interaction without extra logins, downloads, or distractions.

But it’s more than a single-token game. The team behind it is already expanding prediction options to include a broader range of tokens within the ICP ecosystem. That means more opportunities to guess, win, and build up a running score. The expansion helps keep the experience dynamic while showcasing the wider ICP landscape in the process.

There’s also a social hook. A referral system lets users earn bonus points by inviting others to join the game. It’s a setup that nudges organic growth while adding a layer of competition — since points aren’t just about guessing, they’re also about outreach. The more people a user brings in, the better their own scoreboard starts to look.

The process to start playing is deliberately frictionless. Users open the Telegram bot, connect their ICP wallet, and start guessing. Each prediction triggers a five-second price roll. After that, the result flashes on the screen and points are either awarded or the streak breaks. It’s simple enough for first-time players to grasp immediately, and snappy enough to keep them interested.

What helps this stand out is that it’s grounded in ICP’s infrastructure. That means the platform benefits from the protocol’s speed, security, and transparency. Each prediction is logged, and results can be independently verified. While guessing games aren’t new in crypto, many are centralised or opaque. With ICP Racer, there’s a sense of visibility in how everything operates.

This use of ICP for gameplay also adds another layer of real-world application to the protocol, beyond its more typical technical and infrastructure deployments. Here, the tech is being used to support an accessible, game-like experience that’s intended to boost engagement with the wider ICP community. The simplicity of “Moon or Doom” makes it instantly understandable — and that’s a feature, not a limitation.

The scoring system encourages users to return, especially with the multiplier mechanic kicking in after six correct calls in a row. Streak bonuses like this are a staple in casual gaming, but they’re relatively fresh in the crypto prediction space. Instead of introducing complicated odds or confusing tokenomics, ICP Racer sticks with clarity — make the right call, rack up the streak, win more.

Tasks and challenges also feed into the point economy. Players can earn even more by completing assigned tasks, giving them another path to climb the leaderboard. Combined with referrals, these tasks make the system feel open-ended, not just a one-shot game. It’s designed to grow with its users and keep offering something new over time.

At a time when many crypto apps lean toward either full-blown exchanges or abstract metaverse ventures, ICP Racer threads the needle between simplicity and strategy. It invites Telegram users to jump in with minimal setup and start engaging right away. That immediacy lowers the entry barrier, especially for people who are curious about crypto but not yet active traders.

This kind of low-stakes, prediction-based interaction also gives users a way to interact with markets without committing actual funds. Instead of risking tokens, players risk streaks. Instead of watching candles on a chart, they watch a five-second price roll. It makes market movement feel like a quick decision rather than a research project.

What makes it tick is the seamless blend of casual interaction and on-chain trust. The ICP integration ensures that predictions and results aren’t just guesses behind a curtain. There’s a framework ensuring fairness, and a mechanism backing each outcome. It’s not gambling in the traditional sense — it’s point-based engagement with verifiable outcomes.

ICP Racer isn’t shouting from the rooftops, but it is quietly creating a use case that fits naturally into the existing habits of Telegram users. That’s no small thing. Crypto communities already live on Telegram, share predictions, argue about prices, and circulate links. Bringing a game into that space — one that works directly inside the app — taps into existing behaviour instead of trying to create a new one.

As more users discover the mini app, there’s potential for it to evolve beyond predictions. The framework could support leaderboard competitions, seasonal events, or themed challenges around other tokens or events in the ICP world. For now, though, it’s keeping things simple — tap, guess, wait, and see.

That balance of approachability and on-chain infrastructure makes ICP Racer feel more focused than many casual crypto games. It doesn’t require users to learn a new metaverse map or adopt a new token. It just asks them to take a chance — and rewards them for getting it right.

At a time when many in the crypto space are looking for clearer applications and more interactive experiences, ICP Racer might not be flashy, but it’s refreshingly accessible. It strips things down to the basics: price, timing, and instinct. With Telegram integration, referral bonuses, and secure predictions underpinned by the Internet Computer, the project adds a lightweight but structured way to keep users engaged.

And with summer just around the corner, guessing whether ICP will Moon or Doom might become a new kind of habit for chat-happy crypto users. The points are digital, the risks are low, and the taps are easy. Whether you’re an accurate guesser or just in it for the fun, ICP Racer is giving users a reason to come back and check again. And again.

Quietly but confidently, the Internet Computer Protocol (ICP) is getting a serious security boost. Behind the scenes, engineers are shaping up support for AMD’s Secure Encrypted Virtualisation (SEV), marking a bold move in how ICP handles replica upgrades and state encryption. The work is technical, time-consuming, and anything but cosmetic.

SEV is designed to protect the confidentiality of data in use, offering encryption at the virtual machine level. For ICP, adopting SEV means anchoring a node’s encryption keys to the very code it’s running. That makes keys tamper-resistant and unrecoverable outside their intended environment — a smart choice, but one that doesn’t come without some hefty structural consequences.

The team has confirmed that early tests of SEV support are scheduled to begin this summer. While that may sound straightforward, it’s hiding a complex web of engineering challenges. Rolling out SEV on ICP calls for a deep rethink of the upgrade and release machinery that sits under the hood of the protocol.

One of the biggest shifts comes in how encryption keys are generated and protected. Under this new approach, each replica’s keys are derived from a cryptographic hash of the running code. These keys don’t leave the virtual machine, and crucially, the hash changes with every release. That means an upgraded replica won’t be able to read the encrypted state left behind by an older one — unless the system finds a way to securely hand off those keys between versions.

To make that handoff safe and community-approved, the upgrade process itself is being overhauled. The new method will have to enable trusted key-sharing between consecutive replica versions, all while ensuring that no unauthorised or tampered replicas get access to the encrypted state. That’s a major shift from the current system and has knock-on effects across several moving parts.

The process of releasing new code will also need to adapt. Each release must now have its SEV hash calculated and stored, so the NNS Registry — the Internet Computer’s source of truth for node configuration — needs an upgrade of its own. It will have to record and distribute these hashes alongside the usual information, so that nodes know which versions are approved and which are off-limits.

Booting the operating system becomes more complicated, too. The bootloader — responsible for starting up the node and loading the correct software — must now verify that the OS matches the expected hash before anything else can run. That means redesigning the OS boot process from the ground up, with a strong focus on cryptographic assurance.

Beyond the internal mechanics, the way nodes interact is also changing. With SEV in place, nodes will be able to check if their peers are running SEV-enabled replicas — and if they’re not, the connection stops there. By default, data won’t be shared with nodes that don’t meet the new standard, cutting off any unapproved or potentially insecure participants from the network. That raises the bar for trust and integrity, but it also adds complexity to connection and verification protocols.

This isn’t a cosmetic polish or a mild performance tweak. The switch to SEV touches nearly every part of the infrastructure, and getting it right demands careful planning, testing, and coordination. Stability is a top priority, and no one wants to introduce security at the cost of uptime or user data. To that end, the team is taking a methodical approach, building out the necessary support structures and keeping a close eye on performance and safety throughout the rollout.

The upside is a system that can promise higher security guarantees, tighter control over upgrades, and an architecture that’s more resistant to tampering. It also sets the stage for a more fine-grained trust model across the network, where replicas can make smart decisions about who to trust — and who to avoid.

This move may not be loud or flashy, but it reflects a deliberate step towards strengthening the Internet Computer’s foundations. It’s a technical challenge with very real consequences, and one that will shape how secure, reliable, and flexible the network is in the years to come.

More updates are expected as testing begins in earnest. For now, SEV support remains a work-in-progress — a carefully engineered shift in how the Internet Computer handles itself behind the scenes.

DFINITY’s Chief Technology Officer, Jan Camenisch, has received the 2025 PKC Test-of-Time Award, joining forces with fellow cryptographers Markulf Kohlweiss and Claudio Soriente. This prestigious recognition honours research in public key cryptography that has stood the test of time, influencing both theoretical foundations and practical applications.

The award, decided by a panel of experts, acknowledges the trio’s sustained contribution to advancing cryptographic methods, a vital component for secure digital communication and blockchain technologies. Their work has become fundamental within the field, helping shape how secure systems are designed and maintained today.

Jan Camenisch’s role at DFINITY highlights the company’s strong position in cryptographic innovation, underlining their commitment to pushing the boundaries of security in blockchain development. The team’s achievements reinforce their reputation as leaders in the evolving landscape of decentralised technology.

The recognition is a testament to the long-term impact that rigorous research can have, providing tools and frameworks that continue to underpin secure digital interactions worldwide. It shines a spotlight on the individuals whose work quietly but powerfully supports advancements in blockchain and cryptography.

This accolade adds to DFINITY’s growing list of successes, reinforcing the organisation’s influence across the technical and academic communities. Jan, Markulf, and Claudio’s pioneering efforts demonstrate how foundational research remains relevant as technology evolves, inspiring future innovation.

The award-winning research continues to inspire cryptographers and blockchain developers alike, serving as a benchmark for quality and durability in the field. It also reflects a broader commitment to secure digital ecosystems, an essential factor for the growth and trustworthiness of decentralised networks.

Celebrations within the blockchain space mark this achievement as a proud moment, recognising how cryptography forms the backbone of trust and security in digital finance and beyond. The ongoing work by DFINITY and its collaborators is expected to drive further breakthroughs, maintaining momentum in a rapidly changing sector.

By honouring Jan Camenisch and his colleagues, the PKC community not only acknowledges past excellence but also encourages ongoing dedication to research that shapes the future of secure communication. Their work underpins much of today’s cryptographic infrastructure, benefiting users and developers around the globe.

This recognition cements DFINITY’s position at the intersection of academic excellence and practical innovation, showing how sustained effort in cryptography fuels progress across blockchain technology. It provides a reminder of the critical role researchers play behind the scenes in securing digital systems and advancing the field.

With this award, DFINITY’s CTO joins a select group of cryptographers whose contributions have become essential references, inspiring confidence and innovation in the cryptographic community and beyond. It’s a milestone that celebrates enduring impact and opens the door to future achievements in secure digital technology.