@chipi-stack/backend 14.1.0 → 14.2.0

package/README.md

@@ -43,6 +43,15 @@ const tx = await sdk.transfer({
 });
 ```
 
+## What you can ship
+
+- **Wallet-as-a-service APIs** — provision and manage wallets for your users from your backend
+- **SKU marketplace (airtime, bill pay, gift cards)** — integrate real-world purchases with crypto rails
+- **Crypto remittance backends** — build cross-border payment services with stablecoin settlement
+- **Gasless payment processing for fintechs** — accept and send USDC without your users paying gas
+
+Have an idea? [Tell us what you want to build](https://github.com/chipi-pay/build-with-chipi/issues/new)
+
 ## Documentation
 
 Full docs at [docs.chipipay.com](https://docs.chipipay.com)

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _chipi_stack_types from '@chipi-stack/types';
-import { CreateSessionKeyParams, SessionKeyData, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, SessionDataResponse, ExecuteWithSessionParams, Currency, PaymasterAdapter, PaymasterAccount, X402FacilitatorConfig, NonceStore, PaymentPayload, VerifyResponse, SettleResponse, ChipiSDKConfig, ExecuteTransactionParams, SignTypedDataParams, SignTypedDataResult, TransferParams, ApproveParams, CallAnyContractParams, CreateWalletParams, CreateWalletResponse, RecordSendTransactionParams, Transaction, GetTransactionListQuery, PaginatedResponse, GetWalletParams, GetTokenBalanceParams, GetTokenBalanceResponse, CreateSkuPurchaseParams, GetSkuListQuery, Sku, TransactionStatusResponse, PrepareWalletUpgradeParams, PrepareWalletUpgradeResponse, ExecuteWalletUpgradeParams, ExecuteWalletUpgradeResponse, ChipiServerSDKConfig, ChipiBrowserSDKConfig, X402PaymentConfig } from '@chipi-stack/types';
+import { CreateSessionKeyParams, SessionKeyData, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, SessionDataResponse, ExecuteWithSessionParams, SetSpendingPolicyParams, GetSpendingPolicyParams, SpendingPolicyData, RemoveSpendingPolicyParams, Currency, PaymasterAdapter, PaymasterAccount, X402FacilitatorConfig, NonceStore, PaymentPayload, VerifyResponse, SettleResponse, ChipiSDKConfig, ExecuteTransactionParams, SignTypedDataParams, SignTypedDataResult, TransferParams, ApproveParams, CallAnyContractParams, CreateWalletParams, CreateWalletResponse, RecordSendTransactionParams, Transaction, GetTransactionListQuery, PaginatedResponse, GetWalletParams, GetTokenBalanceParams, GetTokenBalanceResponse, CreateSkuPurchaseParams, GetSkuListQuery, Sku, TransactionStatusResponse, PrepareWalletUpgradeParams, PrepareWalletUpgradeResponse, ExecuteWalletUpgradeParams, ExecuteWalletUpgradeResponse, ChipiServerSDKConfig, ChipiBrowserSDKConfig, X402PaymentConfig } from '@chipi-stack/types';
 export * from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
 import { ChipiWallets } from './wallets.mjs';
@@ -168,6 +168,89 @@ declare class ChipiSessions {
      * ```
      */
     executeTransactionWithSession(params: ExecuteWithSessionParams, bearerToken: string): Promise<string>;
+    /**
+     * Split a bigint into Cairo u256 representation (low u128, high u128).
+     */
+    private splitU256;
+    /**
+     * Reconstruct a bigint from Cairo u256 (low, high) hex strings.
+     */
+    private joinU256;
+    /**
+     * 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);
+     * ```
+     */
+    setSpendingPolicy(params: SetSpendingPolicyParams, bearerToken: string): Promise<string>;
+    /**
+     * 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`);
+     * }
+     * ```
+     */
+    getSpendingPolicy(params: GetSpendingPolicyParams): Promise<SpendingPolicyData>;
+    /**
+     * 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);
+     * ```
+     */
+    removeSpendingPolicy(params: RemoveSpendingPolicyParams, bearerToken: string): Promise<string>;
 }
 
 declare class ChipiExchanges {

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _chipi_stack_types from '@chipi-stack/types';
-import { CreateSessionKeyParams, SessionKeyData, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, SessionDataResponse, ExecuteWithSessionParams, Currency, PaymasterAdapter, PaymasterAccount, X402FacilitatorConfig, NonceStore, PaymentPayload, VerifyResponse, SettleResponse, ChipiSDKConfig, ExecuteTransactionParams, SignTypedDataParams, SignTypedDataResult, TransferParams, ApproveParams, CallAnyContractParams, CreateWalletParams, CreateWalletResponse, RecordSendTransactionParams, Transaction, GetTransactionListQuery, PaginatedResponse, GetWalletParams, GetTokenBalanceParams, GetTokenBalanceResponse, CreateSkuPurchaseParams, GetSkuListQuery, Sku, TransactionStatusResponse, PrepareWalletUpgradeParams, PrepareWalletUpgradeResponse, ExecuteWalletUpgradeParams, ExecuteWalletUpgradeResponse, ChipiServerSDKConfig, ChipiBrowserSDKConfig, X402PaymentConfig } from '@chipi-stack/types';
+import { CreateSessionKeyParams, SessionKeyData, AddSessionKeyParams, RevokeSessionKeyParams, GetSessionDataParams, SessionDataResponse, ExecuteWithSessionParams, SetSpendingPolicyParams, GetSpendingPolicyParams, SpendingPolicyData, RemoveSpendingPolicyParams, Currency, PaymasterAdapter, PaymasterAccount, X402FacilitatorConfig, NonceStore, PaymentPayload, VerifyResponse, SettleResponse, ChipiSDKConfig, ExecuteTransactionParams, SignTypedDataParams, SignTypedDataResult, TransferParams, ApproveParams, CallAnyContractParams, CreateWalletParams, CreateWalletResponse, RecordSendTransactionParams, Transaction, GetTransactionListQuery, PaginatedResponse, GetWalletParams, GetTokenBalanceParams, GetTokenBalanceResponse, CreateSkuPurchaseParams, GetSkuListQuery, Sku, TransactionStatusResponse, PrepareWalletUpgradeParams, PrepareWalletUpgradeResponse, ExecuteWalletUpgradeParams, ExecuteWalletUpgradeResponse, ChipiServerSDKConfig, ChipiBrowserSDKConfig, X402PaymentConfig } from '@chipi-stack/types';
 export * from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
 import { ChipiWallets } from './wallets.js';
@@ -168,6 +168,89 @@ declare class ChipiSessions {
      * ```
      */
     executeTransactionWithSession(params: ExecuteWithSessionParams, bearerToken: string): Promise<string>;
+    /**
+     * Split a bigint into Cairo u256 representation (low u128, high u128).
+     */
+    private splitU256;
+    /**
+     * Reconstruct a bigint from Cairo u256 (low, high) hex strings.
+     */
+    private joinU256;
+    /**
+     * 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);
+     * ```
+     */
+    setSpendingPolicy(params: SetSpendingPolicyParams, bearerToken: string): Promise<string>;
+    /**
+     * 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`);
+     * }
+     * ```
+     */
+    getSpendingPolicy(params: GetSpendingPolicyParams): Promise<SpendingPolicyData>;
+    /**
+     * 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);
+     * ```
+     */
+    removeSpendingPolicy(params: RemoveSpendingPolicyParams, bearerToken: string): Promise<string>;
 }
 
 declare class ChipiExchanges {

package/dist/index.js

@@ -1424,6 +1424,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 [starknet.num.toHex(value & mask), starknet.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 shared.ChipiSessionError(
+        `Spending policies only support CHIPI wallets. Got: ${wallet.walletType}`,
+        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
+      );
+    }
+    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,
+        starknet.num.toHex(windowSeconds)
+      ];
+      const txHash = await executePaymasterTransaction({
+        params: {
+          encryptKey,
+          wallet: { ...wallet, walletType: "CHIPI" },
+          calls: [
+            {
+              contractAddress: wallet.publicKey,
+              entrypoint: shared.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 starknet.RpcProvider({
+        nodeUrl: shared.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: shared.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 shared.ChipiSessionError(
+        `Spending policies only support CHIPI wallets. Got: ${wallet.walletType}`,
+        shared.SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
+      );
+    }
+    if (!token || token.trim().length === 0) {
+      throw new shared.ChipiSessionError(
+        `Invalid token address for spending policy removal: "${token}"`,
+        shared.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: shared.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() {