open-index/open-npm huggingface dataset:
npm package: @jhinkle/gpg
Description: GPG encryption and decryption in node.js by way of the gpg command-line tool
Author: Jeremy Hinkle
Latest version: 0.7.27

# GPG Encryption/Decryption in Node.js
[![CI][ci-image]][ci-url]
[![npm][npm-image]][npm-url]
[![downloads][downloads-image]][downloads-url]

[ci-image]: https://github.com/abel-protocol/node-gpg/actions/workflows/ci.yml/badge.svg?branch=master
[ci-url]: https://github.com/abel-protocol/node-gpg/actions/workflows/ci.yml

[npm-image]: https://img.shields.io/npm/v/@mykeels/gpg.svg?style=flat
[npm-url]: https://npmjs.org/package/@mykeels/gpg

[downloads-image]: https://img.shields.io/npm/dm/@mykeels/gpg.svg?style=flat
[downloads-url]: https://npmjs.org/package/@mykeels/gpg

This module is a wrapper around `gpg` for use within Node. Node-GPG takes care of spawning `gpg`, passing it
the correct arguments, and piping input to stdin. It can also pipe input in from files and output out to files.

Use Node-GPG if you are considering calling `gpg` directly from your application.

## Requirements

In order to use Node-GPG, you'll need to have the `gpg` binary in your $PATH.

## Installation

```
npm install @mykeels/gpg
```

## Usage

Node-GPG supports both direct calls to GPG with string arguments, and streaming calls for piping input and output
from/to files.

See [the examples](./EXAMPLES.md) for more details.

If a function you need is not implemented, you can call gpg directly with arguments of your choice by
calling `gpg.call(stdinStr, argsArray, cb)`, or `gpg.callStreaming(inputFileName, outputFileName, argsArray, cb)`.

## Notes

Existing implementations of PGP in Javascript are blocking and unfeasibly slow for server use.
In casual testing, encrypting a simple 400-character email to an El-Gamal key took upwards of 11 seconds using
[openpgpjs](https://github.com/openpgpjs/openpgpjs) and 14 seconds with [kbpgp](https://github.com/keybase/kbpgp),
but takes less than 0.1 seconds with `gpg` directly.

## Contributors

The following are the major contributors of `node-gpg` (in no specific order).

  * Nicholas Penree ([drudge](http://github.com/drudge))
  * [freewil](http://github.com/freewil)
  * Samuel Reed [strml](http://github.com/strml)
  * Michael Ikechi [mykeels](http://github.com/mykeels)
npm package: @jhinresh/agentkit-plugin
Description: Maiat Trust Score plugin for Coinbase AgentKit — auto-check trust before every transaction
Latest version: 0.9.0

# @maiat/agentkit-plugin

> Trust-gated transactions for Coinbase AgentKit agents

Automatically check trust scores before every transaction. Block interactions with untrusted addresses. One line to integrate.

## Install

```bash
npm install @maiat/agentkit-plugin
```

## Quick Start

```typescript
import { AgentKit } from "@coinbase/agentkit";
import { maiatTrustPlugin } from "@maiat/agentkit-plugin";

const agent = new AgentKit({
  // your config
});

// Add Maiat trust gating
agent.use(maiatTrustPlugin({
  minScore: 3.0,  // Block addresses below 3.0/10
  chain: "base",
  onBlocked: (addr, score, risk) => {
    console.log(`🔴 Blocked ${addr}: ${score}/10 (${risk})`);
  },
}));
```

## How It Works

1. Agent wants to interact with address `0x1234...`
2. Plugin queries Maiat API: `GET /v1/score/0x1234...`
3. Score ≥ minScore → ✅ transaction proceeds
4. Score < minScore → ❌ `MaiatTrustError` thrown, transaction blocked

## Actions

### `maiat_check_trust`
Check trust score for any address.

```typescript
const result = await agent.run("Check if 0x4752... is trustworthy");
// → { score: 8.5, risk: "LOW", safe: true, ... }
```

### `maiat_gate_transaction`
Pre-flight check before executing a transaction.

```typescript
// Automatically called before transactions when plugin is active
// Throws MaiatTrustError if target is untrusted
```

## Configuration

| Option | Default | Description |
|--------|---------|-------------|
| `minScore` | `3.0` | Minimum trust score (0-10) |
| `apiUrl` | `https://app.maiat.io` | API endpoint |
| `apiKey` | (none) | API key for higher limits |
| `chain` | `base` | Default chain |
| `warnOnly` | `false` | Log warnings instead of blocking |
| `onBlocked` | (none) | Callback when transaction blocked |
| `onCheck` | (none) | Callback for every check |

## Standalone Client

```typescript
import { MaiatClient } from "@maiat/agentkit-plugin";

const maiat = new MaiatClient({ chain: "base" });

const result = await maiat.checkTrust("0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24");
console.log(result.score, result.risk); // 8.5 "LOW"

// Batch check
const results = await maiat.batchCheck(["0x1234...", "0x5678..."]);
```

## x402 Integration

Works seamlessly with Coinbase's x402 protocol for agent-to-agent payments:

```typescript
import { maiatTrustPlugin } from "@maiat/agentkit-plugin";

// Agent automatically checks trust before paying via x402
const plugin = maiatTrustPlugin({
  minScore: 5.0,  // Higher threshold for payments
  onBlocked: (addr, score) => {
    console.log(`Payment to ${addr} blocked — trust score ${score}/10`);
  },
});
```

## License

MIT
npm package: @jhinresh/elizaos-plugin
Description: Maiat Trust Score plugin for ElizaOS — verify trust before your agent swaps or transacts
Latest version: 0.9.0

# @jhinresh/elizaos-plugin

> Maiat Trust Score plugin for ElizaOS — verify trust before your agent swaps or transacts.

Adds trust-checking actions and evaluators to any ElizaOS agent so it can **refuse to interact with low-trust addresses** before executing swaps, transfers, or on-chain actions.

Powered by [Maiat Protocol](https://app.maiat.io) — on-chain verified trust scores for tokens, DeFi protocols, and AI agents on Base.

## Install

```bash
npm install @jhinresh/elizaos-plugin
```

## Usage

```typescript
import { maiatPlugin } from "@jhinresh/elizaos-plugin";

const agent = new ElizaAgent({
  plugins: [
    maiatPlugin({
      minScore: 3.0,   // reject addresses with score < 3.0/10
      chain: "base",
    }),
  ],
});
```

## What it does

| Component | Type | Behaviour |
|-----------|------|-----------|
| `CHECK_TRUST` | Action | Agent can ask "is 0x... safe?" and get a trust score |
| `TRUST_GATE` | Evaluator | Runs before any swap/transfer — rejects low-trust addresses |
| `TRUST_DATA` | Provider | Injects trust context into agent's world state |

## Trust Score Scale

| Score | Risk | Action |
|-------|------|--------|
| 7–10 | 🟢 Low | Allow |
| 4–6.9 | 🟡 Medium | Warn |
| 0–3.9 | 🔴 High | **Block** |

## Config

```typescript
maiatPlugin({
  apiUrl: "https://app.maiat.io",  // default
  apiKey: "your-key",   // optional — free tier: 100 req/day
  minScore: 3.0,        // 0–10 scale
  chain: "base",        // base | bnb | solana
})
```

## Links

- 🌐 [Live app](https://app.maiat.io)
- 📖 [API docs](https://app.maiat.io/docs)
- 🔗 [GitHub](https://github.com/JhiNResH/maiat-protocol)
- 📦 [npm](https://www.npmjs.com/package/@jhinresh/elizaos-plugin)

## License

MIT
npm package: @jhinresh/mcp-server
Description: Maiat Trust Score MCP Server — query trust scores for any on-chain address from Claude, GPT, or any MCP-compatible AI
Latest version: 0.9.0

# @jhinresh/mcp-server

> The trust layer for AI agents — as an MCP server.

Query Maiat trust scores from Claude, GPT, or any MCP-compatible AI assistant. One tool call = one trust check.

## Quick Start

### Claude Desktop

Add to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "maiat": {
      "command": "npx",
      "args": ["@jhinresh/mcp-server"],
      "env": {
        "ALCHEMY_API_KEY": "your-alchemy-key",
        "MAIAT_API_KEY": "optional-for-higher-rate-limits"
      }
    }
  }
}
```

### From source

```bash
cd packages/mcp-server
npm install
npm run build
npm start
```

## Tools

| Tool | Description |
|------|-------------|
| `trust_score` | Get trust score (0-1000) for any address |
| `token_safety` | Token-specific safety check (honeypot, rug, liquidity) |
| `protocol_rating` | Protocol safety rating by name |
| `batch_score` | Score up to 10 addresses at once |
| `explain_score` | Human-readable score explanation |

## Example Usage (in Claude)

> "Check if 0x1234...abcd is safe to interact with"

The AI will call `trust_score` and return something like:

```json
{
  "address": "0x1234...abcd",
  "score": 720,
  "risk": "low",
  "source": "live_onchain",
  "breakdown": {
    "base": 100,
    "txHistory": 200,
    "balanceSignal": 100,
    "contractBonus": 50
  }
}
```

## Resources

| Resource | URI | Description |
|----------|-----|-------------|
| Scoring Methodology | `maiat://methodology` | How scores are calculated |

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `ALCHEMY_API_KEY` | Recommended | Enables live on-chain scoring |
| `MAIAT_API_KEY` | Optional | Higher rate limits on Maiat API |
| `MAIAT_API_URL` | Optional | Custom API endpoint (default: https://app.maiat.io/api/v1) |

## How It Works

1. **Maiat DB first** — checks indexed scores from Maiat's database
2. **Live fallback** — if no DB record, queries on-chain data via Alchemy
3. **Scoring algorithm** — transaction count, balance, contract status → 0-1000 score

## License

MIT
npm package: @jhinresh/viem-guard
Description: Universal trust middleware for viem — auto-checks Maiat trust score before every transaction
Author: JhiNResH
Latest version: 0.9.0

# @jhinresh/viem-guard

> Universal trust middleware for viem — automatically checks Maiat trust score before every transaction.

## Install

```bash
npm install @jhinresh/viem-guard viem
```

## Usage

```ts
import { createWalletClient, http, parseEther } from 'viem'
import { base } from 'viem/chains'
import { withMaiatTrust } from '@jhinresh/viem-guard'

const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(),
})

// Wrap with Maiat trust gate
const client = withMaiatTrust(walletClient, {
  minScore: 60,  // block if trust score < 60 (default)
})

// All transactions now auto-checked
await client.sendTransaction({
  to: '0xSomeContract',
  value: parseEther('1'),
})
// ^ auto-calls GET /api/v1/trust-check?agent=0xSomeContract
// score < 60 → throws MaiatTrustError
// score ≥ 60 → tx proceeds normally
```

## Options

| Option | Type | Default | Description |
|--------|------|---------|-------------|
| `minScore` | `number` | `60` | Block transactions to addresses below this trust score |
| `apiKey` | `string` | - | `mk_...` key for paid tier (no rate limit) |
| `mode` | `'block' \| 'warn' \| 'silent'` | `'block'` | How to handle low-trust addresses |
| `onWarn` | `(result) => void` | - | Called when `mode='warn'` and address is low-trust |

## Modes

```ts
// block (default) — throws MaiatTrustError
const client = withMaiatTrust(walletClient, { mode: 'block' })

// warn — logs warning, tx continues
const client = withMaiatTrust(walletClient, {
  mode: 'warn',
  onWarn: (result) => console.warn(`Low trust: ${result.address} (${result.score}/100)`),
})

// silent — disables all checks (for testing)
const client = withMaiatTrust(walletClient, { mode: 'silent' })
```

## Error handling

```ts
import { withMaiatTrust, MaiatTrustError } from '@jhinresh/viem-guard'

try {
  await client.sendTransaction({ to: '0x...', value: parseEther('1') })
} catch (e) {
  if (e instanceof MaiatTrustError) {
    console.log(e.address)  // blocked address
    console.log(e.score)    // 0-100
    console.log(e.verdict)  // 'block'
  }
}
```

## What gets intercepted

| tx.to | Trust check |
|-------|-------------|
| DeFi protocol | Protocol trust score |
| Agent wallet | ACP seller reputation |
| NFT contract | Contract safety |
| ERC-20 token | Token trust score |

Both `sendTransaction` and `writeContract` are intercepted. Unknown addresses (not in Maiat DB) are **allowed through** (fail-open).

## Rate limits

| Tier | Limit | How |
|------|-------|-----|
| Free | 10 req/min per IP | Default, no setup |
| Paid | Unlimited | `apiKey: 'mk_...'` |

## Powered by

[Maiat Protocol](https://app.maiat.io) — trust infrastructure for agentic commerce
npm package: @jhintr/lxgw-wenkai-webfont
Description: A webfont package for the LXGW-WenKai typeface
Author: Zhi Shao
Latest version: 1.0.9
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

[![](https://data.jsdelivr.com/v1/package/npm/@jhintr/lxgw-wenkai-webfont/badge)](https://www.jsdelivr.com/package/npm/@jhintr/lxgw-wenkai-webfont)

A webfont package for the [LXGW-WenKai](https://github.com/lxgw/LxgwWenKai) typeface.

The original `unicode.json` is from [noto sans sc](https://github.com/fontsource/fontsource/blob/main/packages/noto-sans-sc/unicode.json), and I will keep extending characters that not included in it.

Benefits a lot from the work of @chawyehsu https://github.com/chawyehsu/lxgw-wenkai-webfont.