@silvana-one/coordination 1.0.25 → 1.0.26

package/dist/node/index.cjs

@@ -31,6 +31,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AgentRegistry: () => AgentRegistry,
+  AppInstanceManager: () => AppInstanceManager,
+  JobManager: () => JobManager,
   buildMovePackage: () => buildMovePackage,
   buildPublishTx: () => buildPublishTx,
   buildUpgradeTx: () => buildUpgradeTx,
@@ -39,6 +41,8 @@ __export(index_exports, {
   convertMinaPublicKeyToFields: () => convertMinaPublicKeyToFields,
   convertMinaSignatureFromBase58: () => convertMinaSignatureFromBase58,
   convertMinaSignatureToBase58: () => convertMinaSignatureToBase58,
+  createTestApp: () => createTestApp,
+  createTestRegistry: () => createTestRegistry,
   executeTx: () => executeTx,
   fetchSuiDynamicField: () => fetchSuiDynamicField,
   fetchSuiDynamicFieldsList: () => fetchSuiDynamicFieldsList,
@@ -58,6 +62,7 @@ __export(index_exports, {
   silvanaFaucetGetKey: () => silvanaFaucetGetKey,
   silvanaFaucetPingKey: () => silvanaFaucetPingKey,
   silvanaFaucetReturnKey: () => silvanaFaucetReturnKey,
+  silvanaRegistryPackage: () => silvanaRegistryPackage,
   sleep: () => sleep,
   suiClient: () => suiClient,
   u256ToFields: () => u256ToFields,
@@ -442,10 +447,17 @@ async function executeTx(params) {
       await releaseLock({ address, id: lockId });
     }
     if (executedTx?.effects?.status?.status === "failure") {
+      const errorMessage = executedTx?.effects?.status?.error || "Unknown error";
       if (showErrors) {
-        console.log(`Errors for tx ${executedTx.digest}:`, executedTx?.effects?.status?.error);
-        throw new Error(`tx execution failed: ${executedTx.digest}`);
+        console.log(`Errors for tx ${executedTx.digest}:`, errorMessage);
       }
+      return {
+        tx: executedTx,
+        digest: executedTx.digest,
+        events: executedTx?.events?.[0]?.parsedJson,
+        executeTime: end - start,
+        error: errorMessage
+      };
     }
     return {
       tx: executedTx,
@@ -641,6 +653,9 @@ async function fetchSuiDynamicField(params) {
   }
 }
 
+// dist/node/package.js
+var silvanaRegistryPackage = process.env.SILVANA_REGISTRY_PACKAGE ?? process.env.NEXT_PUBLIC_SILVANA_REGISTRY_PACKAGE ?? "@silvana/agent";
+
 // dist/node/agent.js
 var AgentRegistry = class {
   constructor(params) {
@@ -650,7 +665,7 @@ var AgentRegistry = class {
     console.log("Creating agent registry", params.name);
     const transaction = new import_transactions6.Transaction();
     transaction.moveCall({
-      target: `@silvana/agent::registry::create_registry`,
+      target: `${silvanaRegistryPackage}::registry::create_registry`,
       arguments: [transaction.pure.string(params.name)]
     });
     return transaction;
@@ -659,7 +674,7 @@ var AgentRegistry = class {
     const { name, github, image, description, site } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::add_developer`,
+      target: `${silvanaRegistryPackage}::registry::add_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -676,7 +691,7 @@ var AgentRegistry = class {
     const { name, github, image, description, site } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::update_developer`,
+      target: `${silvanaRegistryPackage}::registry::update_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -693,7 +708,7 @@ var AgentRegistry = class {
     const { name, agentNames } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::remove_developer`,
+      target: `${silvanaRegistryPackage}::registry::remove_developer`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(name),
@@ -704,10 +719,10 @@ var AgentRegistry = class {
     return tx;
   }
   createAgent(params) {
-    const { developer, name, image, description, site, docker_image, docker_sha256, min_memory_gb, min_cpu_cores, supports_tee, chains } = params;
+    const { developer, name, image, description, site, chains } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::add_agent`,
+      target: `${silvanaRegistryPackage}::registry::add_agent`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -715,11 +730,6 @@ var AgentRegistry = class {
         tx.pure.option("string", image ?? null),
         tx.pure.option("string", description ?? null),
         tx.pure.option("string", site ?? null),
-        tx.pure.string(docker_image),
-        tx.pure.option("string", docker_sha256 ?? null),
-        tx.pure.u16(min_memory_gb),
-        tx.pure.u16(min_cpu_cores),
-        tx.pure.bool(supports_tee),
         tx.pure.vector("string", chains),
         tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
       ]
@@ -727,10 +737,10 @@ var AgentRegistry = class {
     return tx;
   }
   updateAgent(params) {
-    const { developer, name, image, description, site, docker_image, docker_sha256, min_memory_gb, min_cpu_cores, supports_tee, chains } = params;
+    const { developer, name, image, description, site, chains } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::update_agent`,
+      target: `${silvanaRegistryPackage}::registry::update_agent`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -738,11 +748,6 @@ var AgentRegistry = class {
         tx.pure.option("string", image ?? null),
         tx.pure.option("string", description ?? null),
         tx.pure.option("string", site ?? null),
-        tx.pure.string(docker_image),
-        tx.pure.option("string", docker_sha256 ?? null),
-        tx.pure.u16(min_memory_gb),
-        tx.pure.u16(min_cpu_cores),
-        tx.pure.bool(supports_tee),
         tx.pure.vector("string", chains),
         tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
       ]
@@ -753,7 +758,91 @@ var AgentRegistry = class {
     const { developer, agent } = params;
     const tx = new import_transactions6.Transaction();
     tx.moveCall({
-      target: `@silvana/agent::registry::remove_agent`,
+      target: `${silvanaRegistryPackage}::registry::remove_agent`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  addAgentMethod(params) {
+    const { developer, agent, method, dockerImage, dockerSha256, minMemoryGb, minCpuCores, requiresTee } = params;
+    const tx = new import_transactions6.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::add_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.pure.string(dockerImage),
+        tx.pure.option("string", dockerSha256 ?? null),
+        tx.pure.u16(minMemoryGb),
+        tx.pure.u16(minCpuCores),
+        tx.pure.bool(requiresTee),
+        tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  updateAgentMethod(params) {
+    const { developer, agent, method, dockerImage, dockerSha256, minMemoryGb, minCpuCores, requiresTee } = params;
+    const tx = new import_transactions6.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::update_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.pure.string(dockerImage),
+        tx.pure.option("string", dockerSha256 ?? null),
+        tx.pure.u16(minMemoryGb),
+        tx.pure.u16(minCpuCores),
+        tx.pure.bool(requiresTee),
+        tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  removeAgentMethod(params) {
+    const { developer, agent, method } = params;
+    const tx = new import_transactions6.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::remove_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  setDefaultMethod(params) {
+    const { developer, agent, method } = params;
+    const tx = new import_transactions6.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::set_default_method`,
+      arguments: [
+        tx.object(this.registry),
+        tx.pure.string(developer),
+        tx.pure.string(agent),
+        tx.pure.string(method),
+        tx.object(import_utils.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  removeDefaultMethod(params) {
+    const { developer, agent } = params;
+    const tx = new import_transactions6.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::registry::remove_default_method`,
       arguments: [
         tx.object(this.registry),
         tx.pure.string(developer),
@@ -841,22 +930,48 @@ var AgentRegistry = class {
     if (!agentObject) {
       return void 0;
     }
+    const methods = {};
+    const methodsData = agentObject?.methods?.fields?.contents;
+    if (methodsData && Array.isArray(methodsData)) {
+      for (const entry of methodsData) {
+        const key = entry?.fields?.key;
+        const value = entry?.fields?.value;
+        if (key && value) {
+          methods[key] = {
+            dockerImage: value.docker_image,
+            dockerSha256: value.docker_sha256 ?? void 0,
+            minMemoryGb: Number(value.min_memory_gb),
+            minCpuCores: Number(value.min_cpu_cores),
+            requiresTee: Boolean(value.requires_tee)
+          };
+        }
+      }
+    }
+    let defaultMethod;
+    const defaultMethodData = agentObject?.default_method;
+    if (defaultMethodData && typeof defaultMethodData === "object" && !Array.isArray(defaultMethodData)) {
+      defaultMethod = {
+        dockerImage: defaultMethodData.docker_image,
+        dockerSha256: defaultMethodData.docker_sha256 ?? void 0,
+        minMemoryGb: Number(defaultMethodData.min_memory_gb),
+        minCpuCores: Number(defaultMethodData.min_cpu_cores),
+        requiresTee: Boolean(defaultMethodData.requires_tee)
+      };
+    }
     const agent = {
       id: agentObject?.id?.id,
       name: agentObject.name,
       image: agentObject?.image ?? void 0,
       description: agentObject?.description ?? void 0,
       site: agentObject?.site ?? void 0,
-      dockerImage: agentObject.docker_image,
-      dockerSha256: agentObject?.docker_sha256 ?? void 0,
-      minMemoryGb: Number(agentObject.min_memory_gb),
-      minCpuCores: Number(agentObject.min_cpu_cores),
-      supportsTEE: Boolean(agentObject.supports_tee),
+      chains: agentObject?.chains ?? [],
+      methods,
+      defaultMethod,
       createdAt: Number(agentObject.created_at),
       updatedAt: Number(agentObject.updated_at),
       version: Number(agentObject.version)
     };
-    if (!agent.id || !agent.name || !agent.dockerImage || !agent.minMemoryGb || !agent.minCpuCores || !agent.createdAt || !agent.updatedAt) {
+    if (!agent.id || !agent.name) {
       return void 0;
     }
     return agent;
@@ -1220,9 +1335,614 @@ function verifyFields(params) {
   const { publicKey, fields, signature } = params;
   return client.verifyFields({ data: fields, publicKey, signature });
 }
+
+// dist/node/job.js
+var import_transactions7 = require("@mysten/sui/transactions");
+var import_utils2 = require("@mysten/sui/utils");
+var JobManager = class {
+  constructor(params) {
+    this.jobs = params.jobs;
+  }
+  static createJobs(maxAttempts) {
+    const tx = new import_transactions7.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::create_jobs`,
+      arguments: [
+        tx.pure.option("u8", maxAttempts ?? null)
+      ]
+    });
+    return tx;
+  }
+  createJob(params) {
+    const { description, developer, agent, agentMethod, app, appInstance, appInstanceMethod, sequences, data } = params;
+    const tx = new import_transactions7.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(import_utils2.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  startJob(jobId) {
+    const tx = new import_transactions7.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::start_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId),
+        tx.object(import_utils2.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  completeJob(jobId) {
+    const tx = new import_transactions7.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::complete_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId)
+      ]
+    });
+    return tx;
+  }
+  failJob(params) {
+    const { jobId, error } = params;
+    const tx = new import_transactions7.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::fail_job`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(jobId),
+        tx.pure.string(error),
+        tx.object(import_utils2.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  updateMaxAttempts(maxAttempts) {
+    const tx = new import_transactions7.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::jobs::update_max_attempts`,
+      arguments: [
+        tx.object(this.jobs),
+        tx.pure.u64(maxAttempts)
+      ]
+    });
+    return tx;
+  }
+  async getJob(jobId) {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject)
+        return void 0;
+      const jobsTableId = jobsObject?.jobs?.fields?.id?.id;
+      if (!jobsTableId)
+        return void 0;
+      const job = await fetchSuiDynamicField({
+        parentID: jobsTableId,
+        fieldName: "jobs",
+        type: "u64",
+        key: String(jobId)
+      });
+      if (!job)
+        return void 0;
+      const parseStatus = (status) => {
+        if (status?.Pending !== void 0)
+          return { type: "Pending" };
+        if (status?.Running !== void 0)
+          return { type: "Running" };
+        if (status?.Failed !== void 0)
+          return { type: "Failed", error: status.Failed };
+        return { type: "Pending" };
+      };
+      return {
+        id: job?.id?.id,
+        jobId: Number(job.job_id),
+        description: job?.description ?? void 0,
+        developer: job.developer,
+        agent: job.agent,
+        agentMethod: job.agent_method,
+        app: job.app,
+        appInstance: job.app_instance,
+        appInstanceMethod: job.app_instance_method,
+        sequences: job?.sequences?.map((s) => Number(s)) ?? void 0,
+        data: new Uint8Array(job.data),
+        status: parseStatus(job.status),
+        attempts: Number(job.attempts),
+        createdAt: Number(job.created_at),
+        updatedAt: Number(job.updated_at)
+      };
+    } catch (error) {
+      console.error("Error fetching job:", error);
+      return void 0;
+    }
+  }
+  async getPendingJobs() {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject)
+        return [];
+      const pendingJobs = jobsObject?.pending_jobs?.fields?.contents;
+      if (!Array.isArray(pendingJobs))
+        return [];
+      return pendingJobs.map((id) => Number(id));
+    } catch (error) {
+      console.error("Error fetching pending jobs:", error);
+      return [];
+    }
+  }
+  async getNextPendingJob() {
+    const pendingJobs = await this.getPendingJobs();
+    return pendingJobs.length > 0 ? pendingJobs[0] : void 0;
+  }
+  async getMaxAttempts() {
+    try {
+      const jobsObject = await fetchSuiObject(this.jobs);
+      if (!jobsObject)
+        return 3;
+      return Number(jobsObject?.max_attempts ?? 3);
+    } catch (error) {
+      console.error("Error fetching max attempts:", error);
+      return 3;
+    }
+  }
+};
+
+// dist/node/app_instance.js
+var import_transactions8 = require("@mysten/sui/transactions");
+var import_utils3 = require("@mysten/sui/utils");
+var AppInstanceManager = class {
+  constructor(params) {
+    this.registry = params.registry;
+  }
+  // Note: update_method and remove_method functions are not available in the Move module
+  // These would need to be implemented in app_instance.move if needed
+  createAppJob(params) {
+    const { appInstance, description, method, sequences, data } = params;
+    console.log("createAppJob params:", {
+      appInstance,
+      description,
+      method,
+      sequences,
+      data: data instanceof Uint8Array ? `Uint8Array(${data.length})` : typeof data,
+      dataContent: data instanceof Uint8Array ? Array.from(data) : data
+    });
+    const tx = new import_transactions8.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::create_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.string(method),
+        tx.pure.option("string", description ?? null),
+        tx.pure.option("vector<u64>", sequences ?? null),
+        tx.pure.vector("u8", data),
+        tx.object(import_utils3.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  startAppJob(params) {
+    const { appInstance, jobId } = params;
+    const tx = new import_transactions8.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::start_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.u64(jobId),
+        tx.object(import_utils3.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  completeAppJob(params) {
+    const { appInstance, jobId } = params;
+    const tx = new import_transactions8.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::complete_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.u64(jobId),
+        tx.object(import_utils3.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  failAppJob(params) {
+    const { appInstance, jobId, error } = params;
+    const tx = new import_transactions8.Transaction();
+    tx.moveCall({
+      target: `${silvanaRegistryPackage}::app_instance::fail_app_job`,
+      arguments: [
+        tx.object(appInstance),
+        tx.pure.u64(jobId),
+        tx.pure.string(error),
+        tx.object(import_utils3.SUI_CLOCK_OBJECT_ID)
+      ]
+    });
+    return tx;
+  }
+  async getAppInstance(appInstanceId) {
+    try {
+      const appInstance = await fetchSuiObject(appInstanceId);
+      if (!appInstance)
+        return void 0;
+      const fields = appInstance?.data?.content?.fields;
+      if (!fields)
+        return void 0;
+      const methods = {};
+      const methodsArray = fields?.methods?.fields?.contents;
+      if (Array.isArray(methodsArray)) {
+        for (const entry of methodsArray) {
+          const key = entry?.fields?.key;
+          const value = entry?.fields?.value;
+          if (key && value) {
+            const methodFields = value.fields || value;
+            methods[key] = {
+              description: methodFields.description ?? void 0,
+              developer: methodFields.developer,
+              agent: methodFields.agent,
+              agentMethod: methodFields.agent_method || methodFields.agentMethod
+            };
+          }
+        }
+      }
+      return {
+        id: fields?.id?.id,
+        silvanaAppName: fields.silvana_app_name,
+        description: fields?.description ?? void 0,
+        metadata: fields?.metadata ?? void 0,
+        methods,
+        admin: fields.admin,
+        sequence: Number(fields.sequence),
+        blockNumber: Number(fields.block_number),
+        previousBlockTimestamp: Number(fields.previous_block_timestamp),
+        previousBlockLastSequence: Number(fields.previous_block_last_sequence),
+        lastProvedBlockNumber: Number(fields.last_proved_block_number),
+        isPaused: Boolean(fields.isPaused),
+        jobsId: String(fields.jobs?.fields?.id?.id ?? ""),
+        createdAt: Number(fields.created_at),
+        updatedAt: Number(fields.updated_at)
+      };
+    } catch (error) {
+      console.error("Error fetching app instance:", error);
+      return void 0;
+    }
+  }
+  async getAppJob(params) {
+    try {
+      const appInstanceObj = await fetchSuiObject(params.appInstance);
+      if (!appInstanceObj)
+        return void 0;
+      const jobsTableId = appInstanceObj?.data?.content?.fields?.jobs?.fields?.jobs?.fields?.id?.id;
+      if (!jobsTableId)
+        return void 0;
+      const job = await fetchSuiDynamicField({
+        parentID: jobsTableId,
+        fieldName: "jobs",
+        type: "u64",
+        key: String(params.jobId)
+      });
+      if (!job)
+        return void 0;
+      const parseStatus = (status) => {
+        if (status?.variant === "Pending")
+          return { type: "Pending" };
+        if (status?.variant === "Running")
+          return { type: "Running" };
+        if (status?.variant === "Failed") {
+          const error = status?.fields?.error || status?.fields?.[0] || "Unknown error";
+          return { type: "Failed", error };
+        }
+        if (status?.Pending !== void 0)
+          return { type: "Pending" };
+        if (status?.Running !== void 0)
+          return { type: "Running" };
+        if (status?.Failed !== void 0)
+          return { type: "Failed", error: status.Failed };
+        return { type: "Pending" };
+      };
+      return {
+        id: job?.id?.id,
+        jobId: Number(job.job_id),
+        description: job?.description ?? void 0,
+        developer: job.developer,
+        agent: job.agent,
+        agentMethod: job.agent_method,
+        app: job.app,
+        appInstance: job.app_instance,
+        appInstanceMethod: job.app_instance_method,
+        sequences: job?.sequences?.map((s) => Number(s)) ?? void 0,
+        data: new Uint8Array(job.data),
+        status: parseStatus(job.status),
+        attempts: Number(job.attempts),
+        createdAt: Number(job.created_at),
+        updatedAt: Number(job.updated_at)
+      };
+    } catch (error) {
+      console.error("Error fetching app job:", error);
+      return void 0;
+    }
+  }
+  async getAppPendingJobs(appInstance) {
+    try {
+      const appInstanceObj = await fetchSuiObject(appInstance);
+      if (!appInstanceObj)
+        return [];
+      const pendingJobs = appInstanceObj?.data?.content?.fields?.jobs?.fields?.pending_jobs?.fields?.contents;
+      if (!Array.isArray(pendingJobs))
+        return [];
+      return pendingJobs.map((id) => Number(id));
+    } catch (error) {
+      console.error("Error fetching app pending jobs:", error);
+      return [];
+    }
+  }
+};
+
+// dist/node/test.js
+var import_ed255192 = require("@mysten/sui/keypairs/ed25519");
+var import_transactions9 = require("@mysten/sui/transactions");
+async function createTestRegistry(config = {}) {
+  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"];
+  const key = process.env.SUI_KEY;
+  if (!key) {
+    throw new Error("SUI_KEY is not set in environment");
+  }
+  const keyPair = import_ed255192.Ed25519Keypair.fromSecretKey(key);
+  const address = keyPair.toSuiAddress();
+  console.log("Creating test registry with sender address:", address);
+  console.log("Chain:", process.env.SUI_CHAIN);
+  console.log("Step 1: Creating registry...");
+  const createRegistryTx = AgentRegistry.createAgentRegistry({
+    name: registryName
+  });
+  createRegistryTx.setSender(address);
+  createRegistryTx.setGasBudget(1e8);
+  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");
+  }
+  const registryObject = registryResult.tx.objectChanges.find((obj) => 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);
+  }
+  const registry = new AgentRegistry({ registry: registryAddress });
+  const appInstanceManager = new AppInstanceManager({ registry: registryAddress });
+  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(1e8);
+  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);
+  console.log("Step 3: Creating app...");
+  const createAppTx = new import_transactions9.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(1e8);
+  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);
+  let agentName;
+  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(1e8);
+    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
+  };
+}
+async function createTestApp(registryAddress, appName = "test_app") {
+  const key = process.env.SUI_KEY;
+  if (!key) {
+    throw new Error("SUI_KEY is not set in environment");
+  }
+  const keyPair = import_ed255192.Ed25519Keypair.fromSecretKey(key);
+  const address = keyPair.toSuiAddress();
+  console.log("Creating TestApp with AppInstance...");
+  console.log("Registry address:", registryAddress);
+  console.log("Sender address:", address);
+  const createAppTx = new import_transactions9.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(1e8);
+  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")) {
+    console.log("App already exists, continuing:", appName);
+  } else if (appResult?.error) {
+    throw new Error(`Failed to create app for TestApp: ${appResult.error}`);
+  }
+  const tx = new import_transactions9.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(1e8);
+  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");
+  }
+  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");
+  }
+  const testAppObject = result.tx.objectChanges.find((obj) => obj.type === "created" && obj.objectType?.includes("::test_app::TestApp"));
+  if (!testAppObject || !("objectId" in testAppObject)) {
+    throw new Error("Failed to find created TestApp object");
+  }
+  const appInstanceObject = result.tx.objectChanges.find((obj) => 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;
+  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
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentRegistry,
+  AppInstanceManager,
+  JobManager,
   buildMovePackage,
   buildPublishTx,
   buildUpgradeTx,
@@ -1231,6 +1951,8 @@ function verifyFields(params) {
   convertMinaPublicKeyToFields,
   convertMinaSignatureFromBase58,
   convertMinaSignatureToBase58,
+  createTestApp,
+  createTestRegistry,
   executeTx,
   fetchSuiDynamicField,
   fetchSuiDynamicFieldsList,
@@ -1250,6 +1972,7 @@ function verifyFields(params) {
   silvanaFaucetGetKey,
   silvanaFaucetPingKey,
   silvanaFaucetReturnKey,
+  silvanaRegistryPackage,
   sleep,
   suiClient,
   u256ToFields,