@chipi-stack/backend 14.13.1 → 14.14.0

package/dist/index.js

@@ -1952,14 +1952,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 +2158,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 +2401,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 +2430,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 +2511,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 +2701,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 +2745,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 +2755,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 +2927,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 +3113,105 @@ var ChipiTreasury = class {
     };
   }
 };
+var AI_BASE = "/ai";
+var THINK_ACTIONS = /* @__PURE__ */ new Set(["swap", "supply", "withdraw", "hold"]);
+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) {
+    this.client = client;
+    this.apiSecretKey = apiSecretKey;
+  }
+  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.
+   */
+  async think(params) {
+    return this.client.post({
+      endpoint: `${AI_BASE}/think`,
+      bearerToken: this.secret(),
+      body: params
+    });
+  }
+  /**
+   * `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 +3529,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.executeTransaction = this.executeTransaction.bind(this);
     this.executeTransactionWithSession = this.executeTransactionWithSession.bind(this);
     this.transfer = this.transfer.bind(this);
@@ -3623,8 +3793,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).
@@ -4039,6 +4209,79 @@ 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();
@@ -4444,7 +4687,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 +4697,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 +4832,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 +5194,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 +5213,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 +5242,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 +5271,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 +5279,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 +5295,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;