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 { 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