기밀 결제 인프라

// Conceptual integration pattern
// Set up private payroll
const payroll = await nixPayments.createPayroll({
  employer: companyVault,
  frequency: "monthly",
  currency: "USDC"
});

// Add employees with encrypted salaries
await payroll.addEmployee({
  id: employeeId,
  salary: encryptedAmount,
  vestingSchedule: encryptedVesting
});

// Execute payroll - amounts stay private
const batchProof = await payroll.executeBatch({
  period: "2024-01",
  totalBudget: encryptedTotal
});

// Conceptual integration pattern
// Create private invoice
const invoice = await nixPayments.createInvoice({
  from: buyerCompany,
  to: sellerCompany,
  amount: encryptedAmount,
  terms: encryptedTerms,
  dueDate: dueTimestamp
});

// Pay with compliance proof
const paymentProof = await nixZK.proveInvoicePayment({
  invoice: invoice.id,
  amount: encryptedAmount,
  complianceCheck: amlClearance
});

await nixPool.transferPrivate(paymentProof);

// Conceptual integration pattern
// Initiate cross-border transfer
const transfer = await nixPayments.crossBorder({
  from: { region: "US", id: senderKycProof },
  to: { region: "MX", id: receiverKycProof },
  amount: encryptedUSD,
  purpose: "family_support" // encrypted
});

// Compliance layer verifies without seeing details
const complianceProof = await nixCompliance.verify({
  transfer: transfer.id,
  regulations: ["US-FinCEN", "MX-CNBV"],
  proofs: [senderProof, receiverProof]
});

// Conceptual integration pattern
// Initialize merchant account
const merchant = await nixPayments.createMerchant({
  businessId: merchantRegistry,
  settlementVault: encryptedVault,
  acceptedCurrencies: ["USDC", "USDT"]
});

// Process customer payment
const payment = await merchant.acceptPayment({
  amount: encryptedAmount,
  customerProof: nixZK.proveBalance(customerWallet),
  orderId: encryptedOrderRef
});

// Settle to merchant - only total visible
await merchant.settleDaily(batchProof);

// Conceptual integration pattern
// Create subscription plan
const plan = await nixPayments.createSubscription({
  provider: serviceVault,
  tiers: encryptedPricingTiers,
  billingCycle: "monthly"
});

// Subscribe user privately
await plan.subscribe({
  user: userId,
  tier: encryptedTier,
  paymentMethod: userVault
});

// Automatic renewal - amounts hidden
const renewalProof = await nixZK.proveRecurringPayment({
  subscription: subId,
  cycle: currentCycle,
  amount: encryptedAmount
});

// Conceptual integration pattern
// Create escrow agreement
const escrow = await nixPayments.createEscrow({
  buyer: buyerVault,
  seller: sellerVault,
  totalAmount: encryptedTotal,
  milestones: encryptedMilestones
});

// Fund escrow privately
await escrow.fund({
  amount: encryptedDeposit,
  proof: nixZK.proveSufficientFunds(buyerVault)
});

// Release on milestone completion
const releaseProof = await nixZK.proveMilestoneComplete({
  escrow: escrow.id,
  milestone: 1,
  deliverableHash: workHash
});

await escrow.release(releaseProof);