open-index/open-npm huggingface dataset:
npm package: @stellarsecurity/stellar-crypto
Description: Core E2EE cryptography for Stellar (vault, EAK, AES-GCM, PBKDF2).
Author: Stellar Security
Latest version: 1.0.2

# 🚀 stellar-crypto

`stellar-crypto` is the official cryptographic core used across the **Stellar Security** ecosystem — powering encrypted storage, key-wrapping, secure sync, vault creation, and cross-platform AES-GCM operations.

This package provides:

- 🔐 **Vault creation** using PBKDF2-SHA256 (210k iterations)
- 🧩 **EAK (Encrypted Access Key) extraction** for login flows
- 🗝️ **Master Key wrapping/unwrapping** using AES-GCM
- 📦 **Server bundle encoding** (IV || ciphertext)
- 📚 **Typed interfaces** for KDF params, vault headers, bundles
- ✨ **No dependencies** — pure WebCrypto

All crypto happens **client-side**.  
Stellar servers never see plaintext notes or master keys.  
**Stellar ID is optional** — cryptography works independently.

---

## 🔧 Installation

```bash
npm install stellar-crypto
```

or (if using a scoped package):

```bash
npm install @stellarsecurity/stellar-crypto
```

---

## 📦 Quick Start

### 1. Create a vault (new user)

```ts
import { createVault, exportServerBundleFromHeader } from 'stellar-crypto';

const { header, mkRaw } = await createVault("mypassword");

// Send this to your backend:
const bundle = exportServerBundleFromHeader(header);
```

### 2. Login using EAK from server

```ts
import { extractPlainEAK } from 'stellar-crypto';

const { eakB64, eakBytes } = await extractPlainEAK(password, serverBundle);

// eakBytes = 32-byte master key for local encryption/decryption
```

### 3. Encrypt / decrypt notes

```ts
import { encryptTextWithMK, decryptTextWithMK } from 'stellar-crypto';

const blob = await encryptTextWithMK(eakBytes, "Hello world");

// later:
const text = await decryptTextWithMK(eakBytes, blob);
```

---

## 📁 Server Bundle Format

The backend stores:

```json
{
  "crypto_version": "v1",
  "kdf_params": {
    "algo": "PBKDF2",
    "hash": "SHA-256",
    "iters": 210000
  },
  "kdf_salt": "base64",
  "eak": "base64(IV || ciphertext)"
}
```

This allows:
- stateless server operations
- deterministic login flows
- end-to-end encryption without key disclosure

---

## 🛡️ Security Model

- AES‑256‑GCM used for all encryption
- PBKDF2-SHA256 with high iteration count
- All secret material left **only in RAM**
- No plaintext keys are ever sent to the backend
- Optional app-lock layer (Argon2 or PBKDF2) can wrap bundles locally

**Stellar servers cannot decrypt user data. Period.**

---

## 🧪 Browser Compatibility

Uses native WebCrypto:

- Chrome
- Firefox
- Safari
- Edge
- Android WebView
- iOS WKWebView

No polyfills required.

---

## 🏗️ Roadmap

- Argon2id KDF (WebAssembly)
- ECDH key exchange (Secure sharing)
- Multi-device key rotation
- Attachment encryption

---

## 📝 License

MIT — do whatever you want, just don’t break security.

---

## 🧑‍💻 About Stellar Security
Swiss-based security company building open-source, zero-knowledge privacy tools.

https://stellarsecurity.com
npm package: @stellartrack/custom-data-table
Description: A high-performance virtualized React data table with Excel export and filtering
Author: Your Name
Latest version: 1.0.5

# @stellartrack/custom-data-table

A high-performance virtualized data table component for React with built-in search, export to Excel, and adaptive column sizing.

## Installation

```bash
npm install @stellartrack/custom-data-table
```

## Usage

```jsx
import { CustomDataTable } from "@stellartrack/custom-data-table";
import "@stellartrack/custom-data-table/styles/CustomDataTable.css";

<CustomDataTable
  data={[{ name: "John", age: 25 }]}
  columns={[{ name: "Name", key: "name" }, { name: "Age", key: "age" }]}
/>
```
npm package: @stellaservice/react-confirm-alert
Description: react component confirm dialog.
Author: Thawatchai Kuansombat
Latest version: 2.4.2

# react-confirm-alert

react component confirm dialog. [Live demo](https://ga-mo.github.io/react-confirm-alert/demo/)

[![npm version](https://badge.fury.io/js/react-confirm-alert.svg)](https://badge.fury.io/js/react-confirm-alert)

Document for v.1.x.x [see](https://github.com/GA-MO/react-confirm-alert/blob/master/Document-v1.md)

## Getting started

#### Install with NPM:

```
$ npm install react-confirm-alert --save
```

#### Options

```jsx
const options = {
  title: 'Title',
  message: 'Message',
  buttons: [
    {
      label: 'Yes',
      onClick: () => alert('Click Yes')
    },
    {
      label: 'No',
      onClick: () => alert('Click No')
    }
  ],
  childrenElement: () => <div />,
  customUI: ({ onClose }) => <div>Custom UI</div>,
  closeOnEscape: true,
  closeOnClickOutside: true,
  willUnmount: () => {},
  onClickOutside: () => {},
  onKeypressEscape: () => {}
};

confirmAlert(options);
```

#### Use with function:

```jsx
import { confirmAlert } from 'react-confirm-alert'; // Import
import 'react-confirm-alert/src/react-confirm-alert.css'; // Import css

class App extends React.Component {
  submit = () => {
    confirmAlert({
      title: 'Confirm to submit',
      message: 'Are you sure to do this.',
      buttons: [
        {
          label: 'Yes',
          onClick: () => alert('Click Yes')
        },
        {
          label: 'No',
          onClick: () => alert('Click No')
        }
      ]
    });
  };

  render() {
    return (
      <div className='container'>
        <button onClick={this.submit}>Confirm dialog</button>
      </div>
    );
  }
}
```

#### Custom UI Component

```js
confirmAlert({
  customUI: ({ onClose }) => {
    return (
      <div className='custom-ui'>
        <h1>Are you sure?</h1>
        <p>You want to delete this file?</p>
        <button onClick={onClose}>No</button>
        <button
          onClick={() => {
            this.handleClickDelete();
            onClose();
          }}
        >
          Yes, Delete it!
        </button>
      </div>
    );
  }
});
```
npm package: @stellata/webanalyzer
Description: Web Analyzer is a web analysis CLI built using TypeScript to allow immediate retrieval of website information without a GUI or any type of third-party installation.
Author: azazelm3dj3d
Latest version: 0.1.13

<img src="https://raw.githubusercontent.com/stellatatech/webanalyzer/main/assets/webanalyzer_logo.png" alt="Web Analyzer by Stellata">

Web Analyzer is a web analysis CLI built using TypeScript to allow immediate retrieval of website information without a GUI or any type of third-party installation. Currently allows for broken link detection, JSON and HTML export and extraction, website data aggregation, and much more.

### Install

Web Analyzer can easily be installed using npm:

```bash
npm install @stellata/webanalyzer
```

Available arguments:

```
-h, --help              "Help menu"
-u, --url <value>       "Provide a URL for parsing broken links and collecting web info"
-f, --file              "Save website data to a file in JSON format (default: report.json)"
-o, --output            "Specify the name of the JSON or HTML file for extracted data (don't specify an extension)"
-v, --verbose           "Output link information in a file and display the data in terminal"
-d, --debug             "Debug logs (more in-depth information about the domain/tools being used)"
-w, --web               "Saves website data to a file in HTML format (default: report.html)"
-b, --broken            "Scans provided URL for broken links, returning a status code"
```

### Examples

You can run this command to gather broken links on your website and export them to a JSON file:

```bash
webanalyzer -u https://example.com -f -o example_report -b
```

If you need to quickly export the HTML source code instead, you can run the same command as above, but by including the `-w` flag:

```bash
webanalyzer -u https://example.com -f -o example_report -b -w
```

NOTE: Depending on your system and how you installed webanalyzer, you may need to use `npx` alongside the CLI utility in the examples above.
npm package: @stellect/core
Description: x402 payment engine, service registry, and budget guard for Stellect
Author: Cayvox Labs
Latest version: 0.1.0

# @stellect/core

x402 payment engine, service registry, and on-chain budget guard for Stellect.

## Install

```bash
npm install @stellect/core
```

## Usage

### X402Client

Handles the full HTTP 402 payment flow automatically:

```typescript
import { X402Client } from '@stellect/core';

const client = new X402Client({
  signer: {
    address: 'GPUBLIC...',
    signAuthEntry: async (preimage) => ({
      signedAuthEntry: '...',
      signerAddress: 'GPUBLIC...',
    }),
  },
});

// Fetch with automatic payment
const result = await client.request('http://localhost:4021/api/weather?city=Istanbul');
// result.paid === true if payment was made
// result.response contains the API data
```

### ServiceRegistry

Discover x402 services from the bazaar:

```typescript
import { ServiceRegistry } from '@stellect/core';

const registry = new ServiceRegistry({
  registryUrl: 'http://localhost:4021/api/services',
});

const services = await registry.getServices();
const weather = await registry.getService('weather-openweathermap');
const dataServices = await registry.filterByCategory('data');
```

### BudgetGuard

On-chain spending policy enforcement via Soroban:

```typescript
import { BudgetGuard } from '@stellect/core';

const guard = new BudgetGuard({ contractId: 'C...' });
const allowed = await guard.checkSpend(agent, '10000', service);
```

Gracefully degrades to allow-all when no contract is deployed.

## Tests

```bash
npm test  # 23 tests: x402-client, service-registry, budget-guard, e2e-payment
```

## License

MIT
npm package: @stellect/mcp-server
Description: MCP server exposing Stellect tools to AI agents
Author: Cayvox Labs
Latest version: 0.1.0

# @stellect/mcp-server

MCP (Model Context Protocol) server that exposes Stellect tools to AI agents like Claude Desktop.

## Tools

| Tool | Input | Description |
|------|-------|-------------|
| `list_services` | `{ category?: string }` | Browse the service bazaar |
| `call_paid_api` | `{ endpoint, method, params }` | Pay for and call an API |
| `check_balance` | `{}` | View wallet USDC/XLM balance |
| `get_spending_history` | `{ limit?: number }` | Recent transactions |

## Setup with Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "stellect": {
      "command": "node",
      "args": ["/path/to/packages/mcp-server/dist/index.js"],
      "env": {
        "STELLECT_PASSPHRASE": "your-passphrase",
        "STELLECT_GATEWAY_URL": "http://localhost:4021",
        "STELLAR_NETWORK": "testnet"
      }
    }
  }
}
```

Restart Claude Desktop. The four tools will appear in the tool list.

## Run Standalone

```bash
npm run build
npm run dev  # Starts MCP server on stdio
```

## Development

All output to `stdout` is MCP protocol. Use `console.error()` for debug logging.

## Tests

```bash
npm test  # 9 tests for all 4 tools
```

## License

MIT
npm package: @stellect/wallet
Description: Pure TypeScript interface definitions for Stellect wallet adapters
Author: Cayvox Labs
Latest version: 0.1.0

# @stellect/wallet

Pure TypeScript interface definitions for Stellect wallet adapters. Zero runtime dependencies.

## Purpose

This package defines the `WalletProvider` contract that all wallet adapters must implement. Other packages import types from here — they never depend on a specific adapter directly.

## Install

```bash
npm install @stellect/wallet
```

## Key Exports

### WalletProvider Interface

```typescript
interface WalletProvider {
  createWallet(name: string, options?: CreateWalletOptions): Promise<WalletDescriptor>
  loadWallet(name: string): Promise<WalletDescriptor>
  listWallets(): Promise<WalletDescriptor[]>
  sign(walletName: string, request: SignRequest): Promise<SignResult>
  getBalance(walletName: string, asset?: string): Promise<Balance>
  setPolicy(walletName: string, policy: SpendingPolicy): Promise<void>
  getHistory(walletName: string, options?: HistoryOptions): Promise<Transaction[]>
}
```

### Error Classes

- `PolicyRejectionError` — Policy denied the transaction
- `KeystoreError` — Encryption/decryption failure
- `InsufficientBalanceError` — Not enough balance
- `FacilitatorError` — OpenZeppelin facilitator error
- `X402Error` — x402 handshake failure
- `ServiceNotFoundError` — Service not in registry

### Types

`WalletDescriptor`, `SignRequest`, `SignResult`, `SignContext`, `PolicyEvaluation`, `SpendingPolicy`, `Balance`, `AssetBalance`, `Transaction`, `HistoryOptions`, `StellarNetwork`

## License

MIT
npm package: @stellect/wallet-native
Description: Stellar-native wallet implementation for Stellect — keystore, policy engine, signing
Author: Cayvox Labs
Latest version: 0.1.0

# @stellect/wallet-native

Stellar-native wallet implementation for Stellect. Handles key generation, AES-256-GCM encrypted storage, local policy enforcement, and isolated signing.

## Install

```bash
npm install @stellect/wallet-native
```

## Usage

```typescript
import { NativeStellarProvider } from '@stellect/wallet-native';

// Set STELLECT_PASSPHRASE env var for key encryption
const wallet = new NativeStellarProvider({ network: 'stellar:testnet' });

// Create a wallet (generates keypair, encrypts, funds on testnet)
const descriptor = await wallet.createWallet('agent-default');
console.log(descriptor.publicKey); // G...

// Sign a transaction (policy check -> decrypt -> sign -> wipe)
const result = await wallet.sign('agent-default', {
  type: 'auth_entry',
  payload: authEntryBase64,
  context: { amount: '0.001', service: 'weather' },
});

// Check balance
const balance = await wallet.getBalance('agent-default');
```

## Security Model

1. **Policy-before-decrypt** — Policy engine evaluates BEFORE any key material is touched
2. **Scoped decryption** — Secret key decrypted inside `sign()`, never returned or stored
3. **AES-256-GCM** — Keys encrypted with scrypt-derived key (N=16384, r=8, p=1)
4. **Audit trail** — Every sign() logged to append-only JSONL

## Storage

Wallet files stored at `~/.stellect/wallets/{name}.json`:

```json
{
  "version": 1,
  "algorithm": "aes-256-gcm",
  "salt": "hex...",
  "iv": "hex...",
  "tag": "hex...",
  "encrypted": "hex...",
  "metadata": { "publicKey": "G...", "network": "stellar:testnet" }
}
```

## Tests

```bash
npm test  # 27 tests: keystore, policy-engine, signer, native-provider
```

## License

MIT