open-index/open-npm huggingface dataset:
npm package: @keyrock-dev/jotun
Description: Jotun Builder and Client Lib
Author: Charles Olson
Latest version: 23.7.1

# jotun ("yoh-tun")
Web Content Pre-Processor


## Why?

Cornerstone JS Framework needs html templates (Handlebars/Jinja) compiled into js. Might as well handle mjs and SCSS at the same time.

Jotun allows packages (js, css, html, and assets) to be included in other projects, to simplify distribution of web component libraries.


## Development

Build-and-run the docker-compose file. No need to install npm locally (or install package dependencies) for development.

```
cd .docker
docker-compose build
docker-compose up
```


To iterate on the Builder itself (Node.js):

```
docker exec -it jotun_tools_1 /bin/bash
./build-client
./build-example
```


To iterate on the Example content:

browse to:
http://localhost


## Deploying Updates

To publish the latest package to NPM:

1. Increment the version number in package.json.
2. Commit and push to main.
npm package: @keyrock/winston-bugsnag-transport
Description: Bugsnag transport for winston ^3.0.0
Author: The Keyrock Team
Latest version: 0.0.0

# `winston-bugsnag-transport`

`winston` transport for Bugsnag. Sends all messages with level `error` to Bugsnag.

## Usage

First, you'll need to install the package with `yarn` or `npm`:

```
yarn add @keyrock/winston-bugsnag-transport
```

or

```
npm install --save @keyrock/winston-bugsnag-transport
```

Then, when instantiating `winston`:

```js
const winston = require("winston");
const bugsnag = require("bugsnag");
const BugsnagTransport = require("@keyrock/winston-bugsnag-transport");

// You need to properly initialize your bugsnag instance. Refer to the documentation.
bugsnag.register("your api key");

// ...

const logger = winston.createLogger({
  level: "debug",
  transports: [
    new BugsnagTransport({
      bugsnag: bugsnag // Your Busgnag instance
    })
    // ... your other transports
  ]
});
```

Note that the initialization of the Bugnsag library should be done before initializing Winston.

## License

MIT
npm package: @keyrock/winston-logdna-transport
Description: Unofficial LogDNA transport for winston ^3.0.0
Author: The Keyrock Team
Latest version: 0.0.1

# `winston-logdna-transport`

Unofficial `winston` transport for LogDNA

## Usage

First, you'll need to install the package with `yarn` or `npm`:

```
yarn add @keyrock/winston-logdna-transport
```

or

```
npm install --save @keyrock/winston-logdna-transport
```

Then, when instantiating `winston`:

```js
const winston = require("winston");
const LogDNATransport = require("@keyrock/winston-logdna-transport");

// ...

const logger = winston.createLogger({
  level: "debug",
  transports: [
    new LogDNATransport({
      key: "your LogDNA ingestion key",
      app: "your app name",
      env: process.env.NODE_ENV || "development" || "whatever you want"
    })
    // ... your other transports
  ]
});
```

## License

MIT
npm package: @keyrxng/rpc-handler
Description: Uses Chainlist's RPC collection racing them returning the lowest latency RPC
Author: Ubiquity
Latest version: 1.0.3

# `@ubiquity/rpc-handler`

This packages leverages [Chainlist's](https://github.com/DefiLlama/chainlist) network RPC list to return the lowest latency provider from the list for any given network ID.

## Features

- Returns the lowest latency provider for a given network ID
- Drops bad endpoints from the list and creates a runtime/local storage cache
- Can re-test the cached RPCs by calling `handler.getFastestRpcProvider()`
- Can be used in both the browser and Node.js
- Fully configurable and extendable
- Only uses endpoints which Chainlist report as tracking _no_ data (see [`extraRpcs.js`](https://github.com/DefiLlama/chainlist/blob/main/constants/extraRpcs.js))

## Installation

```bash
yarn add @ubiquitydao/rpc-handler
```

## Usage

- Import the handler for your environment

###### Browser

```typescript
import { HandlerConstructorConfig } from "@ubiquity/rpc-handler/dist/esm/src/handler";
import { RPCHandler } from "@ubiquity/rpc-handler/dist/esm/src/rpc-handler";

export function useHandler(networkId: number) {
  const config: HandlerConstructorConfig = {
    networkId,
    autoStorage: true,
    cacheRefreshCycles: 5,
  };
  // No RPCs are tested at this point
  return new RPCHandler(config);
}
```

```typescript
import { useHandler } from "./rpc-handler";
const handler = useHandler(networkId);

// Now the RPCs are tested
app.provider = await handler.getFastestRpcProvider();
```

###### Node.js

```typescript
import { HandlerConstructorConfig } from "@ubiquity/rpc-handler/dist/cjs/src/handler";
import { RPCHandler } from "@ubiquity/rpc-handler/dist/cjs/src/rpc-handler";

const config: HandlerConstructorConfig = {
  networkId: 100;
  autoStorage: false, // only applies to local storage
  cacheRefreshCycles: 5,
};

async function main() {
  const handler = new RPCHandler(config);
  return await handler.getFastestRpcProvider();
}

main().then(console.log).catch(console.error);
```

#### Notes

- The RPCs are not tested on instantiation, but are tested on each call to `handler.getFastestRpcProvider()` or `handler.testRpcPerformance()`

- `networkId` is the only required configuration option

- See the full [config](src\handler.ts) object (optionally passed in the constructor) for more options

- Local storage is not enabled by default, but can be enabled by passing `autoStorage: true` in the config object

- The `cacheRefreshCycles` is the number of roundtrips made before clearing the cache and re-testing all RPCs again

## Testing

- In order to run the tests the package must first be built, this is required otherwise `networkRpcs` will be empty as the RPCs are injected at build time

```bash
yarn test
```
npm package: @keyrxng/webauthn-evm-signer
Description: Template repository with TypeScript support.
Latest version: 1.1.0

# In App Signing Keys

- Early research to fully abstract away the browser extension wallet approach.
- The idea is to deterministically generate an evm signing key based on the device fingerprint, and then automatically add itself to a user's Gnosis SAFE.
- The Gnosis SAFE should be associated with a GitHub user ID.
- All of the user's devices should be able to claim permits on behalf of the user, as the SAFE.
- The SAFE should be automatically registered on GitHub as the user's wallet.

Given that Gnosis Chain sponsors transactions, the user should be able to sign transactions without having to pay for gas. Most importantly, the signing key can strictly be used for signing, and not hold any value. This means that the user should never need to export/expose their private key.

For extended "mainstream" compatibility, in another future SAFE management UI that we build, we can:
1. explicitly list the user's devices as the "signers" or "authorized devices" and refer to the wallet address of each as the "pairing code" for each device. In our applications, we can have some type of control button to "show device pairing code" which is just the public address that is generated.
2. we can have a "sign in with github" button which will automatically deploy a SAFE if there is none associated, or identify the SAFE if there is one associated.

### Performance

This is one of the most exciting parts to me, but assuming that a fast RPC is connected, the interactions should be pretty instantaneous. No insanely slow metamask confirmation popups and we dont need to configure any gas settings etc as it is only for signing. Anything gas related can be left to the sponsor (gelato+gnosis)

The only last step for performance optimization is if we were on Optimism, because the optimistic rollups are basically instant. But that is a future consideration.
npm package: @keys-pub/chill
Description: Typescript client for Chill.app
Author: Gabriel Handford
Latest version: 0.1.8

# tsclient

```shell
yarn add @keys-pub/chill
```

```typescript
import {Credentials, rpcService, RPCService, certPath, RPCError} from '@keys-pub/chill'

export const creds: Credentials = new Credentials(certPath('Chill'))
export const rpc: RPCService = rpcService('localhost:49405', creds)

// Authenticate with service
const auth = await rpc.authUnlock({
  secret: 'mypassword',
  type: AuthType.PASSWORD_AUTH,
  client: 'myapp',
})
// Set auth token from unlock on the service auth
creds.token = auth.authToken

// Search
const keys = await rpc.keys({})
console.log('Keys:', keys)
```

## Publishing

```shell
npm login
npm publish --access public
```
npm package: @keys-pub/tsclient
Description: Typescript client for keys.pub
Author: Gabriel Handford
Latest version: 0.1.8

# tsclient

```shell
yarn add @keys-pub/tsclient
```

```typescript
import {Credentials, rpcService, RPCService, certPath, RPCError} from '@keys-pub/tsclient'

export const creds: Credentials = new Credentials(certPath('MyApp'))
export const rpc: RPCService = rpcService('localhost:22405', creds)

// Authenticate with service
const auth = await rpc.authUnlock({
  secret: 'mypassword',
  type: AuthType.PASSWORD_AUTH,
  client: 'myapp',
})
// Set auth token from unlock on the service auth
creds.token = auth.authToken

// Search
const search = await rpc.search({})
console.log('Search:', search)
```

## Publishing

```shell
npm login
npm publish --access public
```