@orbitmem/sdk 0.1.0

package/src/discovery/discovery-layer.ts

@@ -0,0 +1,244 @@
+import type { Address } from "viem";
+
+import type { DataRegistration, DiscoveryConfig, IDiscoveryLayer } from "../types.js";
+import { MockRegistry } from "./mock-registry.js";
+import { OnChainRegistry } from "./on-chain-registry.js";
+
+export function createDiscoveryLayer(config: DiscoveryConfig): IDiscoveryLayer {
+  if (config.publicClient && config.walletClient) {
+    return createOnChainDiscoveryLayer(config);
+  }
+  return createMockDiscoveryLayer(config);
+}
+
+// ── On-Chain Implementation ──
+
+function createOnChainDiscoveryLayer(config: DiscoveryConfig): IDiscoveryLayer {
+  const registry = new OnChainRegistry({
+    publicClient: config.publicClient!,
+    walletClient: config.walletClient!,
+    dataRegistry: config.dataRegistry as Address,
+    feedbackRegistry: config.reputationRegistry as Address,
+    deployBlock: config.deployBlock,
+  });
+
+  return {
+    // ── Data Discovery ──
+
+    async registerData(opts) {
+      // On-chain: mint data NFT with URI containing metadata
+      const dataURI = JSON.stringify({
+        name: opts.name,
+        description: opts.description,
+        key: opts.key,
+        schema: opts.schema,
+        tags: opts.tags,
+      });
+      const dataId = await registry.registerData(dataURI);
+      return {
+        dataId,
+        dataRegistry: config.dataRegistry,
+        vaultAddress: "",
+        vaultKey: opts.key,
+        name: opts.name,
+        description: opts.description,
+        visibility: "public",
+        schema: opts.schema,
+        tags: opts.tags ?? [],
+        active: true,
+        owner: config.walletClient!.account!.address as any,
+        ownerChain: "evm",
+        lastUpdated: Date.now(),
+        registeredAt: Date.now(),
+      };
+    },
+
+    async updateDataRegistration(dataId, updates) {
+      if (updates.active !== undefined) {
+        await registry.setActive(config.dataRegistry as Address, dataId, updates.active);
+      }
+      // Re-fetch current state
+      const allData = await registry.findData({});
+      const match = allData.find((d) => d.dataId === dataId);
+      if (!match) throw new Error(`Data registration ${dataId} not found`);
+      return { ...match, ...updates, lastUpdated: Date.now() };
+    },
+
+    async findData(query) {
+      return registry.findData({ activeOnly: query.verifiedOnly });
+    },
+
+    async getDataScore(_vaultAddress, _path) {
+      // On-chain mode requires dataId lookup — return zero score for vault-based lookups
+      return {
+        dataId: 0,
+        vaultAddress: _vaultAddress,
+        vaultKey: _path,
+        quality: 0,
+        freshness: { lastUpdated: 0, score: 0 },
+        accuracy: { score: 0, feedbackCount: 0 },
+        completeness: { score: 0, feedbackCount: 0 },
+        verified: false,
+        consumptionCount: 0,
+        totalFeedback: 0,
+        tagScores: {},
+      };
+    },
+
+    async getDataScoreById(dataId) {
+      return registry.getDataScore(dataId);
+    },
+
+    async rateData(feedback) {
+      return registry.rateData(
+        feedback.dataId,
+        feedback.value,
+        feedback.valueDecimals ?? 0,
+        feedback.tag1 ?? "",
+        feedback.tag2 ?? "",
+        feedback.feedbackURI ?? "",
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+      );
+    },
+
+    // ── Validation ──
+
+    async requestValidation(request) {
+      return {
+        agentId: request.agentId,
+        taskId: request.taskId,
+        method: request.method,
+        status: "pending" as const,
+      };
+    },
+
+    async getValidationStatus(_agentId, _taskId) {
+      return null;
+    },
+
+    // ── Lit Protocol Integration ──
+
+    createDataQualityCondition(opts) {
+      return {
+        conditionType: "evmContract",
+        contractAddress: config.dataRegistry,
+        standardContractType: "",
+        chain: config.registryChain,
+        method: "getScore",
+        parameters: [":dataId"],
+        returnValueTest: { comparator: ">=", value: String(opts.minQuality) },
+      };
+    },
+  };
+}
+
+// ── Mock Implementation (unchanged) ──
+
+function createMockDiscoveryLayer(config: DiscoveryConfig): IDiscoveryLayer {
+  const registry = new MockRegistry();
+  let txCounter = 0;
+
+  return {
+    // ── Data Discovery ──
+
+    async registerData(opts) {
+      return registry.registerData({
+        key: opts.key,
+        name: opts.name,
+        description: opts.description,
+        schema: opts.schema,
+        tags: opts.tags,
+      });
+    },
+
+    async updateDataRegistration(dataId, updates) {
+      // Mock: just return the existing registration with updates
+      const existing = Array.from((registry as any).data.values()).find(
+        (d: any) => d.dataId === dataId,
+      ) as DataRegistration | undefined;
+      if (!existing) throw new Error(`Data registration ${dataId} not found`);
+      Object.assign(existing, updates, { lastUpdated: Date.now() });
+      return existing;
+    },
+
+    async findData(query) {
+      return registry.findData({
+        schema: query.schema,
+        tags: query.tags,
+        minQuality: query.minQuality,
+        verifiedOnly: query.verifiedOnly,
+      });
+    },
+
+    async getDataScore(vaultAddress, path) {
+      // Find data registration by vault address + path
+      const allData = registry.findData({});
+      const match = allData.find((d) => d.vaultAddress === vaultAddress && d.vaultKey === path);
+      if (!match) {
+        return {
+          dataId: 0,
+          vaultAddress,
+          vaultKey: path,
+          quality: 0,
+          freshness: { lastUpdated: 0, score: 0 },
+          accuracy: { score: 0, feedbackCount: 0 },
+          completeness: { score: 0, feedbackCount: 0 },
+          verified: false,
+          consumptionCount: 0,
+          totalFeedback: 0,
+          tagScores: {},
+        };
+      }
+      return registry.getDataScore(match.dataId);
+    },
+
+    async getDataScoreById(dataId) {
+      return registry.getDataScore(dataId);
+    },
+
+    async rateData(feedback) {
+      registry.rateData(feedback.dataId, {
+        clientAddress: "0x0" as any,
+        value: feedback.value,
+        valueDecimals: feedback.valueDecimals ?? 0,
+        tag1: feedback.tag1,
+        tag2: feedback.tag2,
+        feedbackURI: feedback.feedbackURI,
+        isRevoked: false,
+        vaultKey: "",
+        qualityDimension: feedback.qualityDimension,
+      });
+      txCounter++;
+      return { txHash: `0xmock_tx_${txCounter}`, feedbackIndex: txCounter };
+    },
+
+    // ── Validation ──
+
+    async requestValidation(request) {
+      return {
+        agentId: request.agentId,
+        taskId: request.taskId,
+        method: request.method,
+        status: "pending" as const,
+      };
+    },
+
+    async getValidationStatus(_agentId, _taskId) {
+      return null;
+    },
+
+    // ── Lit Protocol Integration ──
+
+    createDataQualityCondition(opts) {
+      return {
+        conditionType: "evmContract",
+        contractAddress: config.dataRegistry,
+        standardContractType: "",
+        chain: config.registryChain,
+        method: "getQualityScore",
+        parameters: [":dataId"],
+        returnValueTest: { comparator: ">=", value: String(opts.minQuality) },
+      };
+    },
+  };
+}

package/src/discovery/index.ts

@@ -0,0 +1,3 @@
+export { createDiscoveryLayer } from "./discovery-layer.js";
+export { MockRegistry } from "./mock-registry.js";
+export { OnChainRegistry, type OnChainRegistryConfig } from "./on-chain-registry.js";

package/src/discovery/mock-registry.ts

@@ -0,0 +1,96 @@
+import type {
+  DataFeedbackEntry,
+  DataRegistration,
+  DataScore,
+  DataTag,
+  Visibility,
+  WalletAddress,
+} from "../types.js";
+
+export class MockRegistry {
+  private data = new Map<number, DataRegistration>();
+  private dataFeedback = new Map<number, DataFeedbackEntry[]>();
+  private nextDataId = 1;
+
+  registerData(opts: {
+    key: string;
+    name: string;
+    description: string;
+    schema?: string;
+    tags: DataTag[];
+    owner?: WalletAddress;
+    ownerChain?: any;
+    vaultAddress?: string;
+    visibility?: Visibility;
+  }): DataRegistration {
+    const dataId = this.nextDataId++;
+    const reg: DataRegistration = {
+      dataId,
+      dataRegistry: "mock:0:0xDATA_REG",
+      vaultAddress: opts.vaultAddress ?? "",
+      vaultKey: opts.key,
+      name: opts.name,
+      description: opts.description,
+      visibility: opts.visibility ?? "public",
+      schema: opts.schema,
+      tags: opts.tags,
+      active: true,
+      owner: opts.owner ?? ("0x0" as WalletAddress),
+      ownerChain: opts.ownerChain ?? "evm",
+      lastUpdated: Date.now(),
+      registeredAt: Date.now(),
+    };
+    this.data.set(dataId, reg);
+    return reg;
+  }
+
+  findData(query: {
+    schema?: string;
+    tags?: DataTag[];
+    minQuality?: number;
+    verifiedOnly?: boolean;
+  }): DataRegistration[] {
+    let results = Array.from(this.data.values()).filter((d) => d.active);
+    if (query.schema) results = results.filter((d) => d.schema === query.schema);
+    if (query.tags?.length)
+      results = results.filter((d) => query.tags!.some((t) => d.tags.includes(t)));
+    if (query.verifiedOnly) results = results.filter((d) => d.tags.includes("verified"));
+    return results;
+  }
+
+  rateData(dataId: number, feedback: DataFeedbackEntry): void {
+    const existing = this.dataFeedback.get(dataId) ?? [];
+    existing.push(feedback);
+    this.dataFeedback.set(dataId, existing);
+  }
+
+  getUserFeedback(address: string): { dataId: number; entry: DataFeedbackEntry }[] {
+    const results: { dataId: number; entry: DataFeedbackEntry }[] = [];
+    for (const [dataId, entries] of this.dataFeedback.entries()) {
+      for (const entry of entries) {
+        if (entry.clientAddress === address) results.push({ dataId, entry });
+      }
+    }
+    return results;
+  }
+
+  getDataScore(dataId: number): DataScore {
+    const reg = this.data.get(dataId);
+    const feedback = this.dataFeedback.get(dataId) ?? [];
+    const total = feedback.reduce((sum, f) => sum + f.value, 0);
+    const quality = feedback.length > 0 ? Math.round(total / feedback.length) : 0;
+    return {
+      dataId,
+      vaultAddress: reg?.vaultAddress ?? "",
+      vaultKey: reg?.vaultKey ?? "",
+      quality,
+      freshness: { lastUpdated: reg?.lastUpdated ?? 0, score: 100 },
+      accuracy: { score: quality, feedbackCount: feedback.length },
+      completeness: { score: quality, feedbackCount: feedback.length },
+      verified: reg?.tags.includes("verified") ?? false,
+      consumptionCount: feedback.length,
+      totalFeedback: feedback.length,
+      tagScores: {},
+    };
+  }
+}

package/src/discovery/on-chain-registry.ts

@@ -0,0 +1,237 @@
+import { DataRegistryAbi, FeedbackRegistryAbi } from "@orbitmem/contracts";
+import type { Address, Log, PublicClient, WalletClient } from "viem";
+import { parseEventLogs } from "viem";
+
+import type { DataRegistration, DataScore, WalletAddress } from "../types.js";
+
+export interface OnChainRegistryConfig {
+  publicClient: PublicClient;
+  walletClient?: WalletClient;
+  dataRegistry: Address;
+  feedbackRegistry: Address;
+  deployBlock?: bigint;
+}
+
+export class OnChainRegistry {
+  private pub: PublicClient;
+  private wallet: WalletClient | undefined;
+  private dataReg: Address;
+  private feedbackReg: Address;
+  private deployBlock: bigint;
+
+  constructor(config: OnChainRegistryConfig) {
+    this.pub = config.publicClient;
+    this.wallet = config.walletClient;
+    this.dataReg = config.dataRegistry;
+    this.feedbackReg = config.feedbackRegistry;
+    this.deployBlock = config.deployBlock ?? 0n;
+  }
+
+  private requireWallet(): WalletClient {
+    if (!this.wallet) {
+      throw new Error("WalletClient is required for write operations");
+    }
+    return this.wallet;
+  }
+
+  // ── Data Registry ──
+
+  async registerData(dataURI: string): Promise<number> {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      address: this.dataReg,
+      abi: DataRegistryAbi,
+      functionName: "register",
+      args: [dataURI],
+      chain: wallet.chain,
+      account: wallet.account!,
+    });
+    const receipt = await this.pub.waitForTransactionReceipt({ hash });
+    const logs = parseEventLogs({
+      abi: DataRegistryAbi,
+      logs: receipt.logs as Log[],
+      eventName: "DataRegistered",
+    });
+    return Number(logs[0].args.dataId);
+  }
+
+  async findData(query: { activeOnly?: boolean }): Promise<DataRegistration[]> {
+    const latestBlock = await this.pub.getBlockNumber();
+    const CHUNK = 1000n;
+    const logs: { args: { dataId: bigint; owner: string; dataURI: string } }[] = [];
+    for (let from = this.deployBlock; from <= latestBlock; from += CHUNK) {
+      const to = from + CHUNK - 1n > latestBlock ? latestBlock : from + CHUNK - 1n;
+      const chunk = await this.pub.getContractEvents({
+        address: this.dataReg,
+        abi: DataRegistryAbi,
+        eventName: "DataRegistered",
+        fromBlock: from,
+        toBlock: to,
+      });
+      logs.push(...(chunk as unknown as typeof logs));
+    }
+
+    const results: DataRegistration[] = [];
+    for (const log of logs) {
+      const dataId = Number(log.args.dataId);
+      const active = (await this.pub.readContract({
+        address: this.dataReg,
+        abi: DataRegistryAbi,
+        functionName: "isActive",
+        args: [BigInt(dataId)],
+      })) as boolean;
+      if (query.activeOnly && !active) continue;
+
+      const [owner] = await Promise.all([
+        this.pub.readContract({
+          address: this.dataReg,
+          abi: DataRegistryAbi,
+          functionName: "ownerOf",
+          args: [BigInt(dataId)],
+        }),
+        this.pub.readContract({
+          address: this.dataReg,
+          abi: DataRegistryAbi,
+          functionName: "tokenURI",
+          args: [BigInt(dataId)],
+        }),
+      ]);
+
+      results.push({
+        dataId,
+        dataRegistry: this.dataReg,
+        vaultAddress: "",
+        vaultKey: "",
+        name: "",
+        description: "",
+        visibility: "public",
+        tags: [],
+        active,
+        owner: owner as WalletAddress,
+        ownerChain: "evm",
+        lastUpdated: 0,
+        registeredAt: 0,
+      });
+    }
+    return results;
+  }
+
+  async getDataScore(dataId: number): Promise<DataScore> {
+    const [totalValue, count] = (await this.pub.readContract({
+      address: this.feedbackReg,
+      abi: FeedbackRegistryAbi,
+      functionName: "getScore",
+      args: [this.dataReg, BigInt(dataId)],
+    })) as [bigint, bigint];
+
+    const numCount = Number(count);
+    const quality = numCount > 0 ? Math.round(Number(totalValue) / numCount) : 0;
+
+    return {
+      dataId,
+      vaultAddress: "",
+      vaultKey: "",
+      quality,
+      freshness: { lastUpdated: 0, score: 0 },
+      accuracy: { score: quality, feedbackCount: numCount },
+      completeness: { score: quality, feedbackCount: numCount },
+      verified: false,
+      consumptionCount: numCount,
+      totalFeedback: numCount,
+      tagScores: {},
+    };
+  }
+
+  async getTagScore(
+    registryAddr: Address,
+    entityId: number,
+    tag1: string,
+  ): Promise<{ totalValue: number; count: number }> {
+    const [totalValue, count] = (await this.pub.readContract({
+      address: this.feedbackReg,
+      abi: FeedbackRegistryAbi,
+      functionName: "getTagScore",
+      args: [registryAddr, BigInt(entityId), tag1],
+    })) as [bigint, bigint];
+    return { totalValue: Number(totalValue), count: Number(count) };
+  }
+
+  async rateData(
+    dataId: number,
+    value: number,
+    valueDecimals: number,
+    tag1: string,
+    tag2: string,
+    feedbackURI: string,
+    feedbackHash: `0x${string}`,
+  ): Promise<{ txHash: string; feedbackIndex: number }> {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      address: this.feedbackReg,
+      abi: FeedbackRegistryAbi,
+      functionName: "giveFeedback",
+      args: [
+        this.dataReg,
+        BigInt(dataId),
+        BigInt(value),
+        valueDecimals,
+        tag1,
+        tag2,
+        feedbackURI,
+        feedbackHash,
+      ],
+      chain: wallet.chain,
+      account: wallet.account!,
+    });
+    const receipt = await this.pub.waitForTransactionReceipt({ hash });
+    const logs = parseEventLogs({
+      abi: FeedbackRegistryAbi,
+      logs: receipt.logs as Log[],
+      eventName: "FeedbackGiven",
+    });
+    return { txHash: hash, feedbackIndex: logs.length > 0 ? 1 : 0 };
+  }
+
+  async revokeFeedback(registryAddr: Address, entityId: number, index: number): Promise<string> {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      address: this.feedbackReg,
+      abi: FeedbackRegistryAbi,
+      functionName: "revokeFeedback",
+      args: [registryAddr, BigInt(entityId), BigInt(index)],
+      chain: wallet.chain,
+      account: wallet.account!,
+    });
+    await this.pub.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+
+  async updateDataURI(dataId: number, dataURI: string): Promise<string> {
+    const wallet = this.requireWallet();
+    const hash = await wallet.writeContract({
+      address: this.dataReg,
+      abi: DataRegistryAbi,
+      functionName: "setDataURI",
+      args: [BigInt(dataId), dataURI],
+      chain: wallet.chain,
+      account: wallet.account!,
+    });
+    await this.pub.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+
+  async setActive(registryAddr: Address, entityId: number, active: boolean): Promise<string> {
+    const wallet = this.requireWallet();
+    const abi = DataRegistryAbi;
+    const hash = await wallet.writeContract({
+      address: registryAddr,
+      abi,
+      functionName: "setActive",
+      args: [BigInt(entityId), active],
+      chain: wallet.chain,
+      account: wallet.account!,
+    });
+    await this.pub.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+}

package/src/encryption/__tests__/aes.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+
+import { AESEngine } from "../aes.js";
+
+describe("AESEngine", () => {
+  const engine = new AESEngine({ kdf: "hkdf-sha256" });
+
+  test("deriveKey returns a CryptoKey from wallet signature", async () => {
+    const fakeSignature = new Uint8Array(64).fill(1);
+    const key = await engine.deriveKey(
+      {
+        type: "wallet-signature",
+      },
+      fakeSignature,
+    );
+    expect(key).toBeDefined();
+    expect(key.type).toBe("secret");
+    expect(key.algorithm).toMatchObject({ name: "AES-GCM" });
+  });
+
+  test("encrypt then decrypt returns original data", async () => {
+    const fakeSignature = new Uint8Array(64).fill(1);
+    const key = await engine.deriveKey(
+      {
+        type: "wallet-signature",
+      },
+      fakeSignature,
+    );
+
+    const plaintext = new TextEncoder().encode("Hello OrbitMem");
+    const encrypted = await engine.encrypt(plaintext, key);
+
+    expect(encrypted.engine).toBe("aes");
+    expect(encrypted.ciphertext).toBeInstanceOf(Uint8Array);
+    expect(encrypted.iv).toBeInstanceOf(Uint8Array);
+    expect(encrypted.iv.length).toBe(12);
+    expect(encrypted.authTag).toBeInstanceOf(Uint8Array);
+
+    const decrypted = await engine.decrypt(encrypted, key);
+    expect(new TextDecoder().decode(decrypted)).toBe("Hello OrbitMem");
+  });
+
+  test("decrypt with wrong key fails", async () => {
+    const sig1 = new Uint8Array(64).fill(1);
+    const sig2 = new Uint8Array(64).fill(2);
+    const key1 = await engine.deriveKey({ type: "wallet-signature" }, sig1);
+    const key2 = await engine.deriveKey({ type: "wallet-signature" }, sig2);
+
+    const plaintext = new TextEncoder().encode("secret");
+    const encrypted = await engine.encrypt(plaintext, key1);
+
+    expect(engine.decrypt(encrypted, key2)).rejects.toThrow();
+  });
+
+  test("encrypt with raw key source", async () => {
+    const rawKey = crypto.getRandomValues(new Uint8Array(32));
+    const key = await engine.deriveKey({ type: "raw", key: rawKey });
+
+    const plaintext = new TextEncoder().encode("raw key test");
+    const encrypted = await engine.encrypt(plaintext, key);
+    const decrypted = await engine.decrypt(encrypted, key);
+    expect(new TextDecoder().decode(decrypted)).toBe("raw key test");
+  });
+});