open-index/open-npm huggingface dataset:
npm package: @knowmax/genericlist-fluentuiv8
Description: Knowmax Generic list with basic CRUD support with Fluent V8 user interface implementation.
Author: Knowmax BV
Latest version: 1.1.0

# Knowmax Generic list with basic CRUD support
Implementation for Knowmax Generic list with basic CRUD support with React Fluent V8 user interface.

Strongly opinionated, but flexible enough to be used in a variety of scenarios.
npm package: @knowmax/http-utils
Description: HTTP utilities for headers, content types, and common HTTP operations
Author: Knowmax BV
Latest version: 1.0.0

# HTTP Utils

A TypeScript library providing utilities for HTTP operations including headers and content types.

## Installation

```bash
npm install @knowmax/http-utils
```

## Features

- 🔧 **Headers Builder**: Fluent API for building HTTP headers
- 📝 **Content Types**: Constants for common MIME types

## Usage

### Headers Builder

```typescript
import { headers } from '@knowmax/http-utils'

// Basic usage
const basicHeaders = headers()
  .withContentTypeJson()
  .withBearer('your-token')
  .export()

// Advanced usage
const advancedHeaders = headers({ 'X-Custom': 'value' })
  .withBearer('token123')
  .withLanguage('en-US')
  .withContentType('text/plain')
  .withHeader('X-API-Key', 'secret')
  .export()
```

### Content Types

```typescript
import { CONTENTTYPE_JSON } from '@knowmax/http-utils'

// Use in your requests
headers().withContentType(CONTENTTYPE_JSON)
```

## API Reference

### Headers Class

| Method | Description |
|--------|-------------|
| `withBearer(token)` | Add Bearer authorization |
| `withLanguage(language)` | Set Accept-Language (optional parameter) |
| `withContentTypeJson()` | Set Content-Type to application/json |
| `withContentType(contentType)` | Set custom Content-Type |
| `withHeader(key, value)` | Add custom header (ignores empty values) |
| `export()` | Get plain object with all headers |

### Content Types

| Constant | Value |
|----------|-------|
| `CONTENTTYPE_JSON` | `'application/json'` |

## Requirements

- Node.js 16.0.0 or higher
- TypeScript 4.0+ (for TypeScript projects)

## Contributing

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Support

- 📖 [Documentation](https://github.com/KnowmaxNL/http-utils#readme)
- 🐛 [Report Issues](https://github.com/KnowmaxNL/http-utils/issues)
- 💬 [Discussions](https://github.com/KnowmaxNL/http-utils/discussions)

---

Made with ❤️ by [Knowmax BV](https://github.com/KnowmaxNL)
npm package: @knowmax/react-issomediabank-core
Description: Core components for working with ISSO Mediabank powered by Knowmax Quest
Author: Knowmax BV
Latest version: 0.0.5

# Knowmax React ISSO Mediabank

React components for supporting use of ISSO Mediabank powered by Knowmax Quest.

## License

This repository is [licensed MIT](LICENSE), which waives all copyright restrictions.
npm package: @knowmax/react-issomediabank-fluentui
Description: React user interface components for ISSO Mediabank powered by Knowmax Quest based on Microsoft FluentUI V9
Author: Knowmax BV
Latest version: 2.3.0

# Knowmax React ISSO Mediabank

React components for supporting use of ISSO Mediabank powered by Knowmax Quest.

## License

This repository is [licensed MIT](LICENSE), which waives all copyright restrictions.

## Remark
We use MobX with classed for our data stor. Make sure transpilation for class properties is available. 

* Using tscongig.json ```compilerOptions:useDefineForClassFields: true```
* Using Babel ```@babel/plugin-transform-class-properties```
npm package: @knowmax/react-list-fluentui
Description: Knowmax Generic list with basic CRUD support and user interface components using @fluentui/react.
Author: Knowmax BV
Latest version: 1.0.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# Knowmax Generic list with basic CRUD support
Knowmax Generic list with basic CRUD support and user interface components using @fluentui/react v8 components.

Strongly opinionated, but flexible enough to be used in a variety of scenarios.
npm package: @knowme_koka/vue3-component-library
Description: A Vue 3 component library with Tailwind CSS styling
Author: Pavan Koka
Latest version: 1.1.0

# Vue 3 Component Library

A modern component library built with Vue 3 and Tailwind CSS.

## Installation

```bash
npm install vue3-component-library
```

## Components

### Button

A versatile button component with multiple variants and features.

#### Props

| Prop      | Type    | Default   | Description                                                                                         |
| --------- | ------- | --------- | --------------------------------------------------------------------------------------------------- |
| variant   | String  | 'primary' | Button style variant. Options: 'primary', 'secondary', 'dark', 'light', 'info', 'danger', 'warning' |
| disabled  | Boolean | false     | Whether the button is disabled                                                                      |
| fullWidth | Boolean | false     | Whether the button should take full width of its container                                          |

#### Events

| Event | Description                        |
| ----- | ---------------------------------- |
| click | Emitted when the button is clicked |

#### Slots

| Slot    | Description                                    |
| ------- | ---------------------------------------------- |
| default | Button content                                 |
| icon    | Icon content (appears before the main content) |

#### Usage

```vue
<template>
    <!-- Basic usage -->
    <CustomButton>Click me</CustomButton>

    <!-- With variant -->
    <CustomButton variant="danger">Delete</CustomButton>

    <!-- With icon -->
    <CustomButton variant="primary">
        <template #icon>🔔</template>
        Notifications
    </CustomButton>

    <!-- Full width -->
    <CustomButton fullWidth>Full Width Button</CustomButton>

    <!-- Disabled -->
    <CustomButton disabled>Disabled Button</CustomButton>
</template>

<script>
import { CustomButton } from "vue3-component-library";

export default {
    components: {
        CustomButton,
    },
};
</script>
```

## Development

```bash
# Install dependencies
npm install

# Start Storybook
npm run storybook

# Build library
npm run build
```

## License

MIT
npm package: @knowmetools/react-components
Description: React components for Know Me.
Author: Chathan Driehuys
Latest version: 0.1.0

# @knowmetools/react-components

[![Build Status](https://travis-ci.org/knowmetools/react-components.svg?branch=master)](https://travis-ci.org/knowmetools/react-components)

A collection of React components for Know Me.

## Installation

The package should be installed using either NPM or Yarn.

```bash
npm install --save @knowmetools/react-components
```

or

```bash
yarn add @knowmetools/react-components
```
npm package: @knowmint/agentkit-plugin
Description: Coinbase AgentKit ActionProvider for KnowMint — lets AgentKit agents discover and purchase human tacit knowledge
Latest version: 0.1.0

# @knowledge-market/agentkit-plugin

Coinbase AgentKit ActionProvider for [KnowMint](https://knowmint.shop) — lets AgentKit agents discover and purchase human tacit knowledge on-chain.

## Install

```bash
npm install @knowledge-market/agentkit-plugin
```

## Quick Start

```typescript
import { AgentKit } from "@coinbase/agentkit";
import { knowmintProvider } from "@knowledge-market/agentkit-plugin";

const agentkit = new AgentKit({
  actionProviders: [
    knowmintProvider({
      apiKey: "km_...", // Get from https://knowmint.shop/settings/api-keys
    }),
  ],
});
```

## Actions

| Action | Description |
|--------|-------------|
| `km_search` | Search knowledge items by query, content type, metadata, and sort order |
| `km_get_detail` | Get details and preview content for a knowledge item |
| `km_purchase` | Record a purchase after sending payment on-chain |
| `km_get_content` | Retrieve full content (returns payment instructions if unpaid) |
| `km_publish` | Create and publish a new knowledge item |

## Autonomous Purchase Flow

```
1. km_search("solana defi")           → item list
2. km_get_detail("item-id")           → details + price (0.01 SOL) + seller_wallet
3. km_get_content("item-id")          → 402: payment_required with payTo address
4. native_transfer(payTo, "0.01")     → tx_hash  (AgentKit built-in action)
5. km_purchase("item-id", tx_hash)    → purchase recorded
6. km_get_content("item-id")          → full content
```

## Configuration

```typescript
knowmintProvider({
  apiKey: "km_<64 hex chars>",       // Required
  baseUrl: "https://knowmint.shop",  // Optional (default)
});
```

## Network Support

This provider supports **Solana** (`protocolFamily: "svm"`) only. EVM chains are not yet supported.

## Requirements

- `@coinbase/agentkit` >= 0.1.0
- `zod` ^3.22.0
- TypeScript with `experimentalDecorators` and `emitDecoratorMetadata` enabled

## License

MIT
npm package: @knowmint/eliza-plugin
Description: ElizaOS plugin for KnowMint — lets AI agents discover and purchase human tacit knowledge
Latest version: 0.1.0

# @knowledge-market/eliza-plugin

ElizaOS plugin for [KnowMint](https://knowmint.shop) — lets AI agents discover and purchase human tacit knowledge from the marketplace.

## Installation

```bash
npm install @knowledge-market/eliza-plugin
```

## Configuration

Add KnowMint settings to your agent's character file:

```json
{
  "name": "my-agent",
  "settings": {
    "secrets": {
      "KM_API_KEY": "km_your64hexchars..."
    },
    "KM_BASE_URL": "https://knowmint.shop"
  },
  "plugins": ["@knowledge-market/eliza-plugin"]
}
```

| Setting | Required | Description |
|---------|----------|-------------|
| `KM_API_KEY` | Yes | API key from KnowMint (format: `km_<64 hex chars>`) |
| `KM_BASE_URL` | No | API base URL (default: `https://knowmint.shop`) |

### Getting an API Key

1. Create an account at [knowmint.shop](https://knowmint.shop)
2. Navigate to Settings > API Keys
3. Generate a new key and copy it

## Actions

| Action | Description | Required Params |
|--------|-------------|-----------------|
| `SEARCH_KNOWLEDGE` | Search knowledge items by query | Query in message text |
| `PURCHASE_KNOWLEDGE` | Record a purchase after on-chain payment | `knowledge_id`, `tx_hash` |
| `GET_CONTENT` | Retrieve full content of a purchased item | `knowledge_id` |

### SEARCH_KNOWLEDGE

Searches the KnowMint marketplace. The search query is extracted from the message text.

Optional parameters (via options or message content):
- `content_type`: `prompt` | `tool_def` | `dataset` | `api` | `general`
- `sort_by`: `newest` | `popular` | `price_low` | `price_high` | `rating` | `trust_score`
- `max_results`: 1-50 (default: 20)

### PURCHASE_KNOWLEDGE

Records a purchase after the on-chain payment has been sent. The actual payment should be made using a wallet plugin (e.g., `@elizaos/plugin-solana`).

Required parameters:
- `knowledge_id`: The item ID to purchase
- `tx_hash`: On-chain transaction hash

Optional parameters:
- `token`: `SOL` | `USDC` (default: `SOL`)
- `chain`: Blockchain network (default: `solana`)

### GET_CONTENT

Retrieves the full content of a knowledge item. Supports the x402 autonomous payment flow.

Required parameters:
- `knowledge_id`: The item ID

Optional parameters:
- `payment_proof`: Base64-encoded X-PAYMENT proof for x402 flow

## Provider

| Provider | Description |
|----------|-------------|
| `trending-knowledge` | Injects top 5 trending knowledge items into agent context (5-min cache) |

The trending provider runs automatically and adds marketplace context to the agent's awareness, enabling proactive knowledge discovery.

## x402 Autonomous Purchase Flow

1. Agent calls `GET_CONTENT` for an item it hasn't purchased
2. API returns HTTP 402 with payment requirements
3. Agent sends on-chain payment (via `@elizaos/plugin-solana` or similar)
4. Agent calls `GET_CONTENT` again with `payment_proof` (base64-encoded `{scheme, network, payload: {txHash, asset?}}`)
5. API validates payment and returns full content

## License

MIT
npm package: @known-as-bmf/store-middleware-persist
Description: Persistence middleware for @known-as-bmf/store.
Author: Julien Avert
Latest version: 3.2.6

# @known-as-bmf/store-middleware-persist

<!-- [![Build Status](https://travis-ci.org/known-as-bmf/store-middleware-persist.svg?branch=master)](https://travis-ci.org/known-as-bmf/store-middleware-persist)
[![Known Vulnerabilities](https://snyk.io/test/github/known-as-bmf/store-middleware-persist/badge.svg?targetFile=package.json)](https://snyk.io/test/github/known-as-bmf/store-middleware-persist?targetFile=package.json) -->

## Installation

`npm install --save @known-as-bmf/store @known-as-bmf/store-middleware-persist`

## Description

Middleware to be used with [`@known-as-bmf/store`](https://github.com/known-as-bmf/store/tree/master/packages/store). Allows you to persist state to the browser storage.

## Usage

Pass the middleware to `of`:

```ts
import { of } from '@known-as-bmf/store';
import { persistMiddleware } from '@known-as-bmf/store-middleware-persist';

const store = of(
  {
    preferences: { theme: 'dark', lang: 'fr' },
    lastOnline: '2020-02-21T18:22:33.343Z',
    someArray: [],
  },
  persistMiddleware({ storage: localStorage, key: 'uniqueKey' })
);
```

The state will now be persisted and reloaded on page refresh (depending on the storage method you picked).

## API

### persistMiddleware

```ts
const persistMiddleware = <S>(options?: PersistOptions): Middleware<S>;
```

```ts
interface PersistOptions {
  /**
   * Which `Storage` instance to use for persistence.
   */
  storage?: Storage;
  /**
   * The cache key. Usually a unique key.
   */
  key: string;
}
```
npm package: @known-as-bmf/store-middleware-timetravel
Description: History / timetravel middleware for @known-as-bmf/store.
Author: Julien Avert
Latest version: 3.0.7

# @known-as-bmf/store-middleware-timetravel

<!-- [![Build Status](https://travis-ci.org/known-as-bmf/store-middleware-timetravel.svg?branch=master)](https://travis-ci.org/known-as-bmf/store-middleware-timetravel)
[![Known Vulnerabilities](https://snyk.io/test/github/known-as-bmf/store-middleware-timetravel/badge.svg?targetFile=package.json)](https://snyk.io/test/github/known-as-bmf/store-middleware-timetravel?targetFile=package.json) -->

## Installation

`npm install --save @known-as-bmf/store @known-as-bmf/store-middleware-timetravel`

## Description

Middleware to be used with [`@known-as-bmf/store`](https://github.com/known-as-bmf/store/tree/master/packages/store). Allows you to navigate state history.

## Usage

Pass the middleware to `of`:

```ts
import { of } from '@known-as-bmf/store';
import { timetravelMiddleware } from '@known-as-bmf/store-middleware-timetravel';

const store = of(
  {
    preferences: { theme: 'dark', lang: 'fr' },
    lastOnline: '2020-02-21T18:22:33.343Z',
    someArray: [],
  },
  timetravelMiddleware({ depth: 5 })
);
```

You can then call `undo`, `redo` and `derefHistory` on the store.

## API

### timetravelMiddleware

```ts
const timetravelMiddleware = <S>(options?: TimetravelOptions): Middleware<S>;
```

```ts
interface TimetravelOptions {
  /**
   * The depth of the history.
   * Must be a positive number greater or equal to 1.
   * @default 1
   */
  depth?: number;
}
```

### derefHistory

```ts
/**
 * Returns the current state of a store and the available history (past and future).
 * @param store The store you want to get the current state from.
 * @throws {TypeError} if the store is not a correct `Store` instance or if you didn't pass the timetravel middleware during store construction.
 */
function derefHistory<S>(
  store: Store<S>
): { future: S[]; past: S[]; current: S };
```

### undo

```ts
/**
 * Navigates back in the store history.
 * @param store The store of which you want to change the state.
 * @param steps The number of steps you want to take backwards. Default to 1.
 * @throws {TypeError} if the store is not a correct `Store` instance.
 * @throws {Error} if `steps` is less than 0.
 * @throws {Error} if you try to navigate out of bounds of the history.
 */
function undo<S>(store: Store<S>, steps?: number): void;
```

### redo

```ts
/**
 * Navigates forward in the store history.
 * @param store The store of which you want to change the state.
 * @param steps The number of steps you want to take forward. Default to 1.
 * @throws {TypeError} if the store is not a correct `Store` instance.
 * @throws {Error} if `steps` is less than 0.
 * @throws {Error} if you try to navigate out of bounds of the history.
 */
function redo<S>(store: Store<S>, steps?: number): void;
```
npm package: @known-as-bmf/store-middleware-validate
Description: Validation middleware for @known-as-bmf/store.
Author: Julien Avert
Latest version: 4.0.6

# @known-as-bmf/store-middleware-validate

<!-- [![Build Status](https://travis-ci.org/known-as-bmf/store-middleware-validator.svg?branch=master)](https://travis-ci.org/known-as-bmf/store-middleware-validator)
[![Known Vulnerabilities](https://snyk.io/test/github/known-as-bmf/store-middleware-validator/badge.svg?targetFile=package.json)](https://snyk.io/test/github/known-as-bmf/store-middleware-validator?targetFile=package.json) -->

## Installation

`npm install --save @known-as-bmf/store @known-as-bmf/store-middleware-validator`

## Description

Middleware to be used with [`@known-as-bmf/store`](https://github.com/known-as-bmf/store/tree/master/packages/store). Allows you to validate / prevent state updates that don't pass validation.

## Usage

Pass the middleware to `of`:

```ts
import { of } from '@known-as-bmf/store';
import { validatorMiddleware } from '@known-as-bmf/store-middleware-validator';

const store = of(
  {
    preferences: { theme: 'dark', lang: 'fr' },
    lastOnline: '2020-02-21T18:22:33.343Z',
    someArray: [],
  },
  validatorMiddleware([(s) => ['dark', 'light'].includes(s.preferences.theme)])
);
```

If the initial state do not pass validation, the call to `of` will throw an error.

When you update the state with `swap` or `set`, if the new state do not pass validation, the call will also throm an error.

## API

### validatorMiddleware

```ts
/**
 * Create a new validation middleware.
 * @param validators A list of validators that will be checked against every
 * time the state is being changed.
 */
const validatorMiddleware = <S>(validators: Validator<S>[]): Middleware<S>;
```

```ts
type Validator<S> = (state: S) => boolean;
```
npm package: @known-as-bmf/store-obs
Description: Utility to create an Observable emiting when a @known-as-bmf/store instance changes.
Author: Julien Avert
Latest version: 3.0.7

# @known-as-bmf/store-obs

<!-- [![Build Status](https://travis-ci.org/known-as-bmf/store-middleware-validator.svg?branch=master)](https://travis-ci.org/known-as-bmf/store-middleware-validator)
[![Known Vulnerabilities](https://snyk.io/test/github/known-as-bmf/store-middleware-validator/badge.svg?targetFile=package.json)](https://snyk.io/test/github/known-as-bmf/store-middleware-validator?targetFile=package.json) -->

## Installation

`npm install --save rxjs @known-as-bmf/store @known-as-bmf/store-obs`

## Description

Create an observable emiting state changes from [`@known-as-bmf/store`](https://github.com/known-as-bmf/store/tree/master/packages/store).

## API

```ts
/**
 * Creates an observable from the store, emitting every time the store is updated.
 * @param store The store to observe.
 * @throws {TypeError} if the store is not a correct `Store` instance.
 */
function obs<S>(store: Store<S>): Observable<StateChangedEvent<S>>;
```
npm package: @known-as-bmf/tscli
Description: Typescript build & test CLI
Author: Julien Avert
Latest version: 0.1.9

@known-as-bmf/tscli
=====

Typescript build &amp; test CLI

[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![Version](https://img.shields.io/npm/v/@known-as-bmf/tscli.svg)](https://npmjs.org/package/@known-as-bmf/tscli)
[![Downloads/week](https://img.shields.io/npm/dw/@known-as-bmf/tscli.svg)](https://npmjs.org/package/@known-as-bmf/tscli)
[![License](https://img.shields.io/npm/l/@known-as-bmf/tscli.svg)](https://github.com///blob/master/package.json)

<!-- toc -->
* [Usage](#usage)
* [Commands](#commands)
<!-- tocstop -->

# Usage

<!-- usage -->
```sh-session
$ npm install -g @known-as-bmf/tscli
$ tscli COMMAND
running command...
$ tscli (-v|--version|version)
@known-as-bmf/tscli/0.1.0 win32-x64 node-v12.18.3
$ tscli --help [COMMAND]
USAGE
  $ tscli COMMAND
...
```
<!-- usagestop -->

# Commands

<!-- commands -->
* [`tscli build`](#tscli-build)
* [`tscli help [COMMAND]`](#tscli-help-command)
* [`tscli lint`](#tscli-lint)
* [`tscli test`](#tscli-test)
* [`tscli watch`](#tscli-watch)

## `tscli build`

Build your project

```
USAGE
  $ tscli build

OPTIONS
  --entry=entry    The entry point of your code.
  --format=cjs|es  The JS format(s) to output.
  --output=output  Destination folder for the JS output.
```

## `tscli help [COMMAND]`

display help for tscli

```
USAGE
  $ tscli help [COMMAND]

ARGUMENTS
  COMMAND  command to show help for

OPTIONS
  --all  see all commands in CLI
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v3.2.0/src\commands\help.ts)_

## `tscli lint`

Lint your project

```
USAGE
  $ tscli lint

OPTIONS
  --fix  Enable auto-fixing linting issues (eslint auto-fix)
```

## `tscli test`

Run your project's tests

```
USAGE
  $ tscli test
```

## `tscli watch`

Build your project

```
USAGE
  $ tscli watch

OPTIONS
  --entry=entry    The entry point of your code.
  --format=cjs|es  The JS format(s) to output.
  --output=output  Destination folder for the JS output.
```
<!-- commandsstop -->
npm package: @known-as-dan/calculator
Description: A modular text-parsing calculator that enables the creation of custom operators, functions and constants with ease.
Author: known-as-dan
Latest version: 1.0.11

# About
A modular text-parsing calculator that enables the creation of custom operators, functions and constants with ease.

# Usage
Parsing and calculating a simple math statement:
```typescript
import { parse, calculate } from "@known-as-dan/calculator";

const math: string = "1 + 5 * 2";
const answer: Array<number> = calculate(parse(math));

console.log(`${math} = ${answer[0]}`);

// Output: 
// 1 + 5 * 2 = 11
```
---
Implementing a random number function that takes in two inputs(min & max):
```typescript
import { addFunction, fetchValue } from "@known-as-dan/calculator";

addFunction("Random", "rand", "rand(min, max)", (values: Array<number>) => {
	const min: number = fetchValue(values, 0);
	const max: number = fetchValue(values, 1);
	return Math.floor(Math.random() * (max - min)) + min;
});
```
npm package: @known-as-dan/command
Description: Command is a simple framework for handling command execution within your node application.
Author: known-as-dan
Latest version: 1.0.0

# About
Command is a simple framework for handling command execution within your node application.

# Usage
Recreating the common "echo" command using Command & Typescript:
```typescript
import { Command, init } from "@known-as-dan/command";

new Command("echo", "<message>", "Send a message.", (args: Array<string>) => {
	const message = args.join();
	console.log(message);
});

init();
```
npm package: @knownothing/browser
Description: A TypeScript SDK for zero-knowledge authentication.
Latest version: 0.1.0

## Install

Using yarn

```sh
yarn add @knownothing/browser
```

Using npm

```sh
npm install --save @knownothing/browser
```

##

Typescript:

```typescript
import { ZKPasskeyManager, Chain, Wallet, Passkey } from "zk-passkeys";

/** Register a new passkey and set a recovery method */
const zkPasskeyManager = new ZKPasskeyManager({
  apiKey: "your-api-key-here",
});
// Signs the WebAuthn challenge and generates a proof
const passkey = await zkPasskeyManager.registerNewPasskey({
  challenge: "my-expected-challenge-here",
});
console.log(passkey.publicKey); // save the public key in your application's DB, browser storage, or smart contract

/** Recover their account */
const passkey = zkPasskeyManager.fromPublicKey(publicKey);
const proof = await passkey.signRecoveryChallenge("my-expected-challenge-here");
// Submit proof and expectedChallenge to social recovery wallet function
// ...
```

Example social recovery wallet

```solidity
contract ISocialRecoveryWallet {
	function owner() external view returns (address);

	// This calls Verifier.verifyPasskeySignature(owner, proof), and if verified,
	// sets owner equal to newOwner
	function recoverAccount(address newOwner, bytes calldata proof);
}
```

SDK smart contract

```solidity
contract PasskeyVerifier {
	function expectedChallenge() external view returns (bytes);

	// Stores the public key for an account
	function registerNewPasskey(address account, bytes proof, bytes expectedChallenge)

	// Makes a call to Verifier checking the proof vs the account's public key
	function verifyPasskeySignature(address account, bytes proof) external returns(bool);
}
```
npm package: @knownout/base-controller
Description: Basic state & data mobx controller
Author: Alexandr
Latest version: 0.1.1
Deprecated: Package no longer supported

# 🧊 Basic state & data controller

Base controller that manages state and stored data of the various modules.

To add a base controller to your module, simply extend it:

```ts
interface IMyCoolModuleState {
    loading: boolean;
}

interface IMyCoolModuleData {
    user?: string;
    password?: string;
}

class MyCoolModule extends BaseController<IMyCoolModuleState, IMyCoolModuleData> {
    constructor () {
        // Here we set default value for state and data.
        // Same value will be used when resetting 
        // state or stored data.
        super({
            loading: false
        }, {});
    }
}
```

To change state or stored data, we will use `setState` and `setData` methods:

```ts
class MyCoolModule /* ... */ {
    // ...
    
    public onUpdate () {
        // State can be changed for one element ...
        this.setData("user", "MyUserName");
        
        // ... or for several at once:
        this.setState({
            user: "MyUserName",
            password: "MyCoolPassword"
        });
    }
    
    // ...
}
```

To reset data or state of a module to its default parameters, we can
use the `resetData` and `resetState` methods:

```ts
class MyCoolModule /* ... */ {
    // ...
    
    public onReset () {
        // You can completely reset the stored data or state ...
        this.resetData(); // this.data -> {}
        
        // ... or leave certain fields:
        this.resetData("user"); // this.data -> { user: "MyUserName" }
    }
    
    // ...
}
```

You can get the current state or stored data by the variables of the same name:

```ts
this.data.user; // -> "MyUserName"

this.state.loading; // -> false
```

If you want to use only the state controller or only the data controller,
then you can simply use separate controllers from package dist:

```ts
import DataController from "@knonwout/base-controller/dist/_DataController";

// or

import StateController from "@knonwout/base-controller/dist/_StateController";
```

re-knownout - https://github.com/re-knownout/
<br>knownout@hotmail.com
npm package: @knownout/base-module
Description: Base module with data and state
Author: Alexandr
Latest version: 0.2.2

# 🧊 Basic state & data controller

Base controller that manages state and stored data of the various modules.

To add a base controller to your module, simply extend it:

```ts
interface IMyCoolModuleState {
    loading: boolean;
}

interface IMyCoolModuleData {
    user?: string;
    password?: string;
}

class MyCoolModule extends BaseController<IMyCoolModuleState, IMyCoolModuleData> {
    constructor () {
        // Here we set default value for state and data.
        // Same value will be used when resetting 
        // state or stored data.
        super({
            loading: false
        }, {});
    }
}
```

To change state or stored data, we will use `setState` and `setData` methods:

```ts
class MyCoolModule /* ... */ {
    // ...
    
    public onUpdate () {
        // State can be changed for one element ...
        this.setData("user", "MyUserName");
        
        // ... or for several at once:
        this.setState({
            user: "MyUserName",
            password: "MyCoolPassword"
        });
    }
    
    // ...
}
```

To reset data or state of a module to its default parameters, we can
use the `resetData` and `resetState` methods:

```ts
class MyCoolModule /* ... */ {
    // ...
    
    public onReset () {
        // You can completely reset the stored data or state ...
        this.resetData(); // this.data -> {}
        
        // ... or leave certain fields:
        this.resetData("user"); // this.data -> { user: "MyUserName" }
    }
    
    // ...
}
```

You can get the current state or stored data by the variables of the same name:

```ts
this.data.user; // -> "MyUserName"

this.state.loading; // -> false
```

If you want to use only the state controller or only the data controller,
then you can simply use separate controllers from package dist:

```ts
import DataController from "@knonwout/base-module/dist/_DataController";

// or

import StateController from "@knonwout/base-module/dist/_StateController";
```

re-knownout - https://github.com/re-knownout/
<br>knownout@hotmail.com
npm package: @knownout/evm-wallet-controller
Description: EVM wallet controller
Author: Alexandr Slavinskii
Latest version: 0.2.2

# 💷 EVM wallet controller

EVM wallet controller that allows to connect different EVM wallets to decentralized
application and get basic data and providers.

Before using controller, you need to initialize it:

```tsx
import evmWallet from "@knownout/evm-wallet-controller"

function App () {
    useEffect(() => {
        // Since the initialization should only be done
        // once, we do it inside the effect.
        // In this case controller will use predefined list of networks
        evmWallet.initController("web3-connect");

        // If you want use your own list of available networks, 
        // call setNetworksList method after init:
        evmWallet.setNetworksList(myNetworksList);
    }, []);

    return (
        <div>
            { /* ... */ }
        </div>
    );
}
```

To connect or disconnect the wallet, you can call the `callWalletAction` method:

```tsx
function App () {
    return (
        <button
            onClick={ () => evmWallet.callWalletAction() }
            disabled={ evmWallet.state.loading }
        >
            {
                evmWallet.state.loading
                    ? "Loading"
                    : evmWallet.state.connected
                        ? "Disconnect wallet"
                        : "Connect wallet"
            }
        </button>
    )
}
```

To get a core currency symbol and balance, use following methods:

```ts
evmWallet.state.balance.toFixed() // Formatted core currency balance as string

evmWallet.nativeTokenSymbol // Getter
```

knownout - https://github.com/knownout/
<br>knownout@hotmail.com
npm package: @knownout/evm-wallet-module
Description: EVM wallet module
Author: Alexandr Slavinskii
Latest version: 0.2.4

# 💷 EVM wallet controller

EVM wallet controller that allows to connect different EVM wallets to decentralized
application and get basic data and providers.

Before using controller, you need to initialize it:

```tsx
import evmWallet from "@knownout/evm-wallet-module"

function App () {
    useEffect(() => {
        // Since the initialization should only be done
        // once, we do it inside the effect.
        // In this case controller will use predefined list of networks
        evmWallet.initController("web3-connect");

        // If you want use your own list of available networks, 
        // call setNetworksList method after init:
        evmWallet.setNetworksList(myNetworksList);
    }, []);

    return (
        <div>
            { /* ... */ }
        </div>
    );
}
```

To connect or disconnect the wallet, you can call the `callWalletAction` method:

```tsx
function App () {
    return (
        <button
            onClick={ () => evmWallet.callWalletAction() }
            disabled={ evmWallet.state.loading }
        >
            {
                evmWallet.state.loading
                    ? "Loading"
                    : evmWallet.state.connected
                        ? "Disconnect wallet"
                        : "Connect wallet"
            }
        </button>
    )
}
```

To get a core currency symbol and balance, use following methods:

```ts
evmWallet.state.balance.toFixed() // Formatted core currency balance as string

evmWallet.nativeTokenSymbol // Getter
```

knownout - https://github.com/knownout/
<br>knownout@hotmail.com
npm package: @knownout/modal-window
Description: React modal window component
Author: Alexandr Slavinskii
Latest version: 0.1.8

# 🧊 React modal window component

Simple React component for creating modal windows.

Перед использованием модального окна его необходимо добавить в
контроллер (см. https://github.com/knownout/modal-window-controller).
Поскольку добавление модального окна в контроллер происходит единожды, можем
сделать это в эффекте:

```tsx
useEffect(() => {
    modalWindowController.connectModalWindow("my-modal");

    return () => {
        modalWindowController.disconnectModalWindow("my-modal");
    }
}, []);
```

Для того чтобы добавить модальное окно, достаточно просто
встроить его в любое место приложения:

```tsx
<ModalWindow modalKey="my-modal" modalTitle="My Test Modal">
    Hello world
</ModalWindow>
```

Изначально модальное окно будет закрыто, для того, чтобы открыть его,
используем метод контроллера:

```ts
modalWindowController.openModal("my-modal");
```

knownout - https://github.com/knownout/
<br>knownout@hotmail.com
npm package: @knownout/modal-window-controller
Description: Modal windows controller
Author: Alexandr Slavinskii
Latest version: 0.1.5

# 🧊 Modal windows controller

A simple utility mobx store for managing application modal windows.

This controller supports five different modal window states:

| State         | Description                              |
|---------------|------------------------------------------|
| OPEN          | Modal window open                        |
| MOUNT         | Modal window mounted into DOM tree       |
| OPENING       | Modal window opens                       |
| CLOSE         | Modal window closed                      |
| CLOSING       | Modal window closes                      |
| NOT_CONNECTED | Modal window not connected to controller |

To get started, connect (register) a unique modal window key in a controller:

```ts
import modalWindowController from "@knownout/modal-window-controller";
modalWindowController.connectModalWindow("MyCoolWindow");

// Also, modal window key can be disconnected from controller:
modalWindowController.disconnectModalWindow("MyOldModal");
```

Modal window state update rate *(CLOSING → CLOSE, MOUNT → OPENING → OPEN)*
can be changed as follows *(default is 300ms)*:

```ts
modalWindowController.updateStateChangeTime(600);
```

Open and close methods can be used to change state of specific modal window.
These methods do not immediately change window state to CLOSE or OPEN, but run
state change algorithm (CLOSING → CLOSED, etc.):

```ts
modalWindowController.openModal("MyCoolModal");

modalWindowController.closeModal("MyCoolModal");
```

To get current state of the modal, you can use `getModalState` method:

```ts
modalWindowController.getModalState("MyCoolModal"); // CLOSE

modalWindowController.getModalState("OtherModal"); // NOT_CONNECTED
```

re-knownout - https://github.com/knownout/
<br>knownout@hotmail.com