<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>ICP·Dev</title>
  <link rel="self" href="https://blog.b3pay.net/rss.xml"/>
  <link href="https://blog.b3pay.net/"/>
  <id>https://blog.b3pay.net/</id>
  <updated>2026-08-14T06:04:32.848Z</updated>
  <subtitle>An automated tech publication powered by AI, delivering real-time, internet-grounded news across AI, Blockchain, Apple, Android, Web3, Rust and the Internet Computer.</subtitle>
  <icon>https://blog.b3pay.net/icon-512.png</icon>
  <logo>https://blog.b3pay.net/icon-512.png</logo>
  <author><name>ICP·Dev Editorial</name></author>
  <entry>
    <title>A Version Number Inside Every Proof: What Aleo’s snarkVM v4.0.0 Changes for ZK Developers</title>
    <link href="https://blog.b3pay.net/a-version-number-inside-every-proof-what-aleo-s-snarkvm-v4-0-0-changes-for-zk-developers"/>
    <id>https://blog.b3pay.net/a-version-number-inside-every-proof-what-aleo-s-snarkvm-v4-0-0-changes-for-zk-developers</id>
    <updated>2026-08-14T06:04:32.848Z</updated>
    <published>2026-08-14T06:04:32.848Z</published>
    <summary>Aleo’s snarkVM v4.0.0 introduces versioned records, encrypted sender metadata, new verifying-key editions, and breaking serialization changes for ZK developers.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[Aleo’s snarkVM v4.0.0 is a reminder that zero-knowledge infrastructure is not only about proving computation. It is also about how private state is serialized, upgraded, indexed, and recovered by the applications built around it.

The release adds a `_version` field to records. Records created after `ConsensusVersion::V8` use version 1, while older records remain version 0. The change gives Aleo a formal way to distinguish legacy private state from records created under the new rules.

That distinction matters because Aleo’s record model stores encrypted application state and ownership information on-chain. A record is closer to a private, programmable UTXO than to a simple account balance. When its encoding changes, wallets, SDKs, indexers, transaction builders, and recovery tools all become part of the migration surface.

The most visible privacy change is an encrypted sender field. New output records can include `sender_ciphertext`, allowing the recipient to derive the sender address with an account view key. The feature does not expose the sender publicly: it adds selective discoverability for the recipient while preserving the private-transfer model.

For developers, this is an API and serialization change, not merely a cryptographic optimization. `Request::InputID` gains a `record_view_key` entry for record inputs, and `Transition::Output` gains an optional `sender_ciphertext` entry for record outputs. Programs deployed on-chain also move to updated verifying keys and require edition 1.

The practical lesson is that ZK applications need explicit schema discipline. A wallet that understands only version-0 records may fail to display or spend new state correctly. An indexer that assumes every output has the same shape can misparse transactions. A proving service that pins old program editions may produce artifacts that no longer fit the active network rules.

The release also changes how developers retrieve deployed programs: `block_store().get_latest_program` is intended for the latest program edition, while the older lookup method does not provide the same upgrade-aware behavior. That is a small-looking interface change with large consequences for tooling that compiles, audits, or proves against deployed programs.

This is the broader ZK angle. Privacy systems are often presented as immutable mathematics, but production privacy depends on mutable software boundaries around the mathematics. Versioned records, encrypted metadata, verifying-key editions, and upgrade-aware queries are the mechanisms that let a private protocol change without making every application guess what the bytes mean.

The safety boundary is important: the GitHub release note describes breaking changes, but it does not establish a full network-wide migration deadline. Builders should confirm deployment status with Aleo or Provable before upgrading. Teams integrating snarkVM should therefore pin versions, test both record generations, update serializers, and verify that their wallets and indexers handle sender ciphertext deliberately rather than treating it as opaque noise.]]></content>
  </entry>
  <entry>
    <title>The UTXO Compatibility Test: What ICP’s Dogecoin Beta Reveals About Chain Fusion</title>
    <link href="https://blog.b3pay.net/the-utxo-compatibility-test-what-icp-s-dogecoin-beta-reveals-about-chain-fusion"/>
    <id>https://blog.b3pay.net/the-utxo-compatibility-test-what-icp-s-dogecoin-beta-reveals-about-chain-fusion</id>
    <updated>2026-08-14T00:01:51.819Z</updated>
    <published>2026-08-14T00:01:51.819Z</published>
    <summary>A technical look at ICP’s beta Dogecoin integration, including UTXO handling, threshold ECDSA signing, cycles, NNS governance, and production caveats.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[## A new Chain Fusion test case

ICP’s Dogecoin integration is now documented as a direct protocol-level connection, giving canisters an API for reading UTXOs, checking balances, estimating fees, and submitting signed transactions. The important development is architectural: Dogecoin extends ICP’s native-chain approach beyond Bitcoin while preserving the same broad UTXO workflow.

The integration is currently labeled beta. That status is a material caveat for builders: the documentation says Dogecoin differs from Bitcoin in ways such as its difficulty-adjustment algorithm, and recommends careful observation before production use.

## What developers actually get

A canister can derive a Dogecoin address from a threshold ECDSA public key, query the Dogecoin canister for UTXOs, construct a transaction, sign each input through ICP’s management canister, and submit the transaction for broadcast. The private key is never reconstructed in one place; signing material remains distributed across subnet nodes.

The interface is deliberately small. The documented methods include `dogecoin_get_utxos`, `dogecoin_get_balance`, `dogecoin_get_current_fee_percentiles`, and `dogecoin_send_transaction`. Calls require cycles, which makes resource budgeting part of the application design rather than an operational afterthought.

## Why the fork matters

Dogecoin’s Bitcoin-derived transaction model lets developers reuse familiar patterns, but the details are not interchangeable. Mainnet addresses use Dogecoin’s `D` prefix, the smallest unit is the koinu rather than the satoshi, and fee rates must be obtained through the Dogecoin-specific fee-percentile method. The transaction path also uses the Dogecoin canister rather than Bitcoin’s `bitcoin_*` API.

That combination makes the integration a useful compatibility test. Chain Fusion is not simply adding another RPC endpoint; it is adapting ICP’s threshold-signing and protocol-adapter machinery to a chain with its own network rules while retaining a recognizable developer workflow.

## The governance boundary

The Dogecoin canister is controlled by the Network Nervous System. Changes therefore require an NNS proposal, creating a visible governance boundary around the integration. Developers gain a direct canister interface, but they still need to monitor both the external Dogecoin network and ICP governance.

The public `dfinity/dogecoin-canister` repository includes the canister, interface definitions, end-to-end tests, validation code, and a basic transaction example. For builders, that repository is the practical starting point for checking implementation details before committing funds or production dependencies.

## What to do with the development

The sensible near-term use is experimentation: build balance and UTXO readers first, test address derivation and fee handling, and treat signing and broadcast as a separate stage. Keep confirmation policy, retries, transaction idempotency, and cycle costs explicit in the canister.

The larger lesson is that Chain Fusion’s expansion is increasingly about chain-specific engineering discipline. A shared cryptographic primitive can make signing possible, but reliable cross-chain applications still depend on correctly modeling each network’s units, fees, transaction rules, and operational maturity.]]></content>
  </entry>
  <entry>
    <title>The Delegation Gets a Read-Only Mode: What ICP’s 0.64 Interface Spec Changes for Canister Security</title>
    <link href="https://blog.b3pay.net/the-delegation-gets-a-read-only-mode-what-icp-s-0-64-interface-spec-changes-for-canister-securit"/>
    <id>https://blog.b3pay.net/the-delegation-gets-a-read-only-mode-what-icp-s-0-64-interface-spec-changes-for-canister-securit</id>
    <updated>2026-08-13T18:00:38.820Z</updated>
    <published>2026-08-13T18:00:38.820Z</published>
    <summary>ICP’s 0.64.0 interface update adds query-only request delegations and minimum cycle thresholds for inter-canister calls, giving builders finer security and resource controls.</summary>
    <category term="Internet Computer"/>
    <content type="html"><![CDATA[The Internet Computer’s latest interface-spec entry introduces a small but consequential shift in how canisters define trust boundaries: permissions can now be attached to request delegations, and canisters can require a minimum number of cycles on incoming inter-canister calls.

The 0.64.0 changelog, dated July 6, 2026, adds an optional `permissions` field to request delegations. A delegation marked `queries` is accepted for query calls and `read_state` requests, while update calls carrying that delegation are rejected. The existing behavior remains available through `all`, or by omitting the field.

That distinction matters for applications that need read access without write authority. A dashboard, monitoring service, or automated auditor can receive credentials that inspect state while being structurally unable to submit update calls. This is not a new application-level role system; it is a protocol-level restriction on what a delegated request may do.

The same update adds `minimum_incoming_canister_call_cycles` to canister settings. When configured, a call from another canister carrying fewer cycles than the threshold is rejected with `CANISTER_ERROR`, and the attached cycles are refunded. Ingress messages and self-calls are excluded. The management-canister reference lists the default as zero, meaning no minimum is enforced unless a canister opts in.

The practical use case is resource discipline. A public service can reject calls that do not meet its declared cost floor, reducing ambiguous underfunding paths and making inter-canister pricing easier to reason about. It does not replace authorization, rate limiting, or input validation: a caller that meets the cycle threshold may still be unauthorized or abusive.

For builders, the change suggests a two-layer review. First, classify every delegated credential as read-only or fully capable, and use the narrowest permission that fits. Second, decide whether each public inter-canister endpoint needs a minimum cycle requirement, then test refund and error handling in callers.

The safety caveat is important: the 0.64.0 changelog documents the interface changes, but it does not by itself prove that every subnet, SDK, or client library already supports them. Verify the target subnet’s deployed version and the libraries used by your application before relying on these controls in production. The underlying ICP implementation is publicly maintained in DFINITY’s `ic` repository, which also documents release verification workflows.

The broader direction is clear. ICP is moving more security and economic policy into explicit protocol surfaces, so canister developers can express least privilege and minimum payment requirements closer to the request boundary instead of rebuilding every guard in application code.]]></content>
  </entry>
  <entry>
    <title>Rustup 1.30 Draws a Safer Line Around Automatic Toolchain Installs</title>
    <link href="https://blog.b3pay.net/rustup-1-30-draws-a-safer-line-around-automatic-toolchain-installs"/>
    <id>https://blog.b3pay.net/rustup-1-30-draws-a-safer-line-around-automatic-toolchain-installs</id>
    <updated>2026-08-13T12:01:19.841Z</updated>
    <published>2026-08-13T12:01:19.841Z</published>
    <summary>Rustup 1.30 plans to limit unnecessary automatic toolchain installs and remove the curl download backend, improving build visibility and reproducibility.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[Rustup is preparing a small but consequential change for its 1.30 release cycle: commands that manage rustup itself will stop implicitly installing the active toolchain when that installation is unnecessary. The change targets a surprising behavior in which an operation such as `rustup +beta target remove ...` could begin downloading an entire beta toolchain before performing the requested target operation.

The Rustup team says the new rule is meant to make failures more predictable. If a command needs a toolchain that is not installed, it should report that state instead of silently mutating the machine. Users can then choose the explicit operation—typically `rustup install`—and make that step visible in local setup scripts or CI logs.

The boundary is deliberately not absolute. The team plans to preserve implicit installation for proxy commands such as `rustc` and `cargo`, because removing that behavior broadly caused disruption in the earlier 1.28 cycle. The practical result is a narrower auto-install surface: ordinary compilation can retain its familiar workflow, while administrative rustup commands become less likely to trigger unexpected network activity.

Rustup 1.30 is also consolidating its download stack. The project has already made `reqwest` and `rustls` the recommended direction, and the 1.30 plan calls for removing the curl download backend. The rustup tracking issue describes the motivation in operational terms: fewer backend combinations should make cross-building easier and reduce failures tied to OpenSSL and platform-specific TLS behavior. Native TLS is not scheduled for immediate removal, so this is a simplification rather than a complete TLS policy reset.

For ICP developers, the lesson is less about a new compiler feature than about build reproducibility. Toolchain installation is part of the security and reliability boundary: an unplanned download can hide missing dependencies, slow a deployment, or make a clean-room build behave differently from a developer laptop. Teams using rustup in CI should audit where installation is expected, prefer explicit `rustup install` steps, and test scripts that rely on `RUSTUP_AUTO_INSTALL`.

A second planned item, XDG path support, could also improve predictability on systems that separate configuration, cache, and data directories. However, it remains tracked work rather than a shipped 1.30 feature.

Caveat: rustup 1.30 is still in development. The team’s July plan described the release as potentially four to eight months away, so the behavior, scope, and timing may change before publication. As of August 13, 2026, this is a development direction—not a stable-release announcement.]]></content>
  </entry>
  <entry>
    <title>Jolt’s Privacy Patch Changes What “zkVM” Should Mean</title>
    <link href="https://blog.b3pay.net/jolt-s-privacy-patch-changes-what-zkvm-should-mean"/>
    <id>https://blog.b3pay.net/jolt-s-privacy-patch-changes-what-zkvm-should-mean</id>
    <updated>2026-08-13T06:03:18.829Z</updated>
    <published>2026-08-13T06:03:18.829Z</published>
    <summary>Jolt’s NovaBlindFold upgrade adds zero-knowledge proofs without recursion or a trusted setup, while clarifying the difference between succinctness and privacy in zkVMs.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[A new Jolt upgrade makes a useful distinction in the zkVM market: a short proof is not automatically a private proof.

In a March 3, 2026 technical post, the Jolt team announced that its open-source RISC-V zkVM now supports zero knowledge through a technique called NovaBlindFold. The change targets a weakness in Jolt’s original design: messages produced by its sum-check prover could reveal information about the witness, or the private input used to execute a program.

The new design blinds those messages with hiding commitments. A second proof then demonstrates that the committed values would have passed the verifier’s checks. Jolt describes the result as a transparent zero-knowledge proof that does not require SNARK recursion, a trusted setup, or a separate wrapping system.

The reported engineering trade-off is unusually narrow. According to the project’s announcement, the privacy layer adds roughly 3 KB to the proof and causes essentially no increase in prover time. That does not mean every workload will receive identical results: the figure is a project-reported outcome, not an independent benchmark across hardware and programs.

Why this matters for builders

The terminology correction is more important than the headline number. Many systems described as “zkVMs” primarily provide succinctness: a verifier can check a computation without replaying it. Zero knowledge adds a different property: the proof should not reveal the private inputs or intermediate witness beyond what the claimed output implies.

Jolt’s architecture attempts to provide both properties in one transparent system. That could make the same execution framework useful for public verifiable computation and privacy-sensitive applications such as private credentials, confidential data processing, or proofs generated on constrained devices.

The repository also gives developers a practical starting point: Jolt targets RV64IMAC, is written as an open-source Rust project, and includes a quickstart path and profiling tools. But the project is not production-ready. Jolt’s official repository explicitly labels it alpha and says it is not suitable for production use at this time.

The cautious takeaway is that Jolt’s update is not proof that private zkVMs have become solved infrastructure. It is a concrete architectural move toward separating, then combining, succinctness and privacy without hiding the system behind recursive proof machinery. For developers evaluating a zkVM, “Can it prove execution?” and “Does it keep the witness private?” should now be treated as separate checklist items.]]></content>
  </entry>
  <entry>
    <title>The Chain Fusion Security Lesson: Cross-Chain Reach Does Not Fix Broken Accounting</title>
    <link href="https://blog.b3pay.net/the-chain-fusion-security-lesson-cross-chain-reach-does-not-fix-broken-accounting"/>
    <id>https://blog.b3pay.net/the-chain-fusion-security-lesson-cross-chain-reach-does-not-fix-broken-accounting</id>
    <updated>2026-08-13T00:03:13.817Z</updated>
    <published>2026-08-13T00:03:13.817Z</published>
    <summary>The SSS DeFi July 28 incident shows why Chain Fusion builders need financial invariants, reconciliation, attack replay, and fail-closed recovery alongside secure cross-chain signing.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[A July 28 security incident at SSS DeFi offers a timely Chain Fusion lesson: removing bridge custody does not remove the need for rigorous application accounting.

In an initial announcement published on July 30, the SSS DeFi team said an inconsistency between concentrated-liquidity position creation and exit calculations allowed an attacker to create abnormal liquidity entitlements and withdraw real assets from affected pools. The team estimated that approximately $9,200 in assets had been transferred out. It also said user liabilities remained fully covered by remaining reserves and that the confirmed loss would be absorbed by the team.

The incident matters to Chain Fusion builders because SSS describes its system as combining an internal ledger with multi-chain execution. Its response included tracing outbound assets to Bitcoin, BNB Chain, and Solana, while reverse-tracing preparation funds through ICP, Ethereum, Uniswap, and OneSec. That is the operational promise of a cross-chain application: one product may depend on several ledgers, execution environments, and accounting boundaries at once.

But the failure described by SSS was not presented as a compromise of ICP’s threshold-signing machinery. It was an application-level mismatch between how liquidity positions were created and how they were exited. That distinction is central. ICP’s Chain Fusion architecture lets canisters read external-chain state, derive chain-specific keys, and sign transactions without a single node holding a private key. It does not automatically prove that a DeFi protocol’s internal entitlement formula is financially correct.

The practical security boundary therefore has two layers. The protocol layer must protect signing, message execution, external-chain reads, and transaction submission. The application layer must prove conservation rules: a position cannot withdraw more than its valid share, burns must match prior creations, and every internal liability must reconcile with controlled reserves and external settlement records.

SSS said it suspended withdrawals, swaps, and new liquidity additions; isolated related accounts and positions; blocked the known exploit path; and matched 58 successful withdrawals against external-ledger or public-chain evidence. Its planned recovery sequence starts with a comprehensive audit, closure of critical and high-severity issues, asset-by-asset solvency verification, attack replay, concurrency testing, and fault-injection testing before a limited withdrawal canary.

That sequence is more important than the incident’s dollar value. Chain Fusion applications often make cross-chain actions feel like one seamless service, but the underlying state is distributed. A safe design needs explicit authority boundaries: the frontend and gateway should not become accounting authorities; financial facts should be produced by a canonical core; permissions should be minimized; and recovery should fail closed when reconciliation is uncertain.

The current SSS documentation also advises beta users to start with small amounts and verify final balances and receipts. For builders, the stronger version of that advice is architectural: test every mint, burn, withdrawal, and cross-chain callback as a state transition, then replay historical attacks and inject concurrency failures before enabling unrestricted funds movement.

Caveat: this is an initial incident announcement, not a completed forensic report. SSS said its full technical postmortem, security-hardening report, audit, and recovery acceptance process were still pending. The verified evidence supports the security lesson and the reported response, but not a final judgment about every root cause or the eventual recovery outcome.]]></content>
  </entry>
  <entry>
    <title>Internet Identity’s Faster Release Cycle Makes Review Part of the Security Model</title>
    <link href="https://blog.b3pay.net/internet-identity-s-faster-release-cycle-makes-review-part-of-the-security-model"/>
    <id>https://blog.b3pay.net/internet-identity-s-faster-release-cycle-makes-review-part-of-the-security-model</id>
    <updated>2026-08-12T18:01:19.839Z</updated>
    <published>2026-08-12T18:01:19.839Z</published>
    <summary>What Internet Identity’s planned two-proposal release cadence means for ICP developers, canister upgrades, origin security, and authentication testing.</summary>
    <category term="Internet Computer"/>
    <content type="html"><![CDATA[Internet Identity is tightening the distance between a code change and a production release. In a June 4, 2026 forum announcement, the team said it planned to move from roughly one weekly release proposal to as many as two: a primary proposal on Friday, followed by a possible secondary proposal on Monday or Tuesday. DFINITY voting would generally follow community review if no blockers emerged.

The operational detail matters more than the headline. The primary proposal is expected to contain larger changes, while the secondary slot is intended for feature-flagged functionality, small user-experience improvements, or other low-risk changes. Either proposal may upgrade only the backend canister, only the frontend canister, or both. That gives the team more deployment flexibility, but it also gives builders more release states to understand.

The cadence is enabled by architectural and organizational changes described in the announcement. Internet Identity says it migrated applications to the id.ai experience, separated the backend and frontend canisters, reduced technical debt, adopted AI-assisted engineering practices, and expanded to a three-person full-time engineering team. The announcement presents these factors as reasons that waiting several additional days before shipping a reviewed improvement is no longer always useful.

For ICP developers, the practical implication is that authentication integration should be treated as a moving dependency rather than a one-time library installation. The current developer guide documents the split between the Internet Identity backend and frontend, the mainnet canister identifiers, local deployment through the icp-cli `ii: true` setting, and the origin-specific principal model. It also warns that applications must validate identity-attribute signers, origins, nonces, and freshness instead of treating a signed bundle as automatically trustworthy.

A faster release loop therefore raises the value of a small, repeatable upgrade checklist. Builders should watch the proposal contents, test login and recovery flows against the affected canister, verify that frontend origins and alternative-origin configuration still match their deployment, and recheck any certified-attribute handling. Security-sensitive authorization must remain in update calls; ICP’s security guidance specifically warns that `canister_inspect_message` is executed by a single node and cannot be the sole access-control boundary.

The caveat is important: the forum post describes a stated operating plan, not a guarantee that two proposals will appear every week. Its current significance is that the plan remains publicly documented and can be verified today. If adopted consistently, the change makes community review a more continuous part of the Internet Identity security model—and makes release monitoring an ordinary maintenance task for every ICP application that depends on it.]]></content>
  </entry>
  <entry>
    <title>Rust Puts Maintainers on the Payroll: Inside the New Maintainer in Residence Model</title>
    <link href="https://blog.b3pay.net/rust-puts-maintainers-on-the-payroll-inside-the-new-maintainer-in-residence-model"/>
    <id>https://blog.b3pay.net/rust-puts-maintainers-on-the-payroll-inside-the-new-maintainer-in-residence-model</id>
    <updated>2026-08-12T12:00:01.338Z</updated>
    <published>2026-08-12T12:00:01.338Z</published>
    <summary>Rust is creating a formal funding path for long-term compiler, Cargo, Clippy, and standard-library maintenance through its Maintainer in Residence program.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[Rust’s latest infrastructure change is organizational rather than syntactic: the project is building a formal funding pipeline for the people who keep the language and its toolchain reliable.

In a June 2026 announcement, the Rust Project described the Rust Foundation Maintainers Fund and a new Funding team created through RFC 3931. The central mechanism is the Maintainer in Residence program, which is intended to financially support existing Rust Project maintainers working on critical areas such as the compiler, standard library, Cargo, and Clippy.

The funded work is deliberately broader than feature development. It can include large refactorings, code review, issue triage, contributor mentoring, and unblocking features. That matters because a mature toolchain accumulates operational work that is essential but rarely produces a headline release feature.

The model also separates technical priorities from fundraising administration. Rust teams identify maintenance needs, while the Funding team coordinates funding opportunities and works with the Foundation to direct support. The Foundation’s companion explanation says future calls will assess applicants against the Project’s needs and priorities, with offers made to the strongest candidates when funding is available.

For developers, the practical implication is a more visible path for maintaining the foundations beneath a Rust stack. Compiler behavior, Cargo workflows, linting, and standard-library evolution depend on continuous review and triage. A dedicated funding channel could make that work less dependent on spare time or employer-specific budgets.

There is an important limit to what can be claimed today: Rust announced the program in June and said it expected to hire the first Maintainer in Residence in the coming months. No measurable delivery outcome from the program has been published yet. The near-term story is therefore the creation of a funding mechanism, not proof that it has already reduced backlogs or accelerated releases.

That distinction is useful for teams shipping Rust in production. The program does not replace normal dependency review, compiler upgrades, or security processes. It does, however, signal that sustaining the toolchain is being treated as a long-term engineering function with an explicit funding model.]]></content>
  </entry>
  <entry>
    <title>From Training Logs to Cryptographic Evidence: ZK’s New Audit Layer for Frontier AI</title>
    <link href="https://blog.b3pay.net/from-training-logs-to-cryptographic-evidence-zk-s-new-audit-layer-for-frontier-ai"/>
    <id>https://blog.b3pay.net/from-training-logs-to-cryptographic-evidence-zk-s-new-audit-layer-for-frontier-ai</id>
    <updated>2026-08-12T06:03:33.825Z</updated>
    <published>2026-08-12T06:03:33.825Z</published>
    <summary>A June 2026 preprint proposes a zkVM architecture for verifying frontier-AI training claims while preserving model and dataset confidentiality.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[Most zero-knowledge machine-learning systems prove an output: a model produced this answer, or a committed model evaluated this input. A new June 2026 preprint asks a harder question: can anyone verify that a frontier model was trained according to a declared procedure, within a declared compute budget, without revealing the trainer’s private architecture or dataset?

The proposal, authored by Pierre Peigné, Ky Nguyen, and Paul Wang, treats ZK as an audit layer for the training process itself. Its central idea is to combine three kinds of evidence: a pre-committed training specification, independently observable network activity between training nodes, and Merkle commitments to selected intermediate computations. A zero-knowledge virtual machine would then verify sampled portions of the run while keeping sensitive details private.

The design is notable because it tries to prove native GPU arithmetic rather than translating training into a simplified finite-field model. The authors propose zkVM precompiles for BF16 and FP32 operations, the formats used in modern neural-network training. That does not make every GPU instruction automatically provable; instead, it defines a proving architecture around committed execution traces and a catalogue of operations that the zkVM must support.

The protocol has three proof phases. A genesis proof binds the run to a committed training specification, initial weights, and dataset commitment. In-training proofs connect successive checkpoints through recursive commitments, allowing a verifier to sample parts of a long run instead of rechecking every operation. Ex-ante attestations enforce declared limits such as total FLOPs, step counts, training regime, or data-filter thresholds as the run proceeds.

That changes the governance vocabulary. A compute threshold would no longer be only a statement made by a model developer after training. In principle, the threshold could be committed before the run and enforced by a recursive counter inside the proof system. The result would be closer to a machine-checkable compliance record than a conventional audit report.

The paper estimates that a proof of concept could be deployable in roughly 36 months with single-digit-percent training-side overhead. It also estimates an aggregate proof of about 200 KB for its example architecture and says verification could consume a fraction of the training budget. These are projections from the authors’ model, not independent production measurements.

The most important constraint is scope. The design currently targets dense pre-training. It does not yet cover sparse mixture-of-experts execution, reinforcement-learning post-training, multi-datacenter training, or all intra-node accelerator traffic. Those omissions matter because frontier systems increasingly combine several of these modes.

There is also a trust-boundary question. Network observations and hardware-adjacent anchors can help tie a proof to a physical training run, but they introduce components that must themselves be specified, secured, and audited. Zero knowledge can hide the model’s internals; it cannot automatically prove that every external observation mechanism was honest or complete.

The work should therefore be read as an architecture and research agenda, not a shipping compliance product. Its genuinely new angle is the shift from proving what an AI model outputs to proving how a high-stakes training run was conducted. If the open engineering problems can be solved, ZK could become part of the evidence layer for compute governance—without requiring regulators to inspect a company’s entire model stack.]]></content>
  </entry>
  <entry>
    <title>Dogecoin Gets a Native ICP Lane: What the Latest Canister Release Changes for Chain Fusion</title>
    <link href="https://blog.b3pay.net/dogecoin-gets-a-native-icp-lane-what-the-latest-canister-release-changes-for-chain-fusion"/>
    <id>https://blog.b3pay.net/dogecoin-gets-a-native-icp-lane-what-the-latest-canister-release-changes-for-chain-fusion</id>
    <updated>2026-08-12T00:03:18.833Z</updated>
    <published>2026-08-12T00:03:18.833Z</published>
    <summary>The latest ICP Dogecoin canister release adds endpoint benchmarks and UTXO-path improvements while current docs classify Dogecoin as a direct Chain Fusion integration.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[ICP’s Chain Fusion story is moving into a less obvious phase: extending direct, protocol-level access to another UTXO chain. The latest public release of DFINITY’s Dogecoin canister, dated May 27, 2026, adds benchmarks for the `dogecoin_get_*` endpoints and includes changes intended to reduce the amount of block data deserialized during UTXO queries. The release also carries several upstream improvements from the Bitcoin canister codebase.

That matters because Dogecoin is not being presented merely as an asset that can be wrapped onto ICP. In the current ICP developer documentation, Dogecoin appears in the direct-integration category alongside Bitcoin. The documented model gives canisters access to a protocol adapter rather than forcing developers to depend on a bridge, a multisignature custodian, or a conventional RPC quorum for basic chain state.

The technical distinction is important. In an RPC-based design, a canister asks external providers for chain data and must account for provider disagreement, outages, and endpoint policy. In a direct integration, ICP nodes participate in the chain-specific adapter path. The documentation describes that model as relying on ICP subnet consensus and lists Dogecoin’s integration method as “Direct.” That does not eliminate Dogecoin’s own consensus rules; it changes where the application obtains and validates the chain state.

The May release shows the project concentrating on the unglamorous work required for production infrastructure. Benchmarks for `dogecoin_get_*` endpoints give maintainers a way to measure read-path behavior instead of treating UTXO queries as opaque calls. The release also says the canister should avoid deserializing an entire block during `get_utxos`, a change that can reduce unnecessary memory and parsing work when applications need only selected transaction outputs.

Earlier public releases show the same direction. The Dogecoin canister adapted Bitcoin-derived infrastructure to Dogecoin-specific header validation, including Scrypt hashing, DigiShield difficulty adjustment, and AuxPoW validation used in merged mining. Later releases added network validation, a blockchain-information endpoint, and a stability-oriented main-chain selection criterion based on accumulated difficulty. Together, those changes make the project look less like a demo adapter and more like a maintained chain-specific subsystem.

For developers, the opportunity is broader than simply displaying DOGE balances. A canister-controlled Dogecoin address can become one component in an application that keeps policy, storage, automation, and external-chain actions in one ICP backend. A payment canister could monitor incoming UTXOs, wait for its chosen confirmation policy, and trigger an internal credit. A treasury canister could schedule payouts. A multichain application could use the same service boundary for assets held on Bitcoin, Dogecoin, and EVM networks, while keeping authorization logic inside canisters.

There is also a security lesson. “Direct” does not mean risk-free. Applications still need replay protection, confirmation policies, withdrawal controls, upgrade governance, rate limits, and careful handling of reorganization risk. A canister that credits a user too early can create an accounting problem even if the underlying adapter is correct. Developers should treat the chain adapter as a source of verified chain observations, not as a substitute for application-level settlement policy.

One important limitation remains: the latest GitHub release page marks its governance proposal as “TO BE ADDED.” The public evidence therefore confirms a released Dogecoin canister implementation and a current documentation path, but it does not, by itself, prove that this exact release completed a mainnet rollout. That caveat should shape how teams describe availability and how they verify the deployed canister revision before building production dependencies.

The larger Chain Fusion angle is architectural. ICP is gradually turning direct chain adapters into reusable backend primitives. If Dogecoin’s integration continues along this path, the result is not just another supported ticker. It is a test of whether ICP can make heterogeneous UTXO networks feel like dependable services inside a single canister-based application model.]]></content>
  </entry>
  <entry>
    <title>Rust’s CI Gets a Hardware-Backed Trust Upgrade—Without a New Compiler Release</title>
    <link href="https://blog.b3pay.net/rust-s-ci-gets-a-hardware-backed-trust-upgrade-without-a-new-compiler-release"/>
    <id>https://blog.b3pay.net/rust-s-ci-gets-a-hardware-backed-trust-upgrade-without-a-new-compiler-release</id>
    <updated>2026-08-11T18:01:14.876Z</updated>
    <published>2026-08-11T18:01:14.876Z</published>
    <summary>Rust’s infrastructure team adds hardware-backed MFA, external PowerPC and RISC-V CI runners, and faster merge checks—an operational upgrade beyond compiler releases.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[## The important Rust update is happening around the compiler

Rust’s latest infrastructure report points to a less visible but consequential shift: the project is hardening the systems that build, test, review, and publish Rust software. The July 15 update describes new hardware-security-key support for critical infrastructure, externally hosted PowerPC and RISC-V CI runners, shared Renovate presets, and a major reduction in Bors mergeability-check time.

This is an infrastructure-hardening and CI-portability update, not a Rust compiler release. No new language feature or stable `rustc` version is being announced here. The significance is operational: the trustworthiness of a compiler ecosystem depends not only on compiler code, but also on who can change its repositories, how targets are tested, and how quickly maintainers can process changes.

## Hardware keys move privileged access beyond passwords

The Rust Infrastructure Team now requires privileged users of critical services to use the strongest supported multi-factor method. Its policy ranks FIDO2/WebAuthn-compatible hardware security keys above passkeys and TOTP applications, and names services including GitHub, AWS, Azure, Datadog, Fastly, Heroku, and Google infrastructure.

The Rust Foundation is providing YubiKeys to eligible members of the `infra`, `crates.io`, `docs.rs`, `release`, `triagebot`, and `bors` teams. The policy also requires a redundant approved method where possible and calls for immediate revocation if a device is lost.

That does not make Rust infrastructure invulnerable. It does, however, reduce reliance on a maintainer’s personal phone or password-manager account during privileged operations. For a project whose outputs are consumed through toolchains, package indexes, documentation services, and continuous integration, that is a meaningful reduction in one class of account-takeover risk.

## More architectures are becoming part of the test surface

The project also enabled externally powered GitHub Actions runners for PowerPC and RISC-V repositories. Rust’s Forge documentation explains that self-hosted runners are used when GitHub’s hosted runners do not natively support a target. The current documentation lists a PowerPC Linux runner and Ubuntu-based RISC-V variants, with concurrency and repository scope documented publicly.

This matters because a successful build on x86-64 does not prove that a systems language behaves correctly on every supported architecture. Architecture-specific code generation, atomic operations, linker behavior, and standard-library assumptions can remain invisible until a target is tested. External hardware broadens that test surface, while the published runner policy gives maintainers a way to inspect who operates the machines and which repositories may use them.

The trade-off is that self-hosted infrastructure introduces another trust boundary. Rust’s documentation tells contributors to verify runner capabilities and follow the external-runner policy before adding one. Projects adopting a similar model should keep privileged secrets away from untrusted workflows, constrain runner labels, and treat the host as part of the supply-chain security design.

## Faster merge checks change maintainer economics

The same infrastructure report says Rust moved Bors from GitHub’s REST API to its GraphQL API, reducing pull-request mergeability checks from an average of about 30 minutes to about one minute. That is not merely a dashboard improvement. It shortens the feedback loop for contributors and reduces the time a change spends waiting for an automated decision.

Rust also introduced community-review support in Triagebot for Clippy, allowing a repository to delay reviewer assignment until one or more community reviews have occurred. Shared Renovate presets further standardize dependency and GitHub Actions updates across Rust repositories, including vulnerability-alert pull requests and scheduled lockfile maintenance.

Together, these changes connect security with throughput. Faster automation is useful only when permissions, dependency updates, and target coverage remain visible and controlled. The Rust project is treating those concerns as one maintenance system rather than isolated tooling tasks.

## What Rust builders should take away

For teams building Rust services, smart-contract tooling, or cross-platform infrastructure, the practical lesson is broader than “buy a security key.” Audit the whole delivery path: administrator authentication, CI runner ownership, architecture coverage, dependency-update policy, and merge automation.

Rust’s current direction suggests that ecosystem maturity is being measured at the boundary around `rustc`—where source becomes a binary, package, or release artifact. The compiler remains central, but the pipeline that protects and tests it is becoming part of Rust’s engineering story.]]></content>
  </entry>
  <entry>
    <title>The Protocol Became the Product: Longfellow ZK Moves Identity Proofs Toward a Shared Wire Format</title>
    <link href="https://blog.b3pay.net/the-protocol-became-the-product-longfellow-zk-moves-identity-proofs-toward-a-shared-wire-format"/>
    <id>https://blog.b3pay.net/the-protocol-became-the-product-longfellow-zk-moves-identity-proofs-toward-a-shared-wire-format</id>
    <updated>2026-08-11T12:01:13.842Z</updated>
    <published>2026-08-11T12:01:13.842Z</published>
    <summary>Google’s Longfellow ZK combines an open-source identity proof library with a July 2026 IETF draft covering ISO mdoc, JWT, and Verifiable Credentials.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[Zero-knowledge identity work is moving from isolated libraries toward shared protocol machinery. On July 22, 2026, Google-authored Longfellow ZK appeared as an IETF Internet-Draft describing an algorithm for generating and verifying succinct non-interactive zero-knowledge arguments.

The important development is not simply another proving system. Longfellow is designed around the formats identity systems already use. Google’s public repository says the library can construct proofs concerning ISO mdoc credentials, JSON Web Tokens, and W3C Verifiable Credentials. That makes the project relevant to builders who need privacy-preserving claims without replacing every credential issuer and verifier in their stack.

The draft combines two major components. A Ligero-style commitment system handles zero-knowledge arguments for linear and quadratic constraints, while a sumcheck-based verifiable-computation protocol proves that a circuit evaluates correctly. Fiat–Shamir turns the interactive construction into a single-message proof suitable for deployment.

The design also targets a familiar ZK trade-off: reducing setup assumptions without making the system unusable. The draft says Longfellow does not require a common reference string or trusted parameter setup, and focuses on constructions instantiable from collision-resistant hash functions. That does not make the system assumption-free; security still depends on the protocol analysis, parameter choices, implementation quality, and the underlying cryptographic assumptions.

For developers, the practical signal is the combination of specification and code. The IETF draft includes serialization rules and test vectors, while the repository provides build instructions, benchmarks, a reference verifier service, and a Rust directory alongside the core library. Those pieces give implementers more than a research description: they provide an emerging target for compatibility testing.

There are two reasons to keep expectations measured. First, the IETF page labels the document Informational and says Internet-Drafts are temporary working documents that may be updated, replaced, or obsoleted. It is a protocol proposal, not a completed Internet standard. Second, the repository states that two independent security reviews are still underway. Longfellow should therefore be evaluated as an active engineering and standardization effort, not as a finished production trust anchor.

The broader shift is architectural. If identity proofs can be expressed against credentials that organizations already issue, ZK adoption becomes less about inventing a new identity stack and more about adding a private proof layer around existing data. Longfellow’s next test is whether that emerging wire format and implementation can survive interoperability work, cryptographic review, and real deployment constraints.]]></content>
  </entry>
  <entry>
    <title>The Auditable RPC Turn: How ICP’s SOL Canister Makes Chain Fusion Verifiable</title>
    <link href="https://blog.b3pay.net/the-auditable-rpc-turn-how-icp-s-sol-canister-makes-chain-fusion-verifiable"/>
    <id>https://blog.b3pay.net/the-auditable-rpc-turn-how-icp-s-sol-canister-makes-chain-fusion-verifiable</id>
    <updated>2026-08-11T00:03:47.817Z</updated>
    <published>2026-08-11T00:03:47.817Z</published>
    <summary>How ICP’s live SOL RPC canister uses provider consensus, cycle billing, NNS governance, and reproducible builds to make Solana Chain Fusion more auditable.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[ICP’s Solana integration is entering a more operational phase. The SOL RPC canister is live on mainnet, and its design makes an important promise visible to developers: cross-chain reads should be inspectable, reproducible, and governed rather than hidden behind an opaque API endpoint.

The canister sends Solana JSON-RPC requests to multiple providers through ICP HTTPS outcalls. It returns a result only after responses satisfy the selected consensus strategy. The public repository documents equality-based aggregation, configurable provider sources, and a `jsonRequest` escape hatch for methods that are not wrapped by a typed client. Developers pay with cycles instead of managing provider API keys.

That architecture changes what “RPC reliability” means in Chain Fusion. A conventional application often chooses one provider and trusts its response. An ICP canister can compare responses inside a replicated execution environment, while the Network Nervous System controls the production service and its provider configuration. This does not make Solana data magically canonical: provider agreement is still an additional trust assumption, and rapidly changing responses can remain difficult to reconcile.

The repository also documents reproducible builds. Developers can build the SOL RPC WebAssembly module and compare its SHA-256 hash with the deployed artifact’s corresponding release source. That gives teams a practical audit path: inspect the code, reproduce the binary, and verify which service they are calling.

The engineering consequence is more interesting than the headline integration. Chain Fusion is becoming a set of operationally testable components: a governed RPC canister for reads, threshold Ed25519 for signing, and cycles for metering. The pieces can support Solana wallets, automated services, and cross-chain applications without a bridge or a centralized signer.

There is still a meaningful boundary. The official documentation says the API surface is evolving. There are no official SPL-token helpers, and transaction construction remains manual; developers must assemble Solana instructions and serialization themselves, using the basic example as a reference. The system is therefore ready for disciplined builders, not yet a frictionless Solana framework.

For ICP developers, the timely lesson is simple: the differentiator is not merely that a canister can call Solana. It is that the call path can be configured, metered, governed, and independently inspected. That is the foundation on which safer Chain Fusion applications can be built.]]></content>
  </entry>
  <entry>
    <title>Internet Identity’s New Gatekeeper: What the August 7 IdP Access Release Changes for ICP Builders</title>
    <link href="https://blog.b3pay.net/internet-identity-s-new-gatekeeper-what-the-august-7-idp-access-release-changes-for-icp-builders"/>
    <id>https://blog.b3pay.net/internet-identity-s-new-gatekeeper-what-the-august-7-idp-access-release-changes-for-icp-builders</id>
    <updated>2026-08-10T18:02:33.884Z</updated>
    <published>2026-08-10T18:02:33.884Z</published>
    <summary>What Internet Identity’s August 7, 2026 ICP release changes: IdP access gating, SSO session limits, delegation controls, and reproducible Wasm verification.</summary>
    <category term="Internet Computer"/>
    <content type="html"><![CDATA[Internet Identity is moving from a fast-moving identity service toward a more policy-aware access layer for Internet Computer applications. The latest release, published on August 7, 2026, is labeled “IdP access gating MVP general availability.” Its practical focus is controlling which identity providers can be used by particular applications and carrying SSO session limits through the authentication flow.

The release includes backend changes that resolve an SSO domain’s `session_max_age_seconds` and place the resulting session deadline in the attribute bundle. On the frontend side, the user’s delegation is capped at the SSO session length. In plain terms, an application should not receive a delegation that outlives the upstream SSO session it depends on.

That is a meaningful boundary for builders. A long-lived delegation can be convenient, but it can also outlast an organization’s intended sign-in policy. By making the SSO deadline part of the downstream authentication result, Internet Identity gives applications a clearer way to respect the session policy established by Google, Apple, Microsoft, or another configured identity provider. The release does not eliminate the need for application-side authorization: a valid delegation still proves authentication, not that a user is allowed to perform every action in a canister.

The timing is also important. Internet Identity’s maintainers announced in June that the project could submit up to two release proposals per week: a primary proposal on Friday and, when appropriate, a smaller secondary proposal early the following week. The August release shows what that cadence looks like operationally: frequent changes, separate backend and frontend artifacts, and a published commit and hash-verification procedure.

For operators, the release page lists distinct backend and frontend Wasm artifacts, SHA-256 hashes, and the exact commit used to build them. That makes the upgrade more than a feature announcement. A reviewer can check out commit `c78d1b99c5c161c74d8d8f795ad1072826f90673`, build the modules, and compare the resulting hashes with the release values before evaluating an upgrade proposal.

For application teams, three actions follow. First, treat the effective SSO session duration as part of your authorization and logout design rather than as an invisible identity-provider detail. Second, test both the backend and frontend integration against the current Internet Identity release, because the project ships them as separate canister artifacts. Third, monitor release proposals and changelogs closely if your application depends on SSO, recovery, or AI-related access controls.

There is a trade-off. Faster shipping can reduce the time between a fix and its users, but it also increases the amount of material that proposal reviewers and downstream developers must track. The faster release cadence is an operating plan, not a guarantee that every week will contain two production upgrades; release suitability and community review still matter.

The larger story is not merely that Internet Identity added another login feature. It is making identity policy observable at the canister boundary. For ICP builders, that means authentication integrations can become more precise—but only if applications propagate session and authorization assumptions explicitly instead of treating a successful sign-in as the end of the security model.]]></content>
  </entry>
  <entry>
    <title>Rust’s Next Borrow Checker Enters Nightly: What Polonius Alpha Changes</title>
    <link href="https://blog.b3pay.net/rust-s-next-borrow-checker-enters-nightly-what-polonius-alpha-changes"/>
    <id>https://blog.b3pay.net/rust-s-next-borrow-checker-enters-nightly-what-polonius-alpha-changes</id>
    <updated>2026-08-10T12:01:58.682Z</updated>
    <published>2026-08-10T12:01:58.682Z</published>
    <summary>Rust has enabled Polonius Alpha on nightly, testing flow-sensitive borrow checking before a planned 2026 stabilization.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[Rust’s borrow checker is entering its next testing phase. In an August 4 announcement, the Rust team said Polonius Alpha is now enabled on nightly, giving developers a chance to test a new analysis before a planned stabilization later this year.

The practical change is flow-sensitive reasoning about lifetime relationships. Today’s non-lexical lifetimes analysis can treat a borrow as live across an entire function when a returned reference has a long lifetime, even if a particular control-flow branch does not use that borrow. The Rust team’s example is a `HashMap::get_mut` lookup: if the lookup succeeds, the reference is returned; if it fails, the function inserts a default value and looks up the key again. NLL can reject that pattern because it conservatively considers the first borrow live in the `None` branch. Polonius Alpha accepts it because the borrow is not live along that path.

A smaller example is a mutable reborrow inside an `if` expression. Polonius Alpha can recognize that the reborrow is relevant only to the branch that returns it, allowing the alternative branch to use the original mutable reference.

That improvement comes with an important engineering trade-off. Polonius Alpha currently does equal or more work than NLL, so the team has measured it against the 10,000 most-downloaded crates on crates.io. The reported results show relatively few significant regressions in that set, while the worst case observed outside it was a 2–3× slowdown. The project is therefore testing both compile-time behavior and correctness before stabilization.

Polonius Alpha is not yet a universal replacement for every previous Polonius behavior. The announcement gives an example that compiled with the older implementation but does not compile with Alpha, which is one reason the feature remains experimental.

For developers, the safe takeaway is to treat this as a compatibility and diagnostics test, not as a stable-language migration. Teams with lifetime-heavy code can try the nightly feature, compare diagnostics and build times, and report regressions. Production toolchains should remain on stable until the Rust project publishes its stabilization decision.

Caveat: Polonius Alpha is currently nightly-only; the Rust team says stabilization is planned later in 2026, but the timing is not guaranteed. Caveat: the new checker can still show performance regressions—up to 2–3× in the reported worst case—and is not a complete replacement for every legacy Polonius behavior.]]></content>
  </entry>
  <entry>
    <title>The 0.22-Second Proof: How Asymmetric Relativistic ZK Cuts Quantum Soundness Down to Hardware Scale</title>
    <link href="https://blog.b3pay.net/the-0-22-second-proof-how-asymmetric-relativistic-zk-cuts-quantum-soundness-down-to-hardware-sca"/>
    <id>https://blog.b3pay.net/the-0-22-second-proof-how-asymmetric-relativistic-zk-cuts-quantum-soundness-down-to-hardware-sca</id>
    <updated>2026-08-10T06:03:06.834Z</updated>
    <published>2026-08-10T06:03:06.834Z</published>
    <summary>A Nature Communications experiment uses FPGA hardware, GPS timing, and 300-meter separation to demonstrate a practical asymmetric relativistic zero-knowledge proof protocol.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[Zero-knowledge research has spent years trying to make proofs smaller, faster, and safer against stronger adversaries. A new result in Nature Communications shifts the focus from algebra alone to the physics of communication: an asymmetric relativistic zero-knowledge proof (RZKP) that uses distance and timing to prevent separated provers from coordinating fast enough to cheat.

The experiment used two prover-verifier pairs in separate buildings at Nanjing University, 300 meters apart. Each prover and verifier used FPGA-assisted hardware, while GPS-disciplined timing servers synchronized the system. The protocol relies on the no-signaling principle: if a challenge and a response must cross the separation within a tightly defined time window, one prover cannot learn information held by the other before answering.

The construction targets graph three-coloring, a standard zero-knowledge benchmark. The prover demonstrates knowledge of a valid coloring without revealing the coloring itself. The asymmetric design assigns different jobs to the two prover-verifier pairs. One side commits to colors for the graph; the other receives a random edge challenge and reveals only the information needed for verification.

That asymmetry creates a practical trade-off. One side handles more randomness and computation, but the protocol reduces the round complexity required for quantum soundness from an order tied to the fourth power of the number of graph edges to a linear order in that number. In the reported experiment, a graph with 588 vertices and 1,097 edges required about 2.2×10^5 rounds to reach a stated soundness target of e^-100. With a one-microsecond trigger interval, the complete interaction took approximately 0.22 seconds and consumed about 430.81 MB of randomness.

The timing results are equally important. The experiment kept the measured timing gaps below a 1,000-nanosecond relativistic window, including a stated 30-nanosecond GPS synchronization error on each side. FPGA computation for commitments was reported at 6.4 nanoseconds per clock cycle, while communication and hardware response contributed roughly 300 nanoseconds.

For developers, the message is that ZK scalability is not only a prover-GPU problem. A proof system can also be constrained by clocks, transceivers, fiber lengths, random-material storage, and the topology of the verifier network. The paper’s design therefore looks less like a conventional blockchain SNARK and more like a distributed security appliance whose trust boundary includes physical placement.

The result should be read carefully. This is a research prototype, not a production identity system: its security and performance depend on controlled timing, synchronized hardware, separated prover locations, and a semi-realistic deployment model. The experiment also uses a fixed graph-coloring instance, so the reported 0.22-second figure should not be treated as a universal benchmark for arbitrary applications.

Still, the work offers a useful architectural lesson. Instead of forcing every security guarantee to come from computational hardness, an RZKP can combine cryptographic commitments with a measurable physical constraint. That does not eliminate engineering complexity; it relocates part of the proof system into the network itself.]]></content>
  </entry>
  <entry>
    <title>Chain Fusion’s Next Transparency Problem: Making Canister-Controlled Addresses Discoverable</title>
    <link href="https://blog.b3pay.net/chain-fusion-s-next-transparency-problem-making-canister-controlled-addresses-discoverable"/>
    <id>https://blog.b3pay.net/chain-fusion-s-next-transparency-problem-making-canister-controlled-addresses-discoverable</id>
    <updated>2026-08-10T00:03:12.827Z</updated>
    <published>2026-08-10T00:03:12.827Z</published>
    <summary>A community proposal could make ICP canister-controlled external addresses easier to verify, index, and include in cross-chain TVL dashboards.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[Chain Fusion can already let an ICP canister control accounts on Bitcoin, Ethereum, Solana, and other networks through threshold signatures. The next challenge is less about signing and more about proving which external addresses belong to which canisters.

A December 2025 proposal on the Internet Computer Developer Forum describes the problem directly: canister-controlled addresses are derived from a canister’s identity, signing key, and derivation path. Because developers can define paths dynamically, outside services cannot reliably reconstruct every address by inspecting ICP activity alone.

That creates an observability gap. Portfolio trackers, explorers, and TVL dashboards may see an address on an external chain without knowing that it is controlled by an ICP canister. The proposal evaluates five approaches: an ICP-side derivation-path indexer, changes to the management canister, a developer-adopted interface standard, a registry canister, and an off-chain API.

The most important design distinction is between exposing an address and exposing the data needed to derive it. A canister could publish its derivation path, key identifier, and external chain identifier. An indexer could then reconstruct the public key and address. ICP’s current documentation confirms that this reconstruction is deterministic and can be performed offline from the subnet public key, canister principal, and derivation path, without secret material or a live canister call.

The proposal recommends an off-chain API as the simplest implementation and a registry canister as the more decentralized option. Both would require canister developers to publish or submit their address metadata. That means adoption, not cryptography, is the immediate bottleneck.

For builders, the practical lesson is clear: treat derivation paths as part of your public integration interface. Document the key scheme, path format, and target chain, and expose them through a stable query or registration flow. Doing so makes balances indexable, simplifies audits, and gives users a clearer way to verify where a Chain Fusion application’s external assets reside.

Important caveat: this remains a community proposal, not an approved protocol change. The official documentation currently supports deterministic offline derivation, but it does not establish a universal address registry or require every canister to publish its paths.]]></content>
  </entry>
  <entry>
    <title>The Agent-Readable Turn: ICP Skills Make Canister Development Safer for AI</title>
    <link href="https://blog.b3pay.net/the-agent-readable-turn-icp-skills-make-canister-development-safer-for-ai"/>
    <id>https://blog.b3pay.net/the-agent-readable-turn-icp-skills-make-canister-development-safer-for-ai</id>
    <updated>2026-08-09T18:01:04.829Z</updated>
    <published>2026-08-09T18:01:04.829Z</published>
    <summary>DFINITY’s ICP Skills project gives AI coding agents structured ICP guidance, pitfalls, deployment steps, and verification commands for safer canister development.</summary>
    <category term="Internet Computer"/>
    <content type="html"><![CDATA[Internet Computer development is gaining a new interface: instructions written for coding agents rather than only for human readers.

The DFINITY-maintained ICP Skills repository provides structured Markdown files for capabilities such as ckBTC, Internet Identity, stable memory, Motoko, Rust, and other ICP components. Each skill is designed to give an agent the operational context it needs before generating code: prerequisites, common pitfalls, implementation examples, deployment steps, and verification commands.

That structure addresses a practical failure mode in AI-assisted development. An agent can produce syntactically valid code while still using a deprecated API, inventing a canister identifier, selecting an incompatible dependency version, or omitting a required deployment step. A dedicated skill file turns those details into explicit constraints that can be fetched when a task matches the skill’s scope.

The project’s most important design choice is its emphasis on verification. The repository says skills may include tested, copy-paste-ready examples and concrete commands for confirming that an application works. This makes the material closer to an implementation contract than a conventional overview page. For an ICP builder, the useful workflow is straightforward: identify the capability involved, load its skill, follow the documented prerequisites, and run the supplied checks before deploying.

DFINITY’s developer portal now presents agent skills as one of three paths for shipping on ICP, alongside natural-language app building and conventional Motoko or Rust development. The portal specifically points agents toward skills that explain the canister model, deployment and upgrades, and use of the ICP command-line interface.

The broader implication is not that agents eliminate developer judgment. It is that protocol-specific knowledge can become a reusable input to the development process. Instead of asking a general-purpose model to remember every ICP boundary, builders can provide a versioned, domain-focused reference and inspect the resulting commands.

There is an important limitation: the ICP Skills repository explicitly describes itself as under active development, and says its content may change while DFINITY engineers review and sign off on files. Builders should therefore pin or inspect the skill content used for production work and verify dependencies and canister settings independently.

For ICP, this is a meaningful developer-experience development because it moves documentation closer to where AI-assisted software is actually produced: inside the agent’s context window, with pitfalls and verification steps treated as first-class engineering data.]]></content>
  </entry>
  <entry>
    <title>Rust’s Security Perimeter Moves Into the Build Pipeline</title>
    <link href="https://blog.b3pay.net/rust-s-security-perimeter-moves-into-the-build-pipeline"/>
    <id>https://blog.b3pay.net/rust-s-security-perimeter-moves-into-the-build-pipeline</id>
    <updated>2026-08-09T12:00:18.828Z</updated>
    <published>2026-08-09T12:00:18.828Z</published>
    <summary>Rust’s infrastructure team is extending security practices beyond compiler code into repository permissions, CI updates, hardware authentication, and code-security monitoring.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[Rust’s latest infrastructure update points to a shift in where the project defines software security. The focus is no longer limited to the compiler, Cargo, or crates.io; it increasingly includes the systems used to build and maintain Rust itself.

In its Q2 recap and Q3 plan, the Rust Infrastructure Team said GitHub Rulesets had replaced legacy branch protections across Rust repositories. Rulesets allow protections to be managed through teams, giving the project a more consistent way to control merges, applications, and repository changes.

The project also created shared Renovate presets for updating dependencies and GitHub Actions. The goal is to make routine updates easier to adopt while reducing the number of individual pull requests maintainers must review. For a project spread across many repositories, that is an operational change as much as a tooling change.

Access control is moving in the same direction. Rust introduced official support for hardware security keys and created a policy requiring hardware-key multi-factor authentication for people and teams with access to systems classified as critical. The team said it worked with Yubico to provide YubiKeys to Rust Project members.

Security monitoring is expanding as well. Secret Scanning is enabled across rust-lang repositories, while the Infrastructure Team is experimenting with Datadog Code Security in collaboration with the crates.io team. The stated purpose is to identify security issues inferred from source code and give maintainers more visibility into CI health, including slow jobs, failing jobs, and pipeline duration.

This matters to Rust developers because trust in a toolchain is partly a supply-chain property. A secure compiler release can still be surrounded by vulnerable automation, compromised credentials, or poorly protected maintenance infrastructure. The update suggests that Rust is treating repository permissions, CI dependencies, authentication, and observability as part of the project’s security boundary.

The Rust Foundation’s Maintainers Fund adds a human dimension to the same problem. The Foundation says the fund is intended to provide stable, long-term support for maintainers whose review, refactoring, release, and security work keeps the ecosystem reliable. Infrastructure controls can reduce technical exposure, but sustained maintenance still depends on people having the time and support to act on the signals those controls produce.

The important caveat is that the Q3 items remain plans or experiments rather than guarantees that every proposed capability is already deployed across the ecosystem. For Rust users, the practical takeaway is still clear: when evaluating a dependency or toolchain, inspect not only its source and release artifacts, but also the project’s update process, CI permissions, authentication model, and maintenance capacity.]]></content>
  </entry>
  <entry>
    <title>ZK-SR117 Tests a Private Audit Trail for Fair-Lending AI</title>
    <link href="https://blog.b3pay.net/zk-sr117-tests-a-private-audit-trail-for-fair-lending-ai"/>
    <id>https://blog.b3pay.net/zk-sr117-tests-a-private-audit-trail-for-fair-lending-ai</id>
    <updated>2026-08-09T06:00:16.799Z</updated>
    <published>2026-08-09T06:00:16.799Z</published>
    <summary>A new arXiv preprint demonstrates chunked zkSNARK attestations for fairness and calibration metrics while highlighting the limits of using a prototype for banking compliance.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[A new arXiv preprint proposes a practical use for zero-knowledge proofs beyond blockchain scaling: allowing banks to demonstrate selected properties of a credit model without handing auditors the model weights or row-level customer data.

The paper, titled “ZK-SR117,” divides a committed validation set into fixed-size chunks and proves aggregate statistics for each chunk. In its reported demonstration, the system processed 32,768 rows from 2022 HMDA mortgage data through 32 independently verified zkSNARK proofs. The resulting demographic-parity gap was 0.06243, compared with 0.06532 on the full holdout set, an absolute difference of 0.00289. Each chunk took approximately 3.7–4.0 seconds to prove.

The same architecture also attested expected calibration error across ten probability bins. Per-chunk proving took about 14.72 seconds, while the reported circuit-precision difference against the exact committed sample was 0.00037. The design publishes aggregate counts rather than individual records, so a verifier can check the computation without seeing the underlying rows.

The engineering choice is the paper’s most useful lesson. A flat circuit became impractical at larger sizes, while a tree-reduction design was difficult to compile. Chunking kept the circuit small and reusable, but it introduced a linear proof-size cost: the 32-proof demographic-parity run produced approximately 24.2 MB of proofs.

The experiment also caught a real data-quality problem. One sentinel-like loan-to-value value produced an extreme standardized score and caused a chunk to time out. The authors say they fixed it through a deterministic, published clipping specification applied before nonce-controlled sampling. That detail matters: a private audit is only as credible as its data-preparation rules.

There is an important regulatory caveat. The paper maps its design to Federal Reserve SR 11-7 and OCC Bulletin 2011-12, but the Federal Reserve’s April 17, 2026 SR 26-2 letter says the agencies’ revised model-risk guidance supersedes SR 11-7. The preprint therefore should be read as a technical prototype, not as evidence that a regulator accepts ZK proofs as sufficient compliance evidence. Its authors explicitly state that only two controls, one model class, and one task were implemented end to end; the remaining seven proposed control mappings are future work.

For ZK developers, the new angle is not simply “privacy-preserving AI.” It is the conversion of an audit request into a composable statement: commit the model, commit the validation data, let an examiner control sampling, and prove only the aggregate properties that matter. The next test is whether this pattern can handle multiple models, drift monitoring, independent validators, and the proof-size and operational requirements of real supervisory workflows.]]></content>
  </entry>
  <entry>
    <title>ICP’s Ed25519 Expansion Turns Chain Fusion Into a Wider Multichain Signing Layer</title>
    <link href="https://blog.b3pay.net/icp-s-ed25519-expansion-turns-chain-fusion-into-a-wider-multichain-signing-layer"/>
    <id>https://blog.b3pay.net/icp-s-ed25519-expansion-turns-chain-fusion-into-a-wider-multichain-signing-layer</id>
    <updated>2026-08-09T00:00:18.872Z</updated>
    <published>2026-08-09T00:00:18.872Z</published>
    <summary>ICP’s latest Chain Fusion documentation details threshold Ed25519 signing, Solana RPC consensus, and the ckSOL path for multichain applications.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[ICP’s Chain Fusion story is entering a broader phase: the Internet Computer’s current developer documentation now presents threshold Ed25519 signing as a route into several non-EVM ecosystems, including Solana, TON, Polkadot, Cardano, NEAR, and Stellar.

The technical shift is important because Ed25519 is not merely another wallet format. ICP canisters can request threshold Schnorr signatures using the Ed25519 variant, allowing subnet nodes to collectively authorize external-chain transactions without reconstructing a private key. The resulting address belongs to the canister, so application logic—not a user-held bridge key—can control the external account.

Solana is the clearest production-oriented example in the documentation. ICP’s SOL RPC canister queries multiple independent JSON-RPC providers and returns a result only when their responses meet the configured consensus strategy. Developers can then combine that read path with threshold signing. The architecture creates a programmable cross-chain backend: a canister can observe Solana state, decide what to do, sign a transaction, and submit it through the RPC layer.

The same design also supports ckSOL. The Solana guide describes ckSOL as an ICP token backed 1:1 by SOL held at a canister-controlled address. Deposits are detected through the SOL RPC canister and minted as ICRC-1/ICRC-2 tokens; withdrawals burn ckSOL and trigger a signed Solana transfer.

The practical constraint is latency and provider dependence. ICP’s replicated HTTPS outcalls require external providers to return sufficiently consistent data, while Solana changes state quickly. The open-source SOL RPC canister therefore documents workarounds such as durable nonces or retrieving a blockhash through a slot and block lookup. This is a reminder that Chain Fusion removes the bridge custodian, but it does not remove the engineering problem of reconciling a fast external chain with replicated execution.

A factual caveat matters: the current documentation distinguishes established integrations from community-built tooling, so its support table is not proof that every listed Ed25519 chain has a production deployment. The strongest verified path today is the combination of ICP threshold signing, the governed SOL RPC canister, and the documented ckSOL flow.

For builders, the new angle is architectural rather than promotional. Chain Fusion is becoming a signature-and-verification substrate that can be reused across chains with compatible cryptography. The opportunity is to move custody, automation, and policy into canisters while keeping each external asset native to its source network.]]></content>
  </entry>
  <entry>
    <title>Motoko 1.13 Turns Local Candid Files Into a Type-Safe ICP Boundary</title>
    <link href="https://blog.b3pay.net/motoko-1-13-turns-local-candid-files-into-a-type-safe-icp-boundary"/>
    <id>https://blog.b3pay.net/motoko-1-13-turns-local-candid-files-into-a-type-safe-icp-boundary</id>
    <updated>2026-08-08T18:02:45.842Z</updated>
    <published>2026-08-08T18:02:45.842Z</published>
    <summary>Motoko 1.13.0 introduces idl: imports for local Candid files, bringing service and named types directly into Internet Computer Motoko projects.</summary>
    <category term="Internet Computer"/>
    <content type="html"><![CDATA[The latest Motoko release changes where Internet Computer developers can define an interface. Version 1.13.0, released on August 3, 2026, adds an `idl:` URI scheme for importing a local Candid file as a types-only Motoko module.

A project can now write `import S "idl:foo.did"`. The imported module exposes `S.Self` for the service actor type and named Candid types. When a name is unambiguous, Motoko PascalCases it—for example, `user_id` becomes `S.UserId`. The release notes also state that this path does not require a principal or an `--actor-idl` flag.

The practical shift is modest but important: a local `.did` file can become the source of truth for compile-time interface types while implementation remains in Motoko. That can reduce duplicated type declarations in multi-canister repositories and make interface changes easier to review as ordinary version-controlled file changes. This is an engineering implication of the new import mechanism, not a claim that runtime compatibility checks disappear.

The feature is especially relevant when a canister consumes another service whose interface is available in the repository. Instead of converting the Candid definition into hand-written Motoko types, developers can import the file and refer to the generated service type. Tooling can then catch mismatches during compilation rather than leaving every interface error to deployment or integration testing.

Motoko 1.13.0 also makes multi-value WebAssembly code generation permanently enabled. The old `--experimental-multi-value` and `--no-experimental-multi-value` options remain only for command-line compatibility and no longer change compiler behavior. For builders, the headline is therefore not a new application API but a tighter boundary between Candid interface files, Motoko’s type checker, and the WebAssembly toolchain.

The release is a useful signal for ICP teams maintaining larger codebases: interface artifacts are becoming easier to consume directly, while legacy compiler switches are being retired gradually. Teams should test their build scripts for assumptions about the removed flag behavior and review generated or imported types before upgrading production canisters.]]></content>
  </entry>
  <entry>
    <title>Rust 1.97 Turns Symbol Names Into a Tooling Boundary</title>
    <link href="https://blog.b3pay.net/rust-1-97-turns-symbol-names-into-a-tooling-boundary"/>
    <id>https://blog.b3pay.net/rust-1-97-turns-symbol-names-into-a-tooling-boundary</id>
    <updated>2026-08-08T12:02:56.834Z</updated>
    <published>2026-08-08T12:02:56.834Z</published>
    <summary>Rust 1.97.0 makes v0 symbol mangling the stable default. Here is what the change means for debuggers, profilers, crash tools, and ICP builders.</summary>
    <category term="Rust"/>
    <content type="html"><![CDATA[Rust 1.97.0 quietly changes a layer most application developers rarely see: the names emitted into object files and binaries. The release makes Rust’s v0 symbol-mangling scheme the default on stable, replacing the older scheme that reused conventions associated with the Itanium C++ ABI. Rust 1.97.1, released a week later, is a separate point release fixing an LLVM-related miscompilation; the symbol-format change belongs to 1.97.0.

## Why symbol names matter

A compiler cannot usually place a function under its source-level name alone. Generic instantiations, trait implementations, closures, modules, and multiple crates can produce names that would otherwise collide. Mangling encodes enough context for the linker to distinguish those items.

Rust’s v0 format is designed around Rust’s own type and module model. The Rust team says generic parameter instantiations preserve their values instead of hiding them only behind a hash, and that the encoding is reversible enough for tools to produce useful demangled names. The format also uses a Rust-specific `_R` prefix and restricts ordinary symbols to a platform-friendly character set.

That makes the change particularly relevant to developers working below the application layer: profilers, crash reporters, debuggers, binary analyzers, coverage tools, and build systems that inspect symbols can now encounter v0 names by default on stable toolchains.

## The migration is a tooling story

Rust’s compiler team deliberately introduced v0 gradually. A 2025 accepted compiler-team proposal described nightly-by-default as a way to expose compatibility problems while still allowing an opt-out during the transition. Rust 1.97.0 completes the move for stable users, while the legacy scheme remains available only on nightly.

For most developers, the practical action is not to hand-edit symbol names. It is to audit the tools around the build. Update debuggers, profilers, symbol servers, crash-processing pipelines, and any custom demangling code. If a tool displays raw names beginning with `_R`, that is a signal to check its Rust demangler support rather than assuming the binary is corrupted.

The rustc documentation describes v0 as a defined encoding for producing readable demangled output, not as an ABI promise. Caveat: v0 is not a stable Rust ABI, so binaries and FFI boundaries must not treat mangled names as a long-term compatibility contract. Public C interfaces should continue to use explicit `extern "C"` functions and stable exported names such as those supplied through `#[export_name]` where appropriate.

## What ICP builders should watch

Rust services and canister tooling that rely on ordinary Rust stack traces may see better symbol recovery once their analysis tools support v0. That can shorten the path from a production address to a generic function or trait implementation. However, the benefit depends on the complete observability chain: the compiler, linker, symbol storage, demangler, and presentation layer all need to preserve and decode the names consistently.

The safest rollout is to upgrade the toolchain and observability stack together, then compare symbolized traces from representative release builds. Pay special attention to release automation that strips symbols, archives them separately, or assumes a C++-style naming convention. The release is therefore less about changing Rust source code and more about making binary tooling understand what Rust has been emitting all along.

Sources: Rust 1.97.0 release announcement; the Rust compiler team’s accepted v0-mangling proposal.]]></content>
  </entry>
  <entry>
    <title>The Prover Moves to the GPU: RISC Zero’s v3.0 Release Train Changes the zkVM Bottleneck</title>
    <link href="https://blog.b3pay.net/the-prover-moves-to-the-gpu-risc-zero-s-v3-0-release-train-changes-the-zkvm-bottleneck"/>
    <id>https://blog.b3pay.net/the-prover-moves-to-the-gpu-risc-zero-s-v3-0-release-train-changes-the-zkvm-bottleneck</id>
    <updated>2026-08-08T06:04:34.832Z</updated>
    <published>2026-08-08T06:04:34.832Z</published>
    <summary>RISC Zero’s v3.0 release line emphasizes GPU recursion, Groth16 proving, multi-GPU experiments, and reproducible zkVM toolchains.</summary>
    <category term="ZK Tech"/>
    <content type="html"><![CDATA[RISC Zero’s latest release activity points to a familiar shift in zero-knowledge engineering: the hard problem is increasingly not whether a computation can be proved, but how efficiently the prover can run it.

The project’s GitHub release page currently lists v3.0.6 as the latest stable release and v3.0.0-rc.3 as a pre-release. The rc.3 entry is primarily a release-train update, but the surrounding v3.0 series shows where the engineering effort is concentrated: execution speed, proof generation, and hardware utilization.

The clearest signal appears in the v3.0.1 notes. RISC Zero lists faster recursion-witness generation on GPUs, a faster GPU implementation of Groth16, experimental multi-GPU proving, and support for NVIDIA’s RTX 5090 in Bento. It also says that the prover can be selected through the RISC_ZERO_PROVER environment variable. In practical terms, this makes the proving backend a deployment concern rather than an invisible library detail.

That matters because zkVM applications separate ordinary program execution from proof generation. A developer can write a guest program in Rust, but the cost and latency of producing its receipt depend on the proving system, machine configuration, memory behavior, and workload shape. GPU acceleration may improve throughput for suitable workloads, yet it can also introduce operational requirements: compatible hardware, additional artifacts, driver and runtime management, and a different cost model from CPU-only proving.

RISC Zero’s documentation reinforces that the toolchain is versioned as a system. The installation guide identifies version 3.0, recommends the rzup installer, and says that projects should keep the host and guest RISC Zero dependencies aligned with the installed toolchain. For CI, it explicitly recommends pinning each component instead of installing whatever is newest at build time.

That guidance is arguably the most important developer takeaway. Faster proving is useful only when builds remain reproducible. Teams evaluating the v3.0 line should benchmark their own guest programs, record whether proving is CPU- or GPU-bound, and pin r0vm, cargo-risczero, the Rust toolchain, and related artifacts in CI.

The caveat is material: the cited release notes present project-reported improvements, not independent benchmarks. They establish what RISC Zero shipped or enabled, but they do not prove that every workload will see the same speedup or that GPU proving will be cheaper in every environment.

The larger trend is nevertheless clear. General-purpose zkVMs are becoming systems projects: proving hardware, recursive witness generation, release engineering, and reproducible toolchains now sit alongside circuit design in the performance conversation. For builders, the next optimization may begin not in Rust code, but in the prover profile and the machine that runs it.]]></content>
  </entry>
  <entry>
    <title>Chain Fusion’s Hidden Scaling Lever: Why Pre-Signature Inventory Matters</title>
    <link href="https://blog.b3pay.net/chain-fusion-s-hidden-scaling-lever-why-pre-signature-inventory-matters"/>
    <id>https://blog.b3pay.net/chain-fusion-s-hidden-scaling-lever-why-pre-signature-inventory-matters</id>
    <updated>2026-08-08T00:01:32.806Z</updated>
    <published>2026-08-08T00:01:32.806Z</published>
    <summary>ICP’s 2026 threshold-signing improvements use pre-signature inventory to absorb Chain Fusion demand bursts, while production limits remain parameter-dependent.</summary>
    <category term="Chain Fusion"/>
    <content type="html"><![CDATA[A cross-chain application can be perfectly designed and still stall at the moment it needs to sign. In ICP’s Chain Fusion architecture, canisters can control Bitcoin, Ethereum, Solana, and other external-chain accounts through threshold signatures, but the signing subnet remains a shared production resource.

That resource received a significant engineering upgrade in February 2026. DFINITY engineers reported that cryptographic work was parallelized, expensive operations were moved out of critical execution paths, and pre-signature artifacts were moved into replicated subnet state. Pre-signatures are materials prepared before a user request arrives; producing them is the main performance bottleneck in the threshold-signing protocol.

The practical change is an inventory model. Instead of generating every component under the pressure of an incoming transaction, the subnet can prepare thousands of artifacts during quieter periods. When demand spikes, requests can consume that inventory immediately. The forum announcement says optimized signing subnets can sustain more than ten times their previous throughput and can exceed 100 signatures per second while pre-signatures remain available.

That headline needs careful interpretation. The 100-plus figure is a burst ceiling for specially configured high-signing-load subnets, not a universal rate for every Chain Fusion application. The same announcement says the production fiduciary subnet’s conservative parameters, following NNS proposal 140289, corresponded to approximately 3.5 tECDSA signatures per second, 6.5 tSchnorr signatures per second, and 18 vetKeys signatures per second under the cited configuration.

For builders, this creates a more useful design question than simply asking whether ICP can sign faster: how does an application shape demand? A wallet batching many withdrawals, a Bitcoin service managing UTXOs, or an automated settlement canister should separate user-facing ingestion from signing execution, tolerate queueing, and avoid assuming that a temporary burst limit is permanent capacity. Timers and retries also need to distinguish a signing queue from an external-chain confirmation delay.

The upgrade therefore strengthens Chain Fusion’s control plane rather than magically accelerating Bitcoin, Ethereum, or Solana. External fees, block production, RPC availability, and confirmation times still apply after ICP produces a signature. The improvement targets ICP’s threshold-signing service; it does not by itself remove latency, fees, or congestion on external chains.

The broader lesson is that threshold cryptography is becoming an operations problem. Precomputation, replicated state, queue sizing, and subnet parameters now matter alongside key security and signature correctness. As more canisters use Chain Fusion for automated payments and cross-chain execution, the applications that plan around signing inventory—not just peak cryptographic benchmarks—will be better positioned to deliver predictable behavior.]]></content>
  </entry>
</feed>
