@silvana-one/coordination 1.0.24 → 1.0.26

package/dist/node/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,27 +17,59 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/node/index.js
 var index_exports = {};
 __export(index_exports, {
   AgentRegistry: () => AgentRegistry,
+  AppInstanceManager: () => AppInstanceManager,
+  JobManager: () => JobManager,
+  buildMovePackage: () => buildMovePackage,
   buildPublishTx: () => buildPublishTx,
   buildUpgradeTx: () => buildUpgradeTx,
   convertFieldsToPublicKey: () => convertFieldsToPublicKey,
+  convertMinaPublicKey: () => convertMinaPublicKey,
+  convertMinaPublicKeyToFields: () => convertMinaPublicKeyToFields,
   convertMinaSignatureFromBase58: () => convertMinaSignatureFromBase58,
   convertMinaSignatureToBase58: () => convertMinaSignatureToBase58,
+  createTestApp: () => createTestApp,
+  createTestRegistry: () => createTestRegistry,
   executeTx: () => executeTx,
   fetchSuiDynamicField: () => fetchSuiDynamicField,
   fetchSuiDynamicFieldsList: () => fetchSuiDynamicFieldsList,
   fetchSuiObject: () => fetchSuiObject,
+  getIPFSUrl: () => getIPFSUrl,
+  getWalrusUrl: () => getWalrusUrl,
   network: () => network,
+  publicKeyToU256: () => publicKeyToU256,
   publishCodeToMVR: () => publishCodeToMVR,
   publishToMVR: () => publishToMVR,
+  readFromIPFS: () => readFromIPFS,
+  readFromWalrus: () => readFromWalrus,
+  saveToIPFS: () => saveToIPFS,
+  saveToWalrus: () => saveToWalrus,
+  signFields: () => signFields,
+  silvanaFaucet: () => silvanaFaucet,
+  silvanaFaucetGetKey: () => silvanaFaucetGetKey,
+  silvanaFaucetPingKey: () => silvanaFaucetPingKey,
+  silvanaFaucetReturnKey: () => silvanaFaucetReturnKey,
+  silvanaRegistryPackage: () => silvanaRegistryPackage,
   sleep: () => sleep,
   suiClient: () => suiClient,
-  waitTx: () => waitTx
+  u256ToFields: () => u256ToFields,
+  u256ToPublicKey: () => u256ToPublicKey,
+  verifyFields: () => verifyFields,
+  waitTx: () => waitTx,
+  walrusDaemon: () => walrusDaemon
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -413,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,
@@ -504,8 +545,6 @@ async function buildUpgradeTx(params) {
   tx.setGasOwner(address);
   tx.setGasPayment(coins);
   tx.setGasBudget(3e8);
-  console.time("sign");
-  console.timeEnd("sign");
   return { tx };
 }
 
@@ -614,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) {
@@ -623,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;
@@ -632,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),
@@ -649,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),
@@ -666,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),
@@ -677,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),
@@ -688,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)
       ]
@@ -700,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),
@@ -711,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)
       ]
@@ -726,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),
@@ -814,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;
@@ -906,22 +1048,936 @@ var AgentRegistry = class {
     }
   }
 };
+
+// dist/node/build.js
+async function buildMovePackage(path) {
+  const { execSync } = await import("child_process");
+  let bytes = void 0;
+  console.log("Running sui client publish command...");
+  try {
+    const output = execSync(`sui move build --dump-bytecode-as-base64 --ignore-chain --path ${path}`, {
+      encoding: "utf-8"
+    });
+    bytes = JSON.parse(output);
+    if (!bytes) {
+      throw new Error("Error building package");
+    }
+    return bytes;
+  } catch (error) {
+    console.error("Error running command:", error);
+    throw error;
+  }
+}
+
+// dist/node/walrus.js
+var walrusDaemon = process.env.NEXT_PUBLIC_WALRUS_DAEMON || process.env.WALRUS_DAEMON || "testnet";
+var daemon = walrusDaemon === "local" ? "local" : "testnet";
+var basePublisherUrl = daemon === "local" ? "http://127.0.0.1:31415" : "https://wal-publisher-testnet.staketab.org";
+var readerUrl = daemon === "local" ? "http://127.0.0.1:31415/v1/blobs/" : "https://wal-aggregator-testnet.staketab.org/v1/blobs/";
+var MIN_EPOCHS = 14;
+var MAX_EPOCHS = 53;
+async function saveToWalrus({ data, address, numEpochs = MIN_EPOCHS }) {
+  let sendToParam = address ? `&send_object_to=${address}` : "";
+  let epochs = numEpochs < MIN_EPOCHS ? MIN_EPOCHS : numEpochs > MAX_EPOCHS ? MAX_EPOCHS : numEpochs;
+  console.log("Writing to Walrus");
+  console.time("written");
+  const response = await fetch(`${basePublisherUrl}/v1/blobs?epochs=${epochs}${sendToParam}`, {
+    method: "PUT",
+    body: data
+  });
+  console.timeEnd("written");
+  if (response.status === 200) {
+    const info = await response.json();
+    const blobId = info?.newlyCreated?.blobObject?.blobId ?? info?.alreadyCertified?.blobId;
+    console.log("Walrus blobId", blobId);
+    return blobId;
+  } else {
+    console.error("saveToDA failed:", {
+      statusText: response.statusText,
+      status: response.status
+    });
+    return void 0;
+  }
+}
+async function readFromWalrus({ blobId }) {
+  if (!blobId) {
+    throw new Error("blobId is not provided");
+  }
+  console.log("Reading walrus blob", blobId);
+  console.time("read");
+  const response = await fetch(`${readerUrl}${blobId}`);
+  console.timeEnd("read");
+  if (!response.ok) {
+    console.error("readFromDA failed:", {
+      statusText: response.statusText,
+      status: response.status
+    });
+    return void 0;
+  } else {
+    const blob = await response.text();
+    return blob;
+  }
+}
+async function getWalrusUrl(params) {
+  const { blobId } = params;
+  if (!blobId) {
+    throw new Error("blobId is not set");
+  }
+  const url = `${readerUrl}${blobId}`;
+  return url;
+}
+
+// dist/node/faucet.js
+var import_ed25519 = require("@mysten/sui/keypairs/ed25519");
+async function silvanaFaucet(params) {
+  const { address, amount = 1 } = params;
+  const response = await fetch(`${silvanaFaucetEndpoint()}/fund`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      address,
+      amount
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fund address: ${address} ${amount} ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+async function silvanaFaucetGetKey(params = {
+  autoReturn: false
+}) {
+  const response = await fetch(`${silvanaFaucetEndpoint()}/get_key`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      auto_return: params.autoReturn
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to get key: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+async function silvanaFaucetPingKey(params) {
+  const { address } = params;
+  if (!address) {
+    return {
+      message: "Address is required",
+      success: false
+    };
+  }
+  const response = await fetch(`${silvanaFaucetEndpoint()}/ping_key`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      address
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to return key: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+async function silvanaFaucetReturnKey(params) {
+  const address = params.address ?? (params.secretKey ? import_ed25519.Ed25519Keypair.fromSecretKey(params.secretKey).toSuiAddress() : void 0);
+  if (!address) {
+    return {
+      message: "Address or secret key is required",
+      success: false
+    };
+  }
+  const response = await fetch(`${silvanaFaucetEndpoint()}/return_key`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      address
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to return key: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+function silvanaFaucetEndpoint() {
+  const silvanaFaucetEndpoint2 = process.env.SILVANA_FAUCET_ENDPOINT;
+  if (!silvanaFaucetEndpoint2) {
+    throw new Error("SILVANA_FAUCET_ENDPOINT is not set");
+  }
+  return silvanaFaucetEndpoint2;
+}
+
+// dist/node/ipfs.js
+var import_pinata = require("pinata");
+var pinataJwt = process.env.PINATA_JWT;
+var pinataGateway = process.env.PINATA_GATEWAY_URL;
+var pinataGatewayKey = process.env.PINATA_GATEWAY_API_KEY;
+var pinata = new import_pinata.PinataSDK({
+  pinataJwt,
+  pinataGateway,
+  pinataGatewayKey
+});
+async function saveToIPFS(params) {
+  try {
+    if (!pinataJwt || !pinataGateway || !pinataGatewayKey) {
+      throw new Error("PINATA_JWT, PINATA_GATEWAY_URL, or PINATA_GATEWAY_API_KEY is not set");
+    }
+    const { data, filename, owner, days, description } = params;
+    if (data === void 0 || data === null)
+      throw new Error("data is not set");
+    if (typeof data !== "string")
+      throw new Error("data is not a string");
+    if (data.length === 0)
+      throw new Error("data is empty");
+    const file = new File([data], filename ?? "da", {
+      type: "text/plain"
+    });
+    const expiry = days ? Date.now() + days * 24 * 60 * 60 * 1e3 : void 0;
+    const keyvalues = {
+      app: "dex:devnet",
+      owner: owner ?? "",
+      expires: expiry ? new Date(expiry).toISOString() : "never",
+      expiry: expiry ? expiry.toString() : "0",
+      description: description ?? "",
+      type: "text/plain",
+      mime_type: "text/plain"
+    };
+    const upload = await pinata.upload.public.file(file, {
+      metadata: {
+        name: filename ?? "da",
+        keyvalues
+      }
+    }).name(filename ?? "da");
+    console.log("IPFS: ", upload.cid);
+    return upload.cid;
+  } catch (error) {
+    console.error("Save to IPFS failed", error.message);
+    return void 0;
+  }
+}
+async function readFromIPFS(params) {
+  const { blobId } = params;
+  if (!blobId) {
+    throw new Error("blobId is not set");
+  }
+  try {
+    if (!pinataJwt || !pinataGateway || !pinataGatewayKey) {
+      throw new Error("PINATA_JWT, PINATA_GATEWAY_URL, or PINATA_GATEWAY_API_KEY is not set");
+    }
+    const url = await getIPFSUrl({ blobId });
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error("Failed to fetch from IPFS");
+    }
+    const data = await response.text();
+    return data;
+  } catch (error) {
+    console.error("Read from IPFS failed", error);
+    return void 0;
+  }
+}
+async function getIPFSUrl(params) {
+  const { blobId } = params;
+  if (!blobId) {
+    throw new Error("blobId is not set");
+  }
+  const gateway = process.env.PINATA_GATEWAY_URL ?? "https://gateway.pinata.cloud/ipfs/";
+  const apiToken = process.env.PINATA_GATEWAY_API_KEY;
+  const url = "https://" + gateway + "/ipfs/" + blobId + (apiToken ? "?pinataGatewayToken=" + apiToken : "");
+  return url;
+}
+
+// dist/node/public-key.js
+var import_mina_signer = __toESM(require("mina-signer"), 1);
+var client = new import_mina_signer.default({
+  network: "testnet"
+});
+function publicKeyToU256(publicKey) {
+  const raw = client.publicKeyToRaw(publicKey);
+  const swappedRaw = raw.match(/.{1,2}/g)?.reverse().join("") || "";
+  const u256 = BigInt("0x" + swappedRaw);
+  return u256;
+}
+var MAX_BIT = 2n ** 255n;
+function u256ToFields(u256) {
+  const isOdd = (u256 & MAX_BIT) != 0n;
+  const x = u256 - (isOdd ? MAX_BIT : 0n);
+  return { x, isOdd };
+}
+function u256ToPublicKey(u256) {
+  const { x, isOdd } = u256ToFields(u256);
+  return convertFieldsToPublicKey({ x, isOdd });
+}
+function convertMinaPublicKey(publicKey) {
+  const u256 = publicKeyToU256(publicKey);
+  return u256ToFields(u256);
+}
+function convertMinaPublicKeyToFields(publicKey) {
+  if (!publicKey)
+    return [];
+  const { x, isOdd } = convertMinaPublicKey(publicKey);
+  return [x, isOdd ? 1n : 0n];
+}
+function signFields(params) {
+  const { privateKey, fields } = params;
+  const signedData = client.signFields(fields.map(BigInt), privateKey);
+  return signedData;
+}
+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,
   convertFieldsToPublicKey,
+  convertMinaPublicKey,
+  convertMinaPublicKeyToFields,
   convertMinaSignatureFromBase58,
   convertMinaSignatureToBase58,
+  createTestApp,
+  createTestRegistry,
   executeTx,
   fetchSuiDynamicField,
   fetchSuiDynamicFieldsList,
   fetchSuiObject,
+  getIPFSUrl,
+  getWalrusUrl,
   network,
+  publicKeyToU256,
   publishCodeToMVR,
   publishToMVR,
+  readFromIPFS,
+  readFromWalrus,
+  saveToIPFS,
+  saveToWalrus,
+  signFields,
+  silvanaFaucet,
+  silvanaFaucetGetKey,
+  silvanaFaucetPingKey,
+  silvanaFaucetReturnKey,
+  silvanaRegistryPackage,
   sleep,
   suiClient,
-  waitTx
+  u256ToFields,
+  u256ToPublicKey,
+  verifyFields,
+  waitTx,
+  walrusDaemon
 });