open-index/open-npm huggingface dataset:
npm package: @iopn-zk/zk-proof-authentication-sdk
Description: SDK for zero-knowledge proof authentication - deterministic identity generation, group management, and ZK proof generation
Latest version: 1.0.0

# @iopn-zk/zk-proof-authentication-sdk

SDK for zero-knowledge proof authentication - deterministic identity generation, group management, and ZK proof generation.

## Features

- **Deterministic Identity Generation**: Generate consistent Semaphore identities from OAuth user identifiers
- **Group Management**: Manage Semaphore groups with member commitments
- **ZK Proof Generation**: Generate zero-knowledge proofs with trusted setup support
- **Wallet Integration**: Generate deterministic Ethereum wallets linked to identities

## Installation

```bash
npm install @iopn-zk/zk-proof-authentication-sdk
```

## Usage

### Generate Deterministic Identity

```javascript
import { generateDeterministicIdentity } from '@iopn-zk/zk-proof-authentication-sdk';

const { identity, commitment, privateKey } = generateDeterministicIdentity(
  auth0Sub,      // OAuth user sub
  appSecret,     // Application secret
  userEmail      // Optional user email
);
```

### Retrieve Identity

```javascript
import { retrieveIdentity } from '@iopn-zk/zk-proof-authentication-sdk';

const { identity, commitment } = retrieveIdentity(
  auth0Sub,
  appSecret,
  userEmail
);
```

### Generate ZK Proof

```javascript
import { generateProofWithSetup, Group } from '@iopn-zk/zk-proof-authentication-sdk';

const group = new Group(groupId, treeDepth, members.map(BigInt));
const proof = await generateProofWithSetup(
  identity,
  group,
  BigInt(signal),
  BigInt(externalNullifier),
  {
    wasmPath: './semaphore.wasm',
    zkeyPath: './semaphore.zkey'
  }
);
```

### Generate Deterministic Wallet

```javascript
import { generateDeterministicWallet } from '@iopn-zk/zk-proof-authentication-sdk';

const { walletAddress, privateKey, wallet } = generateDeterministicWallet(
  auth0Sub,
  appSecret
);
```

## API Reference

### Identity Functions

- `generateDeterministicIdentity(auth0Sub, appSecret, userEmail?, options?)` - Generate deterministic Semaphore identity
- `retrieveIdentity(auth0Sub, appSecret, userEmail?, options?)` - Retrieve existing identity
- `generateDeterministicWallet(auth0Sub, salt, infoLabel?)` - Generate deterministic Ethereum wallet
- `generateDeterministicIdentityWithWallet(auth0Sub, appSecret, userEmail?, options?)` - Generate both identity and wallet
- `verifyIdentityCommitment(auth0Sub, appSecret, expectedCommitment, userEmail?, options?)` - Verify identity commitment

### Proof Functions

- `generateProofWithSetup(identity, group, signal, externalNullifier, options)` - Generate ZK proof with trusted setup

### Group Management

- `GroupManager` - Framework-agnostic group management class
- `FileStorageAdapter` - File-based storage adapter for groups

## Requirements

- Node.js >= 18.0.0
- Trusted setup files (WASM and zkey) for proof generation

## License

MIT
npm package: @ioproof/client
Description: HTTP client for the IOProof API — proxy AI calls with cryptographic attestation and dual-secret verification
Author: Alexiuz AS
Latest version: 0.2.0

# @ioproof/client

HTTP client for the IOProof API — proxy AI calls with cryptographic attestation and dual-secret verification.

## Status

SDK is under active development. For now, use the REST API directly.

## Planned API

```js
const { IOProofClient } = require('@ioproof/client');

const client = new IOProofClient({
  apiKey: 'iop_live_...',
  baseUrl: 'https://ioproof.com', // or your self-hosted instance
});

// Proxy a request through IOProof
const result = await client.proxy('openai', '/v1/chat/completions', {
  providerKey: 'sk-...',
  body: { model: 'gpt-4o', messages: [{ role: 'user', content: 'Hello' }] },
});

console.log(result.provider_response);          // Original AI response
console.log(result.verification.secret);        // Owner secret (keep server-side)
console.log(result.verification.user_secret);   // User secret (give to end-user)
console.log(result.verification.user_verify_url); // Verification link for end-user
```

## Dual-secret verification

Every proof generates two independent secrets. The service keeps `secret` and gives `user_secret` to the end-user. Both can verify the full interaction independently — ideal for dispute resolution and regulatory compliance.

## Related packages

- [`ioproof`](https://www.npmjs.com/package/ioproof) — Main package
- [`@ioproof/core`](https://www.npmjs.com/package/@ioproof/core) — Hash verification and Merkle proof utilities

## License

MIT — [Alexiuz AS](https://alexiuz.com)
npm package: @ioproof/core
Description: Core verification utilities for IOProof — SHA-256 hashing, Merkle proof validation, and blinded commitment verification
Author: Alexiuz AS
Latest version: 0.2.0

# @ioproof/core

Core verification utilities for IOProof — SHA-256 hashing, Merkle proof validation, and blinded commitment verification.

## Status

SDK is under active development. For verification today, use the [standalone verifier](https://ioproof.com/standalone-verifier).

## Planned API

```js
const { verifyProof, hashPayload, walkMerkleProof } = require('@ioproof/core');

// Verify an exported proof bundle (works with both owner and user secrets)
const result = await verifyProof(proofBundle);
// { valid: true, steps: [...], onChainRoot: '...', merkleValid: true, accessType: 'owner' | 'user' }
```

## Dual-secret support

IOProof generates two independent secrets per proof — one for the service owner, one for the end-user. Both unlock the same proof. `@ioproof/core` will support verifying with either secret.

## Related packages

- [`ioproof`](https://www.npmjs.com/package/ioproof) — Main package
- [`@ioproof/client`](https://www.npmjs.com/package/@ioproof/client) — HTTP client for the IOProof API

## License

MIT — [Alexiuz AS](https://alexiuz.com)
npm package: @iorder/iorder-query-builder
Description: A query builder to be used with mysql or postgres
Author: Julio Sousa
Latest version: 1.0.1

# iorder-query-builder

# Como criar o link local pelo pnpm

- Cria um link simbólico para o pacote local no diretório node_modules global.
  $ pnpm link global

- Cria um link simbólico para o pacote global especificado no diretório node_modules global.
  $ pnpm link --global <nome-do-pacote>

- Cria um link simbólico para o pacote no diretório especificado no diretório node_modules do projeto atual.
  $ pnpm install ../iorder-query-builder
npm package: @iore8655/react-bus
Description: @iore8655/react-bus is a global/local state management by pub/sub
Author: sanggeun-choi
Latest version: 0.2.7

# @iore8655/react-bus
- @iore8655/react-bus is a global/local state management by pub/sub
- render only subscribers


### Install
```shell
npm install @iore8655/react-bus
```
```shell
yarn add @iore8655/react-bus
```

### Basic Example
```javascript
import React from 'react';
import {
    createEventBus,
    createStateBus,
    useEventBusSelector,
    useStateBusSelector,
} from '@iore8655/react-bus';

const stateBus = createStateBus({
    name: 'john',
    number: 0,
});

const eventBus = createEventBus();

const DisplayAll = () => {
    const { name, number } = useStateBusSelector(stateBus);

    return (
        <React.Fragment>
            <div>name : {name}</div>
            <div>number : {number}</div>
        </React.Fragment>
    );
};

const DisplayName = () => {
    const name = useStateBusSelector(stateBus, (state) => state.name);

    useEventBusSelector(eventBus, (message) => {
        console.log(message);
    });

    return (
        <React.Fragment>
            <div>name : {name}</div>
        </React.Fragment>
    );
};

const DisplayNumber = () => {
    const number = useStateBusSelector(stateBus, (state) => state.number);

    useEventBusSelector(eventBus, (message) => {
        console.log(message);
    });

    return (
        <React.Fragment>
            <div>number : {number}</div>
        </React.Fragment>
    );
};

const Controller = () => {
    return (
        <div>
            <button onClick={() => stateBus.dispatch((state) => (state.number += 1))}>
                increase
            </button>
            <button onClick={() => stateBus.dispatch({ number: stateBus.getState().number - 1 })}>
                decrease
            </button>
            <button onClick={() => console.log(stateBus.getState())}>getState()</button>
            <button onClick={() => stateBus.reset()}>reset</button>
            <button onClick={() => stateBus.restore({ name: 'tom', number: 1 })}>restore</button>
            <button onClick={() => eventBus.dispatch('Hello World')}>event</button>
        </div>
    );
};

const App = () => {
    return (
        <React.Fragment>
            <DisplayAll />
            <DisplayName />
            <DisplayNumber />
            <Controller />
        </React.Fragment>
    );
};

export default App;
```
npm package: @ioredis/as-callback
Description: A performant and standard (Bluebird) library that registers a node-style callback on a promise
Author: Zihua Li
Latest version: 3.0.0

# Standard asCallback
A performant and standard (Bluebird) library that registers a node-style callback on a promise. It's used by [ioredis](https://github.com/luin/ioredis).

[![Build Status](https://github.com/ioredis/as-callback/workflows/Test/badge.svg)](https://github.com/ioredis/as-callback/actions?query=workflow%3ATest+branch%3Amaster) [![npm latest version](https://img.shields.io/npm/v/@ioredis/as-callback/latest.svg)](https://www.npmjs.com/package/@ioredis/as-callback)


## Install

```
$ npm install @ioredis/as-callback
```

## Usage

```javascript
const asCallback = require('@ioredis/as-callback').defaults;

const promise = new Promise(function (resolve) {
  setTimeout(function () {
    resolve('hello world!')
  }, 1000)
})

asCallback(promise, function callback (err, res) {
  console.log(err, res) // null, 'hello world!'
})
```

## Motivation
There are many libraries serve similar functionality. However, none of them I'd found are exactly the same as Bluebird's `asCallback` function (in terms of either performance or functionality). Thus this library comes out.

## Thanks

Most code of this library are ported from the awesome Bluebird library.

## License
The MIT License.
npm package: @ioredis/commands
Description: Redis commands
Author: Zihua Li
Latest version: 1.6.0

# Redis Commands

This module exports all the commands that Redis supports.

## Install

```shell
$ npm install @ioredis/commands
```

## Usage

```js
const commands = require('@ioredis/commands');
```

`.list` is an array contains all the lowercased commands:

```js
commands.list.forEach((command) => {
  console.log(command);
});
```

`.exists()` is used to check if the command exists:

```js
commands.exists('set') // true
commands.exists('other-command') // false
```

`.hasFlag()` is used to check if the command has the flag:

```js
commands.hasFlag('set', 'readonly') // false
```

`.getKeyIndexes()` is used to get the indexes of keys in the command arguments:

```js
commands.getKeyIndexes('set', ['key', 'value']) // [0]
commands.getKeyIndexes('mget', ['key1', 'key2']) // [0, 1]
```