open-index/open-npm huggingface dataset:
npm package: @lepont/async-storage
Description: Async Storage Bridge for lepont
Author: Yoshiya Hinosawa
Latest version: 0.4.2

# @lepont/async-storage v0.4.2

![ci](https://github.com/kt3k/lepont-async-storage/workflows/ci/badge.svg)
[![codecov](https://codecov.io/gh/kt3k/lepont-async-storage/branch/master/graph/badge.svg)](https://codecov.io/gh/kt3k/lepont-async-storage)

> Async Storage Bridge for [lepont][]

You can use [AsyncStorage][] through [lepont][].

# Install

```
npm i --save lepont @react-native-community/async-storage @lepont/async-storage
```

# Usage

React Native side:

```tsx
import React from 'react'
import { useBridge } from 'lepont'
import { WebView } from 'react-native-webview'
import { AsyncStorageBridge } from '@lepont/async-storage/bridge'
import AsyncStorage from '@react-native-community/async-storage'

const App = () => {
  const [ref, onMessage] = useRegistry(AsyncStorageBridge(AsyncStorage))

  return (
    <WebView
      source={{ uri: 'Web.bundle/index.html' }}
      javaScriptEnabled={true}
      ref={ref}
      onMessage={onMessage}
    />
  )
}
```

Browser side:

```ts
import { setItem, getItem } from '@lepont/async-storage'

await setItem('@storage_Key', { my: 'value' })
await getItem('@storage_Key') // => { my: 'value' }
```

# LICENSE

MIT

[lepont]: https://github.com/kt3k/lepont
[AsyncStorage]: https://github.com/react-native-community/async-storage
npm package: @lepont/permissions-android
Description: lepont bridge for PermissionsAndroid
Author: Yoshiya Hinosawa
Latest version: 0.2.2

# lepont-permissions-android v0.2.2

> [lepont][] bridge for [PermissionsAndroid][] feature

# Install

```
npm i lepont @lepont/permissions-android
```

# Usage

RN side:

```tsx
import { WebView } from 'react-native-webview'
import { useBridge } from 'lepont'
import { PermissionsAndroidBridge } from '@lepont/permissions-android'
import { PermissionsAndroid } from 'react-native'

const App = () => {
  const [ref, onMessage] = useBridge(
    PermissionsAndroidBridge(PermissionsAndroid)
  )

  return (
    <WebView
      source={{ uri }}
      ref={ref}
      onMessage={onMessage}
      javaScriptEnabled
    />
  )
}
```

On browser side:

```ts
import { PermissionsAndroid } from '@lepont/permissions-android'

const permission = await PermissionsAndroid.request(
  PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE,
  {
    title: 'Storage Permission',
    message: 'The App needs access to your storage.',
    buttonNeutral: 'Ask Me Later',
    buttonNegative: 'Cancel',
    buttonPositive: 'OK',
  }
)

if (granted === PermissionAndroid.RESULTS.GRANTED) {
  alert('WRITE_EXTERNAL_STORAGE permission is granted!')
} else {
  alert('WRITE_EXTERNAL_STORAGE permission is denied!')
}
```

# APIs: Methods

## `PermissionsAndroid.request(perm: Permission, rationale?: Rationale): Promise<Result>`

Requests the give permissions with the given rationale.

## `PermissionsAndroid.check(perm: Permission): Promise<Result>`

Checks the given permission.

## `PermissionsAndroid.requestMultiple(perms: Permission[]): Promise<{ [K in Permission]: Result }>`

Requests the given mutiple permissions.

# APIs: Constants

## `PermissionsAndroid.PERMISSIONS`

See [shared.ts](https://github.com/kt3k/lepont-permissions-android/blob/main/src/shared.ts) for details.

## `PermissionsAndroid.RESULTS`

See [shared.ts](https://github.com/kt3k/lepont-permissions-android/blob/main/src/shared.ts) for details.

# License

MIT

[lepont]: https://github.com/kt3k/lepont
[PermissionsAndroid]: https://reactnative.dev/docs/permissionsandroid
npm package: @lepont/platform
Description: lepont bridge for React Native's Platform utility
Author: Yoshiya Hinosawa
Latest version: 0.1.4

# @lepont/platform v0.1.4

![ci](https://github.com/kt3k/lepont-platform/workflows/ci/badge.svg)

> [lepont][] bridge for React Native's [Platform](https://reactnative.dev/docs/platform-specific-code) utility

# Install

```
npm i --save lepont @lepont/platform
```

# Usage

On React Native side:

```tsx
import React from 'react'
import { Platform } from 'react-native'
import { WebView } from 'react-native-webview'
import { useBridge } from 'lepont'
import { PlatformBridge } from '@lepont/platform'

const App = () => {
  const [ref, onMessage] = useBridge(
    PlatformBridge(Platform)
  )
  return (
    <WebView
      ref={ref}
      onMessage={onMesssage}
      javaScriptEnabled
    />
  )
}
```

On the browser side:

```ts
import { getOS, select, getVersion } from '@lepont/platform'

await getOS() // => 'ios' or 'android'

await select({
  android: 'foo',
  ios: 'bar'
})
// => 'foo' on Android, 'bar' on iOS

await getVersion() // => 0.63.0 for example
```

# APIs

```
import { select, getOS, getVerion, getConstants } from '@lepont/platform'
```

## `select<A | I | N | W | D>(obj: { android?: A, ios?: I, native?: N, web?: W, default?: D }): Promise<A | I | N | W | D>`

Selects the value according to the platform.

See the example above.

## `getOS(obj): Promise<string>`

Gets the OS string, such as 'ios', 'android', etc.

## `getVersion(): Promise<string | number>`

Gets the OS version.

# License

MIT

[lepont]: https://github.com/kt3k/lepont
npm package: @lepont/share
Description: Share messages and files from browser, a lepont plugin
Author: Yoshiya Hinosawa
Latest version: 0.2.2

# @lepont/share v0.2.2

![ci](https://github.com/kt3k/lepont-share/workflows/ci/badge.svg?)
[![codecov](https://codecov.io/gh/kt3k/lepont-share/branch/master/graph/badge.svg)](https://codecov.io/gh/kt3k/lepont-share)

> Share messages and files from browser, a [lepont][] plugin

# Install

After initializing react-native:

```
npm i --save lepont @lepont/share react-native-share
# or
yarn add lepont @lepont/share react-native-share
```

And then:

```
npx pod-install
```

# Usage

React Native side:

```tsx
import { useBridge } from 'lepont'
import { ShareBridge } from '@lepont/share/bridge'
import Share from 'react-native-share'
import { WebView } from 'react-native-webview'

const App = () => {
  const [ref, onMessage] = useRegistry(ShareBridge(Share))

  return (
    <WebView
      source={{ uri: 'Web.bundle/index.html' }}
      javaScriptEnabled
      ref={ref}
      onMessage={onMessage}
    />
  )
}

export default App
```

Browser side:

```ts
import { share } from '@lepont/share'

await share({
  message: 'Share from my app!'
})
```

# API

```
import { share } from '@lepont/share'
```

## `share(options: Options): Promise<void>`

```ts
type Options = {
  /** array of base64 string you want to share */
  urls?: string[]

  /** array of filename for base64 urls array (only works for Android */
  filenames?: string[]

  /** File mime type ex. "image/png" */
  type?: string

  /** The message to share */
  message?: string

  /** The title of the message */
  title?: string
}
```

Shares the given contents and sends the data to other Apps.

# License

MIT

[lepont]: https://github.com/kt3k/lepont
[react-native]: https://reactnative.dev/
npm package: @leprekon-hub/fault-guard
Description: A resilience layer for HTTP clients that adds retries, backoff, rate-limit handling, and circuit breakers.
Latest version: 0.4.0

# fault-guard

A lightweight resilience layer for Promise-returning functions and HTTP clients. It provides retries with exponential backoff, circuit breaking, concurrency rate limiting, and bulkhead isolation.

## Installation

Install from npm (package name: `@leprekon-hub/fault-guard`) and add `axios` if you plan to use the adapter:

```bash
npm install @leprekon-hub/fault-guard
# if using axios adapter
npm install axios
```

## Quick Start

Wrap a function to apply resilience features:

```ts
import { wrap } from '@leprekon-hub/fault-guard';

const result = await wrap(() => fetchMyApi(), {
  retry: { retries: 3, minDelayMs: 100 },
  circuit: { failureThreshold: 5, timeoutMs: 30_000 },
  rateLimit: { maxConcurrent: 5 },
  bulkhead: { limit: 10 },
});
```

### How `wrap()` works

`wrap()` builds a **linear pipeline** around your function. Mechanisms are layered innermost-first in this fixed order:

```
your fn
 └─ 1. circuit breaker  ← innermost; each retry attempt counts as one failure
 └─ 2. retry
 └─ 3. bulkhead         ← slot acquired only when the job is actually running
 └─ 4. rate limiter     ← outermost; jobs queue here before touching the bulkhead
```

This ordering has two important consequences:

- **Retry × circuit**: every individual retry attempt is seen by the circuit breaker. Once `failureThreshold` is reached the circuit opens and further retry attempts fail fast with `"Circuit is open"`.
- **Bulkhead × rate limiter**: a job waits in the rate-limiter queue _before_ acquiring a bulkhead slot, so the bulkhead slot is held only while the job actively runs — not while it waits.

### Shared instances

By default, `wrap()` creates a fresh mechanism instance on every call. Pass a **pre-built instance** for `bulkhead` or `rateLimit` to share state (and enforce limits) across multiple calls:

```ts
import { wrap, Bulkhead, RateLimiter } from '@leprekon-hub/fault-guard';

const limiter = new RateLimiter(5); // 5 concurrent max, shared
const bh = new Bulkhead(10); // 10 concurrent max, shared

await Promise.all(
  requests.map((req) => wrap(() => fetch(req), { rateLimit: limiter, bulkhead: bh })),
);
```

For full documentation, detailed options, and examples see the docs:

- [Docs Home](docs/index.md)

## Development

- Build: `npm run build`
- Test: `npm test`

## Contributing & License

Contributions welcome. The project is MIT licensed (see `LICENSE`).
npm package: @lepropst/xchacha20-poly1305
Description: XChacha20 Poly 1305 authenticated encryption with additional data library including a password-based key derivation function.
Author: Elias Rangel
Latest version: 1.0.0

# XChaCha20-Poly1305 AEAD

A TypeScript library providing XChaCha20-Poly1305 authenticated encryption with automatic key and nonce management for Node.js and browser environments.

## Features

- **XChaCha20-Poly1305 AEAD encryption** - Industry-standard authenticated encryption
- **Automatic key generation** - Secure 256-bit key creation
- **Nonce collision prevention** - Built-in tracking to prevent nonce reuse
- **Zero configuration** - Sensible defaults, simple API
- **Type-safe** - Full TypeScript support
- **Lightweight** - Minimal dependencies

## Installation

```bash
npm install @lepropst/xchacha20-poly1305
```

## Quick Start

```typescript
import { encrypt, decrypt, generateKey } from "@lepropst/xchacha20-poly1305";

// Generate a key once and store it securely
const key = generateKey();

// Generate a nonce once and store it securely
const nonce = generateKey();

// Generate a password based key using the pbkdf file exports.
const key = passwordBasedKeyDerivation(user, password);
// Encrypt a message
const ciphertext = encrypt(key, nonce, "Hello, World!");

// Decrypt the message
const plaintext = decrypt(key, nonce, ciphertext);
console.log(plaintext); // "Hello, World!"
```

### Error Handling

This project serves as a part of a whole and will throw any native library errors occuring when using `@noble/ciphers` to encrypt with the XChaCha20 Poly1305 AEAD.

### Nonce Management

**It is recommended that you use the associated and tagged KeyStore repository/project in association with this encryption wrapper to ensure secure storage of keys and nonces.**

Each nonce can be reused as long as it is generated randomly for each key. Key Rotation can occur as desired.

[@lepropst/keystore contains the appropriate library to manage keys/nonces](https://github.com/lepropst/keystore)

## License

MIT

## Acknowledgments

Built on [@noble/ciphers](https://github.com/paulmillr/noble-ciphers) - audited, secure cryptographic implementations.

---

**Security Notice**: This library is part of a systems architecture project. Appropriate use including rotation of keys, assurance of random nonces, and secure storage are dependent upon the user. This library purely provides the tools necessary to use the AEAD given the appropriate input.
npm package: @lepswap/core
Description: Core contracts for the LEPswap protocol
Latest version: 3.1.2

# SushiSwap

https://sushi.com/

## Deployed Contracts

https://dev.sushi.com/sushiswap/contracts

## Docs

[Development](docs/DEVELOPMENT.md)

[Deployment](docs/DEPLOYMENT.md)

[History](docs/HISTORY.md)

## Security

[Security Policy](SECURITY.md)

## License

[MIT](LICENSE.txt)
npm package: @lepswap/sdk
Description: 🛠 An SDK for building applications on top of Sushiswap.
Latest version: 8.0.7

# Sushiswap SDK

In-depth documentation on this SDK is available at [uniswap.org](https://uniswap.org/docs/v2/SDK/getting-started/).

This modifies uniswap-sdk's UniswapV2Factory address. The new address for sushiswap is  `0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac`.

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/sushiswap/sushiswap-sdk.git
```

Move into the sushiswap-sdk working directory

```sh
cd sushiswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```