xCompute: Computation on Threshold Shares

import { CircuitBuilder, buildEqualityCircuit } from '@private.me/xcompute';

// Pre-built: 8-bit equality check (Class 1 — FREE, zero AND gates)
const eqCircuit = buildEqualityCircuit(8);

// Custom: build any Boolean circuit
const builder = new CircuitBuilder();
const a = builder.addInput('a');
const b = builder.addInput('b');
const xored = builder.addXor(a, b);   // FREE — no communication
const masked = builder.addAnd(xored, a); // 1 Beaver triple
builder.addOutput(masked);
const circuit = builder.build();

import { simulateComputation, generatePool } from '@private.me/xcompute';

// Generate Beaver triples for AND gates
const triples = generatePool(circuit.andGateCount, 1);

// Input bits: party contributions
const inputs = new Map<number, number>();
inputs.set(0, 1); // wire 0 = 1
inputs.set(1, 0); // wire 1 = 0

// Evaluate circuit on shares — plaintext never assembled
const result = simulateComputation(circuit, inputs, 3, triples);
// result.ok === true, result.value = output bits

import { ArithmeticCircuitBuilder } from '@private.me/xcompute';

// Build arithmetic circuit: weighted sum
const builder = new ArithmeticCircuitBuilder({ prime: 2n ** 61n - 1n });
const salary1 = builder.addInput('salary_1');
const salary2 = builder.addInput('salary_2');
const weight  = builder.addConstant(500n);

// Addition: FREE — zero communication
const sum = builder.addGate(salary1, salary2);

// Multiplication: 1 Beaver triple, 1 round
const weighted = builder.mulGate(sum, weight);

// Comparison: is weighted sum > threshold?
const above = builder.compareGate(weighted, builder.addConstant(100000n));
builder.addOutput(above);

const circuit = builder.build();
// circuit.addGateCount === 1, circuit.mulGateCount === 1

// Initialize xCompute with Xid integration
import { XComputeEngine } from '@private.me/xcompute-cli';
import { XidClient } from '@private.me/xid';

const xid = new XidClient({ mode: 'ephemeral' });
const engine = new XComputeEngine({ identityProvider: xid });

// Each computation derives unlinkable participant DID automatically
const result = await engine.secureCompute({
  circuit: addSalaries,
  myShare: encryptedSalary
});
  → [xCompute] Deriving ephemeral DID from master seed...
  → [xCompute] DID: did:key:z6MkD... (unique to this session + circuit + epoch)
  → [xCompute] Participant authenticated (~50µs)
  → [xCompute] Key purged (<1ms exposure)

// Session is logged with unlinkable participant DID
// Verification works within session, but cross-session correlation fails

import { CircuitBuilder, evaluateCircuit } from '@private.me/xcompute';

// Build 32-bit addition circuit for SUM aggregation
const builder = new CircuitBuilder();
const sumCircuit = builder.buildAdderCircuit(32);  // 32-bit integer addition

// Each party holds XorIDA shares of salary data
// Party 1: share[0] of each salary record
// Party 2: share[1] of each salary record
// Party 3: share[2] of each salary record

// Execute MPC aggregation circuit
const result = await evaluateCircuit(sumCircuit, salaryShares, {
  partyCount: 3,
  beaverTriples: precomputedTriples,
  onProgress: (p) => console.log(`Summing record ${p.gateIndex}/${p.totalGates}`)
});

// Result is the sum — no party saw individual salaries
console.log(`Total payroll: $${result.reconstructed}`);

import { buildEqualityCircuit } from '@private.me/xcompute';

// Search for patient ID without revealing the ID to database hosts
const searchCircuit = buildEqualityCircuit(64);  // 64-bit patient ID

// Query: SELECT * FROM patients WHERE patient_id = ?
// Search value is XorIDA-split across 3 database parties
const matches = [];
for (const recordShares of databaseShares) {
  const isMatch = await evaluateCircuit(searchCircuit, {
    searchValue: targetPatientIdShares,
    recordValue: recordShares
  }, { partyCount: 3 });

  if (isMatch.output === 1) matches.push(recordShares);
}

// matches[] contains XorIDA shares of matching records
// No party learned which patient_id was queried

import { evaluateCircuit, CircuitBuilder } from '@private.me/xcompute';

// Build a 64-bit comparison circuit (63 AND gates)
const circuit = builder.buildComparisonCircuit(64);

// Evaluate with progress callback
const result = await evaluateCircuit(circuit, inputs, {
  partyCount: 3,
  beaverTriples: triples,
  onProgress: (progress) => {
    console.log(`Gate ${progress.gateIndex}/${progress.totalGates}`);
    console.log(`Type: ${progress.gateType}`);          // "xor" | "and" | "not"
    console.log(`Triples used: ${progress.triplesConsumed}`);
    console.log(`Completion: ${progress.percentComplete}%`);
  }
});

// Output example:
//   Gate 1/63 (Type: and, Triples: 1, Completion: 1.6%)
//   Gate 32/63 (Type: and, Triples: 32, Completion: 50.8%)
//   Gate 63/63 (Type: and, Triples: 63, Completion: 100%)

import { simulateComputation } from '@private.me/xcompute';

const result = await simulateComputation(circuit, inputs, 3, triples, {
  onProgress: (progress) => {
    // Per-party computation state
    progress.parties.forEach((party, idx) => {
      console.log(`Party ${idx}: wire ${party.currentWire}, ${party.communicationRounds} rounds`);
    });
  },
  onRoundComplete: (roundInfo) => {
    console.log(`Round ${roundInfo.roundNumber}: ${roundInfo.gatesEvaluated} gates`);
    console.log(`Bandwidth: ${roundInfo.bytesExchanged} bytes`);
  }
});

import {
  CircuitBuilder,
  evaluateCircuit,
  generateBeaverPool,
  thresholdToAdditive,
  additiveToThreshold
} from '@private.me/xcompute';

// Three credit bureaus (Equifax, Experian, TransUnion) compute aggregate
// credit score WITHOUT any bureau seeing the other bureaus' data.

// 1. Build circuit: weighted average of 3 scores
const builder = new CircuitBuilder({ arithmeticField: 2n ** 61n - 1n });

const score1 = builder.addInput('bureau_1_score', 16); // 16-bit integer
const score2 = builder.addInput('bureau_2_score', 16);
const score3 = builder.addInput('bureau_3_score', 16);

// Weights: 40%, 35%, 25%
const w1 = builder.addConstant(40n);
const w2 = builder.addConstant(35n);
const w3 = builder.addConstant(25n);

// Multiplication gates (each requires 1 Beaver triple)
const weighted1 = builder.mulGate(score1, w1);
const weighted2 = builder.mulGate(score2, w2);
const weighted3 = builder.mulGate(score3, w3);

// Addition gates (FREE — local only)
const sum12 = builder.addGate(weighted1, weighted2);
const totalWeighted = builder.addGate(sum12, weighted3);

// Divide by 100 to normalize
const normalizer = builder.addConstant(100n);
const avgScore = builder.divGate(totalWeighted, normalizer);

// Comparison: is avg score > 700 (prime lending threshold)?
const threshold = builder.addConstant(700n);
const isPrime = builder.compareGate(avgScore, threshold); // Boolean output

builder.addOutput(avgScore);
builder.addOutput(isPrime);

const circuit = builder.build();
console.log(`Circuit: ${circuit.mulGateCount} MUL gates, ${circuit.addGateCount} ADD gates`);

// 2. Generate Beaver triples (offline phase, pre-computation)
const triples = generateBeaverPool(circuit.mulGateCount, 3);
console.log(`Generated ${triples.length} Beaver triples`);

// 3. Each bureau splits their score into XorIDA threshold shares
const bureau1Score = 720; // Equifax's private score
const bureau2Score = 695; // Experian's private score
const bureau3Score = 710; // TransUnion's private score

// Convert to additive shares (T2A)
const shares1 = thresholdToAdditive(bureau1Score, 16);
const shares2 = thresholdToAdditive(bureau2Score, 16);
const shares3 = thresholdToAdditive(bureau3Score, 16);

// 4. Evaluate circuit with progress tracking
const result = await evaluateCircuit(circuit, {
  'bureau_1_score': shares1,
  'bureau_2_score': shares2,
  'bureau_3_score': shares3
}, {
  partyCount: 3,
  beaverTriples: triples,
  onProgress: (p) => {
    console.log(`[${p.percentComplete.toFixed(1)}%] Gate ${p.gateIndex}: ${p.gateType}`);
  },
  onRoundComplete: (r) => {
    console.log(`Round ${r.roundNumber} complete: ${r.bytesExchanged} bytes exchanged`);
  }
}).catch((err) => {
  if (err.code === 'E4001') {
    console.error('BEAVER_POOL_EXHAUSTED: regenerate triples');
  } else if (err.code === 'E3001') {
    console.error('SHARE_MISMATCH: parties have different circuit versions');
  } else {
    console.error(`Computation failed: ${err.message}`);
  }
  throw err;
});

// 5. Reconstruct result (only when all parties agree)
const [avgScoreShares, isPrimeShares] = result.outputs;

// A2T: re-share into fresh XorIDA threshold shares (decorrelates I/O)
const finalAvgScore = await additiveToThreshold(avgScoreShares, 3, 2);
const finalDecision = await additiveToThreshold(isPrimeShares, 3, 2);

console.log(`Aggregate credit score: ${finalAvgScore} (prime lending: ${finalDecision})`);

// Expected output:
//   Aggregate credit score: 710 (prime lending: true)
//   Calculation: (720*40 + 695*35 + 710*25) / 100 = 710.25 → 710
//   NO BUREAU SAW ANY OTHER BUREAU'S RAW SCORE

# Clone starter template
git clone https://github.com/privateme/xcompute-starter
cd xcompute-starter

# Install and run
pnpm install
pnpm dev

# Output:
#  Data split into 3 threshold shares (2-of-3)
#  Converted to additive shares for computation
#  Built equality circuit: 128 gates, 64 AND gates
#  Computing on split data...
#    Party 1 has share[0]
#    Party 2 has share[1]
#    Party 3 has share[2]
#    NO party sees the plaintext!

# Clone Vercel template
git clone https://github.com/privateme/xcompute-vercel
cd xcompute-vercel

# Deploy to edge
pnpm install
vercel --prod

# API endpoint live in 60 seconds:
# POST https://your-app.vercel.app/api/compute
# Body: { "shares": ["base64...", "base64...", "base64..."], "bits": 64 }

# Clone multi-platform starter
git clone https://github.com/privateme/xcompute-multi-platform
cd xcompute-multi-platform

# Run locally
pnpm dev:node

# Deploy to Vercel
pnpm dev:vercel

# Build Docker container
docker build -t xcompute -f docker/Dockerfile .
docker run -p 3000:3000 xcompute

import {
  buildEqualityCircuit,
  evaluateCircuit,
  thresholdToAdditive
} from '@private.me/xcompute';
import { split } from '@private.me/crypto';

// 1. Split sensitive data (XorIDA threshold shares)
const data = new TextEncoder().encode('Secret: 42');
const { value: shares } = await split(data, 2, 3);  // 2-of-3 threshold

// 2. Convert to additive shares for MPC
const additiveShares = shares.map((share, idx) =>
  thresholdToAdditive(share, idx + 1, shares.length)
);

// 3. Build circuit (64-bit equality check)
const circuit = buildEqualityCircuit(64);

// 4. Evaluate circuit on shares (NO reconstruction!)
const result = await evaluateCircuit(circuit, additiveShares, {
  partyCount: 3,
  beaverTriples: precomputedPool,  // Pre-generated Beaver triples
  onProgress: (p) => console.log(`Gate ${p.gateIndex}/${p.totalGates}`)
});

//  Result shares distributed - plaintext never existed at any node