@chipi-stack/backend 14.13.1 → 14.15.0

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;
@@ -1952,14 +1958,14 @@ var ChipiTransactions = class {
   /**
    * Get on-chain transaction status
    */
-  async getTransactionStatus(hash10, bearerToken) {
+  async getTransactionStatus(hash11, bearerToken) {
     return this.client.get({
-      endpoint: `${shared.API_ENDPOINTS.TRANSACTIONS}/${hash10}/status`,
+      endpoint: `${shared.API_ENDPOINTS.TRANSACTIONS}/${hash11}/status`,
       bearerToken
     });
   }
   /**
-   * Sync on-chain transfers from Voyager into the DB (read-through cache).
+   * Sync on-chain transfers (Starknet Transfer events) into the DB (read-through cache).
    * Discovers transactions not made through the SDK (e.g., external USDC receives).
    * After sync, getTransactionList returns the newly discovered transactions.
    */
@@ -2158,6 +2164,108 @@ function decodeSessionData(result, nowSeconds) {
   const isActive = validUntil !== 0 && nowSeconds <= validUntil && remainingCalls > 0;
   return { isActive, validUntil, remainingCalls, allowedEntrypoints: [] };
 }
+var U128_MASK = (1n << 128n) - 1n;
+var U256_MAX = (1n << 256n) - 1n;
+var U64_MAX = (1n << 64n) - 1n;
+function splitU256(value) {
+  return [starknet.num.toHex(value & U128_MASK), starknet.num.toHex(value >> 128n)];
+}
+function buildAddSessionKeyCall(walletAddress, sessionConfig) {
+  const allowedEntrypoints = normalizeEntrypoints(sessionConfig.allowedEntrypoints);
+  return {
+    contractAddress: walletAddress,
+    entrypoint: shared.SESSION_ENTRYPOINTS.ADD_OR_UPDATE,
+    calldata: [
+      sessionConfig.sessionPublicKey,
+      starknet.num.toHex(sessionConfig.validUntil),
+      starknet.num.toHex(sessionConfig.maxCalls),
+      starknet.num.toHex(allowedEntrypoints.length),
+      ...allowedEntrypoints
+    ]
+  };
+}
+function buildRevokeSessionKeyCall(walletAddress, sessionPublicKey) {
+  return {
+    contractAddress: walletAddress,
+    entrypoint: shared.SESSION_ENTRYPOINTS.REVOKE,
+    calldata: [sessionPublicKey]
+  };
+}
+function validateSpendingPolicyConfig(config) {
+  const { token, maxPerCall, maxPerWindow, windowSeconds } = config;
+  if (!token || token.trim().length === 0) {
+    throw new shared.ChipiSessionError(
+      `Invalid token address for spending policy: "${token}"`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (typeof windowSeconds !== "number" || !Number.isFinite(windowSeconds) || !Number.isInteger(windowSeconds) || windowSeconds <= 0 || BigInt(windowSeconds) > U64_MAX) {
+    throw new shared.ChipiSessionError(
+      `Invalid window duration: ${windowSeconds}. Must be a positive integer within u64 range.`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerCall < 0n || maxPerCall > U256_MAX) {
+    throw new shared.ChipiSessionError(
+      `Invalid maxPerCall: must be >= 0 and <= 2^256 - 1`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerWindow < 0n || maxPerWindow > U256_MAX) {
+    throw new shared.ChipiSessionError(
+      `Invalid maxPerWindow: must be >= 0 and <= 2^256 - 1`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerWindow > 0n && maxPerCall > maxPerWindow) {
+    throw new shared.ChipiSessionError(
+      `Invalid spending policy: maxPerCall (${maxPerCall}) cannot exceed maxPerWindow (${maxPerWindow})`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+}
+function buildSetSpendingPolicyCall(walletAddress, config) {
+  validateSpendingPolicyConfig(config);
+  const [maxPerCallLow, maxPerCallHigh] = splitU256(config.maxPerCall);
+  const [maxPerWindowLow, maxPerWindowHigh] = splitU256(config.maxPerWindow);
+  return {
+    contractAddress: walletAddress,
+    entrypoint: shared.SESSION_ENTRYPOINTS.SET_SPENDING_POLICY,
+    calldata: [
+      config.sessionPublicKey,
+      config.token,
+      maxPerCallLow,
+      maxPerCallHigh,
+      maxPerWindowLow,
+      maxPerWindowHigh,
+      starknet.num.toHex(config.windowSeconds)
+    ]
+  };
+}
+function buildRemoveSpendingPolicyCall(walletAddress, sessionPublicKey, token) {
+  if (!token || token.trim().length === 0) {
+    throw new shared.ChipiSessionError(
+      `Invalid token address for spending policy removal: "${token}"`,
+      shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  return {
+    contractAddress: walletAddress,
+    entrypoint: shared.SESSION_ENTRYPOINTS.REMOVE_SPENDING_POLICY,
+    calldata: [sessionPublicKey, token]
+  };
+}
+function buildSessionSetupCalls(walletAddress, sessionConfig, spendingPolicies = []) {
+  return [
+    buildAddSessionKeyCall(walletAddress, sessionConfig),
+    ...spendingPolicies.map(
+      (policy) => buildSetSpendingPolicyCall(walletAddress, {
+        ...policy,
+        sessionPublicKey: sessionConfig.sessionPublicKey
+      })
+    )
+  ];
+}
 
 // src/sessions.ts
 var ChipiSessions = class {
@@ -2299,26 +2407,12 @@ var ChipiSessions = class {
         maxCalls: sessionConfig.maxCalls,
         allowedEntrypoints: sessionConfig.allowedEntrypoints.length
       });
-      const allowedEntrypoints = normalizeEntrypoints(sessionConfig.allowedEntrypoints);
-      const calldata = [
-        sessionConfig.sessionPublicKey,
-        starknet.num.toHex(sessionConfig.validUntil),
-        starknet.num.toHex(sessionConfig.maxCalls),
-        // Array: first element is length, then elements
-        starknet.num.toHex(allowedEntrypoints.length),
-        ...allowedEntrypoints
-      ];
+      const addCall = buildAddSessionKeyCall(wallet.publicKey, sessionConfig);
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: shared.SESSION_ENTRYPOINTS.ADD_OR_UPDATE,
-              calldata
-            }
-          ],
+          calls: [addCall],
           saveToDatabase: false
           // Don't record session management txs
         },
@@ -2342,6 +2436,54 @@ var ChipiSessions = class {
       throw error;
     }
   }
+  /**
+   * Register a session and its spending policies in ONE owner-signed transaction.
+   *
+   * Equivalent to `addSessionKeyToContract` followed by one `setSpendingPolicy`
+   * per token, but the owner signs once (one passkey prompt) and the session
+   * never exists on-chain without its caps.
+   *
+   * @example
+   * ```typescript
+   * const txHash = await sdk.sessions.setupSession({
+   *   encryptKey,
+   *   wallet,
+   *   sessionConfig: {
+   *     sessionPublicKey: session.publicKey,
+   *     validUntil: session.validUntil,
+   *     maxCalls: 500,
+   *     allowedEntrypoints: ["transfer", "approve"],
+   *   },
+   *   spendingPolicies: [
+   *     { token: USDC, maxPerCall: 5_000_000n, maxPerWindow: 20_000_000n, windowSeconds: 86400 },
+   *   ],
+   * }, bearerToken);
+   * ```
+   */
+  async setupSession(params, bearerToken) {
+    const { encryptKey, wallet, sessionConfig, spendingPolicies = [] } = params;
+    this.validateWalletSupportsSessions(wallet.walletType, "Setup", wallet.publicKey);
+    const calls = buildSessionSetupCalls(wallet.publicKey, sessionConfig, spendingPolicies);
+    console.log("[ChipiSDK:Session:Setup] Registering session with spending policies", {
+      walletAddress: wallet.publicKey.slice(0, 15) + "...",
+      sessionPubKey: sessionConfig.sessionPublicKey.slice(0, 15) + "...",
+      validUntil: new Date(sessionConfig.validUntil * 1e3).toISOString(),
+      maxCalls: sessionConfig.maxCalls,
+      allowedEntrypoints: sessionConfig.allowedEntrypoints.length,
+      spendingPolicies: spendingPolicies.length
+    });
+    return executePaymasterTransaction({
+      params: {
+        encryptKey,
+        wallet,
+        calls,
+        saveToDatabase: false
+        // Don't record session management txs
+      },
+      bearerToken,
+      client: this.client
+    });
+  }
   /**
    * Revoke a session key from the smart contract.
    *
@@ -2375,13 +2517,7 @@ var ChipiSessions = class {
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: shared.SESSION_ENTRYPOINTS.REVOKE,
-              calldata: [sessionPublicKey]
-            }
-          ],
+          calls: [buildRevokeSessionKeyCall(wallet.publicKey, sessionPublicKey)],
           saveToDatabase: false
           // Don't record session management txs
         },
@@ -2571,13 +2707,6 @@ var ChipiSessions = class {
   // Wraps ISessionSpendingPolicy contract interface.
   // Spending policies enforce per-token limits on ERC-20 operations
   // (transfer, approve, increase_allowance) executed by session keys.
-  /**
-   * Split a bigint into Cairo u256 representation (low u128, high u128).
-   */
-  splitU256(value) {
-    const mask = (1n << 128n) - 1n;
-    return [starknet.num.toHex(value & mask), starknet.num.toHex(value >> 128n)];
-  }
   /**
    * Reconstruct a bigint from Cairo u256 (low, high) hex strings.
    */
@@ -2622,38 +2751,7 @@ var ChipiSessions = class {
         shared.SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
       );
     }
-    const U256_MAX = (1n << 256n) - 1n;
-    const U64_MAX = (1n << 64n) - 1n;
-    if (!token || token.trim().length === 0) {
-      throw new shared.ChipiSessionError(
-        `Invalid token address for spending policy: "${token}"`,
-        shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (typeof windowSeconds !== "number" || !Number.isFinite(windowSeconds) || !Number.isInteger(windowSeconds) || windowSeconds <= 0 || BigInt(windowSeconds) > U64_MAX) {
-      throw new shared.ChipiSessionError(
-        `Invalid window duration: ${windowSeconds}. Must be a positive integer within u64 range.`,
-        shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerCall < 0n || maxPerCall > U256_MAX) {
-      throw new shared.ChipiSessionError(
-        `Invalid maxPerCall: must be >= 0 and <= 2^256 - 1`,
-        shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerWindow < 0n || maxPerWindow > U256_MAX) {
-      throw new shared.ChipiSessionError(
-        `Invalid maxPerWindow: must be >= 0 and <= 2^256 - 1`,
-        shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerWindow > 0n && maxPerCall > maxPerWindow) {
-      throw new shared.ChipiSessionError(
-        `Invalid spending policy: maxPerCall (${maxPerCall}) cannot exceed maxPerWindow (${maxPerWindow})`,
-        shared.SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
+    validateSpendingPolicyConfig(spendingPolicyConfig);
     try {
       console.log("[ChipiSDK:Session:SetSpendingPolicy] Setting spending policy", {
         walletAddress: wallet.publicKey.slice(0, 15) + "...",
@@ -2663,28 +2761,12 @@ var ChipiSessions = class {
         maxPerWindow: maxPerWindow.toString(),
         windowSeconds
       });
-      const [maxPerCallLow, maxPerCallHigh] = this.splitU256(maxPerCall);
-      const [maxPerWindowLow, maxPerWindowHigh] = this.splitU256(maxPerWindow);
-      const calldata = [
-        sessionPublicKey,
-        token,
-        maxPerCallLow,
-        maxPerCallHigh,
-        maxPerWindowLow,
-        maxPerWindowHigh,
-        starknet.num.toHex(windowSeconds)
-      ];
+      const setPolicyCall = buildSetSpendingPolicyCall(wallet.publicKey, spendingPolicyConfig);
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: shared.SESSION_ENTRYPOINTS.SET_SPENDING_POLICY,
-              calldata
-            }
-          ],
+          calls: [setPolicyCall],
           saveToDatabase: false
         },
         bearerToken,
@@ -2851,18 +2933,12 @@ var ChipiSessions = class {
         sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
         token: token.slice(0, 15) + "..."
       });
-      const calldata = [sessionPublicKey, token];
+      const removeCall = buildRemoveSpendingPolicyCall(wallet.publicKey, sessionPublicKey, token);
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: shared.SESSION_ENTRYPOINTS.REMOVE_SPENDING_POLICY,
-              calldata
-            }
-          ],
+          calls: [removeCall],
           saveToDatabase: false
         },
         bearerToken,
@@ -3043,6 +3119,409 @@ 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;
+  if (typeof d.action !== "string" || !THINK_ACTIONS.has(d.action)) return false;
+  if (typeof d.reason !== "string") return false;
+  if (d.amount !== void 0 && (typeof d.amount !== "number" || !Number.isFinite(d.amount)))
+    return false;
+  if (d.confidence !== void 0 && typeof d.confidence !== "number") return false;
+  if (d.from !== void 0 && typeof d.from !== "string") return false;
+  if (d.to !== void 0 && typeof d.to !== "string") return false;
+  return true;
+}
+var ChipiAi = class {
+  constructor(client, apiSecretKey, sessions) {
+    this.client = client;
+    this.apiSecretKey = apiSecretKey;
+    this.sessions = sessions;
+  }
+  secret() {
+    const key = this.apiSecretKey;
+    if (!key || !key.startsWith("sk_")) {
+      throw new shared.ChipiAuthError(
+        "sdk.ai needs a secret key (sk_): configure the SDK with apiSecretKey and call it from a server, never the browser."
+      );
+    }
+    return key;
+  }
+  /**
+   * `GET /v1/ai/signals`: technical signals per token, market sentiment and
+   * DeFi yields. Free up to a monthly quota per organization, then billed per call.
+   */
+  async signals(params = {}) {
+    const query = {};
+    if (params.tokens?.length) query.tokens = params.tokens.join(",");
+    if (params.chain) query.chain = params.chain;
+    return this.client.get({
+      endpoint: `${AI_BASE}/signals`,
+      params: query,
+      bearerToken: this.secret()
+    });
+  }
+  /**
+   * `POST /v1/ai/think`: one DeFi decision for a portfolio, with the latest
+   * signals and your risk parameters injected into the prompt.
+   *
+   * 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 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, options = {}) {
+    try {
+      return await this.postThink(params, options.xPayment);
+    } 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) {
+    return this.client.post({
+      endpoint: `${AI_BASE}/think`,
+      bearerToken: this.secret(),
+      body: params,
+      ...xPayment ? { headers: { "X-PAYMENT": xPayment } } : {}
+    });
+  }
+  /**
+   * 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 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
+   * `walletAddress`. Nothing is submitted; sign the calls with a session key
+   * or the owner's key.
+   */
+  async execute(params) {
+    return this.client.post({
+      endpoint: `${AI_BASE}/execute`,
+      bearerToken: this.secret(),
+      body: params
+    });
+  }
+  /** `POST /v1/ai/chat`: general-purpose chat, billed per token. */
+  async chat(params) {
+    return this.client.post({
+      endpoint: `${AI_BASE}/chat`,
+      bearerToken: this.secret(),
+      body: params
+    });
+  }
+  /**
+   * `GET /v1/ai/prices`: USD prices and 1h / 24h / 7d changes, refreshed about
+   * every 30 seconds. No credits are charged, but like every `sdk.ai` method it
+   * needs the SDK's secret key (`sk_`).
+   */
+  async prices(params = {}) {
+    const query = {};
+    if (params.tokens?.length) query.tokens = params.tokens.join(",");
+    if (params.chain) query.chain = params.chain;
+    return this.client.get({
+      endpoint: `${AI_BASE}/prices`,
+      params: query,
+      bearerToken: this.secret()
+    });
+  }
+  /** `GET /v1/ai/models`: available models, prices and limits. */
+  async models() {
+    return this.client.get({
+      endpoint: `${AI_BASE}/models`,
+      bearerToken: this.secret()
+    });
+  }
+};
 var InMemoryNonceStore = class {
   constructor() {
     this.used = /* @__PURE__ */ new Set();
@@ -3360,6 +3839,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.sessions);
     this.executeTransaction = this.executeTransaction.bind(this);
     this.executeTransactionWithSession = this.executeTransactionWithSession.bind(this);
     this.transfer = this.transfer.bind(this);
@@ -3623,8 +4103,8 @@ var ChipiSDK = class {
   /**
    * Get on-chain transaction status (supports polling for confirmation)
    */
-  async getTransactionStatus(hash10, bearerToken) {
-    return this.transactions.getTransactionStatus(hash10, this.resolveBearerToken(bearerToken));
+  async getTransactionStatus(hash11, bearerToken) {
+    return this.transactions.getTransactionStatus(hash11, this.resolveBearerToken(bearerToken));
   }
   /**
    * Prepare a wallet upgrade (e.g., READY → CHIPI or CHIPI v29 → v33).
@@ -3672,49 +4152,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();
@@ -4444,7 +4881,7 @@ var JWT_APPLE_SUB_KIND_TAG = "JWT_ES256_APPLE_SUB";
 var JWT_APPLE_SUB_KIND_TAG_FELT = BigInt(starknet.shortString.encodeShortString(JWT_APPLE_SUB_KIND_TAG));
 var APPLE_ISSUER = "https://appleid.apple.com";
 var NONCE_B64URL_LEN = 43;
-var U128_MASK = (1n << 128n) - 1n;
+var U128_MASK2 = (1n << 128n) - 1n;
 function assertBytes3(name, b, len) {
   if (b.length !== len) {
     throw new Error(`${name} must be exactly ${len} bytes; got ${b.length}.`);
@@ -4454,7 +4891,7 @@ function bytesBeToU2563(b) {
   assertBytes3("secp256r1 32B value", b, 32);
   let x = 0n;
   for (let i = 0; i < b.length; i++) x = x << 8n | BigInt(b[i]);
-  return { low: x & U128_MASK, high: x >> 128n };
+  return { low: x & U128_MASK2, high: x >> 128n };
 }
 function jwtAppleSubHash(sub) {
   const bytes = new TextEncoder().encode(sub);
@@ -4589,9 +5026,9 @@ function buildEnvelopePayload(fields) {
     BigInt(fields.issOffset),
     BigInt(fields.subOffset),
     BigInt(fields.subLen),
-    fields.r & U128_MASK,
+    fields.r & U128_MASK2,
     fields.r >> 128n,
-    fields.s & U128_MASK,
+    fields.s & U128_MASK2,
     fields.s >> 128n,
     BigInt(fields.yParity)
   ];
@@ -4951,6 +5388,7 @@ Object.defineProperty(exports, "Currency", {
 });
 exports.APPLE_ISSUER = APPLE_ISSUER;
 exports.BOOTSTRAP_DOMAIN_SEPARATOR = BOOTSTRAP_DOMAIN_SEPARATOR;
+exports.ChipiAi = ChipiAi;
 exports.ChipiBrowserSDK = ChipiBrowserSDK;
 exports.ChipiClient = ChipiClient;
 exports.ChipiPaymasterAdapter = ChipiPaymasterAdapter;
@@ -4969,12 +5407,14 @@ exports.OP_ROTATE_OWNER = OP_ROTATE_OWNER;
 exports.OP_SET_THRESHOLD = OP_SET_THRESHOLD;
 exports.ROLE_GUARDIAN = ROLE_GUARDIAN;
 exports.ROLE_OWNER = ROLE_OWNER;
+exports.SessionTxVerifier = SessionTxVerifier;
 exports.ShhhAccount = ShhhAccount;
 exports.TIMELOCK_SECONDS = TIMELOCK_SECONDS;
 exports.VIEW_SELECTORS = VIEW_SELECTORS;
 exports.X402Facilitator = X402Facilitator;
 exports.X402ShhhClient = X402ShhhClient;
 exports.assertValidV2Snip12Envelope = assertValidV2Snip12Envelope;
+exports.buildAddSessionKeyCall = buildAddSessionKeyCall;
 exports.buildBootstrapSignedCall = buildBootstrapSignedCall;
 exports.buildCancelPendingOpCall = buildCancelPendingOpCall;
 exports.buildCancelRecoveryCall = buildCancelRecoveryCall;
@@ -4996,6 +5436,10 @@ exports.buildProposeAddOwnerCall = buildProposeAddOwnerCall;
 exports.buildProposeRemoveOwnerCall = buildProposeRemoveOwnerCall;
 exports.buildProposeRotateOwnerCall = buildProposeRotateOwnerCall;
 exports.buildProposeSetThresholdCall = buildProposeSetThresholdCall;
+exports.buildRemoveSpendingPolicyCall = buildRemoveSpendingPolicyCall;
+exports.buildRevokeSessionKeyCall = buildRevokeSessionKeyCall;
+exports.buildSessionSetupCalls = buildSessionSetupCalls;
+exports.buildSetSpendingPolicyCall = buildSetSpendingPolicyCall;
 exports.buildStarkEnvelope = buildStarkEnvelope;
 exports.buildThresholdEnvelope = buildThresholdEnvelope;
 exports.buildWebAuthnEnvelopeFromAssertion = buildWebAuthnEnvelopeFromAssertion;
@@ -5021,6 +5465,7 @@ exports.hashCalls = hashCalls;
 exports.hashOutsideExecutionStruct = hashOutsideExecutionStruct;
 exports.hashStarknetDomain = hashStarknetDomain;
 exports.isReadyToExecute = isReadyToExecute;
+exports.isThinkDecision = isThinkDecision;
 exports.jwtAppleSubHash = jwtAppleSubHash;
 exports.jwtAppleSubOwnerId = jwtAppleSubOwnerId;
 exports.jwtAppleSubPubkeyFelts = jwtAppleSubPubkeyFelts;
@@ -5028,6 +5473,7 @@ exports.labelToFelt = labelToFelt;
 exports.locateSubClaim = locateSubClaim;
 exports.messageHashToNonceB64url = messageHashToNonceB64url;
 exports.migrateChipiWalletToShhh = migrateChipiWalletToShhh;
+exports.normalizeEntrypoints = normalizeEntrypoints;
 exports.ownerCommitment = ownerCommitment;
 exports.parseAppleIdToken = parseAppleIdToken;
 exports.parseDerEcdsaSignature = parseDerEcdsaSignature;
@@ -5043,6 +5489,7 @@ exports.snip12HashToHexAsciiBytes = snip12HashToHexAsciiBytes;
 exports.starkOwnerId = starkOwnerId;
 exports.starkPubkeyFelts = starkPubkeyFelts;
 exports.submitViaAccount = submitViaAccount;
+exports.validateSpendingPolicyConfig = validateSpendingPolicyConfig;
 exports.waitForTransaction = waitForTransaction;
 exports.webauthnOwnerId = webauthnOwnerId;
 exports.webauthnOwnerPubkeyParam = webauthnOwnerPubkeyParam;