@elizaos/plugin-tee

Multi-language Trusted Execution Environment (TEE) integration plugin for elizaOS, providing secure key management and remote attestation capabilities.

🌐 Multi-Language Support

This plugin is implemented in three languages for maximum flexibility:

| Language | Package | Registry | | ---------- | --------------------- | --------- | | TypeScript | @elizaos/plugin-tee | npm | | Rust | elizaos-plugin-tee | crates.io | | Python | elizaos-plugin-tee | PyPI |

All implementations share the same API design and behavior.

Features

• 🔐 Remote Attestation - Generate verifiable proofs that your agent is running in a secure TEE
• 🔑 Key Derivation - Securely derive Ed25519 (Solana) and ECDSA (EVM) keypairs within the TEE
• 🛡️ Vendor Support - Extensible vendor system (currently supports Phala Network)
• ⚡ Type Safe - Strong typing in all languages (TypeScript, Rust, Python/Pydantic)
• 🔒 No Unsafe Code - Rust implementation uses #![deny(unsafe_code)]

Quick Start

TypeScript

import { teePlugin, TEEService } from "@elizaos/plugin-tee";
import { AgentRuntime } from "@elizaos/core";

// Register the plugin
const runtime = new AgentRuntime({
  plugins: [teePlugin],
});

// Or use the service directly
const service = await TEEService.start(runtime);
const solanaKeys = await service.deriveEd25519Keypair(
  "salt",
  "solana",
  agentId,
);
const evmKeys = await service.deriveEcdsaKeypair("salt", "evm", agentId);

Rust

use elizaos_plugin_tee::{TEEService, TeeMode};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let service = TEEService::start(Some("LOCAL"), None)?;

    let solana = service.derive_ed25519_keypair("salt", "solana", "agent-id").await?;
    println!("Solana: {}", solana.public_key);

    let evm = service.derive_ecdsa_keypair("salt", "evm", "agent-id").await?;
    println!("EVM: {}", evm.address);

    Ok(())
}

Python

from elizaos_plugin_tee import TEEService, TeeMode

async def main():
    service = await TEEService.start(tee_mode="LOCAL")

    solana = await service.derive_ed25519_keypair("salt", "solana", "agent-id")
    print(f"Solana: {solana.public_key}")

    evm = await service.derive_ecdsa_keypair("salt", "evm", "agent-id")
    print(f"EVM: {evm.address}")

    await service.stop()

Configuration

Environment Variables

| Variable | Description | Required | Default | | -------------------- | ----------------------------------------------- | -------- | ------- | | TEE_MODE | Operation mode: LOCAL, DOCKER, PRODUCTION | Yes | - | | WALLET_SECRET_SALT | Secret salt for deterministic key derivation | Yes | - | | TEE_VENDOR | TEE vendor to use | No | phala |

TEE Modes

• LOCAL: Development mode using simulator at localhost:8090
• DOCKER: Docker development mode using simulator at host.docker.internal:8090
• PRODUCTION: Production mode connecting to real TEE infrastructure

Components

Actions

| Action | Description | | -------------------- | --------------------------------------------------------------------- | | REMOTE_ATTESTATION | Generate and upload a remote attestation quote to prove TEE execution |

Providers

| Provider | Description | | -------------------------- | ----------------------------------------------- | | phala-derive-key | Derive Solana and EVM keypairs with attestation | | phala-remote-attestation | Generate remote attestation quotes |

Services

| Service | Description | | ------------ | ---------------------------------------------- | | TEEService | Main service for key derivation and management |

API Reference

TEEService

class TEEService {
  // Derive Ed25519 keypair for Solana
  async deriveEd25519Keypair(
    path: string,
    subject: string,
    agentId: UUID,
  ): Promise<{ keypair: Keypair; attestation: RemoteAttestationQuote }>;

  // Derive ECDSA keypair for EVM
  async deriveEcdsaKeypair(
    path: string,
    subject: string,
    agentId: UUID,
  ): Promise<{
    keypair: PrivateKeyAccount;
    attestation: RemoteAttestationQuote;
  }>;

  // Derive raw key for custom use cases
  async rawDeriveKey(path: string, subject: string): Promise<DeriveKeyResponse>;
}

Remote Attestation

class PhalaRemoteAttestationProvider {
  // Generate attestation quote
  async generateAttestation(
    reportData: string,
    hashAlgorithm?: TdxQuoteHashAlgorithm,
  ): Promise<RemoteAttestationQuote>;
}

Directory Structure

plugins/plugin-tee/
├── typescript/           # TypeScript implementation
│   ├── src/
│   │   ├── actions/      # Remote attestation action
│   │   ├── providers/    # Key derivation & attestation providers
│   │   ├── services/     # TEE service
│   │   ├── types/        # Type definitions
│   │   ├── vendors/      # Vendor implementations
│   │   └── index.ts      # Main entry point
│   └── __tests__/        # Unit tests
├── rust/                 # Rust implementation
│   ├── src/
│   │   ├── actions/      # Remote attestation action
│   │   ├── providers/    # Key derivation & attestation providers
│   │   ├── services/     # TEE service
│   │   ├── types.rs      # Type definitions
│   │   └── lib.rs        # Main entry point
│   ├── tests/            # Integration tests
│   └── Cargo.toml        # Crate manifest
├── python/               # Python implementation
│   ├── elizaos_plugin_tee/
│   │   ├── actions/      # Remote attestation action
│   │   ├── providers/    # Key derivation & attestation providers
│   │   ├── services/     # TEE service
│   │   ├── types.py      # Pydantic models
│   │   └── __init__.py   # Main entry point
│   ├── tests/            # Unit tests
│   └── pyproject.toml    # Package manifest
├── package.json          # NPM manifest
└── README.md             # This file

Development

Building

# TypeScript
bun run build

# Rust (native)
cd rust && cargo build --release

# Rust (WASM)
bun run build:rust:wasm

# Python (install in dev mode)
cd python && pip install -e ".[dev]"

Testing

# TypeScript
bun run test

# Rust
bun run test:rust

# Python
bun run test:python

# All languages
bun run test:all

Linting

# TypeScript
bun run format:check

# Rust
bun run lint:rust

# Python
bun run lint:python

Requirements

• TypeScript: Node.js 18+ or Bun
• Rust: Rust 1.70+
• Python: Python 3.11+
• TEE Environment: Intel TDX-enabled environment or Phala Cloud for production

License

MIT

Related Links

• elizaOS Documentation
• Phala Network
• Intel TDX