@chipi-stack/backend 14.13.1 → 14.14.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { shortString, hash, CallData, ec, RpcProvider, Account, num, CairoCustomEnum, CairoOption, CairoOptionVariant, cairo, typedData, uint256 } from 'starknet';
-import { SHHH_KIND_GAS_OVERHEAD, isValidApiKey, ChipiAuthError, STARKNET_NETWORKS, API_VERSIONING, validateErrorResponse, ChipiApiError, handleApiError, getWalletTypeFromClassHash, WALLET_CLASS_HASHES, WALLET_RPC_ENDPOINTS, SHHH_VERIFIER_CLASS_HASHES, API_ENDPOINTS, ChipiTransactionError, formatAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, ChipiSessionError, SESSION_ERRORS, SESSION_DEFAULTS, SESSION_ENTRYPOINTS, withRpcFallback, CONTRACT_ADDRESSES, TOKEN_DECIMALS } from '@chipi-stack/shared';
+import { SHHH_KIND_GAS_OVERHEAD, isValidApiKey, ChipiAuthError, STARKNET_NETWORKS, API_VERSIONING, validateErrorResponse, ChipiApiError, handleApiError, getWalletTypeFromClassHash, WALLET_CLASS_HASHES, WALLET_RPC_ENDPOINTS, SHHH_VERIFIER_CLASS_HASHES, API_ENDPOINTS, ChipiTransactionError, formatAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, ChipiSessionError, SESSION_ERRORS, SESSION_ENTRYPOINTS, SESSION_DEFAULTS, withRpcFallback, CONTRACT_ADDRESSES, TOKEN_DECIMALS } from '@chipi-stack/shared';
 import CryptoES from 'crypto-es';
 import { randomBytes } from 'crypto';
 import { STARKNET_CONTRACTS, Chain } from '@chipi-stack/types';
@@ -1947,14 +1947,14 @@ var ChipiTransactions = class {
   /**
    * Get on-chain transaction status
    */
-  async getTransactionStatus(hash10, bearerToken) {
+  async getTransactionStatus(hash11, bearerToken) {
     return this.client.get({
-      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/${hash10}/status`,
+      endpoint: `${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.
    */
@@ -2153,6 +2153,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 [num.toHex(value & U128_MASK), num.toHex(value >> 128n)];
+}
+function buildAddSessionKeyCall(walletAddress, sessionConfig) {
+  const allowedEntrypoints = normalizeEntrypoints(sessionConfig.allowedEntrypoints);
+  return {
+    contractAddress: walletAddress,
+    entrypoint: SESSION_ENTRYPOINTS.ADD_OR_UPDATE,
+    calldata: [
+      sessionConfig.sessionPublicKey,
+      num.toHex(sessionConfig.validUntil),
+      num.toHex(sessionConfig.maxCalls),
+      num.toHex(allowedEntrypoints.length),
+      ...allowedEntrypoints
+    ]
+  };
+}
+function buildRevokeSessionKeyCall(walletAddress, sessionPublicKey) {
+  return {
+    contractAddress: walletAddress,
+    entrypoint: SESSION_ENTRYPOINTS.REVOKE,
+    calldata: [sessionPublicKey]
+  };
+}
+function validateSpendingPolicyConfig(config) {
+  const { token, maxPerCall, maxPerWindow, windowSeconds } = config;
+  if (!token || token.trim().length === 0) {
+    throw new ChipiSessionError(
+      `Invalid token address for spending policy: "${token}"`,
+      SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (typeof windowSeconds !== "number" || !Number.isFinite(windowSeconds) || !Number.isInteger(windowSeconds) || windowSeconds <= 0 || BigInt(windowSeconds) > U64_MAX) {
+    throw new ChipiSessionError(
+      `Invalid window duration: ${windowSeconds}. Must be a positive integer within u64 range.`,
+      SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerCall < 0n || maxPerCall > U256_MAX) {
+    throw new ChipiSessionError(
+      `Invalid maxPerCall: must be >= 0 and <= 2^256 - 1`,
+      SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerWindow < 0n || maxPerWindow > U256_MAX) {
+    throw new ChipiSessionError(
+      `Invalid maxPerWindow: must be >= 0 and <= 2^256 - 1`,
+      SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  if (maxPerWindow > 0n && maxPerCall > maxPerWindow) {
+    throw new ChipiSessionError(
+      `Invalid spending policy: maxPerCall (${maxPerCall}) cannot exceed maxPerWindow (${maxPerWindow})`,
+      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: SESSION_ENTRYPOINTS.SET_SPENDING_POLICY,
+    calldata: [
+      config.sessionPublicKey,
+      config.token,
+      maxPerCallLow,
+      maxPerCallHigh,
+      maxPerWindowLow,
+      maxPerWindowHigh,
+      num.toHex(config.windowSeconds)
+    ]
+  };
+}
+function buildRemoveSpendingPolicyCall(walletAddress, sessionPublicKey, token) {
+  if (!token || token.trim().length === 0) {
+    throw new ChipiSessionError(
+      `Invalid token address for spending policy removal: "${token}"`,
+      SESSION_ERRORS.INVALID_SPENDING_POLICY
+    );
+  }
+  return {
+    contractAddress: walletAddress,
+    entrypoint: 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 {
@@ -2294,26 +2396,12 @@ var ChipiSessions = class {
         maxCalls: sessionConfig.maxCalls,
         allowedEntrypoints: sessionConfig.allowedEntrypoints.length
       });
-      const allowedEntrypoints = normalizeEntrypoints(sessionConfig.allowedEntrypoints);
-      const calldata = [
-        sessionConfig.sessionPublicKey,
-        num.toHex(sessionConfig.validUntil),
-        num.toHex(sessionConfig.maxCalls),
-        // Array: first element is length, then elements
-        num.toHex(allowedEntrypoints.length),
-        ...allowedEntrypoints
-      ];
+      const addCall = buildAddSessionKeyCall(wallet.publicKey, sessionConfig);
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: SESSION_ENTRYPOINTS.ADD_OR_UPDATE,
-              calldata
-            }
-          ],
+          calls: [addCall],
           saveToDatabase: false
           // Don't record session management txs
         },
@@ -2337,6 +2425,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.
    *
@@ -2370,13 +2506,7 @@ var ChipiSessions = class {
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: SESSION_ENTRYPOINTS.REVOKE,
-              calldata: [sessionPublicKey]
-            }
-          ],
+          calls: [buildRevokeSessionKeyCall(wallet.publicKey, sessionPublicKey)],
           saveToDatabase: false
           // Don't record session management txs
         },
@@ -2566,13 +2696,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 [num.toHex(value & mask), num.toHex(value >> 128n)];
-  }
   /**
    * Reconstruct a bigint from Cairo u256 (low, high) hex strings.
    */
@@ -2617,38 +2740,7 @@ var ChipiSessions = class {
         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 ChipiSessionError(
-        `Invalid token address for spending policy: "${token}"`,
-        SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (typeof windowSeconds !== "number" || !Number.isFinite(windowSeconds) || !Number.isInteger(windowSeconds) || windowSeconds <= 0 || BigInt(windowSeconds) > U64_MAX) {
-      throw new ChipiSessionError(
-        `Invalid window duration: ${windowSeconds}. Must be a positive integer within u64 range.`,
-        SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerCall < 0n || maxPerCall > U256_MAX) {
-      throw new ChipiSessionError(
-        `Invalid maxPerCall: must be >= 0 and <= 2^256 - 1`,
-        SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerWindow < 0n || maxPerWindow > U256_MAX) {
-      throw new ChipiSessionError(
-        `Invalid maxPerWindow: must be >= 0 and <= 2^256 - 1`,
-        SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
-    if (maxPerWindow > 0n && maxPerCall > maxPerWindow) {
-      throw new ChipiSessionError(
-        `Invalid spending policy: maxPerCall (${maxPerCall}) cannot exceed maxPerWindow (${maxPerWindow})`,
-        SESSION_ERRORS.INVALID_SPENDING_POLICY
-      );
-    }
+    validateSpendingPolicyConfig(spendingPolicyConfig);
     try {
       console.log("[ChipiSDK:Session:SetSpendingPolicy] Setting spending policy", {
         walletAddress: wallet.publicKey.slice(0, 15) + "...",
@@ -2658,28 +2750,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,
-        num.toHex(windowSeconds)
-      ];
+      const setPolicyCall = buildSetSpendingPolicyCall(wallet.publicKey, spendingPolicyConfig);
       const txHash = await executePaymasterTransaction({
         params: {
           encryptKey,
           wallet,
-          calls: [
-            {
-              contractAddress: wallet.publicKey,
-              entrypoint: SESSION_ENTRYPOINTS.SET_SPENDING_POLICY,
-              calldata
-            }
-          ],
+          calls: [setPolicyCall],
           saveToDatabase: false
         },
         bearerToken,
@@ -2846,18 +2922,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: SESSION_ENTRYPOINTS.REMOVE_SPENDING_POLICY,
-              calldata
-            }
-          ],
+          calls: [removeCall],
           saveToDatabase: false
         },
         bearerToken,
@@ -3038,6 +3108,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 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();
@@ -3355,6 +3524,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);
@@ -3618,8 +3788,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).
@@ -4034,6 +4204,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(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();
@@ -4439,7 +4682,7 @@ var JWT_APPLE_SUB_KIND_TAG = "JWT_ES256_APPLE_SUB";
 var JWT_APPLE_SUB_KIND_TAG_FELT = BigInt(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}.`);
@@ -4449,7 +4692,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);
@@ -4584,9 +4827,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)
   ];
@@ -4932,6 +5175,6 @@ function submitViaAccount(funded) {
   };
 }
 
-export { ANY_CALLER_FELT, APPLE_ISSUER, BOOTSTRAP_DOMAIN_SEPARATOR, ChipiBrowserSDK, ChipiClient, ChipiPaymasterAdapter, ChipiSDK, ChipiServerSDK, ChipiSessions, ChipiSkuPurchases, ChipiSkus, ChipiTransactions, ChipiTreasury, ChipiWallets, DEFAULT_OP_EXPIRY_SECONDS, ISIGNER_CANONICAL_LABEL, ISIGNER_ID, ISRC9_V2_ID, MAX_OE_VALIDITY_WINDOW_SECONDS, MIN_THRESHOLD_OWNERS, OE_DOMAIN_NAME, OE_DOMAIN_REVISION, OE_DOMAIN_VERSION, OP_ADD_OWNER, OP_REMOVE_OWNER, OP_ROTATE_OWNER, OP_SET_THRESHOLD, ROLE_GUARDIAN, ROLE_OWNER, SIG_VERSION_V1_HEX_ASCII, SIG_VERSION_V2_SNIP12, SIG_VERSION_V2_THRESHOLD, STARKNET_MESSAGE_PREFIX, ShhhAccount, TIMELOCK_SECONDS, VIEW_SELECTORS, X402Facilitator, X402ShhhClient, assertValidV2Snip12Envelope, buildBootstrapSignedCall, buildCancelPendingOpCall, buildCancelRecoveryCall, buildEd25519Envelope, buildEd25519EnvelopeFromSignature, buildEip191EnvelopeFromPrivateKey, buildEip191EnvelopeFromSignature, buildExecuteAddOwnerCall, buildExecuteRemoveOwnerCall, buildExecuteRotateOwnerCall, buildExecuteSetThresholdCall, buildFinalizeRecoveryCall, buildInitiateRecoveryCall, buildJwtAppleSubEnvelopeFromTestKey, buildJwtAppleSubEnvelopeFromTokenResponse, buildMigrationCalls, buildOutsideExecution, buildProposeAddOwnerCall, buildProposeRemoveOwnerCall, buildProposeRotateOwnerCall, buildProposeSetThresholdCall, buildStarkEnvelope, buildThresholdEnvelope, buildWebAuthnEnvelopeFromAssertion, buildWebAuthnEnvelopeFromPrivateKey, byteArrayToFelts, computeAddressSalt, computeBootstrapMessage, computeISignerId, computeOeHash, computeShhhAddress, computeSnip12Hash, decryptPrivateKey, ed25519OwnerId, ed25519OwnerPubkeyParam, ed25519PubkeyFelts, ed25519SignedBytes, eip191OwnerId, eip191OwnerPubkeyParam, eip191PubkeyFelts, encryptPrivateKey, estimateThresholdGasOverhead, executeShhhSponsoredRaw, hashCall, hashCalls, hashOutsideExecutionStruct, hashStarknetDomain, isReadyToExecute, jwtAppleSubHash, jwtAppleSubOwnerId, jwtAppleSubPubkeyFelts, labelToFelt, locateSubClaim, messageHashToNonceB64url, migrateChipiWalletToShhh, ownerCommitment, parseAppleIdToken, parseDerEcdsaSignature, parseEip191Signature, parseThresholdEnvelope, resolveShhhChainId, secondsUntilExecutable, serializeExecuteFromOutsideV2Calldata, signBootstrapMessage, signTypedData, signTypedDataArray, snip12HashToHexAsciiBytes, starkOwnerId, starkPubkeyFelts, submitViaAccount, waitForTransaction, webauthnOwnerId, webauthnOwnerPubkeyParam, webauthnPubkeyFelts, wrapV2Snip12Envelope, wrapV2ThresholdEnvelope, x402Middleware };
+export { ANY_CALLER_FELT, APPLE_ISSUER, BOOTSTRAP_DOMAIN_SEPARATOR, ChipiAi, ChipiBrowserSDK, ChipiClient, ChipiPaymasterAdapter, ChipiSDK, ChipiServerSDK, ChipiSessions, ChipiSkuPurchases, ChipiSkus, ChipiTransactions, ChipiTreasury, ChipiWallets, DEFAULT_OP_EXPIRY_SECONDS, ISIGNER_CANONICAL_LABEL, ISIGNER_ID, ISRC9_V2_ID, MAX_OE_VALIDITY_WINDOW_SECONDS, MIN_THRESHOLD_OWNERS, OE_DOMAIN_NAME, OE_DOMAIN_REVISION, OE_DOMAIN_VERSION, OP_ADD_OWNER, OP_REMOVE_OWNER, OP_ROTATE_OWNER, OP_SET_THRESHOLD, ROLE_GUARDIAN, ROLE_OWNER, SIG_VERSION_V1_HEX_ASCII, SIG_VERSION_V2_SNIP12, SIG_VERSION_V2_THRESHOLD, STARKNET_MESSAGE_PREFIX, SessionTxVerifier, ShhhAccount, TIMELOCK_SECONDS, VIEW_SELECTORS, X402Facilitator, X402ShhhClient, assertValidV2Snip12Envelope, buildAddSessionKeyCall, buildBootstrapSignedCall, buildCancelPendingOpCall, buildCancelRecoveryCall, buildEd25519Envelope, buildEd25519EnvelopeFromSignature, buildEip191EnvelopeFromPrivateKey, buildEip191EnvelopeFromSignature, buildExecuteAddOwnerCall, buildExecuteRemoveOwnerCall, buildExecuteRotateOwnerCall, buildExecuteSetThresholdCall, buildFinalizeRecoveryCall, buildInitiateRecoveryCall, buildJwtAppleSubEnvelopeFromTestKey, buildJwtAppleSubEnvelopeFromTokenResponse, buildMigrationCalls, buildOutsideExecution, buildProposeAddOwnerCall, buildProposeRemoveOwnerCall, buildProposeRotateOwnerCall, buildProposeSetThresholdCall, buildRemoveSpendingPolicyCall, buildRevokeSessionKeyCall, buildSessionSetupCalls, buildSetSpendingPolicyCall, buildStarkEnvelope, buildThresholdEnvelope, buildWebAuthnEnvelopeFromAssertion, buildWebAuthnEnvelopeFromPrivateKey, byteArrayToFelts, computeAddressSalt, computeBootstrapMessage, computeISignerId, computeOeHash, computeShhhAddress, computeSnip12Hash, decryptPrivateKey, ed25519OwnerId, ed25519OwnerPubkeyParam, ed25519PubkeyFelts, ed25519SignedBytes, eip191OwnerId, eip191OwnerPubkeyParam, eip191PubkeyFelts, encryptPrivateKey, estimateThresholdGasOverhead, executeShhhSponsoredRaw, hashCall, hashCalls, hashOutsideExecutionStruct, hashStarknetDomain, isReadyToExecute, isThinkDecision, jwtAppleSubHash, jwtAppleSubOwnerId, jwtAppleSubPubkeyFelts, labelToFelt, locateSubClaim, messageHashToNonceB64url, migrateChipiWalletToShhh, normalizeEntrypoints, ownerCommitment, parseAppleIdToken, parseDerEcdsaSignature, parseEip191Signature, parseThresholdEnvelope, resolveShhhChainId, secondsUntilExecutable, serializeExecuteFromOutsideV2Calldata, signBootstrapMessage, signTypedData, signTypedDataArray, snip12HashToHexAsciiBytes, starkOwnerId, starkPubkeyFelts, submitViaAccount, validateSpendingPolicyConfig, waitForTransaction, webauthnOwnerId, webauthnOwnerPubkeyParam, webauthnPubkeyFelts, wrapV2Snip12Envelope, wrapV2ThresholdEnvelope, x402Middleware };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map