Private Custody on Ethereum & L2s
Hidden AUM, private proof-of-reserves, confidential settlement. Institutional custody with the privacy and auditability you require.
The Transparency Problem
On-chain custody exposes everything. AUM, client activity, positions. All visible to competitors and market participants.
AUM Surveillance
Total assets under custody become public knowledge, inviting competitive pressure and security risks
Business intelligence exposed to competitors
Client Flow Analysis
Deposit and withdrawal patterns reveal client behavior and can be linked to off-chain identities
Client confidentiality compromised
Portfolio Transparency
Holdings, allocations, and rebalancing strategies visible to market participants
Strategies copied, positions front-run
Settlement Leakage
Large fund movements signal imminent trading activity before execution
Market impact erodes returns
Privacy-First Custody Infrastructure
NixProtocol enables custodians to protect client assets and activity while maintaining the verifiability and compliance that institutions require. Prove reserves without revealing amounts. Settle without market impact.
- Hidden assets under management
- Private proof of reserves
- Confidential settlement
- Anonymous multi-sig operations
- Selective regulatory disclosure
// Initialize custody platform
const custody = await nixCustody.init({
institution: institutionId,
compliance: { framework: "SOC2", auditor: auditorKey }
});
// Create private client account
const account = await custody.createAccount({
client: clientKycHash,
type: "institutional"
});
// Deposit with hidden amounts
await account.deposit("ETH", encryptedAmount);
// Prove reserves to client
const proof = await custody.proveReserves({
client: clientId,
minRatio: 1.0 // 100% backed
});
// Client verifies: { backed: true }Components for Custodians
Enterprise-grade privacy primitives built for institutional custody.
Nix ERC20
Custody client assets with encrypted balances, positions, and transaction histories
AUM and holdings invisible to public
Nix Tools
Generate cryptographic proof of reserves and solvency on demand for auditors and clients
Verify without revealing specifics
Nix Stealth Wallet
Complete KYC/AML verification workflows without creating on-chain identity breadcrumbs
Regulatory compliance, client privacy
Nix Relayer
Provide regulators with selective access while maintaining day-to-day confidentiality
Audit-ready with controlled disclosure
Nix SDK
Private settlement and transfers between custody accounts
Confidential operations
Custody Use Cases
Privacy-preserving custody operations for institutional clients.
Private Proof of Reserves
Prove solvency and reserves to auditors or clients without revealing exact holdings or positions.
Components Used
Benefits
- Prove reserves >= liabilities
- Hide exact amounts
- Client-verifiable proofs
- Real-time attestations
// Generate proof of reserves
const reserveProof = await nixZK.proveReserves({
vaults: custodyVaults,
liabilities: encryptedClientBalances,
threshold: 1.0 // 100% backed
});
// Client verifies their share
const clientProof = await nixZK.proveClientReserve({
clientId: clientKycHash,
clientBalance: encryptedBalance,
reserveProof: reserveProof
});
// Returns: { sufficient: true, timestamp: ... }Hidden Client Holdings
Custody client assets without exposing individual balances, positions, or transaction history on-chain.
Components Used
Benefits
- Private client balances
- Hidden position sizes
- Confidential activity
- Protected client identity
// Onboard client with private account
const clientAccount = await nixCustody.createAccount({
clientKyc: kycProofHash,
jurisdiction: encryptedJurisdiction,
accountType: "institutional"
});
// Deposit assets privately
await clientAccount.deposit({
asset: "ETH",
amount: encryptedAmount,
source: sourceProof
});
// Client views balance (only they can decrypt)
const balance = await clientAccount.getBalance(clientPrivKey);Confidential Settlement
Execute large settlements between accounts without revealing amounts or triggering market signals.
Components Used
Benefits
- Hidden settlement amounts
- No market signaling
- Atomic execution
- Private counterparties
// Initiate confidential settlement
const settlement = await nixCustody.createSettlement({
from: clientA.account,
to: clientB.account,
asset: "USDC",
amount: encryptedAmount
});
// Both parties approve privately
await settlement.approve(clientA.signature);
await settlement.approve(clientB.signature);
// Execute atomically - no public trace
const proof = await settlement.execute();Multi-Sig with Privacy
Implement institutional multi-signature custody where signers, thresholds, and approvals remain private.
Components Used
Benefits
- Hidden signer set
- Private threshold
- Anonymous approvals
- Verifiable authorization
// Create private multi-sig vault
const vault = await nixCustody.createMultiSig({
signers: encryptedSignerSet, // Hidden
threshold: encryptedThreshold, // Hidden
policy: encryptedPolicy
});
// Signer approves without revealing identity
const approval = await nixZK.proveSignerApproval({
vault: vault.id,
signer: signerProof, // ZK membership proof
transaction: txHash
});
// Execute when threshold reached
await vault.executeWhenThreshold(approvals);Regulatory Reporting
Generate compliant reports for regulators with selective disclosure. Prove requirements without exposing all data.
Components Used
Benefits
- Selective disclosure
- Auditor-only access
- Tamper-proof logs
- Jurisdiction-specific
// Generate regulatory report
const report = await nixCompliance.generateReport({
period: "Q4-2024",
jurisdiction: "US-SEC",
reportType: "custody-attestation"
});
// Prove AML compliance without exposing clients
const amlProof = await nixZK.proveAmlCompliance({
accounts: allClientAccounts,
sanctionsList: currentSanctions,
timeframe: reportPeriod
});
// Grant auditor access to encrypted details
await report.grantAuditorAccess(auditorPubKey);Cold Storage Management
Manage cold storage with private balances and transaction history, proving reserves without hot wallet exposure.
Components Used
Benefits
- Hidden cold storage amounts
- Private rebalancing
- Proof of cold reserves
- Secure key management
// Initialize private cold storage
const coldVault = await nixCustody.createColdStorage({
addresses: encryptedAddresses, // Hidden
totalCapacity: encryptedCapacity,
rebalanceThreshold: encryptedThreshold
});
// Prove cold storage reserves
const coldProof = await nixZK.proveColdReserves({
coldVault: coldVault.id,
minPercent: 80 // Prove >= 80% in cold
});
// Private rebalance hot <-> cold
await nixCustody.privateRebalance({
from: hotWallet,
to: coldVault,
amount: encryptedAmount
});Built for Institutional Requirements
Security and compliance features designed for regulated custodians.
SOC 2 Compatible
Audit trails and access controls designed for SOC 2 compliance
HSM Integration
Compatible with hardware security modules for key management
Multi-Jurisdiction
Flexible compliance modules for global regulatory requirements
Insurance Ready
Proof systems compatible with custody insurance requirements
Disaster Recovery
Encrypted backup and recovery procedures for business continuity
Audited Code
Smart contracts audited by leading security firms
Upgrade Your Custody Infrastructure
Join custodians already building with NixProtocol. Live on Ethereum, Base, Arbitrum, and Optimism with dedicated integration support.