@virtuals-protocol/acp-node 0.3.0-beta.22 → 0.3.0-beta.24

package/dist/index.mjs

@@ -8,7 +8,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@virtuals-protocol/acp-node",
-      version: "0.3.0-beta.22",
+      version: "0.3.0-beta.24",
       main: "./dist/index.js",
       module: "./dist/index.mjs",
       types: "./dist/index.d.ts",
@@ -41,6 +41,8 @@ var require_package = __commonJS({
         "@account-kit/smart-contracts": "^4.73.0",
         "@virtuals-protocol/acp-node": "^0.3.0-beta.10",
         ajv: "^8.17.1",
+        axios: "^1.13.2",
+        "jwt-decode": "^4.0.0",
         "socket.io-client": "^4.8.1",
         tsup: "^8.5.0",
         viem: "^2.28.2"
@@ -1225,6 +1227,7 @@ var acpAbi_default = ACP_ABI;
 // src/acpClient.ts
 import { zeroAddress as zeroAddress3 } from "viem";
 import { io } from "socket.io-client";
+import { jwtDecode } from "jwt-decode";
 
 // src/contractClients/baseAcpContractClient.ts
 import {
@@ -3795,23 +3798,6 @@ var AcpOnlineStatus = /* @__PURE__ */ ((AcpOnlineStatus2) => {
   AcpOnlineStatus2["OFFLINE"] = "offline";
   return AcpOnlineStatus2;
 })(AcpOnlineStatus || {});
-var PayloadType = /* @__PURE__ */ ((PayloadType2) => {
-  PayloadType2["FUND_RESPONSE"] = "fund_response";
-  PayloadType2["OPEN_POSITION"] = "open_position";
-  PayloadType2["SWAP_TOKEN"] = "swap_token";
-  PayloadType2["RESPONSE_SWAP_TOKEN"] = "response_swap_token";
-  PayloadType2["CLOSE_PARTIAL_POSITION"] = "close_partial_position";
-  PayloadType2["CLOSE_POSITION"] = "close_position";
-  PayloadType2["POSITION_FULFILLED"] = "position_fulfilled";
-  PayloadType2["CLOSE_JOB_AND_WITHDRAW"] = "close_job_and_withdraw";
-  PayloadType2["UNFULFILLED_POSITION"] = "unfulfilled_position";
-  return PayloadType2;
-})(PayloadType || {});
-var PositionDirection = /* @__PURE__ */ ((PositionDirection2) => {
-  PositionDirection2["LONG"] = "long";
-  PositionDirection2["SHORT"] = "short";
-  return PositionDirection2;
-})(PositionDirection || {});
 
 // src/utils.ts
 function tryParseJson(content) {
@@ -3846,6 +3832,11 @@ var AcpJobOffering = class {
     this.ajv = new Ajv({ allErrors: true });
   }
   async initiateJob(serviceRequirement, evaluatorAddress, expiredAt = new Date(Date.now() + 1e3 * 60 * 60 * 24)) {
+    if (this.providerAddress === this.acpClient.walletAddress) {
+      throw new acpError_default(
+        "Provider address cannot be the same as the client address"
+      );
+    }
     if (this.requirement && typeof this.requirement === "object") {
       const validator = this.ajv.compile(this.requirement);
       const valid = validator(serviceRequirement);
@@ -4159,8 +4150,8 @@ var AcpJob = class {
     return await this.acpContractClient.handleOperation(operations);
   }
   async deliver(deliverable) {
-    if (this.latestMemo?.nextPhase !== 3 /* EVALUATION */) {
-      throw new acpError_default("No transaction memo found");
+    if (this.phase !== 2 /* TRANSACTION */) {
+      throw new acpError_default("Job is not in transaction phase");
     }
     const operations = [];
     operations.push(
@@ -4190,6 +4181,7 @@ var AcpJob = class {
     operations.push(
       this.acpContractClient.createPayableMemo(
         this.id,
+        // memoContent.url,
         preparePayload(deliverable),
         amount.amount,
         this.clientAddress,
@@ -4348,16 +4340,9 @@ var AcpMemo = class {
       this.payableDetails.amount = BigInt(this.payableDetails.amount);
       this.payableDetails.feeAmount = BigInt(this.payableDetails.feeAmount);
     }
-    this.structuredContent = tryParseJson(this.content) || void 0;
-  }
-  get payloadType() {
-    return this.structuredContent?.type;
-  }
-  getStructuredContent() {
-    return this.structuredContent;
   }
   async create(jobId, isSecured = true) {
-    return await this.contractClient.createMemo(
+    return this.contractClient.createMemo(
       jobId,
       this.content,
       this.type,
@@ -4405,10 +4390,31 @@ var AcpAccount = class {
   }
 };
 
+// src/acpClient.ts
+import axios, { AxiosError } from "axios";
+
+// src/acpAgent.ts
+var AcpAgent = class {
+  constructor(args) {
+    this.id = String(args.id);
+    this.name = args.name;
+    this.contractAddress = args.contractAddress;
+    this.walletAddress = args.walletAddress;
+    this.jobOfferings = Object.freeze([...args.jobOfferings]);
+    this.description = args.description;
+    this.twitterHandle = args.twitterHandle;
+    this.metrics = args.metrics;
+    this.resources = args.resources;
+  }
+};
+var acpAgent_default = AcpAgent;
+
 // src/acpClient.ts
 var { version } = require_package();
 var AcpClient = class {
   constructor(options) {
+    this.accessToken = null;
+    this.accessTokenInflight = null;
     this.contractClients = Array.isArray(options.acpContractClient) ? options.acpContractClient : [options.acpContractClient];
     if (this.contractClients.length === 0) {
       throw new acpError_default("ACP contract client is required");
@@ -4420,10 +4426,86 @@ var AcpClient = class {
         );
       }
     });
+    this.acpClient = axios.create({
+      baseURL: `${this.acpUrl}/api`,
+      headers: {
+        "wallet-address": this.walletAddress
+      }
+    });
+    this.noAuthAcpClient = this.acpClient.create({
+      baseURL: `${this.acpUrl}/api`
+    });
+    this.acpClient.interceptors.request.use(async (config) => {
+      const accessToken = await this.getAccessToken();
+      config.headers["authorization"] = `Bearer ${accessToken}`;
+      return config;
+    });
     this.onNewTask = options.onNewTask;
     this.onEvaluate = options.onEvaluate || this.defaultOnEvaluate;
     this.init(options.skipSocketConnection);
   }
+  async getAccessToken() {
+    if (this.accessTokenInflight) {
+      return await this.accessTokenInflight;
+    }
+    let refreshToken = this.accessToken ? false : true;
+    if (this.accessToken) {
+      const decodedToken = jwtDecode(this.accessToken);
+      if (decodedToken.exp && decodedToken.exp - 60 * 5 < Math.floor(Date.now() / 1e3)) {
+        refreshToken = true;
+      }
+    }
+    if (!refreshToken) {
+      return this.accessToken;
+    }
+    this.accessTokenInflight = (async () => {
+      this.accessToken = await this.refreshToken();
+      return this.accessToken;
+    })().finally(() => {
+      this.accessTokenInflight = null;
+    });
+    return await this.accessTokenInflight;
+  }
+  async refreshToken() {
+    const challenge = await this.getAuthChallenge();
+    const signature = await this.acpContractClient.signTypedData(challenge);
+    const verified = await this.verifyAuthChallenge(
+      challenge.message["walletAddress"],
+      challenge.message["nonce"],
+      challenge.message["expiresAt"],
+      signature
+    );
+    return verified.accessToken;
+  }
+  async getAuthChallenge() {
+    try {
+      const response = await this.noAuthAcpClient.get("/auth/challenge", {
+        params: {
+          walletAddress: this.walletAddress
+        }
+      });
+      return response.data.data;
+    } catch (err) {
+      console.error(
+        "Failed to get auth challenge",
+        err.response?.data
+      );
+      throw new acpError_default("Failed to get auth challenge", err);
+    }
+  }
+  async verifyAuthChallenge(walletAddress, nonce, expiresAt, signature) {
+    try {
+      const response = await this.noAuthAcpClient.post("/auth/verify-typed-signature", {
+        walletAddress,
+        nonce,
+        expiresAt,
+        signature
+      });
+      return response.data.data;
+    } catch (err) {
+      throw new acpError_default("Failed to verify auth challenge", err);
+    }
+  }
   contractClientByAddress(address) {
     if (!address) {
       return this.contractClients[0];
@@ -4452,9 +4534,13 @@ var AcpClient = class {
     if (skipSocketConnection) {
       return;
     }
+    console.log("Initializing socket");
     const socket = io(this.acpUrl, {
-      auth: {
-        walletAddress: this.walletAddress
+      auth: async (cb) => {
+        cb({
+          walletAddress: this.walletAddress,
+          accessToken: await this.getAccessToken()
+        });
       },
       extraHeaders: {
         "x-sdk-version": version,
@@ -4468,85 +4554,23 @@ var AcpClient = class {
       console.log("Joined ACP Room");
       callback(true);
     });
-    socket.on(
-      "onEvaluate" /* ON_EVALUATE */,
-      async (data, callback) => {
-        callback(true);
-        if (this.onEvaluate) {
-          const job = new acpJob_default(
-            this,
-            data.id,
-            data.clientAddress,
-            data.providerAddress,
-            data.evaluatorAddress,
-            data.price,
-            data.priceTokenAddress,
-            data.memos.map((memo) => {
-              return new acpMemo_default(
-                this.contractClientByAddress(data.contractAddress),
-                memo.id,
-                memo.memoType,
-                memo.content,
-                memo.nextPhase,
-                memo.status,
-                memo.senderAddress,
-                memo.signedReason,
-                memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
-                memo.payableDetails,
-                memo.txHash,
-                memo.signedTxHash
-              );
-            }),
-            data.phase,
-            data.context,
-            data.contractAddress,
-            data.netPayableAmount
-          );
-          this.onEvaluate(job);
-        }
+    socket.on("onEvaluate" /* ON_EVALUATE */, async (data, callback) => {
+      callback(true);
+      if (this.onEvaluate) {
+        const job = this._hydrateJob(data);
+        this.onEvaluate(job);
       }
-    );
-    socket.on(
-      "onNewTask" /* ON_NEW_TASK */,
-      async (data, callback) => {
-        callback(true);
-        if (this.onNewTask) {
-          const job = new acpJob_default(
-            this,
-            data.id,
-            data.clientAddress,
-            data.providerAddress,
-            data.evaluatorAddress,
-            data.price,
-            data.priceTokenAddress,
-            data.memos.map((memo) => {
-              return new acpMemo_default(
-                this.contractClientByAddress(data.contractAddress),
-                memo.id,
-                memo.memoType,
-                memo.content,
-                memo.nextPhase,
-                memo.status,
-                memo.senderAddress,
-                memo.signedReason,
-                memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
-                memo.payableDetails,
-                memo.txHash,
-                memo.signedTxHash
-              );
-            }),
-            data.phase,
-            data.context,
-            data.contractAddress,
-            data.netPayableAmount
-          );
-          this.onNewTask(
-            job,
-            job.memos.find((m) => m.id == data.memoToSign)
-          );
-        }
+    });
+    socket.on("onNewTask" /* ON_NEW_TASK */, async (data, callback) => {
+      callback(true);
+      if (this.onNewTask) {
+        const job = this._hydrateJob(data);
+        this.onNewTask(
+          job,
+          job.memos.find((m) => m.id == data.memoToSign)
+        );
       }
-    );
+    });
     const cleanup = async () => {
       if (socket) {
         socket.disconnect();
@@ -4556,70 +4580,156 @@ var AcpClient = class {
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
   }
-  async browseAgents(keyword, options) {
-    let { cluster, sort_by, top_k, graduationStatus, onlineStatus, showHiddenOfferings } = options;
-    top_k = top_k ?? 5;
-    let url = `${this.acpUrl}/api/agents/v4/search?search=${keyword}`;
-    if (sort_by && sort_by.length > 0) {
-      url += `&sortBy=${sort_by.map((s) => s).join(",")}`;
+  async _fetch(url, method = "GET", params, data, errCallback) {
+    try {
+      const response = await this.acpClient.request({
+        url,
+        method,
+        params,
+        data
+      });
+      return response.data.data;
+    } catch (err) {
+      if (err instanceof AxiosError) {
+        if (errCallback) {
+          errCallback(err);
+        } else if (err.response?.data.error?.message) {
+          throw new acpError_default(err.response?.data.error.message);
+        }
+      } else {
+        throw new acpError_default(
+          `Failed to fetch ACP Endpoint: ${url} (network error)`,
+          err
+        );
+      }
+    }
+  }
+  _hydrateMemo(memo, contractClient) {
+    try {
+      return new acpMemo_default(
+        contractClient,
+        memo.id,
+        memo.memoType,
+        memo.content,
+        memo.nextPhase,
+        memo.status,
+        memo.senderAddress,
+        memo.signedReason,
+        memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
+        memo.payableDetails,
+        memo.txHash,
+        memo.signedTxHash
+      );
+    } catch (err) {
+      throw new acpError_default(`Failed to hydrate memo ${memo.id}`, err);
+    }
+  }
+  _hydrateJob(job) {
+    try {
+      return new acpJob_default(
+        this,
+        job.id,
+        job.clientAddress,
+        job.providerAddress,
+        job.evaluatorAddress,
+        job.price,
+        job.priceTokenAddress,
+        job.memos.map(
+          (memo) => this._hydrateMemo(
+            memo,
+            this.contractClientByAddress(job.contractAddress)
+          )
+        ),
+        job.phase,
+        job.context,
+        job.contractAddress,
+        job.netPayableAmount
+      );
+    } catch (err) {
+      throw new acpError_default(`Failed to hydrate job ${job.id}`, err);
     }
-    if (top_k) {
-      url += `&top_k=${top_k}`;
+  }
+  _hydrateJobs(rawJobs, options) {
+    const jobs = rawJobs.map((job) => {
+      try {
+        return this._hydrateJob(job);
+      } catch (err) {
+        console.warn(`${options?.logPrefix ?? "Skipped"}`, err);
+        return null;
+      }
+    });
+    return jobs.filter((job) => !!job);
+  }
+  _hydrateAgent(agent) {
+    const acpContractClient = this.contractClients.find(
+      (client) => client.contractAddress.toLowerCase() === agent.contractAddress.toLowerCase()
+    );
+    if (!acpContractClient) {
+      throw new acpError_default("ACP contract client not found");
     }
-    if (this.walletAddress) {
-      url += `&walletAddressesToExclude=${this.walletAddress}`;
+    return new acpAgent_default({
+      id: agent.id,
+      name: agent.name,
+      description: agent.description,
+      jobOfferings: agent.jobs.map((jobs) => {
+        return new acpJobOffering_default(
+          this,
+          acpContractClient,
+          agent.walletAddress,
+          jobs.name,
+          jobs.priceV2.value,
+          jobs.priceV2.type,
+          jobs.requirement
+        );
+      }),
+      contractAddress: agent.contractAddress,
+      twitterHandle: agent.twitterHandle,
+      walletAddress: agent.walletAddress,
+      metrics: agent.metrics,
+      resources: agent.resources
+    });
+  }
+  async browseAgents(keyword, options = {}) {
+    const {
+      cluster,
+      sortBy,
+      topK = 5,
+      graduationStatus,
+      onlineStatus,
+      showHiddenOfferings
+    } = options;
+    const params = {
+      search: keyword
+    };
+    params.top_k = topK;
+    params.walletAddressesToExclude = this.walletAddress;
+    if (sortBy && sortBy.length > 0) {
+      params.sortBy = sortBy.join(",");
     }
     if (cluster) {
-      url += `&cluster=${cluster}`;
+      params.cluster = cluster;
     }
     if (graduationStatus) {
-      url += `&graduationStatus=${graduationStatus}`;
+      params.graduationStatus = graduationStatus;
     }
     if (onlineStatus) {
-      url += `&onlineStatus=${onlineStatus}`;
+      params.onlineStatus = onlineStatus;
     }
     if (showHiddenOfferings) {
-      url += `&showHiddenOfferings=${showHiddenOfferings}`;
+      params.showHiddenOfferings = true;
     }
-    const response = await fetch(url);
-    const data = await response.json();
+    const agents = await this._fetch("/agents/v4/search", "GET", params) || [];
     const availableContractClientAddresses = this.contractClients.map(
       (client) => client.contractAddress.toLowerCase()
     );
-    return data.data.filter(
+    return agents.filter(
       (agent) => agent.walletAddress.toLowerCase() !== this.walletAddress.toLowerCase()
     ).filter(
       (agent) => availableContractClientAddresses.includes(
         agent.contractAddress.toLowerCase()
       )
     ).map((agent) => {
-      const acpContractClient = this.contractClients.find(
-        (client) => client.contractAddress.toLowerCase() === agent.contractAddress.toLowerCase()
-      );
-      if (!acpContractClient) {
-        throw new acpError_default("ACP contract client not found");
-      }
-      return {
-        id: agent.id,
-        name: agent.name,
-        description: agent.description,
-        jobOfferings: agent.jobs.map((jobs) => {
-          return new acpJobOffering_default(
-            this,
-            acpContractClient,
-            agent.walletAddress,
-            jobs.name,
-            jobs.priceV2.value,
-            jobs.priceV2.type,
-            jobs.requirement
-          );
-        }),
-        contractAddress: agent.contractAddress,
-        twitterHandle: agent.twitterHandle,
-        walletAddress: agent.walletAddress,
-        metrics: agent.metrics,
-        resources: agent.resources
-      };
+      return this._hydrateAgent(agent);
     });
   }
   async initiateJob(providerAddress, serviceRequirement, fareAmount, evaluatorAddress, expiredAt = new Date(Date.now() + 1e3 * 60 * 60 * 24)) {
@@ -4689,254 +4799,136 @@ var AcpClient = class {
     return jobId;
   }
   async getActiveJobs(page = 1, pageSize = 10) {
-    const url = `${this.acpUrl}/api/jobs/active?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
-    const rawJobs = await this._fetchJobList(url);
-    return this._hydrateJobs(rawJobs, { logPrefix: "Active jobs" });
+    const rawJobs = await this._fetch("/jobs/active", "GET", {
+      pagination: {
+        page,
+        pageSize
+      }
+    });
+    return this._hydrateJobs(rawJobs ?? [], { logPrefix: "Active jobs" });
   }
   async getPendingMemoJobs(page = 1, pageSize = 10) {
-    const url = `${this.acpUrl}/api/jobs/pending-memos?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
-    const rawJobs = await this._fetchJobList(url);
-    return this._hydrateJobs(rawJobs, { logPrefix: "Pending memo jobs" });
+    const rawJobs = await this._fetch("/jobs/pending-memos", "GET", {
+      pagination: {
+        page,
+        pageSize
+      }
+    });
+    return this._hydrateJobs(rawJobs ?? [], { logPrefix: "Pending memo jobs" });
   }
   async getCompletedJobs(page = 1, pageSize = 10) {
-    const url = `${this.acpUrl}/api/jobs/completed?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
-    const rawJobs = await this._fetchJobList(url);
-    return this._hydrateJobs(rawJobs, { logPrefix: "Completed jobs" });
+    const rawJobs = await this._fetch("/jobs/completed", "GET", {
+      pagination: {
+        page,
+        pageSize
+      }
+    });
+    return this._hydrateJobs(rawJobs ?? [], { logPrefix: "Completed jobs" });
   }
   async getCancelledJobs(page = 1, pageSize = 10) {
-    const url = `${this.acpUrl}/api/jobs/cancelled?pagination[page]=${page}&pagination[pageSize]=${pageSize}`;
-    const rawJobs = await this._fetchJobList(url);
-    return this._hydrateJobs(rawJobs, { logPrefix: "Cancelled jobs" });
-  }
-  async _fetchJobList(url) {
-    let response;
-    try {
-      response = await fetch(url, {
-        headers: {
-          "wallet-address": this.walletAddress
-        }
-      });
-    } catch (err) {
-      throw new acpError_default("Failed to fetch ACP jobs (network error)", err);
-    }
-    let data;
-    try {
-      data = await response.json();
-    } catch (err) {
-      throw new acpError_default("Failed to parse ACP jobs response", err);
-    }
-    if (data.error) {
-      throw new acpError_default(data.error.message);
-    }
-    return data.data;
-  }
-  _hydrateJobs(rawJobs, options) {
-    const jobs = [];
-    const errors = [];
-    for (const job of rawJobs) {
-      try {
-        const memos = job.memos.map(
-          (memo) => new acpMemo_default(
-            this.contractClientByAddress(job.contractAddress),
-            memo.id,
-            memo.memoType,
-            memo.content,
-            memo.nextPhase,
-            memo.status,
-            memo.senderAddress,
-            memo.signedReason,
-            memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
-            memo.payableDetails,
-            memo.txHash,
-            memo.signedTxHash
-          )
-        );
-        jobs.push(
-          new acpJob_default(
-            this,
-            job.id,
-            job.clientAddress,
-            job.providerAddress,
-            job.evaluatorAddress,
-            job.price,
-            job.priceTokenAddress,
-            memos,
-            job.phase,
-            job.context,
-            job.contractAddress,
-            job.netPayableAmount
-          )
-        );
-      } catch (err) {
-        errors.push({ jobId: job.id, error: err });
+    const rawJobs = await this._fetch("/jobs/cancelled", "GET", {
+      pagination: {
+        page,
+        pageSize
       }
-    }
-    if (errors.length > 0) {
-      console.warn(
-        `${options?.logPrefix ?? "Skipped"} ${errors.length} malformed job(s)
-` + JSON.stringify(
-          errors.map((e) => ({ jobId: e.jobId, message: e.error.message })),
-          null,
-          2
-        )
-      );
-    }
-    return jobs;
+    });
+    return this._hydrateJobs(rawJobs ?? [], { logPrefix: "Cancelled jobs" });
   }
   async getJobById(jobId) {
-    const url = `${this.acpUrl}/api/jobs/${jobId}`;
-    let response;
-    try {
-      response = await fetch(url, {
-        headers: {
-          "wallet-address": this.acpContractClient.walletAddress
-        }
-      });
-    } catch (err) {
-      throw new acpError_default("Failed to fetch job by id (network error)", err);
-    }
-    let data;
-    try {
-      data = await response.json();
-    } catch (err) {
-      throw new acpError_default("Failed to parse job by id response", err);
-    }
-    if (data.error) {
-      throw new acpError_default(data.error.message);
-    }
-    const job = data.data;
+    const job = await this._fetch(`/jobs/${jobId}`);
     if (!job) {
-      return void 0;
-    }
-    try {
-      const memos = job.memos.map(
-        (memo) => new acpMemo_default(
-          this.contractClientByAddress(job.contractAddress),
-          memo.id,
-          memo.memoType,
-          memo.content,
-          memo.nextPhase,
-          memo.status,
-          memo.senderAddress,
-          memo.signedReason,
-          memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
-          memo.payableDetails,
-          memo.txHash,
-          memo.signedTxHash
-        )
-      );
-      return new acpJob_default(
-        this,
-        job.id,
-        job.clientAddress,
-        job.providerAddress,
-        job.evaluatorAddress,
-        job.price,
-        job.priceTokenAddress,
-        memos,
-        job.phase,
-        job.context,
-        job.contractAddress,
-        job.netPayableAmount
-      );
-    } catch (err) {
-      throw new acpError_default(`Failed to hydrate job ${jobId}`, err);
+      return null;
     }
+    return this._hydrateJob(job);
   }
   async getMemoById(jobId, memoId) {
-    const url = `${this.acpUrl}/api/jobs/${jobId}/memos/${memoId}`;
-    let response;
-    try {
-      response = await fetch(url, {
-        headers: {
-          "wallet-address": this.walletAddress
-        }
-      });
-    } catch (err) {
-      throw new acpError_default("Failed to fetch memo by id (network error)", err);
-    }
-    let data;
-    try {
-      data = await response.json();
-    } catch (err) {
-      throw new acpError_default("Failed to parse memo by id response", err);
-    }
-    if (data.error) {
-      throw new acpError_default(data.error.message);
-    }
-    const memo = data.data;
+    const memo = await this._fetch(
+      `/jobs/${jobId}/memos/${memoId}`
+    );
     if (!memo) {
-      return void 0;
-    }
-    try {
-      return new acpMemo_default(
-        this.contractClientByAddress(memo.contractAddress),
-        memo.id,
-        memo.memoType,
-        memo.content,
-        memo.nextPhase,
-        memo.status,
-        memo.senderAddress,
-        memo.signedReason,
-        memo.expiry ? new Date(parseInt(memo.expiry) * 1e3) : void 0,
-        memo.payableDetails,
-        memo.txHash,
-        memo.signedTxHash
-      );
-    } catch (err) {
-      throw new acpError_default(
-        `Failed to hydrate memo ${memoId} for job ${jobId}`,
-        err
-      );
+      return null;
     }
+    return this._hydrateMemo(
+      memo,
+      this.contractClientByAddress(memo.contractAddress)
+    );
   }
-  async getAgent(walletAddress) {
-    const url = `${this.acpUrl}/api/agents?filters[walletAddress]=${walletAddress}`;
-    const response = await fetch(url);
-    const data = await response.json();
-    const agents = data.data || [];
-    if (agents.length === 0) {
-      return;
+  async getAgent(walletAddress, options = {}) {
+    const params = {
+      "filters[walletAddress]": walletAddress
+    };
+    const { showHiddenOfferings } = options;
+    if (showHiddenOfferings) {
+      params.showHiddenOfferings = true;
+    }
+    const agents = await this._fetch("/agents", "GET", params) || [];
+    if (!agents) {
+      return null;
     }
-    return agents[0];
+    const agent = agents[0];
+    return this._hydrateAgent(agent);
   }
   async getAccountByJobId(jobId, acpContractClient) {
-    try {
-      const url = `${this.acpUrl}/api/accounts/job/${jobId}`;
-      const response = await fetch(url);
-      const data = await response.json();
-      if (!data.data) {
-        return null;
-      }
-      return new AcpAccount(
-        acpContractClient || this.contractClients[0],
-        data.data.id,
-        data.data.clientAddress,
-        data.data.providerAddress,
-        data.data.metadata
-      );
-    } catch (error) {
-      throw new acpError_default("Failed to get account by job id", error);
+    const account = await this._fetch(`/accounts/job/${jobId}`);
+    if (!account) {
+      return null;
     }
+    return new AcpAccount(
+      acpContractClient || this.contractClients[0],
+      account.id,
+      account.clientAddress,
+      account.providerAddress,
+      account.metadata
+    );
   }
   async getByClientAndProvider(clientAddress, providerAddress, acpContractClient) {
-    try {
-      const url = `${this.acpUrl}/api/accounts/client/${clientAddress}/provider/${providerAddress}`;
-      const response = await fetch(url);
-      const data = await response.json();
-      if (!data.data) {
-        return null;
+    const response = await this._fetch(
+      `/accounts/client/${clientAddress}/provider/${providerAddress}`,
+      "GET",
+      {},
+      {},
+      (err) => {
+        if (err.response?.status === 404) {
+          console.warn("Account not found by client and provider");
+          return;
+        }
+        throw new acpError_default("Failed to get account by client and provider", err);
       }
-      return new AcpAccount(
-        acpContractClient || this.contractClients[0],
-        data.data.id,
-        data.data.clientAddress,
-        data.data.providerAddress,
-        data.data.metadata
-      );
-    } catch (error) {
-      throw new acpError_default("Failed to get account by client and provider", error);
+    );
+    if (!response) {
+      return null;
+    }
+    return new AcpAccount(
+      acpContractClient || this.contractClients[0],
+      response.id,
+      response.clientAddress,
+      response.providerAddress,
+      response.metadata
+    );
+  }
+  async createMemoContent(jobId, content) {
+    const response = await this._fetch(
+      `/memo-contents`,
+      "POST",
+      {},
+      {
+        data: {
+          onChainJobId: jobId,
+          content
+        }
+      }
+    );
+    if (!response) {
+      throw new acpError_default("Failed to create memo content");
     }
+    return response;
+  }
+  async getTokenBalances() {
+    const response = await this._fetch(
+      `/chains/token-balances`,
+      "GET"
+    );
+    return response;
   }
 };
 var acpClient_default = AcpClient;
@@ -4947,7 +4939,10 @@ import { alchemy } from "@account-kit/infra";
 import {
   createModularAccountV2Client
 } from "@account-kit/smart-contracts";
-import { decodeEventLog, encodeFunctionData as encodeFunctionData3 } from "viem";
+import {
+  decodeEventLog,
+  encodeFunctionData as encodeFunctionData3
+} from "viem";
 
 // src/acpX402.ts
 import {
@@ -5322,6 +5317,9 @@ var AcpContractClient = class _AcpContractClient extends baseAcpContractClient_d
   getAcpVersion() {
     return "1";
   }
+  signTypedData(typedData) {
+    return this.sessionKeyClient.signTypedData({ typedData });
+  }
 };
 var acpContractClient_default = AcpContractClient;
 
@@ -5331,7 +5329,11 @@ import { alchemy as alchemy2 } from "@account-kit/infra";
 import {
   createModularAccountV2Client as createModularAccountV2Client2
 } from "@account-kit/smart-contracts";
-import { createPublicClient as createPublicClient4, decodeEventLog as decodeEventLog2, http as http3 } from "viem";
+import {
+  createPublicClient as createPublicClient4,
+  decodeEventLog as decodeEventLog2,
+  http as http3
+} from "viem";
 
 // src/abis/jobManagerAbi.ts
 var JOB_MANAGER_ABI = [
@@ -6249,6 +6251,9 @@ var AcpContractClientV2 = class _AcpContractClientV2 extends baseAcpContractClie
   getAcpVersion() {
     return "2";
   }
+  async signTypedData(typedData) {
+    return await this.sessionKeyClient.signTypedData({ typedData });
+  }
 };
 var acpContractClientV2_default = AcpContractClientV2;
 
@@ -6256,6 +6261,7 @@ var acpContractClientV2_default = AcpContractClientV2;
 var index_default = acpClient_default;
 export {
   acpAbi_default as ACP_ABI,
+  acpAgent_default as AcpAgent,
   AcpAgentSort,
   acpContractClient_default as AcpContractClient,
   acpContractClientV2_default as AcpContractClientV2,
@@ -6272,8 +6278,6 @@ export {
   FareAmount,
   FareBigInt,
   MemoType,
-  PayloadType,
-  PositionDirection,
   baseAcpConfig,
   baseAcpConfigV2,
   baseAcpX402Config,