Unirep protocol package

Client library for protocol related functions which are used in UniRep protocol.

💡 About Unirep

UniRep is a private and non-repudiable data system. Users can receive attestations from attesters, and voluntarily prove facts about their data without revealing the data itself. Moreover, users cannot refuse to receive attestations from an attester.

📘 Documentation

Read the medium article to know more about the concept of Unirep protocol. For more information, refer to the documentation

🛠 Install

npm or yarn

Install the @unirep/core package with npm:

npm i @unirep/core

or yarn:

yarn add @unirep/core

📔 Usage

Check current deployment: 🤝 Testnet Deployment

Synchronizer ⏲

Construct a synchronizer

import { Synchronizer } from '@unirep/core'

const address = '0x....'
const provider = 'YOUR/ETH/PROVIDER'

// 1. initialize a synchronizer
const synchronizer = new Synchronizer({
    unirepAddress: address,
    provider: provider,
})
// 2. start listening to unriep contract events
await synchronizer.start()
// 3. wait until the latest block is processed
await synchronizer.waitForSync()
// 4. stop the synchronizer deamon
synchronizer.stop()

Example: use the synchronizer to generate unirep state

const epoch = 0
const attesterId = 'ATTESTER/ADDRESS' // the msg.sender signs up through `attesterSignUp()`
// e.g.
// const attester = new ethers.Wallet(key, provider)
// const epochLength = 300
// const tx = await unirepContract.connect(attester).attesterSignUp(epochLength)
// await tx.wait()
const stateTree = await synchronizer.genStateTree(epoch, attesterId)

UserState 👤

Construct a user state

import { Identity } from '@semaphore-protocol/identity'
import { UserState } from '@unirep/core'
import { defaultProver } from '@unirep/circuits/provers/defaultProver'

// random generate a user identity
const identity = new Identity()
const provider = 'YOUR/ETH/PROVIDER'
const attesterId = 'ATTESTER/ADDRESS' // the msg.sender signs up through `attesterSignUp()`

// 1. initialize a user state object
const userState = new UserState({
    unirepAddress: address,
    provider: provider,
    prover: defaultProver,
    id: identity,
    attesterId: attesterId,
})
// or through a synchronicr
// const userState = new UserState({synchronizer, id: identity})
// 2. start listening to unriep contract events
await userState.start()
// 3. wait until the latest block is processed
await userState.waitForSync()
// 4. stop the synchronizer deamon
userState.stop()

Schema 📁

Generate a database with the schema

import { schema } from '@unirep/core'
import { SQLiteConnector } from 'anondb/node'
import { IndexedDBConnector } from 'anondb/web'

// in nodejs
const db_mem = await SQLiteConnector.create(schema, ':memory:')
const db_storage = await SQLiteConnector.create(schema, 'db.sqlite')
// in browser
const db_browser = await IndexedDBConnector.create(schema)

Use the database in a synchronizer

const synchronizer = new Synchronizer({
    unirepAddress: address,
    provider: provider,
    db: db_storage
})

Example: use the user state to generate proofs

// 1. generate a signup proof of the user
const { publicSignals, proof } = await userState.genUserSignUpProof({ attesterId: attester.address })

// 2. submit the signup proof through the attester
const tx = await unirepContract
    .connect(attester)
    .userSignUp(publicSignals, proof)
await tx.wait()

🙌🏻 Join our community

• Discord server:
• Twitter account:
• Telegram group:

Privacy & Scaling Explorations

This project is supported by Privacy & Scaling Explorations and the Ethereum Foundation. See more projects on: https://pse.dev/.