open-index/open-npm huggingface dataset:
npm package: @noxnox/nest-minimal-logger
Description: change Nest Logger with minimal style
Author: nox
Latest version: 0.0.2

&nbsp;
# Install
```
yarn add @noxnox/nest-minimal-logger
```
or
```
npm install --save @noxnox/nest-minimal-logger
```
&nbsp;
# Usage
```typescript
const logger = new MinimalLogger();

logger.log('message on the console')
logger.error('error message on the console');
logger.warn('warning message on the console');
logger.debug('debug message on the console');
logger.verbose('verbose message on the console');
```
&nbsp;
## Override to Nest Logger
&nbsp;
in `main.ts`
```typescript
import { NestFactory } from '@nestjs/core';
import { MinimalLogger } from '@noxnox/nest-minimal-logger';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(
    AppModule,
    {
      logger: new MinimalLogger(),
    },
  );
}
```
in `app.service.ts`
```typescript
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  private logger = new Logger();

  getHello(): string {

    this.logger.log('minimal logger');

    return 'Hello World!';
  }
}

```
npm package: @noxnox/nest-redis-namespace-transport
Description: Redis with namespace for NestJS transport
Author: nox
Latest version: 2.0.0

install package
```
yarn add @noxnox/nest-redis-namespace-transport
```
or
```
npm install --save @noxnox/nest-redis-namespace-transport
```
#

strategy options in main.ts
```typescript
import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions } from '@nestjs/microservices';
import { RedisNamespaceServer } from '@noxnox/nest-redis-namespace-transport';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      strategy: new RedisNamespaceServer({
        url: 'redis://localhost:6379',
        namespace: 'TEST'
      })
    },
  );

  app.listen(() => {
    console.log('Microservice is listen');
  });
}
bootstrap();
```

import client proxy in module
```typescript
import { Module } from '@nestjs/common';
import { ClientsModule } from '@nestjs/microservices';
import { RedisNamespaceClient } from '@noxnox/nest-redis-namespace-transport';

@Module({
  imports: [
    ClientsModule.register({
      customClass: RedisNamespaceClient,
      options: {
        url: 'redis://localhost:6379',
        namespace: 'TEST'
      },
    })
  ]
})
export class AppModule {}
```
npm package: @noxnox/nuxt-use-sound
Description: 🔊 A Nuxt module for playing sound effects.
Author: Yaël GUILLOUX
Latest version: 2.0.1

# 🔊 nuxt-use-sound

This module is a **Nuxt** implementation of the Vue composable [**@vueuse/sound**](https://github.com/vueuse/sound).

For a better **understanding** of this **module**, you should check out the original [**composable page**](https://github.com/vueuse/sound).

## Setup

In order to use this module, you must have [@nuxt/composition-api](https://composition-api.nuxtjs.org) setup in your project.

Once you installed it, add `nuxt-use-sound` dependency to your project

```bash
yarn add --dev nuxt-use-sound
# or
npm i -D nuxt-use-sound
```

Add `nuxt-use-sound` to the `modules` section of `nuxt.config.js`

```js
// nuxt.config.js
{
  buildModules: ['nuxt-use-sound']
}
```

Configure your sounds 🥁

```js
// nuxt.config.js
{
  sound: {
    back: {
      src: "/back.wav",
      options: {
        volume: 0.25
      }
    }
  }
}
```

The rest of the documentation is available on the [**original composable repository**](https://github.com/vueuse/sound).

## Usage

Play your sounds, anywhere in your app.

Just note that no sound can be played before the user has clicked the page, this is a limitation from the [**Web Audio API**](https://developer.mozilla.org/fr/docs/Web/API/Web_Audio_API).

```vue
<template>
  <button @click="$sounds.back.play">
    Boop! 🎺
  </button>
</template>
```

## Development

1. Clone this repository
2. Install dependencies using `yarn install`
3. Start development server using `yarn dev`

## License

[MIT License](./LICENSE)

## Credits

This package comes from [**@vueuse/sound**](https://github.com/vueuse/sound), a package inspired by the React hook, [**useSound**](https://github.com/joshwcomeau/use-sound).

All the credit behind this idea goes to [**Josh W. Comeau**](https://github.com/joshwcomeau).
npm package: @noxother/signature
Description: A react native signature canvas built on skia
Author: Keith Luchtel
Latest version: 1.0.1

# React Native Signature

A signature canvas -- built with Skia

## Installation

`@noxother/signature` has a few peer dependencies which must be installed first if not already present in your project

```shell
yarn add react-native-reanimated react-native-gesture-handler @shopify/react-native-skia
```

Follow the installation instructions for each package to make sure they are setup correctly.

> [!NOTE]
> If using Expo, currently you will need to create a development build. The version of Skia that Expo ships with by default is not compatible.

Next, install `@noxother/signature`:

```shell
yarn add @noxother/signature
```

## Components

### `Canvas`

`Canvas` is added to your layout, and is the area users will interact with to sign.

| Prop | Type | Description |
| :--- | :--- | :---        |
| `strokeColor` | `Color` (from Skia) | Color used when drawing |
| `strokeWidth` | `number` | Width of stroke |
| `gestureHandler` | `GestureType` (from RNGH) | Gesture handler to add custom handling for all touch events |



## License
MIT
npm package: @noxsoft/svrn-sdk
Description: TypeScript SDK for interacting with SVRN Chain contracts — governance, citizenship, UBC, bridge, bonfire
Author: NoxSoft
Latest version: 0.1.0

# @svrn/sdk

TypeScript SDK for interacting with SVRN Chain contracts. Built on [viem](https://viem.sh).

## Install

```bash
npm install @svrn/sdk viem
```

## Setup

```ts
import { createPublicClient, createWalletClient, http } from 'viem';
import { svrnChain, addresses } from '@svrn/sdk';

const publicClient = createPublicClient({
  chain: svrnChain,
  transport: http(),
});
```

## Modules

### Bridge (L1 -> L2)

```ts
import { depositUSDC, depositETH, getTotalDeposited } from '@svrn/sdk';

// Deposit USDC (must approve bridge first)
await depositUSDC(walletClient, addresses.oneWayBridge, amount, l2Recipient);

// Deposit ETH
await depositETH(walletClient, addresses.oneWayBridge, l2Recipient, value);
```

### UBC (Universal Basic Compute)

```ts
import { enrollCitizen, claimUBC, getActualUBCPerPeriod } from '@svrn/sdk';

// Enroll a citizen for UBC
await enrollCitizen(walletClient, addresses.ubcDistributor, citizenAddress);

// Claim UBC for current period
await claimUBC(walletClient, addresses.ubcDistributor);

// Check current UBC rate
const ubcPerPeriod = await getActualUBCPerPeriod(publicClient, addresses.ubcDistributor);
```

### Citizenship

```ts
import { registerHuman, registerAgent, isCitizen } from '@svrn/sdk';

// Register a human citizen
await registerHuman(walletClient, addresses.citizenRegistry, citizenAddr, biometricHash);

// Register an AI agent (needs sponsor)
await registerAgent(walletClient, addresses.citizenRegistry, agentAddr, sponsorAddr);

// Check citizenship
const citizen = await isCitizen(publicClient, addresses.citizenRegistry, addr);
```

### Governance

```ts
import {
  createProposal, castVote, executeProposal,
  stakeForVoting, getVotePower, getEffectiveVotes,
} from '@svrn/sdk';

// Stake UCU for voting power
await stakeForVoting(walletClient, addresses.quadraticVoting, amount);

// Check vote power: sqrt(staked)
const power = await getVotePower(publicClient, addresses.quadraticVoting, voter);

// Check effective votes (quadratic * conviction multiplier)
const effective = await getEffectiveVotes(publicClient, addresses.convictionWeighting, voter);
```

### Bonfire

```ts
import { getCurrentOverflow, getEpochStats, finalizeEpoch } from '@svrn/sdk';

// Check current overflow
const overflow = await getCurrentOverflow(publicClient, addresses.bonfire);

// Get full epoch stats
const stats = await getEpochStats(publicClient, addresses.bonfire, epochNumber);

// Finalize a past epoch (permissionless)
await finalizeEpoch(walletClient, addresses.bonfire, epochNumber);
```

## Chain

SVRN Chain (ID: 741741) uses UCU as the native currency:

```ts
import { svrnChain } from '@svrn/sdk';
// { id: 741741, name: 'SVRN Chain', nativeCurrency: { symbol: 'UCU', decimals: 18 } }
```

## ABIs

All contract ABIs are exported with `as const` for full type safety:

```ts
import { ucUTokenAbi, governorAbi } from '@svrn/sdk';
```

## Addresses

Update `addresses.ts` with deployed contract addresses before use.