For Developers

Built for Privacy
at Scale.

Explore InvisiPay's zero-knowledge architecture, smart contract design, and developer SDK. Everything you need to integrate privacy-preserving payments.

( 01 ) Smart Contract Architecture

Three-layer self-custodial
contract architecture.

InvisiPay's smart contract system separates concerns across privacy, liquidity, and cold storage layers — ensuring funds remain safe even if any single component is compromised.

Privacy Pool

ZK-powered mixing layer that severs the on-chain link between sender and receiver. Deposits and withdrawals are unlinkable by design.

Hot Wallet Layer

Fast-access sub-account for daily transactions. Rate-limited withdrawals and automated top-ups from the cold vault ensure operational liquidity.

Cold Vault

Time-locked, multi-sig cold storage for the majority of funds. Requires multiple approvals and enforces withdrawal delays for maximum security.

View Key

Selective disclosure mechanism for regulatory compliance. Share transaction history with auditors without exposing data to the public chain.

Zero-knowledge proofs,
production-ready.

Circuit

Batch Settlement Circuit

A single Noir circuit proves N payments in one go. On-chain, observers see only N nullifiers and a total amount — individual amounts are permanently hidden. Up to 500 payments per on-chain batch.

Privacy

Shielded Payment Circuit

One transaction handles deposit + payment + change. Change is deposited into a Note Tree as a private note — reusable for future payments via pay_shielded_note or withdrawable anytime.

Engine

Client-Side Proving

All ZK proofs are generated locally on the user's device. Private keys never leave the client. Sub-3-second proving time on modern mobile hardware.

Reach

Multi-Chain Native

Deploy across Ethereum, Arbitrum, Base, and any EVM-compatible chain. One SDK integration automatically routes to the lowest-cost settlement path.

( 03 ) Developer SDK

Integrate privacy payments
in minutes.

Our SDK abstracts away the complexity of ZK circuits, key management, and multi-chain routing. A few lines of code is all it takes to add privacy-preserving payments to your application.

// ── TypeScript / Node.js ────────────────────────
npm install @invisi/receiver @invisi/payer @invisi/react @invisi/vue @invisi/contracts

// Merchant: initialize
import { InvisiReceiver } from '@invisi/receiver'

const receiver = new InvisiReceiver({
  masterKey: process.env.INVISI_MASTER_KEY,
  receivingAddress: '0xYourAddress',
  provider: rpcProvider,
  network: 'mainnet'
})

const invoice = await receiver.createInvoice({
  invoiceId: order.id,           // unique per order
  amount: 100_000000n,           // USDC 6-decimal
  token: 'USDC'
})  // payer generates paymentCommitment with a random nonce at payment time

receiver.onPaymentConfirmed(async (invoiceId, txHash) => {
  await fulfillOrder(invoiceId)   // fires once paymentCommitment lands on-chain
})

// Payer: one call to pay
import { InvisiPayer } from '@invisi/payer'

const payer = new InvisiPayer({ signer })
await payer.payPublic(invoice)     // or .payShielded(invoice, inputAmount)

// ── Go (server-side / B2B) ───────────────────────
// go get github.com/invisi-lab/invisi-go
r, _ := receiver.New(receiver.Config{ MasterKey: os.Getenv("INVISI_MASTER_KEY"), ... })
invoice, _ = r.CreateInvoice(ctx, receiver.InvoiceOptions{ InvoiceID: order.ID, Amount: big.NewInt(100_000000), Token: "USDC" })
receipt, _ := p.PayPublic(ctx, invoice)   // approve + pay in one call
01

Install & Initialize

npm install @invisi/receiver (merchant backend), @invisi/payer (payer frontend), @invisi/react or @invisi/vue for framework hooks. Go: go get github.com/invisi-lab/invisi-go.

02

Create Invoice

Merchant calls createInvoice(invoiceId, amount, token). SDK derives claimingKey and receiverCommitment locally from masterKey. The payer generates the final paymentCommitment with a random nonce at payment time — no secrets transmitted.

03

Pay & Confirm

Payer calls payPublic() or payShielded(). SDK handles ZK proof generation and on-chain submission. Once paymentCommitment lands on-chain, the merchant's onPaymentConfirmed callback fires instantly — before batch settlement.

04

Auto Batch Settlement

Batch settlement runs automatically in the background, triggered by count threshold, timer, or total amount. One ZK proof covers N payments; funds arrive in a single on-chain transaction.

( 04 ) Privacy Standards

Compliance-ready
privacy by design.

InvisiPay is designed for institutional adoption. Our privacy model supports selective disclosure, open protocol standards, and enterprise-grade security from the ground up.

View Key Compliance

Selectively disclose transaction history to auditors and regulators using cryptographic view keys — without exposing data publicly on-chain.

Open Protocol

Fully open-source smart contracts and ZK circuits. Audited by leading security firms. Community-driven governance and transparent development.

Institutional Grade

Multi-sig cold storage, time-locked withdrawals, rate-limited hot wallets, and formal verification of core contracts. Built for enterprise treasury requirements.

Two-phase strategy.

Phase 01 — Aggregation

Aggregate. Acquire. Scale.

Global On-Ramp aggregation via unified API. 180+ countries, 90+ fiats. Break down payment barriers with 95%+ success rates. Capture merchant gateway first.

In Progress
Phase 02 — Stealth Layer

Privacy. Yield. Sovereignty.

ZK-powered privacy payment layer. ZK-hidden addresses and amounts, three-layer self-custodial architecture, yield-bearing settlements, and View Key compliance for institutional adoption.

Upcoming
( 06 ) Payment Modes

Two modes.
One protocol.

Payers choose between public and shielded modes at the moment of payment. Both modes use the same smart contract — same security guarantees, no separate deployments or switching costs.

pay_public

Amount and token type visible on-chain. Faster confirmation, lower gas cost. Ideal for standard merchant checkout where speed matters most.

pay_shielded

Amount hidden by ZK proof. Change automatically returns as a private note. One transaction covers deposit, payment, and change — no pre-funding required.

Payer Never Holds Keys

The receiver derives claimingKey from masterKey + invoiceId locally. The payer only holds a commitment hash — cryptographically impossible to reclaim funds after deposit.

Nullifier Anti-Double-Spend

Each payment produces a unique nullifier stored on-chain. Replaying or reusing a commitment is impossible — enforced by contract state, not a trusted party.

The breakthroughs that
make it work.

Key Design

Receiver-Generated Keys

The receiver derives claimingKey from masterKey + invoiceId locally. The payer never holds the key — so they can never reclaim deposited funds. A fundamental security guarantee at the protocol level.

Zero Transmission

No Key Channel Needed

Keys are derived locally via masterKey + invoiceId — nothing secret is transmitted over any channel. Eliminates man-in-the-middle and key interception risks at the architectural level.

Batch Compression

N-Payment ZK Proof

A single Noir circuit proves N payments simultaneously. On-chain, observers only see N nullifiers and a total amount — individual payment amounts are completely and permanently hidden.

ZK Toolchain

Noir + Barretenberg

ZK circuits written in Noir, compiled to ACIR, proven via Barretenberg (Plonk proofs). Client-side WASM proving runs natively in browser and React Native — sub-3-second on modern mobile hardware.

( 08 ) Invoice Modes

Three ways to
agree on a price.

All price negotiation happens off-chain — zero gas until both parties agree. Only the final paymentCommitment goes on-chain.

Fixed

Fixed Invoice

Merchant sets amount and returns a paymentCommitment. Payer verifies the binding relationship and pays directly — no negotiation needed. Ideal for e-commerce checkout and fixed-price packages.

Open

Open Amount

Merchant sends a receiverCommitment. Payer decides the amount and proposes a paymentCommitment. Merchant confirms before it goes on-chain. Ideal for donations, tips, and custom top-ups.

Negotiated

Multi-Round Negotiation

Merchant and payer negotiate the price off-chain across multiple rounds — zero gas per round. Only the agreed paymentCommitment is submitted on-chain. Ideal for B2B procurement and bulk pricing.

Start building with
InvisiPay today.

Full SDK documentation, sandbox environment,
and developer support — all free to start.