JHILKE झिल्के

Deterministic bootstrap key derivation and continuous friend-or-foe peer verification for the Yakmesh mesh.

Overview

JHILKE provides two critical functions for the Yakmesh mesh:

Initialization

JHILKE is initialized from mesh/network.js with four parameters:

import { JhilkeCoordinator } from './mesh/jhilke.js';

const jhilke = new JhilkeCoordinator({
  codeHash:   oracle.selfHash,    // Validation Oracle code hash (hex string)
  nodeId:     identity.nodeId,    // This node's identity
  mesh:       meshInstance,       // MeshNetwork (provides sendTo + peers Map)
  buildNonce: manifest.nonce,     // Per-build secret from manifest.json
});

jhilke.start();  // Begin 30-second chirp loop

Deterministic Bootstrap

When two nodes connect, they both independently compute the same initial 256-bit symmetric key. No KEM exchange needed — traffic is encrypted from the very first message:

deriveBootstrapKey(peerId) {
  // Step 1: Input Key Material — per-build secret
  const ikm = sha3_256.create()
    .update(hexToBytes(this.codeHash))
    .update(utf8ToBytes(this.buildNonce || ''))
    .digest();

  // Step 2: Sort node IDs for order-independence
  const [first, second] = [this.nodeId, peerId].sort();

  // Step 3: HKDF derivation
  const salt = `YAKMESH-JHILKE-BOOTSTRAP-2026:${first}:${second}`;
  const info = 'yakmesh-jhilke-bootstrap-key-v1';
  const key  = hkdf(sha3_256, ikm, salt, info, 32);

  return Buffer.from(key);  // 32-byte (256-bit) symmetric key
}

What JHILKE Provides

JHILKE touches exactly three things in the connection lifecycle. Everything else is ANNEX's job:

Cricket Chirps — Friend-or-Foe

Every 30 seconds (matching the gossip HELLO cadence), each node sends a friend-or-foe chirp to every connected peer. Chirps are hidden inside normal mesh_entropy messages:

// What an observer sees on the wire:
{
  type: 'mesh_entropy',
  entropy: 'a7f3b2c1...',   // 32 bytes genuine PRAHARI sponge entropy
  jhilke: '8e4d1f2a...',    // 8-byte friend-or-foe chirp
  pad:    'c3d2e1f0...',    // 16–64 bytes PRAHARI random padding
  t:      1741564800000     // AGUWA-synchronized timestamp
}
// To an observer: routine entropy exchange. Nothing unusual.
// To nodes sharing the dialect: continuous peer verification.

Dialect Derivation

The "dialect" is the shared secret that makes chirp encoding/verification possible. It's derived from the same SHA3(codeHash + buildNonce) IKM as the bootstrap key, but with different salt and info strings — producing a completely independent seed:

_deriveDialectSeed() {
  const ikm = sha3_256.create()
    .update(hexToBytes(this.codeHash))
    .update(utf8ToBytes(this.buildNonce || ''))
    .digest();

  return hkdf(sha3_256, ikm,
    'jhilke-cricket-salt-2026',    // Salt (different from bootstrap)
    'yakmesh-jhilke-dialect-v1',   // Info (different from bootstrap)
    32);                           // 256-bit dialect seed
}

Chirp Generation

Each chirp is an 8-byte HKDF output encoding both node IDs, the current AGUWA tick, and the SST Fibonacci 24-cycle position for rotational variety:

_generateChirp(peerId, tick) {
  const [first, second] = [this.nodeId, peerId].sort();

  // SST modulation — Fibonacci digital root at this tick position
  const fibPos  = tick % 24;
  const fibRoot = fibonacciRoot(fibPos);

  const context = `${first}:${second}:${tick}:${fibPos}:${fibRoot}`;

  return hkdf(sha3_256, this.dialectSeed, context,
    'jhilke-signal-v1', 8);  // 8-byte chirp
}

Chirp Verification

Verification uses dynamic tick tolerance computed from three sources. This accounts for GPS precision differences AND actual system clock drift:

_verifyChirp(peerId, signalBytes, currentTick) {
  // Source 1: MANI trust-level tolerance (peer's time source precision)
  const maniToleranceMs = aguwa.getToleranceForPeer(peerId);

  // Source 2: Clock drift — our correctionMs + peer margin + propagation
  const driftToleranceMs = Math.abs(aguwa._correctionMs) + 2000;

  // Use the larger of MANI precision vs actual drift
  const toleranceMs  = Math.max(maniToleranceMs, driftToleranceMs);
  const dynamicTicks = Math.ceil(toleranceMs / 1000);
  const tolerance    = Math.max(1, dynamicTicks); // ±1 tick floor

  for (let offset = -tolerance; offset <= tolerance; offset++) {
    const testTick = currentTick + offset;
    if (testTick < 0) continue;
    const expected = this._generateChirp(peerId, testTick);
    if (bytesToHex(expected) === bytesToHex(signalBytes)) {
      return { valid: true, tick: testTick, offset };
    }
  }
  return { valid: false };
}

Wire Format

Chirps are transmitted via _sendChirp(), which constructs a complete mesh_entropy message with genuine entropy, the hidden chirp, and variable camouflage padding:

_sendChirp(peerId) {
  const chirp = this._generateChirp(peerId, this._sharedTick());

  // Variable padding from PRAHARI sponge (16–64 bytes)
  const paddingSize = 16 + (seedStore.squeeze(4, 'JHILKE-PADDING-SIZE')
    .readUInt32BE(0) % 48);
  const padding = seedStore.squeeze(paddingSize, 'JHILKE-PADDING');

  this.mesh.sendTo(peerId, {
    type:    'mesh_entropy',
    entropy: bytesToHex(seedStore.squeeze(32, 'JHILKE-ENTROPY')),
    jhilke:  bytesToHex(chirp),
    pad:     bytesToHex(padding),
    t:       aguwa.now(),
  });
}

ACT — AGUWA Coordinated Transition

When a coordinated transition is needed, JHILKE runs the ACT state machine. ACT uses TRIBHUJ trits and is driven on the same 30-second chirp cadence. All transitions are driven by internal state only — never external signals.

  Node A                              Node B
  ──────                              ──────
  idle                                idle
    │                                   │
    ├── beginACT(targetEpoch) ──────── ┤
    │                                   │
  PREPARE (+1)                        PREPARE (+1)
    │       (broadcast via gossip)      │
    │   ≥ 3 ticks (≥ 90 seconds)        │
    │                                   │
  READY (0)                           READY (0)
    │   ◀── peer state check ──▶        │
    │                                   │
    │       (all peers in READY)        │
    │                                   │
  SWITCH (−1)                         SWITCH (−1)
    │   ≥ 2 ticks, AGUWA r ≥ 0.2       │
    │   wait for epoch boundary         │
    │                                   │
  EXECUTING ── act:execute ──────▶    EXECUTING
    │                                   │
  idle   (transition complete)        idle

Dependencies

Configuration Constants

All constants live in JHILKE_CONFIG (exported for testing):

API Reference

{
  state: 'READY',               // Current phase
  targetEpoch: 42,              // Target epoch
  prepareTicks: 3,              // Ticks spent in PREPARE
  switchTicks: 0,               // Ticks spent in SWITCH
  peerStates: {                 // Tracked peer states
    'abc123...': 'READY',
    'def456...': 'PREPARE'
  }
}

{
  bootstrapKeysDerived: 3,
  chirpsSent: 142,
  chirpsReceived: 138,
  chirpsVerified: 135,
  chirpsFailed: 3,
  peerCount: 2
}

Event Emissions

JhilkeCoordinator extends EventEmitter. It emits soft intelligence signals — it does NOT take punitive action. KARMA handles consequences:

Security Properties

Relationship to ANNEX

JHILKE and ANNEX are deliberately separate modules with clean separation of concerns:

What JHILKE Is NOT