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
Privacy primitives built for institutional custody.
NixPool Contract
Hold client assets in a privacy pool where balances, positions, and transaction histories stay encrypted
AUM and holdings invisible to public
Noir Circuits
Prove reserves and solvency to auditors and clients without revealing exact amounts
Verify without revealing specifics
Nix Wallet
Run KYC/AML verification workflows without creating on-chain identity breadcrumbs
Regulatory compliance, client privacy
Nix Relayer
Give regulators selective access while keeping day-to-day operations confidential
Audit ready with controlled disclosure
NixPool SDK
Settle and transfer between custody accounts privately
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
// Conceptual integration pattern
// 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
// Conceptual integration pattern
// 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
// Conceptual integration pattern
// 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
// Conceptual integration pattern
// 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
// Conceptual integration pattern
// 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
// Conceptual integration pattern
// 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
});Security Foundations
What the protocol provides today and what we're working toward.
Auditor Access Built In
Designated auditor key can decrypt transaction data for compliance reporting
Non-Custodial Architecture
Client keys derived from wallet signatures and never stored server-side
Selective Disclosure
Share encrypted data with regulators without exposing all users
On-Chain Verification
UltraHonk proof verification and Merkle root history on-chain
Deterministic Key Recovery
Keys re-derived from the same wallet signature, no backup needed
Security Audit In Progress
Formal audit underway. Testnet deployed for community review. Do not use with significant value until audit is complete.
Upgrade Your Custody Infrastructure
Testnet live on Avalanche Fuji & Base Sepolia with full auditor compliance. Try the demo or schedule a call to discuss integration.