@chipi-stack/backend 14.14.0 → 14.15.1

package/dist/index.js

@@ -732,7 +732,8 @@ var ChipiClient = class {
         throw new shared.ChipiApiError(
           errorData.message,
           errorData.code || `HTTP_${response.status}`,
-          response.status
+          response.status,
+          data
         );
       }
       return data;
@@ -743,14 +744,15 @@ var ChipiClient = class {
   async post({
     endpoint,
     bearerToken,
-    body
+    body,
+    headers
   }) {
     try {
       const url = new URL(`${this.baseUrl}${endpoint}`);
       this.addVersionParams(url);
       const response = await fetch(url.toString(), {
         method: "POST",
-        headers: this.getHeaders(bearerToken),
+        headers: { ...headers, ...this.getHeaders(bearerToken) },
         body: body ? JSON.stringify(body) : void 0
       });
       const data = await response.json();
@@ -759,7 +761,8 @@ var ChipiClient = class {
         throw new shared.ChipiApiError(
           errorData.message,
           errorData.code || `HTTP_${response.status}`,
-          response.status
+          response.status,
+          data
         );
       }
       return data;
@@ -786,7 +789,8 @@ var ChipiClient = class {
         throw new shared.ChipiApiError(
           errorData.message,
           errorData.code || `HTTP_${response.status}`,
-          response.status
+          response.status,
+          data
         );
       }
       return data;
@@ -813,7 +817,8 @@ var ChipiClient = class {
         throw new shared.ChipiApiError(
           errorData.message,
           errorData.code || `HTTP_${response.status}`,
-          response.status
+          response.status,
+          data
         );
       }
       return data;
@@ -838,7 +843,8 @@ var ChipiClient = class {
         throw new shared.ChipiApiError(
           errorData.message,
           errorData.code || `HTTP_${response.status}`,
-          response.status
+          response.status,
+          data
         );
       }
       return data;
@@ -3113,8 +3119,149 @@ var ChipiTreasury = class {
     };
   }
 };
+var DEFAULT_RETRY_INTERVAL_MS = 3e3;
+var DEFAULT_TIMEOUT_MS = 3e5;
+function isPending(finalityStatus) {
+  return finalityStatus === void 0 || finalityStatus === "RECEIVED" || finalityStatus === "PENDING" || finalityStatus === "PRE_CONFIRMED";
+}
+async function waitForTransaction(transactionHash, options = {}) {
+  const {
+    nodeUrl = shared.WALLET_RPC_ENDPOINTS.CHIPI,
+    retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS,
+    timeoutMs = DEFAULT_TIMEOUT_MS
+  } = options;
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  for (; ; ) {
+    try {
+      const receipt = await shared.withRpcFallback(
+        (provider) => provider.getTransactionReceipt(transactionHash),
+        { fallbackUrl: nodeUrl }
+      );
+      if (!isPending(receipt?.finality_status)) {
+        const reverted = receipt.execution_status === "REVERTED";
+        return {
+          transactionHash,
+          success: !reverted,
+          executionStatus: receipt.execution_status,
+          finalityStatus: receipt.finality_status,
+          ...reverted ? { revertReason: receipt.revert_reason ?? "reverted on chain" } : {},
+          events: receipt.events ?? [],
+          ...receipt.block_number !== void 0 ? { blockNumber: receipt.block_number } : {}
+        };
+      }
+    } catch (err) {
+      lastError = err;
+    }
+    if (Date.now() + retryIntervalMs >= deadline) {
+      const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+      throw new Error(
+        `Timed out after ${timeoutMs}ms waiting for ${transactionHash}${detail}. The transaction may still land; re-check before treating it as failed.`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, retryIntervalMs));
+  }
+}
+var InMemoryTxHashStore = class {
+  constructor() {
+    this.used = /* @__PURE__ */ new Set();
+  }
+  consume(transactionHash) {
+    if (this.used.has(transactionHash)) return false;
+    this.used.add(transactionHash);
+    return true;
+  }
+};
+var TRANSFER_SELECTOR = BigInt(starknet.hash.getSelectorFromName("Transfer"));
+function toBigInt2(value) {
+  if (value === void 0) return void 0;
+  try {
+    return BigInt(value);
+  } catch {
+    return void 0;
+  }
+}
+function decodeTransfer(event) {
+  if (toBigInt2(event.keys[0]) !== TRANSFER_SELECTOR) return void 0;
+  const [from, to, low, high] = event.keys.length >= 3 ? [event.keys[1], event.keys[2], event.data[0], event.data[1]] : [event.data[0], event.data[1], event.data[2], event.data[3]];
+  const values = [from, to, low, high].map(toBigInt2);
+  if (values.some((v) => v === void 0)) return void 0;
+  const [f, t, l, h] = values;
+  return { from: f, to: t, amount: l + (h << 128n) };
+}
+var SessionTxVerifier = class {
+  constructor(config = {}) {
+    const { txHashStore, getReceipt, ...receiptOptions } = config;
+    this.store = txHashStore ?? new InMemoryTxHashStore();
+    this.getReceipt = getReceipt ?? waitForTransaction;
+    this.receiptOptions = receiptOptions;
+  }
+  async verifyTransfer(params) {
+    const { transactionHash, token, from, to, minAmount } = params;
+    const receipt = await this.getReceipt(transactionHash, this.receiptOptions);
+    if (!receipt.success) {
+      return { valid: false, transactionHash, reason: "REVERTED", detail: receipt.revertReason };
+    }
+    const tokenAddress = BigInt(token);
+    const fromAddress = BigInt(from);
+    const toAddress = BigInt(to);
+    let best;
+    for (const event of receipt.events) {
+      if (toBigInt2(event.from_address) !== tokenAddress) continue;
+      const transfer = decodeTransfer(event);
+      if (!transfer || transfer.from !== fromAddress || transfer.to !== toAddress) continue;
+      if (best === void 0 || transfer.amount > best) best = transfer.amount;
+    }
+    if (best === void 0) {
+      return { valid: false, transactionHash, reason: "TRANSFER_NOT_FOUND" };
+    }
+    if (best < minAmount) {
+      return {
+        valid: false,
+        transactionHash,
+        reason: "AMOUNT_TOO_LOW",
+        detail: `paid ${best}, expected at least ${minAmount}`
+      };
+    }
+    const key = "0x" + BigInt(transactionHash).toString(16);
+    if (!await this.store.consume(key)) {
+      return { valid: false, transactionHash, reason: "ALREADY_USED" };
+    }
+    return {
+      valid: true,
+      transactionHash,
+      amount: best,
+      ...receipt.blockNumber !== void 0 ? { blockNumber: receipt.blockNumber } : {}
+    };
+  }
+};
+
+// src/ai.ts
 var AI_BASE = "/ai";
 var THINK_ACTIONS = /* @__PURE__ */ new Set(["swap", "supply", "withdraw", "hold"]);
+var PAID_MAX_ATTEMPTS = 3;
+var PAID_RETRY_DELAY_MS = 5e3;
+var padFelt = (value) => "0x" + BigInt(value).toString(16).padStart(64, "0");
+function sameFelt(a, b) {
+  try {
+    return BigInt(a) === BigInt(b);
+  } catch {
+    return false;
+  }
+}
+function sessionTransferOffer(err) {
+  if (!(err instanceof shared.ChipiApiError) || err.status !== 402) return void 0;
+  const details = err.details;
+  return details?.x402?.accepts?.find(
+    (r) => r.scheme === "exact" && r.network === "starknet-mainnet" && r.extra?.paymentMethod === "session-transfer" && sameFelt(r.asset, shared.CONTRACT_ADDRESSES.USDC_MAINNET)
+  );
+}
+function thinkInputBytes(params) {
+  const bytes = (text) => new TextEncoder().encode(text).length;
+  const chain = params.chain ?? "starknet";
+  return bytes(JSON.stringify(params.portfolio, null, 2)) + (params.history?.recentDecisions ? bytes(String(params.history.recentDecisions)) : 0) + 2 * bytes(chain);
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 function isThinkDecision(decision) {
   if (!decision || typeof decision !== "object") return false;
   const d = decision;
@@ -3128,9 +3275,10 @@ function isThinkDecision(decision) {
   return true;
 }
 var ChipiAi = class {
-  constructor(client, apiSecretKey) {
+  constructor(client, apiSecretKey, sessions) {
     this.client = client;
     this.apiSecretKey = apiSecretKey;
+    this.sessions = sessions;
   }
   secret() {
     const key = this.apiSecretKey;
@@ -3161,13 +3309,200 @@ var ChipiAi = class {
    *
    * The decision is advice, not an order: check it with `isThinkDecision` and
    * enforce your own limits before executing anything.
+   *
+   * **Paying per call (x402).** With `payWithSession`, a 402 that carries a
+   * session-transfer offer (credits short, x402 on) is paid with the agent's
+   * session key: a USDC `transfer` to the offer's `payTo`, then the same call
+   * again with `X-PAYMENT`. The price must be at most `maxAmount`, `model`
+   * must be payable and the input within `maxPromptBytes`, all checked before
+   * paying. The wallet must be a wallet of the organization that owns the
+   * `sk_`: the first request names it in `X-PAYER`, and when the API answers
+   * that a payment from it would be refused, nothing is paid
+   * (`X402_PAYER_NOT_IN_ORG`). The session must whitelist `transfer` and cap
+   * USDC. A payment that was made but not served is reported in
+   * `error.details.xPayment`; pass it back as `options.xPayment` to retry
+   * without paying again.
+   *
+   * @example
+   * ```typescript
+   * const res = await sdk.ai.think(
+   *   { portfolio, model: "haiku" },
+   *   { payWithSession: { encryptKey, wallet, session, maxAmount: 20_000n } } // $0.02 at most
+   * );
+   * res.x402Payment; // set when the call was paid over x402
+   * ```
    */
-  async think(params) {
+  async think(params, options = {}) {
+    let payer;
+    if (options.payWithSession && !options.xPayment) {
+      try {
+        payer = padFelt(options.payWithSession.wallet.publicKey);
+      } catch {
+        payer = void 0;
+      }
+    }
+    try {
+      return await this.postThink(params, options.xPayment, payer);
+    } catch (err) {
+      const offer = options.payWithSession ? sessionTransferOffer(err) : void 0;
+      if (!offer || !options.payWithSession) throw err;
+      return this.payAndThink(params, offer, options.payWithSession);
+    }
+  }
+  postThink(params, xPayment, payer) {
+    const headers = {
+      ...xPayment ? { "X-PAYMENT": xPayment } : {},
+      ...payer ? { "X-PAYER": payer } : {}
+    };
     return this.client.post({
       endpoint: `${AI_BASE}/think`,
       bearerToken: this.secret(),
-      body: params
+      body: params,
+      ...Object.keys(headers).length > 0 ? { headers } : {}
+    });
+  }
+  /**
+   * Pay one think call with a session-key USDC transfer, then send it again
+   * with `X-PAYMENT`. Every check that can refuse the call runs before the
+   * transfer; the transfer counts only once its receipt shows the USDC moved.
+   */
+  async payAndThink(params, offer, pay) {
+    if (!this.sessions) {
+      throw new shared.ChipiApiError(
+        "payWithSession needs the SDK's session client",
+        "X402_NOT_CONFIGURED",
+        402
+      );
+    }
+    let maxAmount;
+    try {
+      maxAmount = BigInt(pay.maxAmount);
+    } catch {
+      throw new shared.ChipiApiError(
+        `maxAmount must be an integer of USDC base units (6 decimals), got ${String(pay.maxAmount)}; nothing was paid`,
+        "X402_INVALID_MAX_AMOUNT",
+        400
+      );
+    }
+    const amount = BigInt(offer.maxAmountRequired);
+    if (amount > maxAmount) {
+      throw new shared.ChipiApiError(
+        `The x402 price (${amount} USDC base units) is above maxAmount (${pay.maxAmount}); nothing was paid`,
+        "X402_PRICE_ABOVE_MAX",
+        402,
+        { x402: { accepts: [offer] } }
+      );
+    }
+    const payable = offer.extra?.payableModels;
+    if (params.model && Array.isArray(payable) && !payable.includes(params.model)) {
+      throw new shared.ChipiApiError(
+        `Model ${params.model} cannot be paid with x402 (payable: ${payable.join(", ")}); nothing was paid`,
+        "X402_MODEL_NOT_PAYABLE",
+        402,
+        { x402: { accepts: [offer] } }
+      );
+    }
+    const maxBytes = offer.extra?.maxPromptBytes;
+    if (typeof maxBytes === "number" && thinkInputBytes(params) > maxBytes) {
+      throw new shared.ChipiApiError(
+        `Paid calls accept at most ${maxBytes} bytes of portfolio, history and chain; nothing was paid`,
+        "X402_PAYLOAD_TOO_LARGE",
+        402,
+        { x402: { accepts: [offer] } }
+      );
+    }
+    const payerCheck = offer.extra?.payer;
+    if (payerCheck?.accepted === false && typeof payerCheck.address === "string" && sameFelt(payerCheck.address, pay.wallet.publicKey)) {
+      throw new shared.ChipiApiError(
+        `Wallet ${pay.wallet.publicKey} is not a wallet of the organization that owns this API key, so the API would refuse its payment; nothing was paid. Pay from a wallet of this organization.`,
+        "X402_PAYER_NOT_IN_ORG",
+        402,
+        { x402: { accepts: [offer] } }
+      );
+    }
+    const payer = pay.wallet.publicKey;
+    const mask = (1n << 128n) - 1n;
+    const transactionHash = await this.sessions.executeTransactionWithSession(
+      {
+        encryptKey: pay.encryptKey,
+        wallet: pay.wallet,
+        session: pay.session,
+        calls: [
+          {
+            contractAddress: offer.asset,
+            entrypoint: "transfer",
+            calldata: [offer.payTo, (amount & mask).toString(), (amount >> 128n).toString()]
+          }
+        ]
+      },
+      this.secret()
+    );
+    const header = {
+      x402Version: 1,
+      scheme: "exact",
+      network: "starknet-mainnet",
+      payload: {
+        signature: { r: padFelt(transactionHash), s: "session" },
+        fromAddress: padFelt(payer),
+        toAddress: padFelt(offer.payTo),
+        amount: amount.toString(),
+        asset: offer.asset,
+        validUntil: Math.floor(Date.now() / 1e3) + offer.maxTimeoutSeconds,
+        nonce: padFelt(transactionHash)
+      }
+    };
+    const xPayment = JSON.stringify(header);
+    const paidError = (message, code, extra = {}) => new shared.ChipiApiError(message, code, 402, {
+      x402: { accepts: [offer] },
+      x402PaymentHash: transactionHash,
+      ...extra
+    });
+    let receipt;
+    try {
+      receipt = await waitForTransaction(transactionHash, { timeoutMs: 12e4 });
+    } catch (err) {
+      throw paidError(
+        `No receipt yet for the x402 payment ${transactionHash}: ${err instanceof Error ? err.message : String(err)}`,
+        "X402_PAYMENT_PENDING",
+        { xPayment }
+      );
+    }
+    const paid = await new SessionTxVerifier({
+      txHashStore: { consume: () => true },
+      getReceipt: async () => receipt
+    }).verifyTransfer({
+      transactionHash,
+      token: offer.asset,
+      from: payer,
+      to: offer.payTo,
+      minAmount: amount
     });
+    if (!paid.valid) {
+      throw paidError(
+        `The x402 payment did not move ${amount} USDC base units to payTo (${paid.reason}). Check the session's whitelist (transfer) and its USDC cap.`,
+        "X402_PAYMENT_FAILED",
+        { reason: paid.reason }
+      );
+    }
+    for (let attempt = 1; ; attempt++) {
+      try {
+        return await this.postThink(params, xPayment);
+      } catch (err) {
+        const retryable = err instanceof shared.ChipiApiError && (err.status === 409 || err.status === 503 && err.details?.retryable === true);
+        if (retryable && attempt < PAID_MAX_ATTEMPTS) {
+          await sleep(PAID_RETRY_DELAY_MS);
+          continue;
+        }
+        if (err instanceof shared.ChipiApiError) {
+          throw new shared.ChipiApiError(err.message, err.code, err.status ?? 402, {
+            ...typeof err.details === "object" && err.details !== null ? err.details : {},
+            x402PaymentHash: transactionHash,
+            xPayment
+          });
+        }
+        throw err;
+      }
+    }
   }
   /**
    * `POST /v1/ai/execute`: unsigned AVNU swap calls (approve + swap) for
@@ -3529,7 +3864,7 @@ var ChipiSDK = class {
     this.sessions = new ChipiSessions(this.client);
     this.exchanges = new ChipiExchanges(this.client);
     this.treasury = new ChipiTreasury(this.client, config.apiSecretKey);
-    this.ai = new ChipiAi(this.client, config.apiSecretKey);
+    this.ai = new ChipiAi(this.client, config.apiSecretKey, this.sessions);
     this.executeTransaction = this.executeTransaction.bind(this);
     this.executeTransactionWithSession = this.executeTransactionWithSession.bind(this);
     this.transfer = this.transfer.bind(this);
@@ -3842,49 +4177,6 @@ var ChipiBrowserSDK = class extends ChipiSDK {
   // All methods are inherited from ChipiSDK
   // bearerToken parameter is required for each authenticated request
 };
-var DEFAULT_RETRY_INTERVAL_MS = 3e3;
-var DEFAULT_TIMEOUT_MS = 3e5;
-function isPending(finalityStatus) {
-  return finalityStatus === void 0 || finalityStatus === "RECEIVED" || finalityStatus === "PENDING" || finalityStatus === "PRE_CONFIRMED";
-}
-async function waitForTransaction(transactionHash, options = {}) {
-  const {
-    nodeUrl = shared.WALLET_RPC_ENDPOINTS.CHIPI,
-    retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS,
-    timeoutMs = DEFAULT_TIMEOUT_MS
-  } = options;
-  const deadline = Date.now() + timeoutMs;
-  let lastError;
-  for (; ; ) {
-    try {
-      const receipt = await shared.withRpcFallback(
-        (provider) => provider.getTransactionReceipt(transactionHash),
-        { fallbackUrl: nodeUrl }
-      );
-      if (!isPending(receipt?.finality_status)) {
-        const reverted = receipt.execution_status === "REVERTED";
-        return {
-          transactionHash,
-          success: !reverted,
-          executionStatus: receipt.execution_status,
-          finalityStatus: receipt.finality_status,
-          ...reverted ? { revertReason: receipt.revert_reason ?? "reverted on chain" } : {},
-          events: receipt.events ?? [],
-          ...receipt.block_number !== void 0 ? { blockNumber: receipt.block_number } : {}
-        };
-      }
-    } catch (err) {
-      lastError = err;
-    }
-    if (Date.now() + retryIntervalMs >= deadline) {
-      const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
-      throw new Error(
-        `Timed out after ${timeoutMs}ms waiting for ${transactionHash}${detail}. The transaction may still land; re-check before treating it as failed.`
-      );
-    }
-    await new Promise((resolve) => setTimeout(resolve, retryIntervalMs));
-  }
-}
 
 // src/index.ts
 init_encryption2();
@@ -4209,79 +4501,6 @@ function x402Middleware(config) {
     next();
   };
 }
-var InMemoryTxHashStore = class {
-  constructor() {
-    this.used = /* @__PURE__ */ new Set();
-  }
-  consume(transactionHash) {
-    if (this.used.has(transactionHash)) return false;
-    this.used.add(transactionHash);
-    return true;
-  }
-};
-var TRANSFER_SELECTOR = BigInt(starknet.hash.getSelectorFromName("Transfer"));
-function toBigInt2(value) {
-  if (value === void 0) return void 0;
-  try {
-    return BigInt(value);
-  } catch {
-    return void 0;
-  }
-}
-function decodeTransfer(event) {
-  if (toBigInt2(event.keys[0]) !== TRANSFER_SELECTOR) return void 0;
-  const [from, to, low, high] = event.keys.length >= 3 ? [event.keys[1], event.keys[2], event.data[0], event.data[1]] : [event.data[0], event.data[1], event.data[2], event.data[3]];
-  const values = [from, to, low, high].map(toBigInt2);
-  if (values.some((v) => v === void 0)) return void 0;
-  const [f, t, l, h] = values;
-  return { from: f, to: t, amount: l + (h << 128n) };
-}
-var SessionTxVerifier = class {
-  constructor(config = {}) {
-    const { txHashStore, getReceipt, ...receiptOptions } = config;
-    this.store = txHashStore ?? new InMemoryTxHashStore();
-    this.getReceipt = getReceipt ?? waitForTransaction;
-    this.receiptOptions = receiptOptions;
-  }
-  async verifyTransfer(params) {
-    const { transactionHash, token, from, to, minAmount } = params;
-    const receipt = await this.getReceipt(transactionHash, this.receiptOptions);
-    if (!receipt.success) {
-      return { valid: false, transactionHash, reason: "REVERTED", detail: receipt.revertReason };
-    }
-    const tokenAddress = BigInt(token);
-    const fromAddress = BigInt(from);
-    const toAddress = BigInt(to);
-    let best;
-    for (const event of receipt.events) {
-      if (toBigInt2(event.from_address) !== tokenAddress) continue;
-      const transfer = decodeTransfer(event);
-      if (!transfer || transfer.from !== fromAddress || transfer.to !== toAddress) continue;
-      if (best === void 0 || transfer.amount > best) best = transfer.amount;
-    }
-    if (best === void 0) {
-      return { valid: false, transactionHash, reason: "TRANSFER_NOT_FOUND" };
-    }
-    if (best < minAmount) {
-      return {
-        valid: false,
-        transactionHash,
-        reason: "AMOUNT_TOO_LOW",
-        detail: `paid ${best}, expected at least ${minAmount}`
-      };
-    }
-    const key = "0x" + BigInt(transactionHash).toString(16);
-    if (!await this.store.consume(key)) {
-      return { valid: false, transactionHash, reason: "ALREADY_USED" };
-    }
-    return {
-      valid: true,
-      transactionHash,
-      amount: best,
-      ...receipt.blockNumber !== void 0 ? { blockNumber: receipt.blockNumber } : {}
-    };
-  }
-};
 
 // src/shhh/index.ts
 init_snip12_hash();