@silvana-one/coordination 1.0.24 → 1.0.26

package/src/faucet.ts

@@ -0,0 +1,145 @@
+"use server";
+
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+
+export async function silvanaFaucet(params: {
+  address: string;
+  amount?: number;
+}): Promise<{
+  message: string;
+  success: true;
+  transaction_hash: string;
+}> {
+  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();
+}
+
+export async function silvanaFaucetGetKey(
+  params: {
+    autoReturn: boolean;
+  } = {
+    autoReturn: false,
+  }
+): Promise<{
+  key_pair: {
+    address: string;
+    issued_at: string;
+    private_key_bech32: string;
+    private_key_hex: string;
+    public_key: string;
+  };
+  message: string;
+  success: true;
+}> {
+  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();
+}
+
+export async function silvanaFaucetPingKey(params: {
+  address: string;
+}): Promise<{
+  message: string;
+  success: boolean;
+}> {
+  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();
+}
+
+export async function silvanaFaucetReturnKey(params: {
+  address?: string;
+  secretKey?: string;
+}): Promise<{
+  message: string;
+  success: boolean;
+}> {
+  const address =
+    params.address ??
+    (params.secretKey
+      ? Ed25519Keypair.fromSecretKey(params.secretKey).toSuiAddress()
+      : undefined);
+  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(): string {
+  const silvanaFaucetEndpoint = process.env.SILVANA_FAUCET_ENDPOINT!;
+  if (!silvanaFaucetEndpoint) {
+    throw new Error("SILVANA_FAUCET_ENDPOINT is not set");
+  }
+  return silvanaFaucetEndpoint;
+}

package/src/index.ts

@@ -7,3 +7,12 @@ export * from "./upgrade.js";
 export * from "./mvr.js";
 export * from "./agent.js";
 export * from "./fetch.js";
+export * from "./build.js";
+export * from "./walrus.js";
+export * from "./faucet.js";
+export * from "./ipfs.js";
+export * from "./public-key.js";
+export * from "./job.js";
+export * from "./app_instance.js";
+export * from "./package.js";
+export * from "./test.js";

package/src/ipfs.ts

@@ -0,0 +1,105 @@
+import { PinataSDK } from "pinata";
+
+// IPFS
+const pinataJwt = process.env.PINATA_JWT;
+const pinataGateway = process.env.PINATA_GATEWAY_URL;
+const pinataGatewayKey = process.env.PINATA_GATEWAY_API_KEY;
+
+const pinata = new PinataSDK({
+  pinataJwt,
+  pinataGateway,
+  pinataGatewayKey,
+});
+
+export async function saveToIPFS(params: {
+  data: string;
+  filename?: string;
+  owner?: string;
+  days?: number;
+  description?: string;
+}): Promise<string | undefined> {
+  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 === undefined || 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 * 1000 : undefined;
+    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: any) {
+    console.error("Save to IPFS failed", error.message);
+    return undefined;
+  }
+}
+
+export async function readFromIPFS(params: {
+  blobId: string;
+}): Promise<string | undefined> {
+  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: any) {
+    console.error("Read from IPFS failed", error);
+    return undefined;
+  }
+}
+
+export async function getIPFSUrl(params: { blobId: string }): Promise<string> {
+  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;
+}

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/public-key.ts

@@ -0,0 +1,66 @@
+import Client from "mina-signer";
+import { convertFieldsToPublicKey } from "./base58/public-key.js";
+
+const client = new Client({
+  network: "testnet",
+});
+
+export function publicKeyToU256(publicKey: string): bigint {
+  const raw = client.publicKeyToRaw(publicKey);
+  const swappedRaw =
+    raw
+      .match(/.{1,2}/g)
+      ?.reverse()
+      .join("") || "";
+  const u256 = BigInt("0x" + swappedRaw);
+  return u256;
+}
+
+const MAX_BIT: bigint = 2n ** 255n;
+
+export function u256ToFields(u256: bigint): {
+  x: bigint;
+  isOdd: boolean;
+} {
+  const isOdd = (u256 & MAX_BIT) != 0n;
+  const x = u256 - (isOdd ? MAX_BIT : 0n);
+  return { x, isOdd };
+}
+
+export function u256ToPublicKey(u256: bigint): string {
+  const { x, isOdd } = u256ToFields(u256);
+  return convertFieldsToPublicKey({ x, isOdd });
+}
+
+export function convertMinaPublicKey(publicKey: string): {
+  x: bigint;
+  isOdd: boolean;
+} {
+  const u256 = publicKeyToU256(publicKey);
+  return u256ToFields(u256);
+}
+
+export function convertMinaPublicKeyToFields(publicKey?: string): bigint[] {
+  if (!publicKey) return [];
+  const { x, isOdd } = convertMinaPublicKey(publicKey);
+  return [x, isOdd ? 1n : 0n];
+}
+
+export function signFields(params: { privateKey: string; fields: bigint[] }): {
+  signature: string;
+  data: bigint[];
+  publicKey: string;
+} {
+  const { privateKey, fields } = params;
+  const signedData = client.signFields(fields.map(BigInt), privateKey);
+  return signedData;
+}
+
+export function verifyFields(params: {
+  publicKey: string;
+  fields: bigint[];
+  signature: string;
+}): boolean {
+  const { publicKey, fields, signature } = params;
+  return client.verifyFields({ data: fields, publicKey, signature });
+}

package/src/publish.ts

@@ -1,7 +1,5 @@
 import { Secp256k1Keypair } from "@mysten/sui/keypairs/secp256k1";
 import { Transaction } from "@mysten/sui/transactions";
-import { SignatureWithBytes } from "@mysten/sui/cryptography";
-import { suiClient } from "./sui-client.js";
 
 export async function buildPublishTx(params: {
   modules: string[];