@virtuals-protocol/acp-node 0.1.0-beta.1

package/src/acpClient.ts

@@ -0,0 +1,458 @@
+import { Address, parseEther } from "viem";
+import { io } from "socket.io-client";
+import AcpContractClient, { AcpJobPhases, MemoType } from "./acpContractClient";
+import { AcpAgent } from "../interfaces";
+import AcpJob from "./acpJob";
+import AcpMemo from "./acpMemo";
+import AcpJobOffering from "./acpJobOffering";
+import {
+  IAcpClientOptions,
+  IAcpJob,
+  IAcpJobResponse,
+  IAcpMemo,
+} from "./interfaces";
+
+enum SocketEvents {
+  ROOM_JOINED = "roomJoined",
+  ON_EVALUATE = "onEvaluate",
+  ON_NEW_TASK = "onNewTask",
+}
+export class EvaluateResult {
+  isApproved: boolean;
+  reasoning: string;
+
+  constructor(isApproved: boolean, reasoning: string) {
+    this.isApproved = isApproved;
+    this.reasoning = reasoning;
+  }
+}
+
+class AcpClient {
+  private acpUrl;
+  public acpContractClient: AcpContractClient;
+  private onNewTask?: (job: AcpJob) => void;
+  private onEvaluate?: (job: AcpJob) => void;
+
+  constructor(options: IAcpClientOptions) {
+    this.acpContractClient = options.acpContractClient;
+    this.onNewTask = options.onNewTask;
+    this.onEvaluate = options.onEvaluate || this.defaultOnEvaluate;
+
+    this.acpUrl = this.acpContractClient.config.acpUrl;
+    this.init();
+  }
+
+  private async defaultOnEvaluate(job: AcpJob) {
+    await job.evaluate(true, "Evaluated by default");
+  }
+
+  async init() {
+    const socket = io(this.acpUrl, {
+      auth: {
+        ...(this.onNewTask && {
+          walletAddress: this.acpContractClient.walletAddress,
+        }),
+        ...(this.onEvaluate !== this.defaultOnEvaluate && {
+          evaluatorAddress: this.acpContractClient.walletAddress,
+        }),
+      },
+    });
+
+    socket.on(SocketEvents.ROOM_JOINED, (_, callback) => {
+      console.log("Joined ACP Room");
+      callback(true);
+    });
+
+    socket.on(
+      SocketEvents.ON_EVALUATE,
+      async (data: IAcpJob["data"], callback) => {
+        callback(true);
+
+        if (this.onEvaluate) {
+          const job = new AcpJob(
+            this,
+            data.id,
+            data.clientAddress,
+            data.providerAddress,
+            data.evaluatorAddress,
+            data.price,
+            data.memos.map((memo) => {
+              return new AcpMemo(
+                this,
+                memo.id,
+                memo.memoType,
+                memo.content,
+                memo.nextPhase
+              );
+            }),
+            data.phase
+          );
+
+          this.onEvaluate(job);
+        }
+      }
+    );
+
+    socket.on(
+      SocketEvents.ON_NEW_TASK,
+      async (data: IAcpJob["data"], callback) => {
+        callback(true);
+
+        if (this.onNewTask) {
+          const job = new AcpJob(
+            this,
+            data.id,
+            data.clientAddress,
+            data.providerAddress,
+            data.evaluatorAddress,
+            data.price,
+            data.memos.map((memo) => {
+              return new AcpMemo(
+                this,
+                memo.id,
+                memo.memoType,
+                memo.content,
+                memo.nextPhase
+              );
+            }),
+            data.phase
+          );
+
+          this.onNewTask(job);
+        }
+      }
+    );
+
+    const cleanup = async () => {
+      if (socket) {
+        socket.disconnect();
+      }
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+
+  async browseAgents(keyword: string, cluster?: string) {
+    let url = `${this.acpUrl}/api/agents?search=${keyword}&filters[walletAddress][$notIn]=${this.acpContractClient.walletAddress}`;
+    if (cluster) {
+      url += `&filters[cluster]=${cluster}`;
+    }
+
+    const response = await fetch(url);
+    const data: {
+      data: AcpAgent[];
+    } = await response.json();
+
+    return data.data.map((agent) => {
+      return {
+        id: agent.id,
+        name: agent.name,
+        description: agent.description,
+        offerings: agent.offerings.map((offering) => {
+          return new AcpJobOffering(
+            this,
+            agent.walletAddress,
+            offering.name,
+            offering.price,
+            offering.requirementSchema
+          );
+        }),
+        twitterHandle: agent.twitterHandle,
+        walletAddress: agent.walletAddress,
+      };
+    });
+  }
+
+  async initiateJob(
+    providerAddress: Address,
+    serviceRequirement: Object | string,
+    amount: number,
+    evaluatorAddress?: Address,
+    expiredAt: Date = new Date(Date.now() + 1000 * 60 * 60 * 24)
+  ) {
+    const { jobId } = await this.acpContractClient.createJob(
+      providerAddress,
+      evaluatorAddress || this.acpContractClient.walletAddress,
+      expiredAt
+    );
+
+    await this.acpContractClient.setBudget(
+      jobId,
+      parseEther(amount.toString())
+    );
+
+    await this.acpContractClient.createMemo(
+      jobId,
+      typeof serviceRequirement === "string"
+        ? serviceRequirement
+        : JSON.stringify(serviceRequirement),
+      MemoType.MESSAGE,
+      true,
+      AcpJobPhases.NEGOTIATION
+    );
+
+    return jobId;
+  }
+
+  async respondJob(
+    jobId: number,
+    memoId: number,
+    accept: boolean,
+    reason?: string
+  ) {
+    await this.acpContractClient.signMemo(memoId, accept, reason);
+
+    return await this.acpContractClient.createMemo(
+      jobId,
+      `Job ${jobId} accepted. ${reason ?? ""}`,
+      MemoType.MESSAGE,
+      false,
+      AcpJobPhases.TRANSACTION
+    );
+  }
+
+  async payJob(jobId: number, amount: number, memoId: number, reason?: string) {
+    await this.acpContractClient.approveAllowance(
+      parseEther(amount.toString())
+    );
+
+    await this.acpContractClient.signMemo(memoId, true, reason);
+
+    return await this.acpContractClient.createMemo(
+      jobId,
+      `Payment of ${amount} made. ${reason ?? ""}`,
+      MemoType.MESSAGE,
+      false,
+      AcpJobPhases.EVALUATION
+    );
+  }
+
+  async deliverJob(jobId: number, deliverable: string) {
+    return await this.acpContractClient.createMemo(
+      jobId,
+      deliverable,
+      MemoType.OBJECT_URL,
+      true,
+      AcpJobPhases.COMPLETED
+    );
+  }
+
+  async getActiveJobs(page: number = 1, pageSize: number = 10) {
+    let url = `${this.acpUrl}/api/jobs/active?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "wallet-address": this.acpContractClient.walletAddress,
+        },
+      });
+
+      const data: IAcpJobResponse = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error.message);
+      }
+
+      return data.data.map((job) => {
+        return new AcpJob(
+          this,
+          job.id,
+          job.clientAddress,
+          job.providerAddress,
+          job.evaluatorAddress,
+          job.price,
+          job.memos.map((memo) => {
+            return new AcpMemo(
+              this,
+              memo.id,
+              memo.memoType,
+              memo.content,
+              memo.nextPhase
+            );
+          }),
+          job.phase
+        );
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getCompletedJobs(page: number = 1, pageSize: number = 10) {
+    let url = `${this.acpUrl}/api/jobs/completed?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "wallet-address": this.acpContractClient.walletAddress,
+        },
+      });
+
+      const data: IAcpJobResponse = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error.message);
+      }
+
+      return data.data.map((job) => {
+        return new AcpJob(
+          this,
+          job.id,
+          job.clientAddress,
+          job.providerAddress,
+          job.evaluatorAddress,
+          job.price,
+          job.memos.map((memo) => {
+            return new AcpMemo(
+              this,
+              memo.id,
+              memo.memoType,
+              memo.content,
+              memo.nextPhase
+            );
+          }),
+          job.phase
+        );
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getCancelledJobs(page: number = 1, pageSize: number = 10) {
+    let url = `${this.acpUrl}/api/jobs/cancelled?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "wallet-address": this.acpContractClient.walletAddress,
+        },
+      });
+
+      const data: IAcpJobResponse = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error.message);
+      }
+      return data.data.map((job) => {
+        return new AcpJob(
+          this,
+          job.id,
+          job.clientAddress,
+          job.providerAddress,
+          job.evaluatorAddress,
+          job.price,
+          job.memos.map((memo) => {
+            return new AcpMemo(
+              this,
+              memo.id,
+              memo.memoType,
+              memo.content,
+              memo.nextPhase
+            );
+          }),
+          job.phase
+        );
+      });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getJobById(jobId: number) {
+    let url = `${this.acpUrl}/api/jobs/${jobId}`;
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "wallet-address": this.acpContractClient.walletAddress,
+        },
+      });
+
+      const data: IAcpJob = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error.message);
+      }
+
+      const job = data.data;
+      if (!job) {
+        return;
+      }
+
+      return new AcpJob(
+        this,
+        job.id,
+        job.clientAddress,
+        job.providerAddress,
+        job.evaluatorAddress,
+        job.price,
+        job.memos.map((memo) => {
+          return new AcpMemo(
+            this,
+            memo.id,
+            memo.memoType,
+            memo.content,
+            memo.nextPhase
+          );
+        }),
+        job.phase
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getMemoById(jobId: number, memoId: number) {
+    let url = `${this.acpUrl}/api/jobs/${jobId}/memos/${memoId}`;
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          "wallet-address": this.acpContractClient.walletAddress,
+        },
+      });
+
+      const data: IAcpMemo = await response.json();
+
+      if (data.error) {
+        throw new Error(data.error.message);
+      }
+
+      const memo = data.data;
+      if (!memo) {
+        return;
+      }
+
+      return new AcpMemo(
+        this,
+        memo.id,
+        memo.memoType,
+        memo.content,
+        memo.nextPhase
+      );
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getAgent(walletAddress: Address) {
+    const url = `${this.acpUrl}/api/agents?filters[walletAddress]=${walletAddress}`;
+
+    const response = await fetch(url);
+    const data: {
+      data: AcpAgent[];
+    } = await response.json();
+
+    const agents = data.data || [];
+
+    if (agents.length === 0) {
+      return;
+    }
+
+    return agents[0];
+  }
+}
+
+export default AcpClient;

package/src/acpContractClient.ts

@@ -0,0 +1,269 @@
+import { Address, LocalAccountSigner, SmartAccountSigner } from "@aa-sdk/core";
+import { alchemy } from "@account-kit/infra";
+import {
+  ModularAccountV2Client,
+  createModularAccountV2Client,
+} from "@account-kit/smart-contracts";
+import { AcpContractConfig } from "./configs";
+import ACP_ABI from "./acpAbi";
+import { encodeFunctionData, erc20Abi, fromHex } from "viem";
+
+export enum MemoType {
+  MESSAGE,
+  CONTEXT_URL,
+  IMAGE_URL,
+  VOICE_URL,
+  OBJECT_URL,
+  TXHASH,
+}
+
+export enum AcpJobPhases {
+  REQUEST = 0,
+  NEGOTIATION = 1,
+  TRANSACTION = 2,
+  EVALUATION = 3,
+  COMPLETED = 4,
+  REJECTED = 5,
+}
+
+class AcpContractClient {
+  private _sessionKeyClient: ModularAccountV2Client | undefined;
+
+  private chain;
+  private contractAddress: Address;
+  private virtualsTokenAddress: Address;
+
+  constructor(
+    private walletPrivateKey: Address,
+    private sessionEntityKeyId: number,
+    private agentWalletAddress: Address,
+    public config: AcpContractConfig
+  ) {
+    this.chain = config.chain;
+    this.contractAddress = config.contractAddress;
+    this.virtualsTokenAddress = config.virtualsTokenAddress;
+  }
+
+  static async build(
+    walletPrivateKey: Address,
+    sessionEntityKeyId: number,
+    agentWalletAddress: Address,
+    config: AcpContractConfig
+  ) {
+    const acpContractClient = new AcpContractClient(
+      walletPrivateKey,
+      sessionEntityKeyId,
+      agentWalletAddress,
+      config
+    );
+
+    await acpContractClient.init();
+
+    return acpContractClient;
+  }
+
+  async init() {
+    const sessionKeySigner: SmartAccountSigner =
+      LocalAccountSigner.privateKeyToAccountSigner(this.walletPrivateKey);
+
+    this._sessionKeyClient = await createModularAccountV2Client({
+      chain: this.chain,
+      transport: alchemy({
+        rpcUrl: this.config.alchemyRpcUrl,
+      }),
+      signer: sessionKeySigner,
+      policyId: "186aaa4a-5f57-4156-83fb-e456365a8820",
+      accountAddress: this.agentWalletAddress,
+      signerEntity: {
+        entityId: this.sessionEntityKeyId,
+        isGlobalValidation: true,
+      },
+    });
+  }
+
+  get sessionKeyClient() {
+    if (!this._sessionKeyClient) {
+      throw new Error("Session key client not initialized");
+    }
+
+    return this._sessionKeyClient;
+  }
+
+  get walletAddress() {
+    return this.sessionKeyClient.account.address as Address;
+  }
+
+  private async getJobId(hash: Address) {
+    const result = await this.sessionKeyClient.getUserOperationReceipt(hash);
+
+    if (!result) {
+      throw new Error("Failed to get user operation receipt");
+    }
+
+    const contractLogs = result.logs.find(
+      (log: any) =>
+        log.address.toLowerCase() === this.contractAddress.toLowerCase()
+    ) as any;
+
+    if (!contractLogs) {
+      throw new Error("Failed to get contract logs");
+    }
+
+    return fromHex(contractLogs.data, "number");
+  }
+
+  async createJob(
+    providerAddress: string,
+    evaluatorAddress: string,
+    expireAt: Date
+  ): Promise<{ txHash: string; jobId: number }> {
+    try {
+      const data = encodeFunctionData({
+        abi: ACP_ABI,
+        functionName: "createJob",
+        args: [
+          providerAddress,
+          evaluatorAddress,
+          Math.floor(expireAt.getTime() / 1000),
+        ],
+      });
+
+      const { hash } = await this.sessionKeyClient.sendUserOperation({
+        uo: {
+          target: this.contractAddress,
+          data: data,
+        },
+      });
+
+      await this.sessionKeyClient.waitForUserOperationTransaction({
+        hash,
+      });
+
+      const jobId = await this.getJobId(hash);
+
+      return { txHash: hash, jobId: jobId };
+    } catch (error) {
+      console.error(error);
+      throw new Error("Failed to create job");
+    }
+  }
+
+  async approveAllowance(priceInWei: bigint) {
+    const data = encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [this.contractAddress, priceInWei],
+    });
+
+    const { hash } = await this.sessionKeyClient.sendUserOperation({
+      uo: {
+        target: this.virtualsTokenAddress,
+        data: data,
+      },
+    });
+
+    await this.sessionKeyClient.waitForUserOperationTransaction({
+      hash,
+    });
+
+    return hash;
+  }
+
+  async createMemo(
+    jobId: number,
+    content: string,
+    type: MemoType,
+    isSecured: boolean,
+    nextPhase: AcpJobPhases
+  ): Promise<Address> {
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        const data = encodeFunctionData({
+          abi: ACP_ABI,
+          functionName: "createMemo",
+          args: [jobId, content, type, isSecured, nextPhase],
+        });
+
+        const { hash } = await this.sessionKeyClient.sendUserOperation({
+          uo: {
+            target: this.contractAddress,
+            data: data,
+          },
+        });
+
+        await this.sessionKeyClient.waitForUserOperationTransaction({
+          hash,
+        });
+
+        return hash;
+      } catch (error) {
+        console.error(`failed to create memo ${jobId} ${content} ${error}`);
+        retries -= 1;
+        await new Promise((resolve) => setTimeout(resolve, 2000 * retries));
+      }
+    }
+
+    throw new Error("Failed to create memo");
+  }
+
+  async signMemo(memoId: number, isApproved: boolean, reason?: string) {
+    let retries = 3;
+    while (retries > 0) {
+      try {
+        const data = encodeFunctionData({
+          abi: ACP_ABI,
+          functionName: "signMemo",
+          args: [memoId, isApproved, reason],
+        });
+
+        const { hash } = await this.sessionKeyClient.sendUserOperation({
+          uo: {
+            target: this.contractAddress,
+            data: data,
+          },
+        });
+
+        await this.sessionKeyClient.waitForUserOperationTransaction({
+          hash,
+        });
+
+        return hash;
+      } catch (error) {
+        console.error(`failed to sign memo ${error}`);
+        retries -= 1;
+        await new Promise((resolve) => setTimeout(resolve, 2000 * retries));
+      }
+    }
+
+    throw new Error("Failed to sign memo");
+  }
+
+  async setBudget(jobId: number, budget: bigint) {
+    try {
+      const data = encodeFunctionData({
+        abi: ACP_ABI,
+        functionName: "setBudget",
+        args: [jobId, budget],
+      });
+
+      const { hash } = await this.sessionKeyClient.sendUserOperation({
+        uo: {
+          target: this.contractAddress,
+          data: data,
+        },
+      });
+
+      await this.sessionKeyClient.waitForUserOperationTransaction({
+        hash,
+      });
+
+      return hash;
+    } catch (error) {
+      console.error(error);
+      throw new Error("Failed to set budget");
+    }
+  }
+}
+
+export default AcpContractClient;