Lero Network
Documentation

An enhanced TLS protocol that introduces MPC nodes into the standard handshake process. This enables secure data verification without API access or data source authorization.

Randomly selected task nodes supervise the 3-party handshake, obtaining a portion of the MAC key to ensure data integrity while maintaining complete user privacy.

• - No single node can access complete data
• - Byzantine fault tolerant (2/3 honest majority)
• - Cryptographic commitment to data authenticity

Users generate ZKPs locally using TLS response data and MPC attestations. Proofs can be stored on-chain as zkSBTs or shared privately.

constructor(config)

Initialize a new Lero client instance.

const client = new LeroClient({
  appId: string,           // Your application ID
  environment: 'production' | 'testnet',
  network: 'ethereum' | 'polygon' | 'arbitrum',
  onExtensionMissing?: () => void  // Callback when extension not found
})

generateProof(options)

Request the user to generate a proof for a specific claim.

const proof = await client.generateProof({
  schemaId: string,        // Schema identifier
  claim: {
    type: 'eq' | 'gt' | 'lt' | 'range' | 'membership',
    value: number | string | [number, number] | string[]
  },
  options?: {
    timeout?: number,      // Request timeout in ms
    silent?: boolean       // Skip user confirmation
  }
})

// Returns: LeroProof object

mintZkSBT(proof)

Mint a zkSBT representing the verified proof.

const txHash = await client.mintZkSBT(proof, {
  recipient?: address,     // Default: connected wallet
  metadata?: {
    name?: string,
    description?: string
  }
})

// Returns: Transaction hash

verifyProof(proof)

Verify a proof's validity client-side.

const isValid = await client.verifyProof(proof)

// Returns: boolean

constructor(config)

Initialize the server SDK with your API key.

import { LeroServer } from '@lero/sdk/server'

const server = new LeroServer({
  apiKey: process.env.LERO_API_KEY,
  environment: 'production'
})

verifyProof(proofData)

Verify a proof server-side with full validation.

const result = await server.verifyProof(proofData)

// Returns:
{
  isValid: boolean,
  schemaId: string,
  claim: object,
  timestamp: number,
  mpcNodeCount: number
}

getZkSBT(address, schemaId)

Check if an address holds a zkSBT for a specific schema.

const sbt = await server.getZkSBT(
  '0x1234...', 
  'twitter-follower-count'
)

// Returns: zkSBT data or null

Do data sources need to integrate with Lero?

No. Lero works with any HTTPS data source without requiring API access or server-side changes. Verification happens through the standard TLS connection.

Can MPC nodes see my data?

No. MPC nodes participate in key generation but never have access to decrypted data. They verify authenticity through distributed MAC computation only.

How long does proof generation take?

Typical proof generation takes 5-15 seconds depending on the schema complexity and network conditions. The user sees a simple verification flow in their browser.

What chains are supported?

Currently Ethereum, Polygon, and Arbitrum. Additional chains are being added based on community demand.

What happens if a data source changes their website?

Schemas may need updates when data source structure changes. The schema registry maintains versioning, and affected schemas are flagged for review.