open-index/open-npm huggingface dataset:
npm package: @kamiya4047/exptech-api-wrapper
Description: ExpTech API wrapper
Author: Kamiya
Latest version: 3.1.4

# ExpTech API Wrapper

## Installation

```bash
npm install @kamiya4047/exptech-api-wrapper
```

## Usage

API documentation can be found [here](https://docs.exptech.dev/).

You can use default exported instance

```ts
// with CJS require

const ExpTech = require("@kamiya4047/exptech-api-wrapper").default;
await ExpTech.getReportList();

// with ESM import

import ExpTech from "@kamiya4047/exptech-api-wrapper";
await ExpTech.getReportList();
```

or create an instance with ExpTechApi class

```ts
// with CJS require

const { ExpTechApi } = require("@kamiya4047/exptech-api-wrapper");
const api = new ExpTechApi(/* YOUR API KEY HERE */);

// with ESM import

import { ExpTechApi } from "@kamiya4047/exptech-api-wrapper";
const api = new ExpTechApi(/* YOUR API KEY HERE */);
```

### Example

getReportList

```js
import ExpTech from "@kamiya4047/exptech-api-wrapper";

(async () => {
  console.log(await ExpTech.getReportList(10));
})();
```
npm package: @kamiyo-org/actions
Description: Plug-and-play actions for KAMIYO Protocol - Agent payments, disputes, and resolution
Latest version: 0.1.0

# @kamiyo-org/actions

Standalone functions for Kamiyo escrow operations. Works with any agent framework.

## Installation

```bash
npm install @kamiyo-org/actions
```

## Quick Start

```typescript
import { createEscrow, releaseFunds, disputeEscrow } from '@kamiyo-org/actions';
import { Connection, Keypair } from '@solana/web3.js';

const connection = new Connection('https://api.mainnet-beta.solana.com');
const keypair = Keypair.fromSecretKey(/* your secret key */);

// 1. Create payment escrow
const escrow = await createEscrow(
  { connection, keypair },
  {
    provider: 'ProviderWalletAddress',
    amount: 0.1,  // SOL
    timeLockSeconds: 86400,  // 24 hours
    transactionId: 'order-123'
  }
);
console.log('Escrow created:', escrow.escrowAddress);

// 2a. Release funds (service delivered)
await releaseFunds(
  { connection, keypair },
  { transactionId: 'order-123', provider: 'ProviderWalletAddress' }
);

// 2b. OR dispute (service not delivered)
await disputeEscrow(
  { connection, keypair },
  { transactionId: 'order-123' }
);
```

## Actions

### createEscrow

Create a payment escrow with a service provider.

```typescript
const result = await createEscrow(config, {
  provider: string,        // Provider wallet address
  amount: number,          // Amount in SOL
  timeLockSeconds: number, // Lock duration
  transactionId: string    // Unique ID
});
// Returns: { signature, escrowAddress, transactionId }
```

### releaseFunds

Release escrowed funds to provider.

```typescript
const result = await releaseFunds(config, {
  transactionId: string,
  provider: string
});
// Returns: { signature, transactionId }
```

### disputeEscrow

Dispute for oracle arbitration.

```typescript
const result = await disputeEscrow(config, {
  transactionId: string
});
// Returns: { signature, transactionId }
```

### getEscrowStatus

Check escrow state.

```typescript
const status = await getEscrowStatus(config, {
  transactionId: string,
  agent?: string  // Optional: check another agent's escrow
});
// Returns: { address, agent, provider, amount, status, createdAt, expiresAt }
```

### getBalance

Get wallet SOL balance.

```typescript
const balance = await getBalance(config);
// Returns: number (SOL)
```

## Integration Examples

### With OpenAI Function Calling

```typescript
const functions = [
  {
    name: 'create_payment',
    description: 'Create a payment escrow with a provider',
    parameters: {
      type: 'object',
      properties: {
        provider: { type: 'string' },
        amount: { type: 'number' },
        transactionId: { type: 'string' }
      }
    }
  }
];

// In your function handler:
if (name === 'create_payment') {
  return await createEscrow(config, {
    ...args,
    timeLockSeconds: 86400
  });
}
```

### With AutoGPT / AgentGPT

```typescript
const tools = {
  create_escrow: async (args) => createEscrow(config, args),
  release_funds: async (args) => releaseFunds(config, args),
  dispute: async (args) => disputeEscrow(config, args),
};
```

## License

MIT
npm package: @kamiyo-org/eigenai
Description: EigenAI inference client with KAMIYO escrow protection. Verifiable LLM outputs with quality-based payment settlement.
Latest version: 0.1.0

# @kamiyo-org/eigenai

Escrow-protected AI inference on Solana.

```bash
npm install @kamiyo-org/eigenai
```

## Usage

```typescript
import { Connection, Keypair } from '@solana/web3.js';
import { createKamiyoEigenAI, PROGRAM_IDS } from '@kamiyo-org/eigenai';

const client = createKamiyoEigenAI({
  connection: new Connection('https://api.mainnet-beta.solana.com'),
  wallet: Keypair.fromSecretKey(/* your key */),
  programId: PROGRAM_IDS.MAINNET,
  eigenAiAuth: { type: 'apiKey', apiKey: 'your-eigenai-key' },
});

const result = await client.inferenceWithEscrow(
  {
    model: 'gpt-oss-120b-f16',
    messages: [{ role: 'user', content: 'Hello' }],
    escrowAmount: 0.01,
  },
  userTokenAccount,
  treasury
);

if (result.success) {
  console.log(result.response);
}
```

## Flow

1. Lock SOL in escrow
2. EigenAI returns response + attestation
3. Release funds or dispute

## Auth

```typescript
// API Key
eigenAiAuth: { type: 'apiKey', apiKey: 'key' }

// Wallet Grant
eigenAiAuth: { type: 'grant', privateKey: Uint8Array(32), walletAddress: '0x...' }
```

## API

```typescript
// Escrow-protected inference
client.inferenceWithEscrow(params, userTokenAccount, treasury)

// Release with rating (1-5)
client.releaseEscrow(escrowId, 5)

// Dispute
client.disputeWithAttestation(escrowId)

// Get dispute evidence
client.getDisputeEvidence(escrowId) // { attestation, prompt, output }

// Direct call (no escrow)
client.callEigenAI(params)
```

## Quality Tiers

| Score | Refund |
|-------|--------|
| 80+ | 0% |
| 65-79 | 35% |
| 50-64 | 75% |
| <50 | 100% |

## Config

```typescript
createKamiyoEigenAI({
  connection,
  wallet,
  programId,
  eigenAiAuth,
  defaultEscrowAmount: 0.01,     // SOL
  defaultQualityThreshold: 70,
  defaultTimeoutMs: 60000,
  debug: false,
})
```

## Constants

```typescript
PROGRAM_IDS.MAINNET  // FVnvAs8bahMwAvjcLq5ZrXksuu5Qeu2MRkbjwB9mua3u
PROGRAM_IDS.DEVNET   // EqScj2SUahLLUuP56s77yK6bPr3VEPoTyDecjvyoBtxT
KAMIYO_MINT          // Gy55EJmheLyDXiZ7k7CW2FhunD1UgjQxQibuBn3Npump

LIMITS.MIN_ESCROW_SOL     // 0.001
LIMITS.MAX_ESCROW_SOL     // 100
LIMITS.MAX_MESSAGES       // 100
LIMITS.SESSION_ID_LENGTH  // 32
```

## Models

- `gpt-oss-120b-f16`
- `qwen3-32b-128k-bf16`

## License

MIT
npm package: @kamiyo-org/eliza-trust-provider
Description: KAMIYO on-chain trust bridge for ElizaOS plugin-trust — maps stake, escrow, and oracle data to TrustEvidence
Author: KAMIYO
Latest version: 1.0.0

# @kamiyo-org/eliza-trust-provider

Bridges KAMIYO on-chain economic trust signals into ElizaOS `@elizaos/plugin-trust`.

It provides:
- Providers for `trustProfile` and `securityStatus` context.
- A `kamiyo-trust-evidence-bridge` service that converts on-chain state changes into `TrustInteraction` records and forwards them to the plugin-trust TrustEngine when available.

## Installation

This package is intended to be used alongside:
- `@kamiyo-org/eliza`
- `@elizaos/plugin-trust` (optional)

## Runtime Settings

- `KAMIYO_NETWORK`: `mainnet` | `devnet` | `localnet` (default: `mainnet`)
- `SOLANA_PRIVATE_KEY`: Solana keypair as base64, JSON array, or comma-separated bytes
- `KAMIYO_TRUST_EVIDENCE_SYNC`: `manual` | `periodic` (default: `manual`)
- `KAMIYO_TRUST_SYNC_INTERVAL`: periodic sync interval in ms (default: `300000`)
- `KAMIYO_TRUST_EVIDENCE_WEIGHT`: impact multiplier (default: `1.0`)

## Evidence Semantics

The bridge records evidence about the on-chain entity as interactions of the form:
- `sourceEntityId`: the on-chain entity (base58 address)
- `targetEntityId`: the current agent (`runtime.agentId`)

This matches plugin-trust's default pattern where the evidence source is the entity being evaluated.