Case study
← All workPrivacy layer and SDK suite
A pluggable privacy layer for an agent commerce protocol, shipped as a Rust core with contracts and a TypeScript SDK over it.
- Client
- Undisclosed — under NDA
- Year
- 2026
- Discipline
- Blockchain · Cryptography
- Status
- Delivered
Context
Autonomous agents transacting with each other on a public chain leak their entire commercial history by default — who paid whom, how much, how often. That is fine for a demo and unusable for a business. The work was a privacy layer that could be added to an existing agent commerce protocol rather than replacing it, so adopting it did not mean rebuilding.
Constraints
Cryptographic code is the one place where writing it yourself is almost always the wrong answer, so the core had to build on established primitives rather than invent any. It also had to be adoptable by application developers who are not cryptographers — if using it correctly requires understanding it, it will be used incorrectly. And it had to be pluggable: an existing protocol could not be asked to fork itself to gain privacy.
Architecture
Three components, deliberately separated by audience. A Rust core carries the cryptography, built over established C libraries rather than a fresh implementation. Solidity contracts hold the on-chain half. A TypeScript SDK sits over both and is the only surface most integrators ever touch — it exposes the operations an application needs and none of the primitives underneath. The split is what allows the hard part to be reviewed as cryptography while the integration surface is reviewed as ordinary application code.
01
Rust core over existing C cryptographic libraries.
Rust gives memory safety at the boundary where it matters most, while the underlying primitives remain the audited, widely deployed C implementations. Writing new cryptography would have been the single largest risk in the project.
What it cost
An FFI boundary to maintain, and a build that has to produce and link native artefacts across targets.
02
A TypeScript SDK as the only surface integrators use.
The failure mode for privacy tooling is misuse, not breakage. Narrowing the public API to the operations an application actually needs removes most of the ways to hold it wrong.
What it cost
Anything the SDK does not expose is unreachable without dropping to the core, so the API surface has to be got right early.
- Repositories in the suite
- 3
- counted in source
- Core implementation language
- Rust, over C cryptography
- counted in source
- Integration surface
- TypeScript SDK
- counted in source
- On-chain component
- Solidity contracts
- counted in source
Three repositories: a Rust core over C primitives, Solidity contracts, and a TypeScript SDK — layered so the cryptography and the integration surface can be reviewed by different people.
Stack
Rust · C · Solidity · TypeScript · EVM