zk-polka-sdk

zk-polka-sdk lets any JS developer build with ZK : no Solidity, crypto, or web3 needed. Write Circom, auto-compile, test, deploy to Asset Hub, and verify proofs with one simple SDK.

Comment

Inspiration

Zero-knowledge proofs are powerful, but painfully hard for most developers.
From Circom to Groth16 setup, Solidity verifiers, on-chain deployment, and proof verificatio, the workflow is fragmented and intimidating.

We built zk-polka-sdk to remove this complexity.

  • Make ZK accessible to every JavaScript developer
  • Eliminate the need to learn Solidity, cryptography, or web3
  • Provide a one-click path from Circom → Proof → Verifier → Deployment

Our inspiration was simple:
Bring ZK technology to mainstream developers by wrapping the entire pipeline into a clean, familiar, NPM-installable developer experience.

What It Does

zk-polka-sdk is a plug-and-play Zero-Knowledge toolkit for JavaScript developers.
It compresses the entire ZK workflow into a simple set of commands that feel natural to any JS developer.

Core Capabilities:

  • Write Circom circuits inside any project
  • Compile them using npx zk-polka-sdk compile
  • Auto-run Groth16 setup and test proofs locally with one click
  • Generate Solidity verifier contracts instantly
  • Deploy to Polkadot Asset Hub testnet using a single deploy command
  • Verify proofs on-chain using a clean verifyProof() JS function

In short:
zk-polka-sdk lets anyone integrate production-grade ZK proofs without touching Solidity, cryptography, or blockchain. Just npm install and build.

How We Built It

We engineered zk-polka-sdk as a full end-to-end ZK automation pipeline, designed around a familiar JavaScript developer experience.

Core Architecture

  • Node.js CLI + SDK built from scratch
  • Circom compiler integration to process circuits and generate .r1cs, wasm, and witness files
  • Automated Groth16 setup using snarkjs for proving + verification key generation
  • Solidity verifier generator that converts the Groth16 keys into a deployable verifier contract
  • Revive + PolkaVM integration to compile Solidity into .polkavm bytecode
  • Deployment module that ships verifiers directly to Polkadot Asset Hub testnet
  • JS-based verification helper exposing a simple verifyProof() function to interact with the deployed contract

Design Principles

  • Abstract all blockchain complexity behind clean JS functions
  • One-command actions for compile, setup, test, deploy
  • Zero touch with Solidity, cryptography, or RPC internals

Outcome

A seamless SDK that transforms the messy ZK workflow into a smooth, NPM-first developer experience, enabling any JavaScript developer to build ZK-powered apps effortlessly.

Challenges We Ran Into

Building zk-polka-sdk required solving multiple technical and architectural hurdles:

1. Integrating the Entire ZK Pipeline

Connecting Circom → Groth16 → Solidity → PolkaVM was complex.
Each tool had its own format, requirements, and breaking points, and aligning them into a single seamless flow took deep debugging.

2. Automating Revive + PolkaVM Compilation

Compiling Solidity to .polkavm wasn’t straightforward.
We discovered that @parity/revive and the correct solc version must be installed in the same environment, and we built logic to handle this automatically.

3. Handling Proof Generation and Verification

Translating snarkjs outputs into on-chain verifier inputs required multiple transformations.
Ensuring the generated verifier and the proof matched consistently was a major challenge.

4. Creating a One-Click Developer Experience

The hardest part wasn’t the cryptography—
it was hiding all the complexity behind a clean NPM interface while keeping it reliable for every environment.

5. Reliable Deployment to Asset Hub

PolkaVM deployment flows had strict requirements, from bytecode formatting to RPC-level quirks.
We built precise deployment scripts to ensure smooth contract creation.

Overall, the biggest challenge was turning a deeply technical ZK workflow into an SDK that “just works” for any JavaScript developer.

Accomplishments That We’re Proud Of

1. End-to-End ZK Workflow in a Single SDK

We successfully unified Circom → Groth16 → Solidity → PolkaVM deployment into one streamlined toolkit—something developers typically struggle to piece together manually.

2. One-Command Developer Experience

We built a UX where complex ZK operations happen with simple commands like
npx zk-polka-sdk compile and zk-polka-sdk deploy, making ZK accessible to any JS developer.

3. Automatic Groth16 Setup + Local Testing

Running a full proving setup and verifying proofs locally is usually painful.
Our SDK handles it in one click, without exposing cryptographic details.

4. Seamless Polkadot Asset Hub Deployment

We created a fully automated pipeline that compiles Solidity to .polkavm and deploys directly to Asset Hub—no manual RPC calls or tooling issues.

5. Production-Ready verifyProof() Abstraction

We implemented a clean JS function that interacts with the on-chain verifier, enabling developers to verify proofs with a single line of code.

6. Making ZK Accessible to Everyone

Our biggest achievement:
transforming advanced ZK cryptography into a plug-and-play NPM experience that anyone can use.

What We Learned

1. ZK Tooling Is Powerful but Fragmented

Circom, Groth16, snarkjs, Solidity verifiers, and PolkaVM all operate in different ecosystems.
We learned how challenging it is for developers to stitch these pieces together—and how valuable abstraction can be.

2. Developer Experience Matters More Than Features

Even the best cryptography won’t get adoption if the workflow feels complex.
A smooth one-command experience can unlock far more usage than raw technical depth.

3. PolkaVM + Revive Requires Precision

Compiling and deploying to Polkadot Asset Hub through Revive taught us the importance of tooling alignment—versions, environments, and bytecode formatting all matter.

4. Proof/Verifier Consistency Is Critical

We understood how strict the mapping is between Groth16 proof data, verification keys, and the generated Solidity verifier.
A single mismatch breaks the entire pipeline.

5. Abstraction Doesn’t Mean Hiding Power

We learned how to wrap complexity without reducing flexibility—developers can still work with Circom logic, but everything else “just works.”

6. The ZK Learning Curve Can Be Flattened

Most importantly, we learned that with the right SDK, any JS developer can build ZK apps—no cryptography background required.

What's Next for zk-polka-sdk

1. Full On-Chain Verification Dashboard

A web dashboard to visualize circuits, proofs, deployed verifiers, and on-chain verification logs in real time.

2. Multi-Network Support

Extend deployment beyond Asset Hub to other Polkadot parachains and EVM-compatible testnets for greater flexibility.

3. One-Command Proof Generation APIs

Expose a hosted API endpoint so developers can generate proofs without running heavy computation locally.

4. Circuit Templates & Marketplace

Ready-made Circom templates (KYC, age verification, voting, identity proofs) and a community-driven circuit library.

5. Frontend Components for Plug-and-Play ZK

React components that integrate proof generation + verification into UI flows with zero configuration.

6. Performance & Security Audits

Optimizing proving times, performing audits, and tightening security across the entire pipeline.

7. Developer-Friendly Documentation & Examples

Dedicated tutorials, example apps, and copy-paste integration guides to accelerate adoption.

Our goal:
To make zk-polka-sdk the simplest, most reliable way for any JavaScript developer to build real ZK applications on Polkadot.

Built With

Share this project:

Updates