Explore InvisiPay's zero-knowledge architecture, smart contract design, and developer SDK. Everything you need to integrate privacy-preserving payments.
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.
ZK-powered mixing layer that severs the on-chain link between sender and receiver. Deposits and withdrawals are unlinkable by design.
Fast-access sub-account for daily transactions. Rate-limited withdrawals and automated top-ups from the cold vault ensure operational liquidity.
Time-locked, multi-sig cold storage for the majority of funds. Requires multiple approvals and enforces withdrawal delays for maximum security.
Selective disclosure mechanism for regulatory compliance. Share transaction history with auditors without exposing data to the public chain.
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.
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.
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.
Deploy across Ethereum, Arbitrum, Base, and any EVM-compatible chain. One SDK integration automatically routes to the lowest-cost settlement path.
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
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.
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.
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.
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.
InvisiPay is designed for institutional adoption. Our privacy model supports selective disclosure, open protocol standards, and enterprise-grade security from the ground up.
Selectively disclose transaction history to auditors and regulators using cryptographic view keys — without exposing data publicly on-chain.
Fully open-source smart contracts and ZK circuits. Audited by leading security firms. Community-driven governance and transparent development.
Multi-sig cold storage, time-locked withdrawals, rate-limited hot wallets, and formal verification of core contracts. Built for enterprise treasury requirements.
Global On-Ramp aggregation via unified API. 180+ countries, 90+ fiats. Break down payment barriers with 95%+ success rates. Capture merchant gateway first.
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.
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.
Amount and token type visible on-chain. Faster confirmation, lower gas cost. Ideal for standard merchant checkout where speed matters most.
Amount hidden by ZK proof. Change automatically returns as a private note. One transaction covers deposit, payment, and change — no pre-funding required.
The receiver derives claimingKey from masterKey + invoiceId locally. The payer only holds a commitment hash — cryptographically impossible to reclaim funds after deposit.
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 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.
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.
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 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.
All price negotiation happens off-chain — zero gas until both parties agree. Only the final paymentCommitment goes on-chain.
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.
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.
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.
Full SDK documentation, sandbox environment,
and developer support — all free to start.