@silvana-one/coordination 1.0.25 → 1.0.26

package/src/job.ts

@@ -0,0 +1,223 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
+import { silvanaRegistryPackage } from "./package.js";
+import { fetchSuiDynamicField, fetchSuiObject } from "./fetch.js";
+
+export type JobStatus = 
+  | { type: "Pending" }
+  | { type: "Running" }
+  | { type: "Failed"; error: string };
+
+export interface Job {
+  id: string;
+  jobId: number;
+  description?: string;
+  developer: string;
+  agent: string;
+  agentMethod: string;
+  app: string;
+  appInstance: string;
+  appInstanceMethod: string;
+  sequences?: number[];
+  data: Uint8Array;
+  status: JobStatus;
+  attempts: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CreateJobParams {
+  jobs: string; // Jobs object ID
+  description?: string;
+  developer: string;
+  agent: string;
+  agentMethod: string;
+  app: string;
+  appInstance: string;
+  appInstanceMethod: string;
+  sequences?: number[];
+  data: Uint8Array;
+}
+
+export class JobManager {
+  private readonly jobs: string;
+
+  constructor(params: { jobs: string }) {
+    this.jobs = params.jobs;
+  }
+
+  static createJobs(maxAttempts?: number): Transaction {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::create_jobs`,
+      arguments: [
+        tx.pure.option("u8", maxAttempts ?? null),
+      ],
+    });
+    return tx;
+  }
+
+  createJob(params: CreateJobParams): Transaction {
+    const {
+      description,
+      developer,
+      agent,
+      agentMethod,
+      app,
+      appInstance,
+      appInstanceMethod,
+      sequences,
+      data,
+    } = params;
+    
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::create_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.option("string", description ?? null),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(agentMethod),
+        tx.pure.string(app),
+        tx.pure.string(appInstance),
+        tx.pure.string(appInstanceMethod),
+        tx.pure.option("vector<u64>", sequences ?? null),
+        tx.pure.vector("u8", Array.from(data)),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+    return tx;
+  }
+
+  startJob(jobId: number): Transaction {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::start_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+    return tx;
+  }
+
+  completeJob(jobId: number): Transaction {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::complete_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId),
+      ],
+    });
+    return tx;
+  }
+
+  failJob(params: { jobId: number; error: string }): Transaction {
+    const { jobId, error } = params;
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::fail_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId),
+        tx.pure.string(error),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+      ],
+    });
+    return tx;
+  }
+
+  updateMaxAttempts(maxAttempts: number): Transaction {
+    const tx = new Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::update_max_attempts`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(maxAttempts),
+      ],
+    });
+    return tx;
+  }
+
+  async getJob(jobId: number): Promise<Job | undefined> {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject) return undefined;
+
+      const jobsTableId = (jobsObject as any)?.jobs?.fields?.id?.id;
+      if (!jobsTableId) return undefined;
+
+      const job = await fetchSuiDynamicField({
+        parentID: jobsTableId,
+        fieldName: "jobs",
+        type: "u64",
+        key: String(jobId),
+      });
+
+      if (!job) return undefined;
+
+      const parseStatus = (status: any): JobStatus => {
+        if (status?.Pending !== undefined) return { type: "Pending" };
+        if (status?.Running !== undefined) return { type: "Running" };
+        if (status?.Failed !== undefined) return { type: "Failed", error: status.Failed };
+        return { type: "Pending" };
+      };
+
+      return {
+        id: (job as any)?.id?.id,
+        jobId: Number((job as any).job_id),
+        description: (job as any)?.description ?? undefined,
+        developer: (job as any).developer,
+        agent: (job as any).agent,
+        agentMethod: (job as any).agent_method,
+        app: (job as any).app,
+        appInstance: (job as any).app_instance,
+        appInstanceMethod: (job as any).app_instance_method,
+        sequences: (job as any)?.sequences?.map((s: string) => Number(s)) ?? undefined,
+        data: new Uint8Array((job as any).data),
+        status: parseStatus((job as any).status),
+        attempts: Number((job as any).attempts),
+        createdAt: Number((job as any).created_at),
+        updatedAt: Number((job as any).updated_at),
+      };
+    } catch (error) {
+      console.error("Error fetching job:", error);
+      return undefined;
+    }
+  }
+
+  async getPendingJobs(): Promise<number[]> {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject) return [];
+
+      const pendingJobs = (jobsObject as any)?.pending_jobs?.fields?.contents;
+      if (!Array.isArray(pendingJobs)) return [];
+
+      return pendingJobs.map((id: string) => Number(id));
+    } catch (error) {
+      console.error("Error fetching pending jobs:", error);
+      return [];
+    }
+  }
+
+  async getNextPendingJob(): Promise<number | undefined> {
+    const pendingJobs = await this.getPendingJobs();
+    return pendingJobs.length > 0 ? pendingJobs[0] : undefined;
+  }
+
+  async getMaxAttempts(): Promise<number> {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject) return 3; // default value
+
+      return Number((jobsObject as any)?.max_attempts ?? 3);
+    } catch (error) {
+      console.error("Error fetching max attempts:", error);
+      return 3;
+    }
+  }
+}

package/src/package.ts

@@ -0,0 +1,6 @@
+// Get Silvana registry package address from environment variables
+// Compatible with both Node.js and Next.js environments
+export const silvanaRegistryPackage =
+  process.env.SILVANA_REGISTRY_PACKAGE ??
+  process.env.NEXT_PUBLIC_SILVANA_REGISTRY_PACKAGE ??
+  "@silvana/agent";

package/src/test.ts

@@ -0,0 +1,383 @@
+import { AgentRegistry } from "./agent.js";
+import { AppInstanceManager } from "./app_instance.js";
+import { executeTx, waitTx } from "./execute.js";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { Transaction } from "@mysten/sui/transactions";
+
+export interface TestRegistryConfig {
+  registryName?: string;
+  developerName?: string;
+  developerGithub?: string;
+  developerImage?: string;
+  developerDescription?: string;
+  developerSite?: string;
+  appName?: string;
+  appDescription?: string;
+  appImage?: string;
+  appSite?: string;
+  testAgentName?: string;
+  testAgentImage?: string;
+  testAgentChains?: string[];
+}
+
+export interface TestRegistryResult {
+  registryAddress: string;
+  developerName: string;
+  appName: string;
+  agentName?: string;
+  registry: AgentRegistry;
+  appInstanceManager: AppInstanceManager;
+  keyPair: Ed25519Keypair;
+  address: string;
+}
+
+export interface TestAppResult {
+  testAppAddress: string;
+  appInstanceAddress: string;
+  appInstanceCapAddress: string;
+  registryAddress: string;
+  appName: string;
+  keyPair: Ed25519Keypair;
+  address: string;
+  appInstanceManager: AppInstanceManager;
+}
+
+/**
+ * Creates a test Silvana Registry with a test developer, app, and optionally an agent
+ * This is a helper function for testing that sets up a complete test environment
+ */
+export async function createTestRegistry(
+  config: TestRegistryConfig = {}
+): Promise<TestRegistryResult> {
+  // Default values
+  const registryName = config.registryName ?? "Test Silvana Registry";
+  const developerName = config.developerName ?? "TestDev";
+  const developerGithub = config.developerGithub ?? "testdev";
+  const developerImage = config.developerImage;
+  const developerDescription = config.developerDescription ?? "Test developer for automated testing";
+  const developerSite = config.developerSite ?? "https://test.dev";
+  
+  const appName = config.appName ?? "TestApp";
+  const appDescription = config.appDescription ?? "Test application for automated testing";
+  const appImage = config.appImage;
+  const appSite = config.appSite ?? "https://testapp.dev";
+  
+  const testAgentName = config.testAgentName ?? "TestAgent";
+  const testAgentImage = config.testAgentImage;
+  const testAgentChains = config.testAgentChains ?? ["sui-testnet", "sui-devnet"];
+
+  // Get key from environment
+  const key = process.env.SUI_KEY;
+  if (!key) {
+    throw new Error("SUI_KEY is not set in environment");
+  }
+  
+  const keyPair = Ed25519Keypair.fromSecretKey(key);
+  const address = keyPair.toSuiAddress();
+  
+  console.log("Creating test registry with sender address:", address);
+  console.log("Chain:", process.env.SUI_CHAIN);
+  
+  // Step 1: Create the registry
+  console.log("Step 1: Creating registry...");
+  const createRegistryTx = AgentRegistry.createAgentRegistry({
+    name: registryName,
+  });
+  createRegistryTx.setSender(address);
+  createRegistryTx.setGasBudget(100_000_000);
+  
+  const registryResult = await executeTx({
+    tx: createRegistryTx,
+    keyPair,
+  });
+  
+  if (!registryResult) {
+    throw new Error("Failed to create registry - no result");
+  }
+  
+  if (registryResult.error) {
+    throw new Error(`Failed to create registry: ${registryResult.error}`);
+  }
+  
+  if (!registryResult.tx?.objectChanges) {
+    throw new Error("Failed to create registry - no object changes");
+  }
+  
+  // Find the created registry object
+  const registryObject = registryResult.tx.objectChanges.find(
+    (obj: any) => obj.type === "created" && obj.objectType?.includes("::registry::SilvanaRegistry")
+  );
+  
+  if (!registryObject || !('objectId' in registryObject)) {
+    throw new Error("Failed to find created registry object");
+  }
+  
+  const registryAddress = registryObject.objectId;
+  console.log("Registry created with address:", registryAddress);
+  
+  if (registryResult.digest) {
+    await waitTx(registryResult.digest);
+  }
+  
+  // Create registry instance for further operations
+  const registry = new AgentRegistry({ registry: registryAddress });
+  const appInstanceManager = new AppInstanceManager({ registry: registryAddress });
+  
+  // Step 2: Create developer
+  console.log("Step 2: Creating developer...");
+  const createDeveloperTx = registry.createDeveloper({
+    name: developerName,
+    github: developerGithub,
+    image: developerImage,
+    description: developerDescription,
+    site: developerSite,
+  });
+  createDeveloperTx.setSender(address);
+  createDeveloperTx.setGasBudget(100_000_000);
+  
+  const developerResult = await executeTx({
+    tx: createDeveloperTx,
+    keyPair,
+  });
+  
+  if (!developerResult) {
+    throw new Error("Failed to create developer - no result");
+  }
+  
+  if (developerResult.error) {
+    throw new Error(`Failed to create developer: ${developerResult.error}`);
+  }
+  
+  if (developerResult.digest) {
+    await waitTx(developerResult.digest);
+  }
+  console.log("Developer created:", developerName);
+  
+  // Step 3: Create app (using registry::add_app)
+  console.log("Step 3: Creating app...");
+  const createAppTx = new Transaction();
+  createAppTx.moveCall({
+    target: `${process.env.SILVANA_REGISTRY_PACKAGE ?? "@silvana/agent"}::registry::add_app`,
+    arguments: [
+      createAppTx.object(registryAddress),
+      createAppTx.pure.string(appName),
+      createAppTx.pure.option("string", appDescription),
+      createAppTx.object("0x6"), // SUI_CLOCK_OBJECT_ID
+    ],
+  });
+  createAppTx.setSender(address);
+  createAppTx.setGasBudget(100_000_000);
+  
+  const appResult = await executeTx({
+    tx: createAppTx,
+    keyPair,
+  });
+  
+  if (!appResult) {
+    throw new Error("Failed to create app - no result");
+  }
+  
+  if (appResult.error) {
+    throw new Error(`Failed to create app: ${appResult.error}`);
+  }
+  
+  if (appResult.digest) {
+    await waitTx(appResult.digest);
+  }
+  console.log("App created:", appName);
+  
+  // Step 4: Optionally create agent (if test agent name is provided with chains)
+  let agentName: string | undefined;
+  if (config.testAgentName && config.testAgentChains) {
+    console.log("Step 4: Creating agent...");
+    const createAgentTx = registry.createAgent({
+      developer: developerName,
+      name: testAgentName,
+      image: testAgentImage,
+      description: "Test agent for automated testing",
+      chains: testAgentChains,
+    });
+    createAgentTx.setSender(address);
+    createAgentTx.setGasBudget(100_000_000);
+    
+    const agentResult = await executeTx({
+      tx: createAgentTx,
+      keyPair,
+    });
+    
+    if (!agentResult) {
+      throw new Error("Failed to create agent - no result");
+    }
+    
+    if (agentResult.error) {
+      throw new Error(`Failed to create agent: ${agentResult.error}`);
+    }
+    
+    if (agentResult.digest) {
+      await waitTx(agentResult.digest);
+    }
+    agentName = testAgentName;
+    console.log("Agent created:", testAgentName);
+  }
+  
+  console.log("Test registry setup complete!");
+  console.log("Registry address:", registryAddress);
+  console.log("Developer:", developerName);
+  console.log("App:", appName);
+  if (agentName) {
+    console.log("Agent:", agentName);
+  }
+  
+  return {
+    registryAddress,
+    developerName,
+    appName,
+    agentName,
+    registry,
+    appInstanceManager,
+    keyPair,
+    address,
+  };
+}
+
+/**
+ * Creates a TestApp with an initialized AppInstance using the new TestApp module
+ * This uses the create_test_app function from the Move contract
+ */
+export async function createTestApp(
+  registryAddress: string,
+  appName: string = "test_app"
+): Promise<TestAppResult> {
+  // Get key from environment
+  const key = process.env.SUI_KEY;
+  if (!key) {
+    throw new Error("SUI_KEY is not set in environment");
+  }
+  
+  const keyPair = Ed25519Keypair.fromSecretKey(key);
+  const address = keyPair.toSuiAddress();
+  
+  console.log("Creating TestApp with AppInstance...");
+  console.log("Registry address:", registryAddress);
+  console.log("Sender address:", address);
+  
+  // First, check if the app already exists by trying to create it
+  // If it fails with "already exists" error, that's fine - we can continue
+  const createAppTx = new Transaction();
+  createAppTx.moveCall({
+    target: `${process.env.SILVANA_REGISTRY_PACKAGE ?? "@silvana/agent"}::registry::add_app`,
+    arguments: [
+      createAppTx.object(registryAddress),
+      createAppTx.pure.string(appName),
+      createAppTx.pure.option("string", "Test app for TestApp module"),
+      createAppTx.object("0x6"), // SUI_CLOCK_OBJECT_ID
+    ],
+  });
+  createAppTx.setSender(address);
+  createAppTx.setGasBudget(100_000_000);
+  
+  const appResult = await executeTx({
+    tx: createAppTx,
+    keyPair,
+    showErrors: false,  // Don't throw, we'll handle the error
+  });
+  
+  if (appResult?.digest && !appResult.error) {
+    await waitTx(appResult.digest);
+    console.log("App created:", appName);
+  } else if (appResult?.error?.includes("0) in command 0")) {
+    // Error code 0 from dynamic_field::add means the field already exists
+    console.log("App already exists, continuing:", appName);
+  } else if (appResult?.error) {
+    throw new Error(`Failed to create app for TestApp: ${appResult.error}`);
+  }
+  
+  // Call create_test_app to create a TestApp with an AppInstance
+  const tx = new Transaction();
+  tx.moveCall({
+    target: `${process.env.SILVANA_REGISTRY_PACKAGE ?? "@silvana/agent"}::test_app::create_test_app`,
+    arguments: [
+      tx.object(registryAddress),
+      tx.object("0x6"), // SUI_CLOCK_OBJECT_ID
+    ],
+  });
+  
+  tx.setSender(address);
+  tx.setGasBudget(100_000_000);
+  
+  const result = await executeTx({
+    tx,
+    keyPair,
+  });
+  
+  if (!result) {
+    throw new Error("Failed to create TestApp - no result");
+  }
+  
+  if (result.error) {
+    throw new Error(`Failed to create TestApp: ${result.error}`);
+  }
+  
+  if (!result.tx) {
+    throw new Error("Failed to create TestApp - no transaction result");
+  }
+  
+  // Wait for the transaction to be confirmed
+  if (result.digest) {
+    const confirmedTx = await waitTx(result.digest);
+    result.tx = confirmedTx;
+  }
+  
+  if (!result?.tx?.objectChanges) {
+    throw new Error("Failed to create TestApp - no object changes");
+  }
+  
+  // Find the created TestApp object (it will be shared)
+  const testAppObject = result.tx.objectChanges.find(
+    (obj: any) => 
+      obj.type === "created" && 
+      obj.objectType?.includes("::test_app::TestApp")
+  );
+  
+  if (!testAppObject || !('objectId' in testAppObject)) {
+    throw new Error("Failed to find created TestApp object");
+  }
+  
+  // Find the created AppInstance object (it will be shared)
+  const appInstanceObject = result.tx.objectChanges.find(
+    (obj: any) => 
+      obj.type === "created" && 
+      obj.objectType?.includes("::app_instance::AppInstance")
+  );
+  
+  if (!appInstanceObject || !('objectId' in appInstanceObject)) {
+    throw new Error("Failed to find created AppInstance object");
+  }
+  
+  const testAppAddress = testAppObject.objectId;
+  const appInstanceAddress = appInstanceObject.objectId;
+  
+  // AppInstanceCap is stored inside the TestApp, not as a separate shared object
+  // We'll use the TestApp address as a placeholder since the cap is embedded
+  const appInstanceCapAddress = testAppAddress;
+  
+  console.log("TestApp created:", testAppAddress);
+  console.log("AppInstance created:", appInstanceAddress);
+  console.log("AppInstanceCap created:", appInstanceCapAddress);
+  
+  const appInstanceManager = new AppInstanceManager({ registry: registryAddress });
+  
+  return {
+    testAppAddress,
+    appInstanceAddress,
+    appInstanceCapAddress,
+    registryAddress,
+    appName,
+    keyPair,
+    address,
+    appInstanceManager,
+  };
+}
+
+// Note: createTestAppInstance has been removed. Use createTestApp instead, which creates
+// a TestApp with an embedded AppInstance using the Move test_app module.