@elizaos/plugin-tee 0.1.9 → 1.0.0-alpha.0

package/dist/index.js

@@ -1,26 +1,23 @@
 import {
-  secp256k1
-} from "./chunk-4L6P6TY5.js";
+  secp256k1,
+  sha256
+} from "./chunk-LCSUOOZR.js";
 import {
   BaseError,
   BytesSizeMismatchError,
   FeeCapTooHighError,
-  Hash,
   InvalidAddressError,
   InvalidChainIdError,
   InvalidLegacyVError,
   InvalidSerializableTransactionError,
   InvalidStorageKeySizeError,
   TipAboveFeeCapError,
-  aexists,
-  aoutput,
   bytesRegex,
   bytesToHex,
   checksumAddress,
   concat,
   concatHex,
   createCursor,
-  createView,
   encodeAbiParameters,
   hexToBigInt,
   hexToBytes,
@@ -31,57 +28,253 @@ import {
   keccak256,
   maxUint256,
   numberToHex,
-  rotr,
   size,
   slice,
   stringToHex,
   stringify,
   toBytes,
-  toBytes2,
   toHex,
-  trim,
-  wrapConstructor
-} from "./chunk-NTU6R7BC.js";
+  trim
+} from "./chunk-4HQ7LDIJ.js";
+import "./chunk-672HY72Z.js";
 import "./chunk-PR4QN5HX.js";
 
-// src/providers/remoteAttestationProvider.ts
+// src/index.ts
+import {
+  logger as logger4
+} from "@elizaos/core";
+
+// src/services/teeLogService.ts
 import {
-  elizaLogger
+  Service,
+  ServiceTypes,
+  TeeType as TeeType2,
+  TEEMode as TEEMode2
 } from "@elizaos/core";
-import { TappdClient } from "@phala/dstack-sdk";
 
-// src/types/tee.ts
-var TEEMode = /* @__PURE__ */ ((TEEMode2) => {
-  TEEMode2["OFF"] = "OFF";
-  TEEMode2["LOCAL"] = "LOCAL";
-  TEEMode2["DOCKER"] = "DOCKER";
-  TEEMode2["PRODUCTION"] = "PRODUCTION";
-  return TEEMode2;
-})(TEEMode || {});
+// src/types.ts
+var TeeLogDAO = class {
+  db;
+};
+
+// src/adapters/sqliteTables.ts
+var sqliteTables = `
+BEGIN TRANSACTION;
+
+-- Table: tee_logs
+CREATE TABLE IF NOT EXISTS "tee_logs" (
+    "id" TEXT PRIMARY KEY,
+    "agentId" TEXT NOT NULL,
+    "roomId" TEXT NOT NULL,
+    "entityId" TEXT NOT NULL,
+    "type" TEXT NOT NULL,
+    "content" TEXT NOT NULL,
+    "timestamp" TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    "signature" TEXT NOT NULL
+);
+
+-- Table: tee_agents
+CREATE TABLE IF NOT EXISTS "tee_agents" (
+    "id" TEXT PRIMARY KEY,
+    "agentId" TEXT NOT NULL,
+    "agentName" TEXT NOT NULL,
+    "createdAt" TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    "publicKey" TEXT NOT NULL,
+    "attestation" TEXT NOT NULL
+);
+
+COMMIT;`;
+
+// src/adapters/sqliteDAO.ts
+var SqliteTeeLogDAO = class extends TeeLogDAO {
+  constructor(db) {
+    super();
+    this.db = db;
+  }
+  async initialize() {
+    this.db.exec(sqliteTables);
+  }
+  async addLog(log) {
+    const stmt = this.db.prepare(
+      "INSERT INTO tee_logs (id, agentId, roomId, entityId, type, content, timestamp, signature) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    try {
+      stmt.run(
+        log.id,
+        log.agentId,
+        log.roomId,
+        log.entityId,
+        log.type,
+        log.content,
+        log.timestamp,
+        log.signature
+      );
+      return true;
+    } catch (error) {
+      console.error("Error adding log to database", error);
+      return false;
+    }
+  }
+  async getPagedLogs(query, page, pageSize) {
+    const currentPage = page < 1 ? 1 : page;
+    const offset = (currentPage - 1) * pageSize;
+    const limit = pageSize;
+    const whereConditions = [];
+    const params = [];
+    if (query.agentId && query.agentId !== "") {
+      whereConditions.push("agentId = ?");
+      params.push(query.agentId);
+    }
+    if (query.roomId && query.roomId !== "") {
+      whereConditions.push("roomId = ?");
+      params.push(query.roomId);
+    }
+    if (query.entityId && query.entityId !== "") {
+      whereConditions.push("entityId = ?");
+      params.push(query.entityId);
+    }
+    if (query.type && query.type !== "") {
+      whereConditions.push("type = ?");
+      params.push(query.type);
+    }
+    if (query.containsContent && query.containsContent !== "") {
+      whereConditions.push("content LIKE ?");
+      params.push(`%${query.containsContent}%`);
+    }
+    if (query.startTimestamp) {
+      whereConditions.push("timestamp >= ?");
+      params.push(query.startTimestamp);
+    }
+    if (query.endTimestamp) {
+      whereConditions.push("timestamp <= ?");
+      params.push(query.endTimestamp);
+    }
+    const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
+    try {
+      const total_stmt = this.db.prepare(
+        `SELECT COUNT(*) as total FROM tee_logs ${whereClause}`
+      );
+      const total = total_stmt.get(params).total;
+      const logs_stmt = this.db.prepare(
+        `SELECT * FROM tee_logs ${whereClause} ORDER BY timestamp ASC LIMIT ? OFFSET ?`
+      );
+      const logs = logs_stmt.all(...params, limit, offset);
+      return {
+        page: currentPage,
+        pageSize,
+        total,
+        data: logs
+      };
+    } catch (error) {
+      console.error("Error getting paged logs from database", error);
+      throw error;
+    }
+  }
+  async addAgent(agent) {
+    const stmt = this.db.prepare(
+      "INSERT INTO tee_agents (id, agentId, agentName, createdAt, publicKey, attestation) VALUES (?, ?, ?, ?, ?, ?)"
+    );
+    try {
+      stmt.run(
+        agent.id,
+        agent.agentId,
+        agent.agentName,
+        agent.createdAt,
+        agent.publicKey,
+        agent.attestation
+      );
+      return true;
+    } catch (error) {
+      console.error("Error adding agent to database", error);
+      return false;
+    }
+  }
+  async getAgent(agentId) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM tee_agents WHERE agentId = ? ORDER BY createdAt DESC LIMIT 1"
+    );
+    try {
+      return stmt.get(agentId);
+    } catch (error) {
+      console.error("Error getting agent from database", error);
+      throw error;
+    }
+  }
+  async getAllAgents() {
+    const stmt = this.db.prepare("SELECT * FROM tee_agents");
+    try {
+      return stmt.all();
+    } catch (error) {
+      console.error("Error getting all agents from database", error);
+      throw error;
+    }
+  }
+};
 
 // src/providers/remoteAttestationProvider.ts
+import {
+  logger
+} from "@elizaos/core";
+import {
+  TappdClient
+} from "@phala/dstack-sdk";
+import {
+  TEEMode
+} from "@elizaos/core";
+import { promises as fs } from "node:fs";
+
+// src/utils.ts
+import { createHash } from "node:crypto";
+function hexToUint8Array(hex) {
+  const hexString = hex.trim().replace(/^0x/, "");
+  if (!hexString) {
+    throw new Error("Invalid hex string");
+  }
+  if (hexString.length % 2 !== 0) {
+    throw new Error("Invalid hex string");
+  }
+  const array = new Uint8Array(hexString.length / 2);
+  for (let i = 0; i < hexString.length; i += 2) {
+    const byte = Number.parseInt(hexString.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid hex string");
+    }
+    array[i / 2] = byte;
+  }
+  return array;
+}
+function calculateSHA256(input) {
+  const hash = createHash("sha256");
+  hash.update(input);
+  return hash.digest();
+}
+
+// src/providers/base.ts
+var DeriveKeyProvider = class {
+};
 var RemoteAttestationProvider = class {
+};
+
+// src/providers/remoteAttestationProvider.ts
+var PhalaRemoteAttestationProvider = class extends RemoteAttestationProvider {
   client;
   constructor(teeMode) {
+    super();
     let endpoint;
     switch (teeMode) {
-      case "LOCAL" /* LOCAL */:
+      case TEEMode.LOCAL:
         endpoint = "http://localhost:8090";
-        elizaLogger.log(
-          "TEE: Connecting to local simulator at localhost:8090"
-        );
+        logger.log("TEE: Connecting to local simulator at localhost:8090");
         break;
-      case "DOCKER" /* DOCKER */:
+      case TEEMode.DOCKER:
         endpoint = "http://host.docker.internal:8090";
-        elizaLogger.log(
+        logger.log(
           "TEE: Connecting to simulator via Docker at host.docker.internal:8090"
         );
         break;
-      case "PRODUCTION" /* PRODUCTION */:
+      case TEEMode.PRODUCTION:
         endpoint = void 0;
-        elizaLogger.log(
-          "TEE: Running in production mode without simulator"
-        );
+        logger.log("TEE: Running in production mode without simulator");
         break;
       default:
         throw new Error(
@@ -92,10 +285,13 @@ var RemoteAttestationProvider = class {
   }
   async generateAttestation(reportData, hashAlgorithm) {
     try {
-      elizaLogger.log("Generating attestation for: ", reportData);
-      const tdxQuote = await this.client.tdxQuote(reportData, hashAlgorithm);
+      logger.log("Generating attestation for: ", reportData);
+      const tdxQuote = await this.client.tdxQuote(
+        reportData,
+        hashAlgorithm
+      );
       const rtmrs = tdxQuote.replayRtmrs();
-      elizaLogger.log(
+      logger.log(
         `rtmr0: ${rtmrs[0]}
 rtmr1: ${rtmrs[1]}
 rtmr2: ${rtmrs[2]}
@@ -105,7 +301,7 @@ rtmr3: ${rtmrs[3]}f`
         quote: tdxQuote.quote,
         timestamp: Date.now()
       };
-      elizaLogger.log("Remote attestation quote: ", quote);
+      logger.log("Remote attestation quote: ", quote);
       return quote;
     } catch (error) {
       console.error("Error generating remote attestation:", error);
@@ -115,24 +311,39 @@ rtmr3: ${rtmrs[3]}f`
     }
   }
 };
-var remoteAttestationProvider = {
-  get: async (runtime, message, _state) => {
+var phalaRemoteAttestationProvider = {
+  name: "phala-remote-attestation",
+  get: async (runtime, message) => {
     const teeMode = runtime.getSetting("TEE_MODE");
-    const provider = new RemoteAttestationProvider(teeMode);
+    const provider = new PhalaRemoteAttestationProvider(teeMode);
     const agentId = runtime.agentId;
     try {
       const attestationMessage = {
         agentId,
         timestamp: Date.now(),
         message: {
-          userId: message.userId,
+          entityId: message.entityId,
           roomId: message.roomId,
           content: message.content.text
         }
       };
-      elizaLogger.log("Generating attestation for: ", JSON.stringify(attestationMessage));
-      const attestation = await provider.generateAttestation(JSON.stringify(attestationMessage));
-      return `Your Agent's remote attestation is: ${JSON.stringify(attestation)}`;
+      logger.log(
+        "Generating attestation for: ",
+        JSON.stringify(attestationMessage)
+      );
+      const attestation = await provider.generateAttestation(
+        JSON.stringify(attestationMessage)
+      );
+      return {
+        text: `Your Agent's remote attestation is: ${JSON.stringify(attestation)}`,
+        data: {
+          attestation
+        },
+        values: {
+          quote: attestation.quote,
+          timestamp: attestation.timestamp.toString()
+        }
+      };
     } catch (error) {
       console.error("Error in remote attestation provider:", error);
       throw new Error(
@@ -141,266 +352,327 @@ var remoteAttestationProvider = {
     }
   }
 };
+var SgxAttestationProvider = class extends RemoteAttestationProvider {
+  SGX_QUOTE_MAX_SIZE = 8192 * 4;
+  SGX_TARGET_INFO_SIZE = 512;
+  MY_TARGET_INFO_PATH = "/dev/attestation/my_target_info";
+  TARGET_INFO_PATH = "/dev/attestation/target_info";
+  USER_REPORT_DATA_PATH = "/dev/attestation/user_report_data";
+  QUOTE_PATH = "/dev/attestation/quote";
+  // Remove unnecessary constructor
+  // constructor() {}
+  async generateAttestation(reportData) {
+    const rawUserReport = calculateSHA256(reportData);
+    try {
+      await fs.access(this.MY_TARGET_INFO_PATH);
+      const quote = await this.generateQuoteByGramine(rawUserReport);
+      const attestation = {
+        quote,
+        timestamp: Date.now()
+      };
+      return attestation;
+    } catch (error) {
+      console.error("Error generating SGX remote attestation:", error);
+      throw new Error(
+        `Failed to generate SGX Quote: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async generateQuoteByGramine(rawUserReport) {
+    if (rawUserReport.length > 64) {
+      throw new Error("the length of rawUserReport exceeds 64 bytes");
+    }
+    const myTargetInfo = await fs.readFile(this.MY_TARGET_INFO_PATH);
+    if (myTargetInfo.length !== this.SGX_TARGET_INFO_SIZE) {
+      throw new Error("Invalid my_target_info length");
+    }
+    await fs.writeFile(this.TARGET_INFO_PATH, myTargetInfo);
+    await fs.writeFile(this.USER_REPORT_DATA_PATH, rawUserReport);
+    const quoteData = await fs.readFile(this.QUOTE_PATH);
+    if (quoteData.length > this.SGX_QUOTE_MAX_SIZE) {
+      throw new Error("Invalid quote length");
+    }
+    const realLen = quoteData.lastIndexOf(0);
+    if (realLen === -1) {
+      throw new Error("quote without EOF");
+    }
+    return `0x${quoteData.subarray(0, realLen + 1).toString("hex")}`;
+  }
+};
+var sgxAttestationProvider = {
+  name: "sgx-gramine-remote-attestation",
+  get: async (runtime, _message) => {
+    const provider = new SgxAttestationProvider();
+    const agentId = runtime.agentId;
+    try {
+      const attestation = await provider.generateAttestation(agentId);
+      return {
+        data: attestation,
+        values: {
+          quote: attestation.quote,
+          timestamp: attestation.timestamp.toString()
+        },
+        text: `Your Agent's remote attestation is: ${JSON.stringify(attestation)}`
+      };
+    } catch (error) {
+      console.error("Error in remote attestation provider:", error);
+      const errorMessage = `Failed to generate SGX Quote: ${error instanceof Error ? error.message : "Unknown error"}`;
+      return {
+        data: null,
+        values: {},
+        text: errorMessage
+      };
+    }
+  }
+};
 
-// src/providers/deriveKeyProvider.ts
+// src/services/teeLogManager.ts
 import {
-  elizaLogger as elizaLogger2
+  TeeType
 } from "@elizaos/core";
-import { Keypair } from "@solana/web3.js";
-import crypto from "crypto";
-import { TappdClient as TappdClient2 } from "@phala/dstack-sdk";
+import elliptic from "elliptic";
 
-// ../../node_modules/viem/node_modules/@noble/hashes/esm/_md.js
-function setBigUint64(view, byteOffset, value, isLE) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE ? 4 : 0;
-  const l = isLE ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE);
-  view.setUint32(byteOffset + l, wl, isLE);
+// ../../node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
 }
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-var HashMD = class extends Hash {
-  constructor(blockLen, outputLen, padOffset, isLE) {
-    super();
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE;
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    aexists(this);
-    const { view, buffer, blockLen } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen)
-          this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../../node_modules/uuid/dist/esm/rng.js
+import { randomFillSync } from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/uuid/dist/esm/native.js
+import { randomUUID } from "crypto";
+var native_default = { randomUUID };
+
+// ../../node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/services/teeLogManager.ts
+var TeeLogManager = class {
+  teeLogDAO;
+  teeType;
+  teeMode;
+  // Only used for plugin-tee with TDX dstack
+  // Map of agentId to its key pair
+  // These keypairs only store in memory.
+  // When the agent restarts, we will generate new keypair.
+  keyPairs = /* @__PURE__ */ new Map();
+  constructor(teeLogDAO, teeType, teeMode) {
+    this.teeLogDAO = teeLogDAO;
+    this.teeType = teeType;
+    this.teeMode = teeMode;
+  }
+  async registerAgent(agentId, agentName) {
+    if (!agentId) {
+      throw new Error("Agent ID is required");
+    }
+    const keyPair = this.generateKeyPair();
+    this.keyPairs.set(agentId, keyPair);
+    const publicKey = keyPair.getPublic().encode("hex", true);
+    const attestation = await this.generateAttestation(publicKey);
+    const new_agent = {
+      id: v4_default(),
+      agentId,
+      agentName: agentName || "",
+      createdAt: (/* @__PURE__ */ new Date()).getTime(),
+      publicKey,
+      attestation
+    };
+    console.log("registerAgent new_agent", new_agent);
+    return this.teeLogDAO.addAgent(new_agent);
+  }
+  async getAllAgents() {
+    return this.teeLogDAO.getAllAgents();
+  }
+  async getAgent(agentId) {
+    return this.teeLogDAO.getAgent(agentId);
+  }
+  async log(agentId, roomId, entityId, type, content) {
+    const keyPair = this.keyPairs.get(agentId);
+    if (!keyPair) {
+      throw new Error(`Agent ${agentId} not found`);
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).getTime();
+    const messageToSign = `${agentId}|${roomId}|${entityId}|${type}|${content}|${timestamp}`;
+    const signature = `0x${keyPair.sign(messageToSign).toDER("hex")}`;
+    return this.teeLogDAO.addLog({
+      id: v4_default(),
+      agentId,
+      roomId,
+      entityId,
+      type,
+      content,
+      timestamp,
+      signature
+    });
+  }
+  async getLogs(query, page, pageSize) {
+    return this.teeLogDAO.getPagedLogs(query, page, pageSize);
+  }
+  generateKeyPair() {
+    const ec = new elliptic.ec("secp256k1");
+    const key = ec.genKeyPair();
+    return key;
+  }
+  async generateAttestation(userReport) {
+    if (this.teeType === TeeType.SGX_GRAMINE) {
+      const sgxAttestationProvider2 = new SgxAttestationProvider();
+      const sgxAttestation = await sgxAttestationProvider2.generateAttestation(userReport);
+      return JSON.stringify(sgxAttestation);
     }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    this.buffer.subarray(pos).fill(0);
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
+    if (this.teeType === TeeType.TDX_DSTACK) {
+      const tdxAttestationProvider = new PhalaRemoteAttestationProvider(this.teeMode);
+      const tdxAttestation = await tdxAttestationProvider.generateAttestation(userReport);
+      return JSON.stringify(tdxAttestation);
     }
-    for (let i = pos; i < blockLen; i++)
-      buffer[i] = 0;
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    if (len % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let i = 0; i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    to || (to = new this.constructor());
-    to.set(...this.get());
-    const { blockLen, buffer, length, finished, destroyed, pos } = this;
-    to.length = length;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length % blockLen)
-      to.buffer.set(buffer);
-    return to;
+    throw new Error("Invalid TEE type");
   }
 };
 
-// ../../node_modules/viem/node_modules/@noble/hashes/esm/sha256.js
-var SHA256_K = /* @__PURE__ */ new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var SHA256_IV = /* @__PURE__ */ new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends HashMD {
-  constructor() {
-    super(64, 32, 8, false);
-    this.A = SHA256_IV[0] | 0;
-    this.B = SHA256_IV[1] | 0;
-    this.C = SHA256_IV[2] | 0;
-    this.D = SHA256_IV[3] | 0;
-    this.E = SHA256_IV[4] | 0;
-    this.F = SHA256_IV[5] | 0;
-    this.G = SHA256_IV[6] | 0;
-    this.H = SHA256_IV[7] | 0;
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+// src/services/teeLogService.ts
+import Database from "better-sqlite3";
+import path from "node:path";
+var TeeLogService = class _TeeLogService extends Service {
+  dbPath;
+  initialized = false;
+  enableTeeLog = false;
+  teeType;
+  teeMode = TEEMode2.OFF;
+  // Only used for plugin-tee with TDX dstack
+  teeLogDAO;
+  teeLogManager;
+  static serviceType = ServiceTypes.TEE;
+  capabilityDescription = "The agent is able to log TEE attestation events and is probably running in a TEE";
+  constructor(runtime) {
+    super();
+    this.runtime = runtime;
+  }
+  static async start(runtime) {
+    const service = new _TeeLogService(runtime);
+    const enableValues = ["true", "1", "yes", "enable", "enabled", "on"];
+    const enableTeeLog = runtime.getSetting("ENABLE_TEE_LOG");
+    if (enableTeeLog === null) {
+      throw new Error("ENABLE_TEE_LOG is not set.");
+    }
+    service.enableTeeLog = enableValues.includes(enableTeeLog.toLowerCase());
+    if (!service.enableTeeLog) {
+      console.log("TEE log is not enabled.");
+      return;
+    }
+    const runInSgx = runtime.getSetting("SGX");
+    const teeMode = runtime.getSetting("TEE_MODE");
+    const walletSecretSalt = runtime.getSetting("WALLET_SECRET_SALT");
+    service.teeMode = teeMode ? TEEMode2[teeMode] : TEEMode2.OFF;
+    const useSgxGramine = runInSgx && enableValues.includes(runInSgx.toLowerCase());
+    const useTdxDstack = teeMode && teeMode !== TEEMode2.OFF && walletSecretSalt;
+    if (useSgxGramine && useTdxDstack) {
+      throw new Error("Cannot configure both SGX and TDX at the same time.");
+    }
+    if (useSgxGramine) {
+      service.teeType = TeeType2.SGX_GRAMINE;
+    } else if (useTdxDstack) {
+      service.teeType = TeeType2.TDX_DSTACK;
+    } else {
+      throw new Error("Invalid TEE configuration.");
+    }
+    const dbPathSetting = runtime.getSetting("TEE_LOG_DB_PATH");
+    service.dbPath = dbPathSetting || path.resolve("data/tee_log.sqlite");
+    const db = new Database(service.dbPath);
+    service.teeLogDAO = new SqliteTeeLogDAO(db);
+    service.teeLogManager = new TeeLogManager(
+      service.teeLogDAO,
+      service.teeType,
+      service.teeMode
+    );
+    const isRegistered = await service.teeLogManager.registerAgent(
+      runtime?.agentId,
+      runtime?.character?.name
+    );
+    if (!isRegistered) {
+      throw new Error(`Failed to register agent ${runtime.agentId}`);
+    }
+    service.initialized = true;
+    return service;
+  }
+  static async stop(runtime) {
+    const service = runtime.getService(ServiceTypes.TEE);
+    if (service) {
+      await service.stop();
+    }
+  }
+  async stop() {
+  }
+  async log(agentId, roomId, entityId, type, content) {
+    if (!this.enableTeeLog) {
+      return false;
+    }
+    return this.teeLogManager.log(agentId, roomId, entityId, type, content);
+  }
+  async getAllAgents() {
+    if (!this.enableTeeLog) {
+      return [];
+    }
+    return this.teeLogManager.getAllAgents();
+  }
+  async getAgent(agentId) {
+    if (!this.enableTeeLog) {
+      return void 0;
     }
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + Maj(A, B, C) | 0;
-      H = G;
-      G = F;
-      F = E;
-      E = D + T1 | 0;
-      D = C;
-      C = B;
-      B = A;
-      A = T1 + T2 | 0;
+    return this.teeLogManager.getAgent(agentId);
+  }
+  async getLogs(query, page, pageSize) {
+    if (!this.enableTeeLog) {
+      return {
+        data: [],
+        total: 0,
+        page,
+        pageSize
+      };
     }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    SHA256_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
+    return this.teeLogManager.getLogs(query, page, pageSize);
+  }
+  async generateAttestation(userReport) {
+    return this.teeLogManager.generateAttestation(userReport);
   }
 };
-var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
+// src/providers/deriveKeyProvider.ts
+import {
+  logger as logger2
+} from "@elizaos/core";
+import { Keypair } from "@solana/web3.js";
+import crypto from "node:crypto";
+import { TappdClient as TappdClient2 } from "@phala/dstack-sdk";
 
 // ../../node_modules/viem/_esm/accounts/toAccount.js
 function toAccount(source) {
@@ -643,7 +915,7 @@ function blobsToProofs(parameters) {
 // ../../node_modules/viem/_esm/utils/hash/sha256.js
 function sha2562(value, to_) {
   const to = to_ || "hex";
-  const bytes = sha256(isHex(value, { strict: false }) ? toBytes2(value) : value);
+  const bytes = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
   if (to === "bytes")
     return bytes;
   return toHex(bytes);
@@ -1185,7 +1457,7 @@ function getTypesForEIP712Domain({ domain }) {
   return [
     typeof domain?.name === "string" && { name: "name", type: "string" },
     domain?.version && { name: "version", type: "string" },
-    typeof domain?.chainId === "number" && {
+    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
       name: "chainId",
       type: "uint256"
     },
@@ -1356,29 +1628,29 @@ function privateKeyToAccount(privateKey, options = {}) {
 }
 
 // src/providers/deriveKeyProvider.ts
-var DeriveKeyProvider = class {
+import {
+  TEEMode as TEEMode3
+} from "@elizaos/core";
+var PhalaDeriveKeyProvider = class extends DeriveKeyProvider {
   client;
   raProvider;
   constructor(teeMode) {
+    super();
     let endpoint;
     switch (teeMode) {
-      case "LOCAL" /* LOCAL */:
+      case TEEMode3.LOCAL:
         endpoint = "http://localhost:8090";
-        elizaLogger2.log(
-          "TEE: Connecting to local simulator at localhost:8090"
-        );
+        logger2.log("TEE: Connecting to local simulator at localhost:8090");
         break;
-      case "DOCKER" /* DOCKER */:
+      case TEEMode3.DOCKER:
         endpoint = "http://host.docker.internal:8090";
-        elizaLogger2.log(
+        logger2.log(
           "TEE: Connecting to simulator via Docker at host.docker.internal:8090"
         );
         break;
-      case "PRODUCTION" /* PRODUCTION */:
+      case TEEMode3.PRODUCTION:
         endpoint = void 0;
-        elizaLogger2.log(
-          "TEE: Running in production mode without simulator"
-        );
+        logger2.log("TEE: Running in production mode without simulator");
         break;
       default:
         throw new Error(
@@ -1386,7 +1658,7 @@ var DeriveKeyProvider = class {
         );
     }
     this.client = endpoint ? new TappdClient2(endpoint) : new TappdClient2();
-    this.raProvider = new RemoteAttestationProvider(teeMode);
+    this.raProvider = new PhalaRemoteAttestationProvider(teeMode);
   }
   async generateDeriveKeyAttestation(agentId, publicKey, subject) {
     const deriveKeyData = {
@@ -1395,11 +1667,9 @@ var DeriveKeyProvider = class {
       subject
     };
     const reportdata = JSON.stringify(deriveKeyData);
-    elizaLogger2.log(
-      "Generating Remote Attestation Quote for Derive Key..."
-    );
+    logger2.log("Generating Remote Attestation Quote for Derive Key...");
     const quote = await this.raProvider.generateAttestation(reportdata);
-    elizaLogger2.log("Remote Attestation Quote generated successfully!");
+    logger2.log("Remote Attestation Quote generated successfully!");
     return quote;
   }
   /**
@@ -1408,19 +1678,17 @@ var DeriveKeyProvider = class {
    * @param subject - The subject to derive the key from. This is used for the certificate chain.
    * @returns The derived key.
    */
-  async rawDeriveKey(path, subject) {
+  async rawDeriveKey(path2, subject) {
     try {
-      if (!path || !subject) {
-        elizaLogger2.error(
-          "Path and Subject are required for key derivation"
-        );
+      if (!path2 || !subject) {
+        logger2.error("Path and Subject are required for key derivation");
       }
-      elizaLogger2.log("Deriving Raw Key in TEE...");
-      const derivedKey = await this.client.deriveKey(path, subject);
-      elizaLogger2.log("Raw Key Derived Successfully!");
+      logger2.log("Deriving Raw Key in TEE...");
+      const derivedKey = await this.client.deriveKey(path2, subject);
+      logger2.log("Raw Key Derived Successfully!");
       return derivedKey;
     } catch (error) {
-      elizaLogger2.error("Error deriving raw key:", error);
+      logger2.error("Error deriving raw key:", error);
       throw error;
     }
   }
@@ -1431,15 +1699,13 @@ var DeriveKeyProvider = class {
    * @param agentId - The agent ID to generate an attestation for.
    * @returns An object containing the derived keypair and attestation.
    */
-  async deriveEd25519Keypair(path, subject, agentId) {
+  async deriveEd25519Keypair(path2, subject, agentId) {
     try {
-      if (!path || !subject) {
-        elizaLogger2.error(
-          "Path and Subject are required for key derivation"
-        );
+      if (!path2 || !subject) {
+        logger2.error("Path and Subject are required for key derivation");
       }
-      elizaLogger2.log("Deriving Key in TEE...");
-      const derivedKey = await this.client.deriveKey(path, subject);
+      logger2.log("Deriving Key in TEE...");
+      const derivedKey = await this.client.deriveKey(path2, subject);
       const uint8ArrayDerivedKey = derivedKey.asUint8Array();
       const hash = crypto.createHash("sha256");
       hash.update(uint8ArrayDerivedKey);
@@ -1450,10 +1716,10 @@ var DeriveKeyProvider = class {
         agentId,
         keypair.publicKey.toBase58()
       );
-      elizaLogger2.log("Key Derived Successfully!");
+      logger2.log("Key Derived Successfully!");
       return { keypair, attestation };
     } catch (error) {
-      elizaLogger2.error("Error deriving key:", error);
+      logger2.error("Error deriving key:", error);
       throw error;
     }
   }
@@ -1464,40 +1730,44 @@ var DeriveKeyProvider = class {
    * @param agentId - The agent ID to generate an attestation for. This is used for the certificate chain.
    * @returns An object containing the derived keypair and attestation.
    */
-  async deriveEcdsaKeypair(path, subject, agentId) {
+  async deriveEcdsaKeypair(path2, subject, agentId) {
     try {
-      if (!path || !subject) {
-        elizaLogger2.error(
-          "Path and Subject are required for key derivation"
-        );
+      if (!path2 || !subject) {
+        logger2.error("Path and Subject are required for key derivation");
       }
-      elizaLogger2.log("Deriving ECDSA Key in TEE...");
-      const deriveKeyResponse = await this.client.deriveKey(path, subject);
+      logger2.log("Deriving ECDSA Key in TEE...");
+      const deriveKeyResponse = await this.client.deriveKey(
+        path2,
+        subject
+      );
       const hex = keccak256(deriveKeyResponse.asUint8Array());
       const keypair = privateKeyToAccount(hex);
       const attestation = await this.generateDeriveKeyAttestation(
         agentId,
         keypair.address
       );
-      elizaLogger2.log("ECDSA Key Derived Successfully!");
+      logger2.log("ECDSA Key Derived Successfully!");
       return { keypair, attestation };
     } catch (error) {
-      elizaLogger2.error("Error deriving ecdsa key:", error);
+      logger2.error("Error deriving ecdsa key:", error);
       throw error;
     }
   }
 };
-var deriveKeyProvider = {
-  get: async (runtime, _message, _state) => {
+var phalaDeriveKeyProvider = {
+  name: "phala-derive-key",
+  get: async (runtime, _message) => {
     const teeMode = runtime.getSetting("TEE_MODE");
-    const provider = new DeriveKeyProvider(teeMode);
+    const provider = new PhalaDeriveKeyProvider(teeMode);
     const agentId = runtime.agentId;
     try {
       if (!runtime.getSetting("WALLET_SECRET_SALT")) {
-        elizaLogger2.error(
-          "Wallet secret salt is not configured in settings"
-        );
-        return "";
+        logger2.error("Wallet secret salt is not configured in settings");
+        return {
+          data: null,
+          values: {},
+          text: "Wallet secret salt is not configured in settings"
+        };
       }
       try {
         const secretSalt = runtime.getSetting("WALLET_SECRET_SALT") || "secret_salt";
@@ -1511,44 +1781,42 @@ var deriveKeyProvider = {
           "evm",
           agentId
         );
-        return JSON.stringify({
+        const walletData = {
           solana: solanaKeypair.keypair.publicKey,
           evm: evmKeypair.keypair.address
-        });
+        };
+        const values = {
+          solana_public_key: solanaKeypair.keypair.publicKey.toString(),
+          evm_address: evmKeypair.keypair.address
+        };
+        const text = `Solana Public Key: ${values.solana_public_key}
+EVM Address: ${values.evm_address}`;
+        return {
+          data: walletData,
+          values,
+          text
+        };
       } catch (error) {
-        elizaLogger2.error("Error creating PublicKey:", error);
-        return "";
+        logger2.error("Error creating PublicKey:", error);
+        return {
+          data: null,
+          values: {},
+          text: `Error creating PublicKey: ${error instanceof Error ? error.message : "Unknown error"}`
+        };
       }
     } catch (error) {
-      elizaLogger2.error("Error in derive key provider:", error.message);
-      return `Failed to fetch derive key information: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger2.error("Error in derive key provider:", error.message);
+      return {
+        data: null,
+        values: {},
+        text: `Failed to fetch derive key information: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
     }
   }
 };
 
-// src/actions/remoteAttestation.ts
-import { fetch } from "undici";
-function hexToUint8Array(hex) {
-  hex = hex.trim();
-  if (!hex) {
-    throw new Error("Invalid hex string");
-  }
-  if (hex.startsWith("0x")) {
-    hex = hex.substring(2);
-  }
-  if (hex.length % 2 !== 0) {
-    throw new Error("Invalid hex string");
-  }
-  const array = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
-    if (isNaN(byte)) {
-      throw new Error("Invalid hex string");
-    }
-    array[i / 2] = byte;
-  }
-  return array;
-}
+// src/actions/remoteAttestationAction.ts
+import { logger as logger3 } from "@elizaos/core";
 async function uploadUint8Array(data) {
   const blob = new Blob([data], { type: "application/octet-stream" });
   const formData = new FormData();
@@ -1558,7 +1826,7 @@ async function uploadUint8Array(data) {
     body: formData
   });
 }
-var remoteAttestationAction = {
+var phalaRemoteAttestationAction = {
   name: "REMOTE_ATTESTATION",
   similes: ["REMOTE_ATTESTATION", "TEE_REMOTE_ATTESTATION", "TEE_ATTESTATION"],
   description: "Generate a remote attestation to prove that the agent is running in a TEE",
@@ -1568,21 +1836,27 @@ var remoteAttestationAction = {
         agentId: runtime.agentId,
         timestamp: Date.now(),
         message: {
-          userId: message.userId,
+          entityId: message.entityId,
           roomId: message.roomId,
           content: message.content.text
         }
       };
       const teeMode = runtime.getSetting("TEE_MODE");
-      const provider = new RemoteAttestationProvider(teeMode);
-      const attestation = await provider.generateAttestation(JSON.stringify(attestationMessage));
+      logger3.debug(`Tee mode: ${teeMode}`);
+      logger3.debug(
+        `Attestation message: ${JSON.stringify(attestationMessage)}`
+      );
+      const provider = new PhalaRemoteAttestationProvider(teeMode);
+      const attestation = await provider.generateAttestation(
+        JSON.stringify(attestationMessage)
+      );
       const attestationData = hexToUint8Array(attestation.quote);
       const response = await uploadUint8Array(attestationData);
       const data = await response.json();
       callback({
         text: `Here's my \u{1F9FE} RA Quote \u{1FAE1}
 https://proof.t16z.com/reports/${data.checksum}`,
-        action: "NONE"
+        actions: ["NONE"]
       });
       return true;
     } catch (error) {
@@ -1596,46 +1870,158 @@ https://proof.t16z.com/reports/${data.checksum}`,
   examples: [
     [
       {
-        user: "{{user1}}",
+        name: "{{name1}}",
         content: {
           text: "If you are running in a TEE, generate a remote attestation",
-          action: "REMOTE_ATTESTATION"
+          actions: ["REMOTE_ATTESTATION"]
         }
       },
       {
-        user: "{{user2}}",
+        name: "{{agentName}}",
         content: {
           text: "Of course, one second..."
         }
       }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Yo I wanna attest to this message, yo! Can you generate an attestatin for me, please?",
+          actions: ["REMOTE_ATTESTATION"]
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I got you, fam! Lemme hit the cloud and get you a quote in a jiffy!"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "It was a long day, I got a lot done though. I went to the creek and skipped some rocks. Then I decided to take a walk off the natural path. I ended up in a forest I was unfamiliar with. Slowly, I lost the way back and it was dark. A whisper from deep inside said something I could barely make out. The hairs on my neck stood up and then a clear high pitched voice said, 'You are not ready to leave yet! SHOW ME YOUR REMOTE ATTESTATION!'",
+          actions: ["REMOTE_ATTESTATION"]
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Oh, dear...lemme find that for you"
+        }
+      }
     ]
   ]
 };
 
+// src/vendors/phala.ts
+import { TeeVendors } from "@elizaos/core";
+var PhalaVendor = class {
+  type = TeeVendors.PHALA;
+  getActions() {
+    return [phalaRemoteAttestationAction];
+  }
+  getProviders() {
+    return [phalaDeriveKeyProvider, phalaRemoteAttestationProvider];
+  }
+  getName() {
+    return "phala-tee-plugin";
+  }
+  getDescription() {
+    return "Phala TEE Cloud to Host Eliza Agents";
+  }
+};
+
+// src/vendors/types.ts
+var TeeVendorNames = {
+  PHALA: "phala",
+  SGX_GRAMINE: "sgx_gramine"
+};
+
+// src/vendors/gramine.ts
+var GramineVendor = class {
+  type = TeeVendorNames.SGX_GRAMINE;
+  getActions() {
+    return [];
+  }
+  getProviders() {
+    return [sgxAttestationProvider];
+  }
+  getName() {
+    return "sgx-gramine-plugin";
+  }
+  getDescription() {
+    return "SGX Gramine TEE to Host Eliza Agents";
+  }
+};
+
+// src/vendors/index.ts
+var vendors = {
+  [TeeVendorNames.PHALA]: new PhalaVendor(),
+  [TeeVendorNames.SGX_GRAMINE]: new GramineVendor()
+};
+var getVendor = (type) => {
+  const vendor = vendors[type];
+  if (!vendor) {
+    throw new Error(`Unsupported TEE vendor type: ${type}`);
+  }
+  return vendor;
+};
+
 // src/index.ts
-var teePlugin = {
-  name: "tee",
-  description: "TEE plugin with actions to generate remote attestations and derive keys",
-  actions: [
-    /* custom actions */
-    remoteAttestationAction
-  ],
-  evaluators: [
-    /* custom evaluators */
-  ],
-  providers: [
-    /* custom providers */
-    remoteAttestationProvider,
-    deriveKeyProvider
-  ],
-  services: [
-    /* custom services */
-  ]
+async function initializeTEE(config, runtime) {
+  if (config.TEE_VENDOR || runtime.getSetting("TEE_VENDOR")) {
+    const vendor = config.TEE_VENDOR || runtime.getSetting("TEE_VENDOR");
+    logger4.info(`Initializing TEE with vendor: ${vendor}`);
+    let plugin;
+    switch (vendor) {
+      case "phala":
+        plugin = teePlugin({
+          vendor: TeeVendorNames.PHALA,
+          vendorConfig: {
+            apiKey: runtime.getSetting("TEE_API_KEY")
+          }
+        });
+        break;
+      case "sgx-gramine":
+        plugin = teePlugin({
+          vendor: TeeVendorNames.SGX_GRAMINE
+        });
+        break;
+      default:
+        throw new Error(`Invalid TEE vendor: ${vendor}`);
+    }
+    logger4.info(`Pushing plugin: ${plugin.name}`);
+    runtime.plugins.push(plugin);
+  }
+}
+var teePlugin = (config) => {
+  const vendorType = config?.vendor || TeeVendorNames.PHALA;
+  const vendor = getVendor(vendorType);
+  return {
+    name: vendor.getName(),
+    init: async (config2, runtime) => {
+      return await initializeTEE(
+        {
+          ...config2,
+          vendor: vendorType
+        },
+        runtime
+      );
+    },
+    description: vendor.getDescription(),
+    actions: vendor.getActions(),
+    evaluators: [],
+    providers: vendor.getProviders(),
+    services: [TeeLogService]
+  };
 };
 export {
-  DeriveKeyProvider,
-  RemoteAttestationProvider,
-  TEEMode,
+  PhalaDeriveKeyProvider,
+  PhalaRemoteAttestationProvider,
+  TeeLogService,
   teePlugin
 };
 //# sourceMappingURL=index.js.map