open-index/open-npm huggingface dataset:
npm package: @galva-io/galva-admin-node
Description: Node.js SDK for Galva Admin API
Latest version: 1.0.10-dev

# Galva Admin Node SDK

Node.js SDK for syncing billing events and managing end users with Galva.

## Installation

```bash
npm install galva-admin-node
```

**Peer dependencies** (install as needed):
```bash
npm install @paddle/paddle-node-sdk  # For Paddle
npm install googleapis               # For Play Store
```

## Quick Start

```typescript
import { Galva } from 'galva-admin-node';

const galva = new Galva({ apiKey: 'your-api-key' });
// Or set GALVA_API_KEY environment variable
```

## Billing Events

### With Pre-verified Payloads

Use when you've already decoded/verified payloads yourself.

```typescript
// App Store
await galva.billingEvent.appstore('user-123', {
  signedPayload: '...',
  bundleId: 'com.example.app',
  appAppleId: 123456789,
});

// Play Store (decoded notification)
await galva.billingEvent.playstore('user-123', decodedNotification);

// Paddle (verified event)
await galva.billingEvent.paddle('user-123', verifiedEvent);
```

### With Credentials (Auto-verification)

Use `withCredentials()` to let the SDK handle decoding and verification.

```typescript
const galvaWithCreds = galva.withCredentials({
  appstore: {
    bundleId: 'com.example.app',
    appAppleId: 123456789,
  },
  playstore: {
    email: 'service-account@project.iam.gserviceaccount.com',
    key: '-----BEGIN PRIVATE KEY-----\n...',
  },
  paddle: {
    apiKey: 'pdl_...',
    secretKey: 'whsec_...',
  },
});

// App Store (signed payload only)
await galvaWithCreds.billingEvent.appstore('user-123', signedPayload);

// Play Store (base64 from Pub/Sub - auto-decodes and fetches subscription)
await galvaWithCreds.billingEvent.playstore('user-123', base64Payload);

// Paddle (raw body + signature - auto-verifies)
await galvaWithCreds.billingEvent.paddle('user-123', rawBody, signature);
```

## End User Management

```typescript
import { EndUserDefaultTraitName } from 'galva-admin-node';

// Identify with traits
await galva.endUser.identify('user-123', {
  traits: {
    [EndUserDefaultTraitName.EMAIL]: 'user@example.com',
    [EndUserDefaultTraitName.FULL_NAME]: 'John Doe',
    customTrait: 'value',
  },
});

// Update default profile info
await galva.endUser.updateDefaultInfo('user-123', {
  email: 'user@example.com',
  fullName: 'John Doe',
  country: 'US',
});
```

## Configuration

```typescript
interface GalvaOptions {
  apiKey?: string;                          // Falls back to GALVA_API_KEY env
  environment?: 'production' | 'development'; // Falls back to NODE_ENV
  timeout?: number;                         // Request timeout in ms (default: 10000)
}
```

## Error Handling

```typescript
import { GalvaError } from 'galva-admin-node';

try {
  await galva.billingEvent.appstore('user-123', payload);
} catch (error) {
  if (error instanceof GalvaError) {
    console.error(error.code, error.message);
  }
}
```

## Requirements

- Node.js >= 18.0

## License

MIT
npm package: @galvanize-inc/jwtdown-for-react
Description: Toolkit for authenticating with Jwtdown_fastapi in React
Author: Galvanize Inc.
Latest version: 0.2.4

# JWTdown for React

Front end for
[jwtdown_fastapi](https://jwtdown-fastapi.readthedocs.io)

## Contributing

This project has a special workflow that requires NPM cli to
tag and commit a new version each time it is pushed.

To make changes, please:

1. Install the pre-commit Python module.

   ```sh
   pip install pre-commit
   ```

1. Using pre-commit, install the pre-commit git hooks inside
   the root level of this project. It will read the
   configuration file `.pre-commit-config.yaml` and check
   code quality and perform some formatting.

   ```sh
   pre-commit install
   ```

1. Then, stage and commit changes like you normally would in
   any other git project.
1. When you push, use the npm script provided instead of
   calling git directly.

   ```sh
   npm run push
   ```

## Examples

Coming soon...
npm package: @galvanize/node-vendorer
Description: Package production dependencies in a Yarn workspace
Author: Galvanize
Latest version: 0.0.4

Vendor a (Yarn workspace) package for distribution purposes. Typical use case will be for vendoring a Serverless function for deployment in a monorepository structure.

```typescript
import Vendorer from '@galvanize/node-vendorer'

// Vendor a package named `demo_api`
Vendorer.vendor('/monorepo', 'demo_api', 'dist')

// Will generate a `dist/node_modules` folder inside `demo_api` package
```
npm package: @galvanize/typescript-conventions
Description: TypeScript conventions used by Galvanize projects.
Latest version: 0.0.7

TypeScript conventions used by Galvanize projects.

## Install Dependency
```
npm install @galvanize/typescript-conventions --save-dev
```

## Usage
Inside your project create the associated files and artifacts to pick up the convention.

## TypeScript Compilation Options
Inside `tsconfig.json`
```json
{
  "extends": "@galvanize/typescript-conventions/tsconfig",
  "compilerOptions": {
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src"]
}
```
Install TypeScript:
``` 
npm install --save-dev typescript @types/node

```

## Prettier
Inside `package.json`
``` 
{
    ...
    "prettier": "@galvanize/typescript-conventions/.prettierrc.json",
    ...
}
```
Install `prettier`
``` 
npm install --save-dev prettier
```

## ESLint (base)
Inside `.eslintrc.js`
```
module.exports = {
  "extends": [
    require.resolve("@galvanize/typescript-conventions/.eslintrc.js"),
  ]
}
```
Additionally, you'll want to install peer dependencies:
``` 
npm install --save-dev @typescript-eslint/eslint-plugin @typescript-eslint/parser eslint \
                        eslint-config-prettier eslint-plugin-prettier 
```

## ESLint (React)
If using React, inside `.eslintrc.js`
``` 
module.exports = {
  "extends": [
    require.resolve("@galvanize/typescript-conventions/.eslintrc.js"),
    require.resolve("@galvanize/typescript-conventions/.eslintrc.react.js"),
  ]
}
```
Additionally, you'll want to install peer dependencies:
``` 
npm install --save-dev eslint-plugin-react  
```
npm package: @galvarez/platzoom
Description: Traductor de idioma platzom
Author: Gerlis Álvarez C.
Latest version: 0.1.0

# Platzoom

**Platzom** se trata de un idioma avanzado creado en el curso de fundamentos de JavaScript en [Platzi](https://platzi.com)

## Descripcion

- Si la palabra termina con "ar", se le quitan esas dos letras
- Si la palabra inicia con Z, se le añade "pe" al final.
- Si la palabra traducida tiene 10 o más letras, se debe partir en dos por la mitad y unir con con un guión medio
- Por último, si la palabra original en un palíndromo, ninguna ragla anterior cuenta y se devuelve la misma palabra pero intercalando letras mayúsculas y minúsculas

# Instalacion

```
npm install platzoom
```

# Uso

```
import platzoom from 'platzoom'

platzoom("programar") // Program
platzoom("Zorro") // Zorrope
platzoom("Zarpar") // Zarppe
platzoom("abecedario") // abece-dario
platzoom("sometemos") // SoMeTeMoS

```
npm package: @galvesmash/fortune-teller-game
Description: Fortune Teller Game standalone package
Author: Gabriel Galves Taliatti
Latest version: 0.5.2

# fortune-teller-game

## About
Fortune Teller Game is still a work in progress and it's being made with love and sorcery.
This project is being developed with JavaScript, TypeScript and Vue.js.
Standalone project to be included as [NPM package](https://www.npmjs.com/package/fortune-teller-game) inside our other project, [Fortune Machine](https://github.com/Galvesmash/fortune-machine?tab=readme-ov-file#fortune-machine), or maybe other projects.

Created by Gabriel Galves Taliatti and Camila de Oliveira Mônaco.

## GitHub Page
- [Repository](https://galvesmash.github.io/Fortune-Teller-Game/)
- [NPM package](https://www.npmjs.com/package/fortune-teller-game)

### APIs:
- [Fortune Cookie by wh-iterabb-it](https://rapidapi.com/wh-iterabb-it-wh-iterabb-it-default/api/fortune-cookie4/)
- [OpenTranslator by falcondsp](https://rapidapi.com/falcondsp/api/opentranslator)

## Project setup
```
npm install --save fortune-teller-game
```
or
```
yarn add fortune-teller-game
```

## Basic Usage
```
//src/components/YourComponent.vue
<template>
  <FortuneTellerGame
    :locale="defaultLocale"
    :rapid-api-key="rapidApiKey"/>
</template>

<script>
  import FortuneTellerGame from "fortune-teller-game";

  export default {
    components: {
      FortuneTellerGame
    },

    data() {
      return {
        defaultLocale: 'pt-br',
        rapidApiKey: 'your-rapid-api-key', // Required
      }
    },
  };
</script>
```
npm package: @galxe-identity-protocol/evm-contracts
Description: Galxe Identity Protocol EVM Contracts
Latest version: 1.0.3

# Galxe Identity Protocol EVM Contracts

This repository houses the Typescript adaptors for the Galxe Identity Protocol EVM contracts. The adaptors are generated
using the `typechain` package, for the `ethers` v6 library. Solidity contracts are located in the `contracts` directory.

## Commands

```bash
pnpm clean
pnpm compile
pnpm build
pnpm lint
pnpm test
```

## Contract Address List

### Registry contracts

```json
{
  "TypeRegistry": "0x77dA3Cf4418009D171B4963db815Ca46d6F2E79D",
  "ContextRegistry": "0x42D6444840842F0484C1624899c9a3E835738592",
  "IssuerRegistry": "0xc4525dA874A6A3877db65e37f21eEc0b41ef9877"
}
```

### Babyzk verification stack

```json
{
  "BabyzkDefaultPublicSignalGetter": "0x1418b5e79eE53396dE4a454d78DF2ab522CE24CC",
  "BabyzkStatefulVerifier": "0xF3D3404eb75D076Ab8A0F728C7FAA3c0A5e6549F"
}
```

#### Primitive type static verifier contracts

```json
{
  "BabyZKGroth16UnitVerifier": "0x4B8794e78E27B8eb9d57E7566E657C23C747f3b4",
  "BabyZKGroth16BooleanVerifier": "0x03d01B9d3F3eF125bdfC4a66DCb4362d4064E522",
  "BabyZKGroth16ScalarVerifier": "0x1ec111fc8aEAcCD989d6F7c556b12575cAc3a7E0",
  "BabyZKGroth16Scalar256Verifier": "0x5F6CFf23e9A4f63e934891eE8eb6071423385aD0",
  "BabyZKGroth16PropertyVerifier": "0x97194020ac576aA8a08c954DebFe14Ca583415AC",
  "BabyZKGroth16PassportVerifier": "0xCA355CE1D55670F7CE29Bb2d23061fe041Fd4B35"
}
```
npm package: @galxe-identity-protocol/sdk
Description: Galxe Identity Protocol TypeScript SDK
Latest version: 1.0.9

# Galxe Protocol SDK

## About

This is Galxe protocol's typescript SDK, compatible with both node and browser.

The package is built with both esm and cjs modules. A browser version (fully-bundled, very large) is also available under `dist/browser`.

For more information, please refer to the [docs](https://docs.galxe.com/identity/introduction).

## For developers

### Node Version

Developers should use the current LTS version of node. Currently, node v20.11.1.

```bash
# For nvm users:
nvm install --lts
nvm use --lts
```

### Setup

Install dependencies:

```bash
corepack enable
corepack install
```

## Coding conventions

### uint256 encoding

When encoding uint256 into two uint128(s), the order must be [msb, lsb].
This should apply to both claim values, circom generation for claim values and
statements.

### Zero value is the null value

Zero value is consider to be the null value in the following cases:

1. For property type, value 0 is considered to represent null. Issuers should not issue
   credential with any property-typed claims being 0.
2. For Signature ID, 0 is also an invalid value. For revocable credential with signature
   ID 0, they are considered to be non-revocable, meaning that they generate proof against
   any revocation tree root hash, because the verification will be skipped.
3. For revocable credentials, the merkle root 0 meaning that no credential has been revoked.
   Circuit will skip merkle proof verification when the root is 0.

## NOTICE

For better bundling experience for end users, we make manually copied the browser bundled version of `eta` into site-packages.
npm package: @gamalabs/eslint-config
Description: ESLint configuration used by Gama Labs.
Latest version: 1.0.0

# Gama Labs ESLint config

## Whats included?

- Standard config base;
- React plugin;
- React Hooks plugin;
- JSX a11y plugin;
- Prettier;

## Setup

1. Install the dependencies
```
npm i -D eslint @gamalabs/eslint-config
```

2. Create a `.eslintrc.json` file extending the config:
```
{
  "extends": "@gamalabs/eslint-config/react"
  // "extends": "@gamalabs/eslint-config/node"
}
```

> You can also use a `.eslintrc.js` instead of JSON if you prefer.
npm package: @gamalielmh921230/node_timer
Description: [![alt text](https://www.paypalobjects.com/es_XC/MX/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=HJT3RJKJ44EWQ&source=url ) # Para Instalar ```javascript  npm i @gamalielmh921230/node_timer  //o ya
Author: Gamaliel Mendez
Latest version: 1.0.13

# node_timer
### Clase para crear timers que se ejecuten indefinidamente
### **Apoyar el proyecto**
[![alt text](https://www.paypalobjects.com/es_XC/MX/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=HJT3RJKJ44EWQ&source=url
)
# Para Instalar
```javascript 
npm i @gamalielmh921230/node_timer 
//o
yarn add @gamalielmh921230/node_timer
````

# Como se Usa
```javascript 
    const Timer = require('@gamalielmh921230/node_timer')

    const Reloj= new Timer(1000,()=>{ 
        
        const horas = (new Date()).getHours();
        const minutos = (new Date()).getMinutes();
        const segundos = (new Date()).getSeconds();

        console.log(`${horas}:${minutos}:${segundos}`)
    })

    //se arranca el timer
    Reloj.start()

```` 
# Definicion de la clase
### **Metodos**
- **start():** *Arranca la ejecucion del timer*
- **stop():** *Detiene la ejecucion del timer*
- **setCallback():** *Establece la funcion que  se ejecutara en cada ciclo*
- **setInterval():** *Establece el intervalo de tiempo que tardara en ejecutar un ciclo*
- **isrunning():** *true si el timer esta activo*
npm package: @gaman/cors
Description: **Lightweight & High-Performance CORS Middleware for GamanJS**. Built for Bun, optimized for speed.
Author: angga7togk
Latest version: 1.0.9

# @gaman/cors
**Lightweight & High-Performance CORS Middleware for GamanJS**. Built for Bun, optimized for speed.

## Installation
```bash
bun add @gaman/cors
```

## Quick Used
```ts
import { defineBootstrap } from "gaman";
import { Cors } from "@gaman/cors";

defineBootstrap((app) => {
  app.mount(Cors());
  
  app.mountServer(...)
});
```
npm package: @gaman/michi
Description: Radix Tree Router designed as the core routing engine for GamanJS
Author: Angga7Togk
Latest version: 0.1.3

# 🛣️ Michi (道)
**Michi** (Japanese for Path) is a high-performance Radix Tree Router designed as the core routing engine for **GamanJS**. Built with a focus on extreme speed, minimal memory allocation, and native support for Universal Transport Layers (HTTP, IPC, WebSockets).

Unlike standard Regex-based routers that perform linear searches $O(n)$, Michi utilizes a **Radix Tree** structure $O(k)$, ensuring lookup speeds remain constant regardless of how many routes you define.

## Installation
```bash
bun install @gaman/michi
```