What is GenLayer?

GenLayer is an AI-native blockchain. Its smart contracts — Intelligent Contracts, written in Python — can natively call LLMs and read the live web from inside contract execution. Because that output is non-deterministic, GenLayer settles it with Optimistic Democracy consensus: a randomly chosen leader proposes a result, independent validators re-run the same logic, and the value commits only when validators agree on its meaning — not on exact bytes. The result is AI reasoning that is trustless and verifiable on-chain, with no centralized oracle and no single model deciding the outcome.

How GenLayer Contributes & the Problems It Solves

FHE makes the eligibility decision private and correct, but a raw boolean isn't enough for real users. GenLayer adds the reasoning layer FHE cannot — and does it without ever weakening the privacy guarantee. Each row below is a concrete gap the advisor closes.

Advisor Capabilities

Consensus & Equivalence

Every write method follows the same pattern — a leader proposes, validators independently evaluate, and only equivalent results settle. Because LLM and web output are non-deterministic, validators agree on meaning, not exact bytes.

leader_fn()
  → calls gl.nondet.exec_prompt() / gl.nondet.web.render()
  → parses + validates JSON defensively (prefix: LLM_ERROR / EXPECTED)
  → returns structured calldata

validator_fn(leaders_res)
  → re-runs leader_fn() independently
  → checks leaders_res is gl.vm.Return
  → compares on the DECIDED field (status / verdict / boolean)
  → True  ⇒ accept
  → False ⇒ reject

gl.vm.run_nondet_unsafe(leader_fn, validator_fn)
  → only an accepted result is written to contract storage

Privacy Boundary

The advisor is strictly additive and isolated. It never receives raw or encrypted patient medical data — only anonymized, de-identified inputs.

Advisor Contract API

GenVM dispatch uses snake_case methods with kwargs. Names mirror the deployed schema in config/genLayerContracts.ts.

Stored data structures

View methods return these dataclasses from contract storage. List-valued fields are stored as JSON strings — decode them client-side with parseCriteria().

@dataclass
class ValidationResult:        # get_validation(trial_id)
    valid: bool                #   true only if coherent AND real ICD-10 code
    reason: str                #   required when valid=false
    suggestions: str           #   JSON-encoded list[str]

@dataclass
class Recommendation:          # get_recommendations(profile_hash)
    trial_ids: str             #   JSON-encoded list[int], 1-3 picks
    reasoning: str

@dataclass
class EligibilityCheck:        # get_eligibility_check(check_id)
    trial_registry_url: str
    anonymized_summary: str    #   20-2000 chars, PII-screened
    result: str                #   'ELIGIBLE' | 'NOT_ELIGIBLE' | 'UNCLEAR'
    reasoning: str
    matched_criteria: str      #   JSON-encoded list[str]
    failed_criteria: str       #   JSON-encoded list[str]

# Storage layout (on-chain TreeMaps):
#   explanations:       u32 trial_id -> (str patient_address -> str)
#   recommendations:    str profile_hash -> Recommendation
#   validations:        u32 trial_id -> ValidationResult
#   eligibility_checks: str check_id -> EligibilityCheck

On-chain web sources

Web reads run inside the leader via gl.nondet.web.render(url, mode="text") and are length-bounded so the prompt stays deterministic across validators.

import { generateExplanation } from '@/lib/genLayerClient';

await generateExplanation({
  trialId: 1,
  patientAddress: '0x...',
  isEligible: true,           // computed under FHE by AegisCare.sol
  trialName: 'Diabetes Treatment Study 2025',
  minAge: 18, maxAge: 65,
  conditionCode: 'E11',
  minBmi: '18.5', maxBmi: '35',
});

import { getEligibilityCheck, parseCriteria } from '@/lib/genLayerClient';

const check = await getEligibilityCheck('check-001');
// check.result  -> 'ELIGIBLE' | 'NOT_ELIGIBLE' | 'UNCLEAR'
// parseCriteria(check.matched_criteria) -> string[]
// parseCriteria(check.failed_criteria)  -> string[]

FHE Client API

Client-side encryption utilities in lib/fheClient.ts

import { encryptPatientData } from '@/lib/fheClient';

const encryptedData = await encryptPatientData({
  age: 45,
  gender: 1,  // 1=male, 2=female, 3=other
  bmiScore: 28.5,
  hasMedicalCondition: true,
  conditionCode: "E11"  // ICD-10 code
});

// Returns:
// {
//   age: { handle: "0x...", ... },
//   ageProof: "0x...",
//   gender: { handle: "0x...", ... },
//   genderProof: "0x...",
//   ...
// }

import { encryptTrialCriteria } from '@/lib/fheClient';

const encryptedCriteria = await encryptTrialCriteria({
  trialName: "Diabetes Study 2025",
  description: "Testing new treatment",
  minAge: 18,
  maxAge: 65,
  requiredGender: 0,
  minBMIScore: 18.5,
  maxBMIScore: 35,
  hasSpecificCondition: true,
  conditionCode: "E11"
});

import { decryptEligibilityResult } from '@/lib/fheClient';

const isEligible = await decryptEligibilityResult(
  encryptedResult,
  contractAddress,
  signer
);

console.log(isEligible); // true or false

Web3 Client API

Blockchain interaction utilities in lib/web3Client.ts

import { registerPatient } from '@/lib/web3Client';

await registerPatient(signer, encryptedData, publicKeyHash);

import { registerTrial } from '@/lib/web3Client';

await registerTrial(
  signer,
  trialName,
  description,
  encryptedCriteria
);

import { computeEligibility } from '@/lib/web3Client';

await computeEligibility(signer, trialId, patientAddress);