Use Cases

Real-world applications for private payments on Solana

ENTERPRISE

Private Payroll

Companies can pay employees without revealing individual salaries on-chain. Each payment goes to a unique stealth address, so even if someone monitors the company's wallet, they cannot link payments to specific employees or determine compensation amounts. This protects employee privacy while maintaining full compliance with labor laws and accounting requirements. Supports batch processing for multiple employees in a single transaction, reducing gas costs and administrative overhead. Perfect for startups, remote teams, and any organization prioritizing financial privacy.

How it works

Company registers meta-addresses for each employee during onboarding

HR initiates batch payment with individual amounts for each employee

Each payment creates a unique stealth escrow with recipient-specific keys

Employees scan and claim using their view keys from wallet or mobile app

No on-chain link between payments and recipients preserves complete privacy

Batch Payroll Paymenttypescript

import { ZkiraClient } from '@zkira/sdk';
import { Connection, PublicKey } from '@solana/web3.js';

// Initialize client
const client = new ZkiraClient(connection);

// Create batch payroll payment
const employees = [
  { metaAddress: 'meta1...', amount: 5000_000000 }, // $5,000 USDC
  { metaAddress: 'meta2...', amount: 7500_000000 }, // $7,500 USDC
  { metaAddress: 'meta3...', amount: 4200_000000 }, // $4,200 USDC
];

const batchPayment = await client.createBatchPayment({
  payments: employees.map(emp => ({
    recipient: emp.metaAddress,
    amount: emp.amount,
    token: 'USDC',
  })),
  payer: companyWallet.publicKey,
});

console.log('Payroll distributed:', batchPayment.signature);

SOCIAL IMPACT

Anonymous Donations

Non-profits and charities can accept donations without creating a permanent on-chain link between donors and the organization. Donors get cryptographic proof of their contribution without public exposure, protecting them from unwanted solicitation or political targeting. Especially valuable in politically sensitive contexts, whistleblower support, or when donor privacy is legally required. Organizations can still track total donations for transparency reports while preserving individual donor anonymity. Supports recurring donations and automatic tax receipt generation.

How it works

Organization publishes their meta-address on website and donation pages

Donor creates stealth payment to the meta-address with chosen amount

Organization scans for incoming payments using their view key

Donor receives claim receipt and proof for tax deduction purposes

No public ledger link between donor and organization preserves anonymity

Anonymous Donationtypescript

import { ZkiraClient } from '@zkira/sdk';

const client = new ZkiraClient(connection);

// Create anonymous donation
const donation = await client.createPayment({
  recipient: 'charity_meta_address_here',
  amount: 100_000000, // $100 USDC
  token: 'USDC',
  memo: 'Supporting clean water initiative', // Optional private memo
});

// Generate proof for donor records
const proof = await client.generateDonationProof({
  payment: donation,
  recipientName: 'Clean Water Foundation',
  taxId: '12-3456789',
});

console.log('Anonymous donation sent:', donation.signature);
console.log('Tax receipt proof:', proof.receiptHash);

FREELANCE

Escrow Services

Milestone-based escrow for freelance and contract work eliminates payment disputes and builds trust between clients and contractors. Clients lock funds that release incrementally as contractors complete agreed milestones, providing security for both parties. The contractor knows funds exist and are guaranteed upon completion, while the client knows they only release for verified work delivery. Built directly on Solana for instant settlement without traditional escrow fees. Supports complex milestone structures, dispute resolution, and partial releases. Perfect for development projects, design work, consulting, and any service-based contracts.

How it works

Client creates milestone escrow with defined deliverables and payment amounts

Contractor completes first milestone and submits deliverables

Client reviews work and approves milestone release through the platform

Funds for that milestone automatically transfer to contractor's stealth address

Process repeats for each milestone until project completion

Milestone Escrow Creationtypescript

import { ZkiraClient } from '@zkira/sdk';

const client = new ZkiraClient(connection);

// Create milestone-based escrow
const escrow = await client.createMilestoneEscrow({
  client: clientWallet.publicKey,
  contractor: 'contractor_meta_address',
  milestones: [
    { description: 'UI/UX Design', amount: 2000_000000 }, // $2,000 USDC
    { description: 'Frontend Development', amount: 3500_000000 }, // $3,500 USDC
    { description: 'Backend Integration', amount: 2500_000000 }, // $2,500 USDC
    { description: 'Testing & Deployment', amount: 2000_000000 }, // $2,000 USDC
  ],
  token: 'USDC',
  deadline: new Date('2024-06-30'),
});

// Approve milestone completion
await client.approveMilestone({
  escrow: escrow.address,
  milestoneIndex: 0,
  approver: clientWallet,
});

console.log('Milestone escrow created:', escrow.address);

DAO / TEAM

Multi-sig Treasury

Shared treasury management requiring multiple approvals before any payment executes. Teams, DAOs, and partnerships can set M-of-N approval thresholds — for example, requiring 3-of-5 team members to approve any payment over $1,000. Combined with stealth addresses, even approved payments remain private from external observers. Supports complex approval workflows, spending limits, and time-locked releases. Perfect for startup teams managing runway, DAO treasuries distributing grants, investment partnerships, or any shared financial responsibility requiring transparency among stakeholders while maintaining external privacy.

How it works

Create multi-sig escrow with authorized signers and approval threshold

Any authorized signer proposes a payment with justification

Required number of signers review and approve the proposed payment

Once approval threshold is met, payment executes automatically

All approvals recorded on-chain for internal auditability

Multi-sig Treasury Setuptypescript

import { ZkiraClient } from '@zkira/sdk';

const client = new ZkiraClient(connection);

// Create multi-sig escrow
const multisig = await client.createMultisigEscrow({
  signers: [
    founderWallet.publicKey,
    ctoWallet.publicKey, 
    cfoWallet.publicKey,
    advisorWallet.publicKey,
    investorWallet.publicKey,
  ],
  threshold: 3, // Require 3 out of 5 signatures
  spendingLimits: [
    { amount: 10000_000000, timeframe: '30days' }, // $10k/month limit
    { amount: 50000_000000, timeframe: 'quarter' }, // $50k/quarter limit
  ],
});

// Propose payment
const proposal = await client.proposePayment({
  multisig: multisig.address,
  recipient: 'contractor_meta_address',
  amount: 15000_000000, // $15,000 USDC
  justification: 'Q1 development contractor payment',
  proposer: founderWallet,
});

// Approve payment
await client.approvePayment({
  proposal: proposal.id,
  signer: ctoWallet,
});

INVOICING

Payment Links

Generate shareable payment links for invoicing clients, collecting payments from customers, or requesting funds from anyone. Each link creates a unique escrow — the sender deposits funds, and the recipient claims with a secret embedded in the URL. Perfect for freelancers, small businesses, content creators, and anyone needing simple payment collection. Links can have expiry dates, custom messages, and support any SPL token. No account creation required for payers, making it friction-free for customers. Provides immediate confirmation and receipt generation for both parties.

How it works

Create payment link with amount, token, description, and expiry date

Share the generated claim URL via email, message, or embed in invoice

Payer opens link, connects wallet, and reviews payment details

Payment transaction executes and escrow locks funds

Recipient claims funds to their stealth address using claim secret

Payment Link Creationtypescript

import { ZkiraClient } from '@zkira/sdk';

const client = new ZkiraClient(connection);

// Create payment link
const paymentLink = await client.createPaymentLink({
  amount: 2500_000000, // $2,500 USDC
  token: 'USDC',
  description: 'Web Development Services - March 2024',
  expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30 days
  recipient: recipientMetaAddress,
});

console.log('Share this link:', paymentLink.url);
// Output: https://zkira.xyz/pay/claim?t=abc123...

// Check payment status
const status = await client.getPaymentStatus({
  paymentId: paymentLink.id,
});

if (status === 'completed') {
  console.log('Payment received! Claiming funds...');
  
  const claim = await client.claimPayment({
    paymentId: paymentLink.id,
    claimSecret: paymentLink.claimSecret,
    recipient: recipientWallet,
  });
}

COMMERCE

E-commerce Integration

Online stores can accept private payments using the ZKIRA widget with minimal integration effort. Drop a single script tag into your HTML or use the React hook for programmatic integration. Customers pay with any supported SPL token, and the merchant receives funds without exposing transaction details to competitors or market analysts. Supports subscription payments, partial payments, refunds, and complex checkout flows. Widget handles wallet connection, network switching, and transaction signing automatically. Perfect for SaaS products, digital goods, physical products, and any online business accepting crypto payments.

How it works

Install widget script tag or React component in your checkout flow

Configure payment amount, accepted tokens, and completion callback

Customer clicks pay button and widget handles wallet connection

Payment processes through stealth escrow for privacy

Merchant receives webhook confirmation and can fulfill order

HTML Widget Integrationhtml

<!-- HTML Embed -->
<script src="https://cdn.zkira.xyz/widget.js"></script>
<zkira-pay 
  amount="49.99" 
  token="USDC"
  description="Premium Subscription - Monthly"
  merchant-address="merchant_meta_address_here"
  callback="https://mystore.com/webhooks/payment"
></zkira-pay>

React Hook Integrationtypescript

import { useZkiraPay } from '@zkira/widget';

function CheckoutButton({ amount, description }: { 
  amount: number; 
  description: string; 
}) {
  const { createPayment, status, error } = useZkiraPay({
    apiUrl: 'https://api.zkira.xyz',
    apiKey: process.env.NEXT_PUBLIC_ZKIRA_KEY,
    merchantAddress: process.env.NEXT_PUBLIC_MERCHANT_META_ADDRESS,
  });

  const handlePayment = async () => {
    const payment = await createPayment({ 
      amount, 
      token: 'USDC',
      description,
      successUrl: '/success',
      cancelUrl: '/checkout',
    });
    
    if (payment.success) {
      // Redirect to success page
      window.location.href = '/order-confirmation';
    }
  };

  return (
    <button 
      onClick={handlePayment}
      disabled={status === 'pending'}
      className="bg-[#FF2828] text-white px-6 py-3 rounded-none font-semibold"
    >
      {status === 'pending' ? 'Processing...' : `Pay $${amount}`}
    </button>
  );
}