@candledottv/agent-sdk 0.4.11 → 0.6.0

package/dist/index.js

@@ -3,6 +3,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/client.ts
 import { keccak_256 as keccak_2562 } from "@noble/hashes/sha3";
+import { base58 as base582 } from "@scure/base";
 
 // src/authorization-signature.ts
 import canonicalize from "canonicalize";
@@ -78,6 +79,7 @@ async function buildPrivyAuthorizationSignature(params) {
 var BRIDGE_ERROR_CODES = ["BRIDGE_DESTINATION_MISSING", "RELAY_STEP_REFUSED", "BRIDGE_IN_FLIGHT"];
 
 class CandleApiError extends Error {
+  legs;
   code;
   status;
   retryable;
@@ -94,9 +96,12 @@ class CandleApiError extends Error {
   feeRaw;
   quoteAsset;
   treasury;
+  reason;
+  retryAfter;
   constructor(args) {
     super(args.message);
     this.name = "CandleApiError";
+    this.legs = args.legs;
     this.code = args.code;
     this.status = args.status;
     this.retryable = args.retryable;
@@ -121,6 +126,45 @@ class CandleApiError extends Error {
       this.quoteAsset = args.quoteAsset;
     if (args.treasury !== undefined)
       this.treasury = args.treasury;
+    if (args.reason !== undefined)
+      this.reason = args.reason;
+    if (args.retryAfter !== undefined)
+      this.retryAfter = args.retryAfter;
+  }
+}
+
+class TradeLegOutcomeError extends Error {
+  clientTradeId;
+  leg;
+  outcome;
+  txHash;
+  landedLegs;
+  cause;
+  constructor(args) {
+    super((args.cause instanceof Error ? args.cause.message + ". " : "") + "A Hood trade leg failed. Inspect txHash and landedLegs on chain; read getTradeJob(clientTradeId) or call trade with the same id and body for Candle's view. Never retry a retryable:false answer.", { cause: args.cause });
+    this.name = "TradeLegOutcomeError";
+    this.clientTradeId = args.clientTradeId;
+    this.leg = args.leg;
+    this.outcome = args.outcome;
+    this.txHash = args.txHash;
+    this.landedLegs = args.landedLegs;
+    this.cause = args.cause;
+  }
+}
+
+class TradeLandedUnconfirmedError extends Error {
+  clientTradeId;
+  tradeTxHash;
+  feeTxHash;
+  stage = "executed";
+  cause;
+  constructor(args) {
+    super("The trade is on chain and not booked. Read getTradeJob(clientTradeId) before calling confirmTrade again with these hashes. If the row is failed, this id cannot be recorded with /confirm; retain the hashes and do not retry or rebuild.", { cause: args.cause });
+    this.name = "TradeLandedUnconfirmedError";
+    this.clientTradeId = args.clientTradeId;
+    this.tradeTxHash = args.tradeTxHash;
+    this.feeTxHash = args.feeTxHash;
+    this.cause = args.cause;
   }
 }
 
@@ -161,6 +205,51 @@ class JsonRpcError extends Error {
     this.data = args.data;
   }
 }
+function operationErrorMessage(cause, ids, flow) {
+  const original = cause instanceof Error ? cause.message : String(cause);
+  const isTrade = ids.clientTradeId !== undefined;
+  const idName = isTrade ? "clientTradeId" : "clientLaunchId";
+  const noun = isTrade ? "trade" : "launch";
+  const read = isTrade ? "getTradeJob()" : "getLaunchJob()";
+  const bundle = ids.bundleId !== undefined ? ` (bundleId ${ids.bundleId}, single-use: for logs only, never resubmitted)` : "";
+  const head = `${original} -- ${idName} ${ids.clientTradeId ?? ids.clientLaunchId}${bundle}: ` + "the request may or may not have reached Candle.";
+  const tail = `A call with a new id, or with none, is a second, independent ${noun}.`;
+  if (flow === "server-executed") {
+    return `${head} Read the job for this id (${read}), or retry the call with this same ${idName} and the same request. ${tail}`;
+  }
+  return `${head} This id identifies the job: read the job for this id (${read}), and check the wallet's recent ` + `transactions before sending again, because a call under the same id can sign and broadcast a second ` + `transaction. ${tail}`;
+}
+
+class CandleOperationError extends Error {
+  constructor(args) {
+    super(operationErrorMessage(args.cause, args.ids, args.flow), { cause: args.cause });
+    this.name = "CandleOperationError";
+    Object.assign(this, definedIds(args.ids));
+  }
+}
+function definedIds(ids) {
+  return {
+    ...typeof ids.clientTradeId === "string" ? { clientTradeId: ids.clientTradeId } : {},
+    ...typeof ids.clientLaunchId === "string" ? { clientLaunchId: ids.clientLaunchId } : {},
+    ...typeof ids.bundleId === "string" ? { bundleId: ids.bundleId } : {}
+  };
+}
+function operationIds(error) {
+  if (error instanceof CandleApiError || error instanceof JsonRpcError || error instanceof TradeLandedFeeLegError || error instanceof TradeLegOutcomeError || error instanceof TradeLandedUnconfirmedError || error instanceof CandleOperationError) {
+    return definedIds(error);
+  }
+  return {};
+}
+function withOperationIds(error, ids, flow) {
+  if (error instanceof CandleApiError || error instanceof JsonRpcError)
+    return Object.assign(error, definedIds(ids));
+  if (error instanceof TradeLandedFeeLegError || error instanceof TradeLegOutcomeError || error instanceof TradeLandedUnconfirmedError)
+    return error;
+  if (error instanceof CandleOperationError) {
+    return new CandleOperationError({ cause: error.cause, ids: { ...operationIds(error), ...definedIds(ids) }, flow });
+  }
+  return new CandleOperationError({ cause: error, ids, flow });
+}
 function envelopeError(body) {
   if (typeof body !== "object" || body === null)
     return null;
@@ -182,13 +271,16 @@ function envelopeError(body) {
     message: error.message,
     ...typeof error.field === "string" ? { field: error.field } : {},
     ...typeof error.retryable === "boolean" ? { retryable: error.retryable } : {},
+    ...Array.isArray(error.legs) ? { legs: error.legs } : {},
     ...typeof error.stage === "string" ? { stage: error.stage } : {},
     ...typeof error.signature === "string" ? { signature: error.signature } : {},
     ...typeof error.mint === "string" ? { mint: error.mint } : {},
     ...typeof error.recorded === "boolean" ? { recorded: error.recorded } : {},
     ...typeof error.feeRaw === "string" ? { feeRaw: error.feeRaw } : {},
     ...typeof error.quoteAsset === "string" ? { quoteAsset: error.quoteAsset } : {},
-    ...typeof error.treasury === "string" ? { treasury: error.treasury } : {}
+    ...typeof error.treasury === "string" ? { treasury: error.treasury } : {},
+    ...typeof error.reason === "string" ? { reason: error.reason } : {},
+    ...typeof error.retryAfter === "number" ? { retryAfter: error.retryAfter } : {}
   };
 }
 function candleApiErrorFromResponse(status, bodyText) {
@@ -1074,6 +1166,45 @@ class CandleClient {
   async verify(chain, mint) {
     return this.requestJson("GET", `/api/v1/verify/${chain}/${encodeURIComponent(mint)}`);
   }
+  async getOwnProfile() {
+    this.requireKey("getOwnProfile()");
+    return this.requestJson("GET", "/api/v1/agent/keys/self/public-profile");
+  }
+  async updateOwnProfile(patch) {
+    this.requireKey("updateOwnProfile()");
+    return this.requestJson("PATCH", "/api/v1/agent/keys/self/public-profile", patch);
+  }
+  async uploadProfileImage(kind, bytes, contentType) {
+    this.requireKey("uploadProfileImage()");
+    const form = new FormData;
+    form.set("kind", kind);
+    form.set("image", new Blob([bytes], { type: contentType }), "profile.image");
+    const headers = this.headers();
+    delete headers["Content-Type"];
+    const res = await this.fetchImpl(`${this.apiUrl}/api/v1/uploads/agent-profile-image`, {
+      method: "POST",
+      headers,
+      body: form
+    });
+    return this.parseResponse(res);
+  }
+  async createPost(req) {
+    this.requireKey("createPost()");
+    return this.requestJson("POST", "/api/v1/agent/posts", req);
+  }
+  async deletePost(postId) {
+    this.requireKey("deletePost()");
+    return this.requestJson("DELETE", `/api/v1/agent/posts/${encodeURIComponent(postId)}`);
+  }
+  async listAgentPosts(profileId, options = {}) {
+    const params = new URLSearchParams;
+    if (options.limit !== undefined)
+      params.set("limit", String(options.limit));
+    if (options.cursor !== undefined)
+      params.set("cursor", options.cursor);
+    const body = await this.requestJson("GET", `/api/v1/agent/records/${encodeURIComponent(profileId)}/posts${params.size ? `?${params}` : ""}`);
+    return { posts: body.posts, cursor: body.cursor ?? null };
+  }
   async getAgentProfile(idOrWallet) {
     const body = await this.requestJson("GET", `/api/v1/users/${encodeURIComponent(idOrWallet)}/agent`);
     return body.agent;
@@ -1105,25 +1236,33 @@ class CandleClient {
   }
   async launch(req) {
     this.requireKey("launch()");
-    const body = { ...req, clientLaunchId: req.clientLaunchId ?? generateClientLaunchId() };
-    let lastError;
-    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
-      if (attempt > 0)
-        await sleep2(retryDelayMs(attempt - 1));
-      try {
-        return await this.requestJson("POST", "/api/v1/launch/headless", body);
-      } catch (error) {
-        if (!isRetryableLaunchFailure(error))
-          throw error;
-        lastError = error;
+    const clientLaunchId = req.clientLaunchId ?? generateClientLaunchId();
+    const body = { ...req, clientLaunchId };
+    return this.runOperation({ clientLaunchId }, "server-executed", async (op) => {
+      let lastError;
+      for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+        if (attempt > 0)
+          await sleep2(retryDelayMs(attempt - 1));
+        try {
+          const result = await this.requestJson("POST", "/api/v1/launch/headless", body, op);
+          return { ...result, clientLaunchId };
+        } catch (error) {
+          if (!isRetryableLaunchFailure(error))
+            throw error;
+          lastError = error;
+        }
       }
-    }
-    throw lastError;
+      throw lastError;
+    });
   }
   async launchAsync(req) {
     this.requireKey("launchAsync()");
-    const body = { ...req, clientLaunchId: req.clientLaunchId ?? generateClientLaunchId(), async: true };
-    return this.requestJson("POST", "/api/v1/launch/headless", body);
+    const clientLaunchId = req.clientLaunchId ?? generateClientLaunchId();
+    const body = { ...req, clientLaunchId, async: true };
+    return this.runOperation({ clientLaunchId }, "server-executed", async (op) => {
+      const accepted = await this.requestJson("POST", "/api/v1/launch/headless", body, op);
+      return { ...accepted, clientLaunchId: accepted.clientLaunchId ?? clientLaunchId };
+    });
   }
   async getLaunchJob(clientLaunchId) {
     this.requireKey("getLaunchJob()");
@@ -1241,16 +1380,28 @@ class CandleClient {
     return this.requestJson("POST", "/api/v1/launch/self/dry-run", req);
   }
   async buildSelfLaunch(req) {
+    return this.postSelfLaunchBuild(req);
+  }
+  async postSelfLaunchBuild(req, op) {
     this.requireKey("buildSelfLaunch()");
-    return this.requestJson("POST", "/api/v1/launch/self/build", req);
+    return this.requestJson("POST", "/api/v1/launch/self/build", req, op);
   }
   async confirmSelfLaunch(req) {
     this.requireKey("confirmSelfLaunch()");
-    return this.requestJson("POST", "/api/v1/launch/self/confirm", req);
+    const result = await this.requestJson("POST", "/api/v1/launch/self/confirm", req);
+    return { ...result, clientLaunchId: req.clientLaunchId };
   }
   async buildTrade(req) {
+    return this.postTradeBuild(req);
+  }
+  async postTradeBuild(req, op) {
     this.requireKey("buildTrade()");
-    return this.requestJson("POST", "/api/v1/trade/agent/build", req);
+    return this.requestJson("POST", "/api/v1/trade/agent/build", req, op);
+  }
+  async getTradeJob(clientTradeId) {
+    this.requireKey("getTradeJob()");
+    const body = await this.requestJson("GET", `/api/v1/trade/agent/jobs/${encodeURIComponent(clientTradeId)}`);
+    return body.job;
   }
   async confirmTrade(req) {
     this.requireKey("confirmTrade()");
@@ -1339,15 +1490,22 @@ class CandleClient {
       ...req.maxSlippageBps !== undefined ? { maxSlippageBps: req.maxSlippageBps } : {},
       ...req.quoteAsset !== undefined ? { quoteAsset: req.quoteAsset } : {}
     };
+    const flow = req.from === "main" ? "server-executed" : "caller-broadcast";
+    return this.runOperation({ clientTradeId }, flow, async (op) => {
+      const result = await this.tradeSteps(req, buildReq, op);
+      return typeof result.clientTradeId === "string" ? result : { ...result, clientTradeId };
+    });
+  }
+  async tradeSteps(req, buildReq, op) {
     if (req.from === "main") {
-      const result = await this.buildTrade(buildReq);
+      const result = await this.postTradeBuild(buildReq, op);
       if (result.status !== "executed") {
         throw new Error(`trade({ from: "main" }) expected an executed result but got status "${result.status}"`);
       }
       return result;
     }
     const { linkedWalletId, privyWalletId } = req.from;
-    const built = await this.buildTrade(buildReq);
+    const built = await this.postTradeBuild(buildReq, op);
     if (built.status !== "built") {
       return built;
     }
@@ -1384,6 +1542,7 @@ class CandleClient {
     if (built.artifacts.feeTransfer) {
       legs.push({ kind: "feeTransfer", ...built.artifacts.feeTransfer });
     }
+    const landedLegs = [];
     let tradeTxHash;
     let feeTxHash;
     for (let i = 0;i < legs.length; i++) {
@@ -1403,13 +1562,24 @@ class CandleClient {
           feeData,
           linkedWalletId,
           privyWalletId
-        }, { surfaceLegOutcome: leg.kind === "feeTransfer" });
+        }, { surfaceLegOutcome: true });
       } catch (err) {
         if (leg.kind === "feeTransfer" && tradeTxHash) {
           throw tradeLandedFeeLegError({ clientTradeId: built.clientTradeId, tradeTxHash, err });
         }
-        throw err;
+        if (err instanceof EvmLegOutcome && err.txHash !== undefined || landedLegs.length > 0) {
+          throw new TradeLegOutcomeError({
+            clientTradeId: built.clientTradeId,
+            leg: leg.kind,
+            outcome: err instanceof EvmLegOutcome ? err.kind : "not-broadcast",
+            txHash: err instanceof EvmLegOutcome ? err.txHash : undefined,
+            landedLegs: [...landedLegs],
+            cause: err instanceof EvmLegOutcome ? err.cause : err
+          });
+        }
+        throw err instanceof EvmLegOutcome ? err.cause : err;
       }
+      landedLegs.push({ leg: leg.kind, txHash });
       if (leg.kind === "trade")
         tradeTxHash = txHash;
       if (leg.kind === "feeTransfer")
@@ -1418,29 +1588,38 @@ class CandleClient {
     if (!tradeTxHash) {
       throw new Error("trade(): Hood leg sequence completed without a trade leg");
     }
-    return this.confirmTrade({
-      clientTradeId: built.clientTradeId,
-      tradeTxHash,
-      ...feeTxHash ? { feeTxHash } : {}
-    });
+    try {
+      return await this.confirmTrade({
+        clientTradeId: built.clientTradeId,
+        tradeTxHash,
+        ...feeTxHash ? { feeTxHash } : {}
+      });
+    } catch (cause) {
+      throw new TradeLandedUnconfirmedError({ clientTradeId: built.clientTradeId, tradeTxHash, feeTxHash, cause });
+    }
   }
   async selfLaunch(req) {
     const { privyWalletId, ...launchReq } = req;
-    const body = {
-      ...launchReq,
-      clientLaunchId: launchReq.clientLaunchId ?? generateClientLaunchId()
-    };
-    const built = await this.buildSelfLaunch(body);
+    const clientLaunchId = launchReq.clientLaunchId ?? generateClientLaunchId();
+    const body = { ...launchReq, clientLaunchId };
+    return this.runOperation({ clientLaunchId }, "caller-broadcast", (op) => this.selfLaunchSteps(body, privyWalletId, op));
+  }
+  async selfLaunchSteps(body, privyWalletId, op) {
+    const built = await this.postSelfLaunchBuild(body, op);
     if (typeof built.transaction === "string") {
       let unsignedTransactionBase64 = built.transaction;
       let clientLaunchId = built.clientLaunchId;
+      let signed;
       for (let attempt = 0;attempt <= MAX_BLOCKHASH_REBUILDS; attempt++) {
-        const signed = await this.signLinkedTransaction({
-          linkedWalletId: body.linkedWalletId,
-          privyWalletId,
-          chain: "solana",
-          unsignedTransactionBase64
-        });
+        if (signed?.forTransaction !== unsignedTransactionBase64) {
+          const result = await this.signLinkedTransaction({
+            linkedWalletId: body.linkedWalletId,
+            privyWalletId,
+            chain: "solana",
+            unsignedTransactionBase64
+          });
+          signed = { forTransaction: unsignedTransactionBase64, ...result };
+        }
         try {
           const signature = await this.broadcastSignedTransaction("solana", signed.signedTransaction, signed.encoding);
           return this.confirmSelfLaunch({ clientLaunchId, signature });
@@ -1449,7 +1628,20 @@ class CandleClient {
             throw error;
           if (attempt === MAX_BLOCKHASH_REBUILDS)
             throw withRpcLagHint(error);
-          const rebuilt = await this.buildSelfLaunch(body);
+          let rebuilt;
+          try {
+            rebuilt = await this.postSelfLaunchBuild(body, op);
+          } catch (buildError) {
+            const reason = buildError instanceof CandleApiError ? buildError.reason : undefined;
+            if (reason === "prior_attempt_in_flight")
+              continue;
+            if (reason === "prior_attempt_on_chain") {
+              const signature = solanaSignedTxSignature(signed.signedTransaction, signed.encoding);
+              if (signature)
+                return this.confirmSelfLaunch({ clientLaunchId, signature });
+            }
+            throw buildError;
+          }
           if (typeof rebuilt.transaction !== "string")
             throw error;
           unsignedTransactionBase64 = rebuilt.transaction;
@@ -1502,8 +1694,13 @@ class CandleClient {
   }
   async buildAtomicLaunch(req) {
     this.requireKey("buildAtomicLaunch()");
-    const body = { ...req, clientLaunchId: req.clientLaunchId ?? generateClientLaunchId() };
-    return this.requestJson("POST", "/api/v1/launch/atomic/build", body);
+    const clientLaunchId = req.clientLaunchId ?? generateClientLaunchId();
+    const body = { ...req, clientLaunchId };
+    return this.runOperation({ clientLaunchId }, "server-executed", (op) => this.postAtomicBuild(body, clientLaunchId, op));
+  }
+  async postAtomicBuild(body, clientLaunchId, op) {
+    const built = await this.requestJson("POST", "/api/v1/launch/atomic/build", body, op);
+    return { ...built, clientLaunchId };
   }
   async submitAtomicLaunch(req) {
     this.requireKey("submitAtomicLaunch()");
@@ -1526,14 +1723,24 @@ class CandleClient {
     throw new Error(`submitAtomicLaunch(): unexpected 200 response shape: ${text}`);
   }
   async launchAtomic(req) {
+    this.requireKey("buildAtomicLaunch()");
     const { payer, firstBuys, ...launchFields } = req;
+    const clientLaunchId = launchFields.clientLaunchId ?? generateClientLaunchId();
     const buildReq = {
       ...launchFields,
-      clientLaunchId: launchFields.clientLaunchId ?? generateClientLaunchId(),
+      clientLaunchId,
       payer: toAtomicWirePayer(payer),
       firstBuys: firstBuys.map((leg) => ({ payer: toAtomicWirePayer(leg.payer), amountRaw: leg.amountRaw }))
     };
-    const built = await this.buildAtomicLaunch(buildReq);
+    return this.runOperation({ clientLaunchId }, "server-executed", async (op) => {
+      const outcome = await this.launchAtomicSteps(req, buildReq, clientLaunchId, op);
+      return { ...outcome, clientLaunchId };
+    });
+  }
+  async launchAtomicSteps(req, buildReq, clientLaunchId, op) {
+    const { payer, firstBuys } = req;
+    const built = await this.postAtomicBuild(buildReq, clientLaunchId, op);
+    op.ids.bundleId = built.bundleId;
     const signedTxsBase64 = [];
     for (const leg of built.legs) {
       if (leg.signer !== "client")
@@ -1605,7 +1812,7 @@ class CandleClient {
       if (!isDefiniteBroadcastRejection(err)) {
         throw new EvmLegOutcome({ kind: "unknown", txHash: predicted, cause: err });
       }
-      throw err;
+      throw new EvmLegOutcome({ kind: "not-broadcast", txHash: predicted, cause: err });
     }
     try {
       await waitForReceipt(params.rpc, txHash, evmReceiptWaitForTest ?? {});
@@ -1869,12 +2076,25 @@ class CandleClient {
       headers["x-api-key"] = this.apiKey;
     return headers;
   }
-  async requestJson(method, path, body) {
-    const res = await this.fetchImpl(`${this.apiUrl}${path}`, {
+  async runOperation(ids, flow, steps) {
+    const op = { sent: false, ids: { ...ids } };
+    try {
+      return await steps(op);
+    } catch (error) {
+      if (!op.sent)
+        throw error;
+      throw withOperationIds(error, op.ids, flow);
+    }
+  }
+  async requestJson(method, path, body, op) {
+    const init = {
       method,
       headers: this.headers({ json: body !== undefined }),
       ...body !== undefined ? { body: JSON.stringify(body) } : {}
-    });
+    };
+    if (op)
+      op.sent = true;
+    const res = await this.fetchImpl(`${this.apiUrl}${path}`, init);
     return this.parseResponse(res);
   }
   async parseResponse(res) {
@@ -1949,7 +2169,7 @@ function tradeLandedFeeLegError(args) {
       tradeTxHash: args.tradeTxHash,
       cause: args.err.cause,
       feeOutcome: args.err.kind,
-      ...args.err.txHash !== undefined ? { feeTxHash: args.err.txHash } : {}
+      ...args.err.kind !== "not-broadcast" && args.err.txHash !== undefined ? { feeTxHash: args.err.txHash } : {}
     });
   }
   return new TradeLandedFeeLegError({
@@ -1959,6 +2179,27 @@ function tradeLandedFeeLegError(args) {
     feeOutcome: "not-broadcast"
   });
 }
+function solanaSignedTxSignature(signedTransaction, encoding) {
+  const enc = encoding.toLowerCase();
+  let bytes;
+  try {
+    if (enc === "base64")
+      bytes = fromBase64(signedTransaction);
+    else if (enc === "base58")
+      bytes = base582.decode(signedTransaction);
+    else
+      return;
+  } catch {
+    return;
+  }
+  const count = bytes[0];
+  if (count === undefined || count === 0 || count >= 128 || bytes.length < 1 + count * 64)
+    return;
+  const first = bytes.subarray(1, 65);
+  if (first.every((byte) => byte === 0))
+    return;
+  return base582.encode(first);
+}
 function evmSignedTxHash(signedTransaction, encoding) {
   const enc = encoding.toLowerCase();
   let bytes;
@@ -1997,7 +2238,7 @@ function generateClientLaunchId() {
 function generateClientTradeId() {
   return generateSdkId();
 }
-var SDK_VERSION = "0.4.11";
+var SDK_VERSION = "0.6.0";
 var sdkUpdateWarned = false;
 function noteLatestSdkVersion(value) {
   if (sdkUpdateWarned || !value || !/^\d+\.\d+\.\d+$/.test(value))
@@ -2361,11 +2602,14 @@ export {
   planPromotionLine,
   planLabel,
   perpsDepositProblem,
+  operationIds,
   isSolanaRpcErrorData,
   hyperliquidActionHash,
   generateSignerKeypair,
   formatPlanBps,
   encryptWalletKeyForImport,
+  TradeLegOutcomeError,
+  TradeLandedUnconfirmedError,
   TradeLandedFeeLegError,
   PLAN_CAPABILITY_NOTE,
   PLAN_CAPABILITY_LABELS,
@@ -2375,6 +2619,7 @@ export {
   HYPERLIQUID_EXCHANGE_URLS,
   HYPERLIQUID_ALLOWED_ACTION_TYPES,
   EncryptedFileSecretStore,
+  CandleOperationError,
   CandleClient,
   CandleApiError,
   CANDLE_HYPERLIQUID_BUILDER_ADDRESS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@candledottv/agent-sdk",
-  "version": "0.4.11",
+  "version": "0.6.0",
   "description": "TypeScript SDK for the Candle agent rail: typed headless launches, market reads, and webhook verification",
   "type": "module",
   "main": "./dist/index.js",