@chipi-stack/backend 14.1.1 → 14.2.1

package/dist/index.mjs

@@ -1419,6 +1419,324 @@ var ChipiSessions = class {
       client: this.client
     });
   }
+  // --- Spending Policy Methods ---
+  // 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.
+   */
+  joinU256(low, high) {
+    return BigInt(low) + (BigInt(high) << 128n);
+  }
+  /**
+   * Set a spending policy for a session key + token pair.
+   *
+   * This executes a sponsored transaction (using owner signature) to call
+   * `set_spending_policy` on the CHIPI wallet contract.
+   *
+   * The contract enforces these limits automatically during `__execute__()` on
+   * ERC-20 operations (transfer, approve, increase_allowance) made by the session.
+   *
+   * @param params - Spending policy parameters
+   * @param bearerToken - Authentication token
+   * @returns Transaction hash
+   *
+   * @example
+   * ```typescript
+   * // Set a spending limit: max 1 USDC per call, 50 USDC per day
+   * const txHash = await sdk.sessions.setSpendingPolicy({
+   *   encryptKey: userEncryptKey,
+   *   wallet: userWallet,
+   *   spendingPolicyConfig: {
+   *     sessionPublicKey: session.publicKey,
+   *     token: USDC_ADDRESS,
+   *     maxPerCall: 1_000_000n,     // 1 USDC (6 decimals)
+   *     maxPerWindow: 50_000_000n,  // 50 USDC
+   *     windowSeconds: 86400,       // 24 hours
+   *   }
+   * }, bearerToken);
+   * ```
+   */
+  async setSpendingPolicy(params, bearerToken) {
+    const { encryptKey, wallet, spendingPolicyConfig } = params;
+    const { sessionPublicKey, token, maxPerCall, maxPerWindow, windowSeconds } = spendingPolicyConfig;
+    if (wallet.walletType && wallet.walletType !== "CHIPI") {
+      throw new ChipiSessionError(
+        `Spending policies only support CHIPI wallets. Got: ${wallet.walletType}`,
+        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
+      );
+    }
+    try {
+      console.log("[ChipiSDK:Session:SetSpendingPolicy] Setting spending policy", {
+        walletAddress: wallet.publicKey.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
+        token: token.slice(0, 15) + "...",
+        maxPerCall: maxPerCall.toString(),
+        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 txHash = await executePaymasterTransaction({
+        params: {
+          encryptKey,
+          wallet: { ...wallet, walletType: "CHIPI" },
+          calls: [
+            {
+              contractAddress: wallet.publicKey,
+              entrypoint: SESSION_ENTRYPOINTS.SET_SPENDING_POLICY,
+              calldata
+            }
+          ],
+          saveToDatabase: false
+        },
+        bearerToken,
+        client: this.client
+      });
+      console.log("[ChipiSDK:Session:SetSpendingPolicy] Spending policy set successfully", {
+        txHash,
+        sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
+        token: token.slice(0, 15) + "..."
+      });
+      return txHash;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error("[ChipiSDK:Session:SetSpendingPolicy] Failed to set spending policy", {
+        error: err.message,
+        walletAddress: wallet.publicKey?.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey?.slice(0, 15) + "...",
+        token: token?.slice(0, 15) + "..."
+      });
+      throw error;
+    }
+  }
+  /**
+   * Query a spending policy from the smart contract.
+   *
+   * This is a read-only call that does not require signing or gas.
+   * Returns zeroed data if no policy is set (meaning no enforcement).
+   *
+   * @param params - Query parameters
+   * @returns Spending policy data including limits and current window state
+   *
+   * @example
+   * ```typescript
+   * const policy = await sdk.sessions.getSpendingPolicy({
+   *   walletAddress: userWallet.publicKey,
+   *   sessionPublicKey: session.publicKey,
+   *   token: USDC_ADDRESS,
+   * });
+   * if (policy.maxPerWindow > 0n) {
+   *   console.log(`Spent ${policy.spentInWindow} of ${policy.maxPerWindow} this window`);
+   * }
+   * ```
+   */
+  async getSpendingPolicy(params) {
+    const { walletAddress, sessionPublicKey, token } = params;
+    try {
+      const provider = new RpcProvider({
+        nodeUrl: WALLET_RPC_ENDPOINTS["CHIPI"]
+      });
+      console.log("[ChipiSDK:Session:GetSpendingPolicy] Querying spending policy", {
+        walletAddress: walletAddress.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
+        token: token.slice(0, 15) + "..."
+      });
+      const result = await provider.callContract({
+        contractAddress: walletAddress,
+        entrypoint: SESSION_ENTRYPOINTS.GET_SPENDING_POLICY,
+        calldata: [sessionPublicKey, token]
+      });
+      const resultArray = Array.isArray(result) ? result : result.result || [];
+      if (resultArray.length < 8) {
+        console.warn("[ChipiSDK:Session:GetSpendingPolicy] Unexpected response format", {
+          resultLength: resultArray.length,
+          result: resultArray
+        });
+        return {
+          maxPerCall: 0n,
+          maxPerWindow: 0n,
+          windowSeconds: 0,
+          spentInWindow: 0n,
+          windowStart: 0
+        };
+      }
+      const policyData = {
+        maxPerCall: this.joinU256(resultArray[0], resultArray[1]),
+        maxPerWindow: this.joinU256(resultArray[2], resultArray[3]),
+        windowSeconds: Number(BigInt(resultArray[4])),
+        spentInWindow: this.joinU256(resultArray[5], resultArray[6]),
+        windowStart: Number(BigInt(resultArray[7]))
+      };
+      console.log("[ChipiSDK:Session:GetSpendingPolicy] Spending policy retrieved", {
+        maxPerCall: policyData.maxPerCall.toString(),
+        maxPerWindow: policyData.maxPerWindow.toString(),
+        windowSeconds: policyData.windowSeconds,
+        spentInWindow: policyData.spentInWindow.toString(),
+        windowStart: policyData.windowStart
+      });
+      return policyData;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      const notFoundPatterns = [
+        /entry point.*not found/i,
+        /requested entrypoint was not found/i,
+        /invalid message selector/i,
+        /contract not found/i,
+        /is not deployed/i
+      ];
+      const isNotFound = notFoundPatterns.some((p) => p.test(err.message));
+      if (isNotFound) {
+        console.log(
+          "[ChipiSDK:Session:GetSpendingPolicy] No policy found (contract or entrypoint missing)",
+          {
+            walletAddress: walletAddress?.slice(0, 15) + "...",
+            sessionPubKey: sessionPublicKey?.slice(0, 15) + "...",
+            token: token?.slice(0, 15) + "..."
+          }
+        );
+        return {
+          maxPerCall: 0n,
+          maxPerWindow: 0n,
+          windowSeconds: 0,
+          spentInWindow: 0n,
+          windowStart: 0
+        };
+      }
+      console.error("[ChipiSDK:Session:GetSpendingPolicy] RPC/network error", {
+        error: err.message,
+        walletAddress: walletAddress?.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey?.slice(0, 15) + "...",
+        token: token?.slice(0, 15) + "..."
+      });
+      throw err;
+    }
+  }
+  /**
+   * Remove a spending policy for a session key + token pair.
+   *
+   * This executes a sponsored transaction (using owner signature) to call
+   * `remove_spending_policy` on the CHIPI wallet contract.
+   *
+   * After removal, the session key has no spending limits for this token.
+   *
+   * @param params - Policy removal parameters
+   * @param bearerToken - Authentication token
+   * @returns Transaction hash
+   *
+   * @example
+   * ```typescript
+   * const txHash = await sdk.sessions.removeSpendingPolicy({
+   *   encryptKey: userEncryptKey,
+   *   wallet: userWallet,
+   *   sessionPublicKey: session.publicKey,
+   *   token: USDC_ADDRESS,
+   * }, bearerToken);
+   * ```
+   */
+  async removeSpendingPolicy(params, bearerToken) {
+    const { encryptKey, wallet, sessionPublicKey, token } = params;
+    if (wallet.walletType && wallet.walletType !== "CHIPI") {
+      throw new ChipiSessionError(
+        `Spending policies only support CHIPI wallets. Got: ${wallet.walletType}`,
+        SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
+      );
+    }
+    if (!token || token.trim().length === 0) {
+      throw new ChipiSessionError(
+        `Invalid token address for spending policy removal: "${token}"`,
+        SESSION_ERRORS.INVALID_SPENDING_POLICY
+      );
+    }
+    try {
+      console.log("[ChipiSDK:Session:RemoveSpendingPolicy] Removing spending policy", {
+        walletAddress: wallet.publicKey.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
+        token: token.slice(0, 15) + "..."
+      });
+      const calldata = [sessionPublicKey, token];
+      const txHash = await executePaymasterTransaction({
+        params: {
+          encryptKey,
+          wallet: { ...wallet, walletType: "CHIPI" },
+          calls: [
+            {
+              contractAddress: wallet.publicKey,
+              entrypoint: SESSION_ENTRYPOINTS.REMOVE_SPENDING_POLICY,
+              calldata
+            }
+          ],
+          saveToDatabase: false
+        },
+        bearerToken,
+        client: this.client
+      });
+      console.log("[ChipiSDK:Session:RemoveSpendingPolicy] Spending policy removed successfully", {
+        txHash,
+        sessionPubKey: sessionPublicKey.slice(0, 15) + "...",
+        token: token.slice(0, 15) + "..."
+      });
+      return txHash;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error("[ChipiSDK:Session:RemoveSpendingPolicy] Failed to remove spending policy", {
+        error: err.message,
+        walletAddress: wallet.publicKey?.slice(0, 15) + "...",
+        sessionPubKey: sessionPublicKey?.slice(0, 15) + "...",
+        token: token?.slice(0, 15) + "..."
+      });
+      throw error;
+    }
+  }
 };
 var InMemoryNonceStore = class {
   constructor() {