open-index/open-npm huggingface dataset:
npm package: @sqchenxiyuan/element-theme
Description: Theme generator cli tool for Element
Author: qingwei-li
Latest version: 3.0.0

# element-theme
[![Build Status](https://travis-ci.org/ElementUI/element-theme.svg?branch=master)](https://travis-ci.org/ElementUI/element-theme)
[![npm](https://img.shields.io/npm/v/element-theme.svg)](https://www.npmjs.com/package/element-theme)

> Theme generator cli tool for Element.

![](./media/element.gif)

> The current version is compatible with element-ui@2.x. For element-ui@1.x, please check out the legacy branch.

## Installation
install local or global
```shell
npm i element-theme -D
```

install `theme-chalk`
```shell
npm i element-theme-chalk -D
# or from github
npm i https://github.com/ElementUI/theme-chalk -D
```

## CLI
```shell
# init variables file
et --init [file path]

# watch then build
et --watch [--config variable file path] [--out theme path]

# build
et [--config variable file path] [--out theme path] [--minimize]
```

## Node API
```javascript
var et = require('element-theme')

// watch mode
et.watch({
  config: 'variables/path',
  out: 'output/path'
})

// build
et.run({
  config: 'variables/path',
  out: 'output/path',
  minimize: true
})
```

## Options
### config
Variable file path, default `./element-variables.css`.

### out
Theme output path, default `./theme`.

### minimize
Compressed file.

### browsers
set browsers, default `['ie > 9', 'last 2 versions']`.

### watch
watch variable file changes then build.

### components
A lists of components that you want to generate themes for.  All by default.

## Config
You can configure some options in `element-theme` by putting it in package.json:
```json
{
  "element-theme": {
    "browsers": ["ie > 9", "last 2 versions"],
    "out": "./theme",
    "config": "./element-variables.css",
    "theme": "element-theme-chalk",
    "minimize": false,
    "components": ["button", "input"]
  }
}
```

## License
MIT
npm package: @sqd-pipes/core
Description: Core package of the SQD Pipes ecosystem that provides specialized streams for blockchain data consumption.
Latest version: 0.0.1-alpha.6

# @sqd-pipes/core

Core package of the SQD Pipes ecosystem that provides specialized streams for blockchain data consumption.

## Overview

This package offers a collection of stream implementations for different blockchain platforms:

- **Stream Abstractions**: Provides a common interface for consuming blockchain data via the Subsquid Portal
- **Chain-Specific Implementations**: Includes specialized streams for Solana and EVM blockchains
- **State Management**: Utilities for tracking stream progress and handling checkpoints

Unlike a general-purpose stream processing library, this package is specifically designed for consuming and processing blockchain-specific data types like swaps, liquidity events, and token metadata.

## Key Components

### Core Functionality
- `PortalAbstractStream`: Base abstract class for all blockchain data streams
- State management interfaces for tracking progress
- Error handling and retry mechanisms

## Installation

```bash
yarn add @sqd-pipes/core
```

## License

MIT
npm package: @sqd-pipes/pipes
Description: > ⚠️ **Warning**: This SDK is currently in the experimental stage. > APIs may change without notice. > Use with caution in production environments.
Author: Subsquid Team
Latest version: 0.0.1-alpha.38

# @sqd-pipes/pipes

> ⚠️ **Warning**: This SDK is currently in the experimental stage.
> APIs may change without notice.
> Use with caution in production environments.

Core package of the **SQD Pipes** ecosystem. It provides specialized, composable streams for blockchain data ingestion, transformation, and storage.

---

## Overview

`@sqd-pipes/pipes` is a TypeScript library designed for **efficient blockchain data processing**.  
It implements a **pipeline-based architecture** that makes it easy to consume, decode, and persist blockchain data, while remaining flexible and extensible.

---

## Features

- **TypeScript-first** — full type safety with both ESM and CJS builds.
- **Blockchain integration**:
  - EVM helpers (portal sources, event decoders).
- **Storage targets**:
  - Built-in support for ClickHouse with batching and rollback handling.
- **Observability**:
  - Prometheus metrics.
  - Pino-compatible logging.
  - Benchmarking utilities.
- **Extensible architecture** — create custom sources, decoders, and targets for any chain or sink.

---

## Installation

```bash
npm install @sqd-pipes/pipes
```

---

## Quick Start

Example: consume events from an EVM chain and write them into ClickHouse.

```ts
import { commonAbis, createEvmDecoder, createEvmPortalSource } from '@sqd-pipes/pipes/evm'

async function cli() {
  const stream = createEvmPortalSource({
    portal: 'https://portal.sqd.dev/datasets/ethereum-mainnet',
  }).pipe(
    createEvmDecoder({
      profiler: { id: 'ERC20 transfers' },
      range: { from: '12,000,000' },
      events: {
        transfers: commonAbis.erc20.events.Transfer,
      },
    }),
  )

  for await (const { data } of stream) {
    console.log(`parsed ${data.transfers.length} transfers`)
  }
}

void cli()
```

---

## Usage

Pipelines are fully composable:

- **Sources** provide blockchain data (e.g., blocks, logs, transactions).
- **Decoders** transform raw data into structured objects.
- **Targets** handle persistence in databases, message queues, or custom sinks.

You can easily extend the system by implementing custom components that conform to the `Transformer` / `Target` interfaces.

---

## Documentation

Full documentation is available in the [project wiki](./docs) (WIP).

---

## Contributing

Contributions are welcome! Please open an issue or submit a PR with improvements.

---

## License

MIT © SQD
npm package: @sqds/grid
Description: Grid SDK - Core TypeScript client (platform-agnostic)
Latest version: 3.1.2

# @sqds/grid

Grid SDK for typescript applications.

## Installation

```bash
npm install @sqds/grid
```

## Features

- **Multi-provider**: Turnkey, Privy, and passkey authentication
- **Smart accounts**: Multi-sig policies, spending limits, time locks
- **Smart transactions**: Automated DCA, limit orders, and trading strategies
- **Fiat on/off-ramp**: ACH, SEPA, wire transfers with virtual accounts
- **KYC verification**: Identity verification for regulated operations

## Usage

```typescript
import { GridClient } from '@sqds/grid';

const client = new GridClient({
  apiKey: 'your-api-key',
  environment: 'sandbox',
});

try {
  const sessionSecrets = await client.generateSessionSecrets();

  await client.createAccount({
    email: 'user@example.com'
  });

  const otpCode = '123456';

  const response = await client.completeAuthAndCreateAccount({
    email: 'user@example.com',
    code: otpCode,
    sessionSecrets
  });

  const balances = await client.getBalances({
    accountAddress: response.data.address,
  });

  console.log('Balances:', balances.data);
} catch (error) {
  console.error('Error:', error.message);
}
```

**Note:** After calling `createAccount`, an OTP code will be sent to the user's email. The user must enter this code, which you then pass to `completeAuthAndCreateAccount` to complete the authentication flow.
npm package: @sqds/grid-crypto
Description: Cryptographic utilities for Grid SDK - Standalone package for key generation, signing, and encryption
Latest version: 1.0.0

# @sqds/grid-crypto

Cryptographic utilities for the Grid SDK. Provides key generation and signing functions for Turnkey and Privy providers.

## Installation

```bash
npm install @sqds/grid-crypto
```

## Usage

### Turnkey

Generate a P-256 key pair and sign a payload:

```typescript
import { generateTurnkeyKeyPair, signWithTurnkey } from '@sqds/grid-crypto';

const keyPair = await generateTurnkeyKeyPair();

const result = await signWithTurnkey(
  payload,
  credentialBundle,
  keyPair.privateKey
);
```

### Privy

Generate an HPKE key pair and sign a payload:

```typescript
import { generateHPKEKeyPair, signWithPrivy } from '@sqds/grid-crypto';

const keyPair = await generateHPKEKeyPair();

const signature = await signWithPrivy(
  payload,
  keyPair,
  encryptedAuthKey
);
```

## Types

```typescript
import type { KeyPair, SignatureResult } from '@sqds/grid-crypto';
```

## License

MIT
npm package: @sqds/grid-react
Description: React hooks and components for Grid SDK
Latest version: 2.0.5

# @sqds/grid-react

React hooks for Grid SDK - authentication, balances, and transactions.

## Installation

```bash
npm install @sqds/grid-react
```

## Quick Start

### 1. Setup Provider

```tsx
import { GridProvider } from "@sqds/grid-react";

export default function App({ children }) {
  return <GridProvider>{children}</GridProvider>;
}
```

**For Production:** Generate an App ID in the [Grid Dashboard](https://grid.squads.xyz/dashboard), whitelist your domain, and pass it to the provider:

```tsx
<GridProvider appId="your-app-id" environment="production">
  {children}
</GridProvider>
```

### 2. Email Authentication

```tsx
import { useEmailAuth } from "@sqds/grid-react";

function Auth() {
  const { requestOtp, verifyOtp, logout, user, account, isAuthenticated } = useEmailAuth();

  const handleLogin = async () => {
    await requestOtp("user@example.com");
    const code = prompt("Enter OTP:");
    await verifyOtp(code);
  };

  if (isAuthenticated) {
    return (
      <div>
        <p>Signed in as {user?.data.email}</p>
        <p>Account: {account?.data.address}</p>
        <button onClick={logout}>Logout</button>
      </div>
    );
  }

  return <button onClick={handleLogin}>Sign In</button>;
}
```

### 3. Balances and Transfers

```tsx
import { useBalance, useTransfer } from "@sqds/grid-react";

function Wallet() {
  const { balance } = useBalance({ symbol: "USDC" });
  const { transfer, isLoading, signature } = useTransfer();

  const handleSend = async () => {
    await transfer({ to: "recipient_address", amount: "1000000", currency: "usdc" });
  };

  return (
    <div>
      <p>{balance?.amountDecimal || "0"} USDC</p>
      <button onClick={handleSend} disabled={isLoading}>
        Send 1 USDC
      </button>
      {signature && <p>Transaction: {signature}</p>}
    </div>
  );
}
```

## Available Hooks

- **`useEmailAuth()`** - Email + OTP authentication with session management
- **`usePasskeyAuth()`** - WebAuthn passkey authentication
- **`useAccount()`** - Real-time account state
- **`useBalance(options)`** - Fetch single token balance
- **`useBalances(options)`** - Fetch all balances with pagination
- **`useTransfer()`** - Send funds
- **`useTransfers(options)`** - Fetch transfer history with filtering
- **`useGrid()`** - Access Grid SDK client directly

## TypeScript

```tsx
import type { EmailAuthState, PasskeyAuthState, UseBalanceResult } from "@sqds/grid-react";
```
npm package: @sqds/grid-react-native
Description: React Native hooks and components for Grid SDK
Latest version: 1.0.5

# @sqds/grid-react-native

React Native SDK for Grid - authentication, smart accounts, and payments.

## Installation

```bash
npm install @sqds/grid-react-native
```

## Required Polyfills

**IMPORTANT:** Configure polyfills at your app's entry point before importing any other code.

### 1. Install Dependencies

```bash
npm install text-encoding react-native-get-random-values buffer @ethersproject/shims
```

### 2. Configure Polyfills

Create a file `entrypoint.js`:
```js
import 'text-encoding';
import 'react-native-get-random-values';

import { Buffer } from 'buffer';
global.Buffer = Buffer;

import '@ethersproject/shims';

import 'expo-router/entry';
```

Set this as your entry point in `package.json`:
```json
{
  "name": "your-app-name",
  "main": "entrypoint.js"
}
```

## Quick Start

```typescript
import { GridClient } from '@sqds/grid-react-native';

const gridClient = new GridClient({
  environment: 'sandbox',
  apiKey: '<your api key>'
});

try {
  const sessionSecrets = await gridClient.generateSessionSecrets();

  await gridClient.createAccount({
    email: 'user@example.com'
  });

  const otpCode = '123456';

  const response = await gridClient.completeAuthAndCreateAccount({
    email: 'user@example.com',
    code: otpCode,
    sessionSecrets
  });

  console.log('Authentication successful:', response.data);
} catch (error) {
  console.error('Authentication failed:', error.message);
}
```

**Note:** After calling `createAccount`, an OTP code will be sent to the user's email. The user must enter this code, which you then pass to `completeAuthAndCreateAccount` to complete the authentication flow.

## License

MIT