@chipi-stack/backend 13.12.0 → 14.0.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { isValidApiKey, ChipiAuthError, STARKNET_NETWORKS, API_VERSIONING, validateErrorResponse, ChipiApiError, handleApiError, WALLET_RPC_ENDPOINTS, WALLET_CLASS_HASHES, API_ENDPOINTS, ChipiTransactionError, formatAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, ChipiSessionError, SESSION_ERRORS, SESSION_DEFAULTS, SESSION_ENTRYPOINTS } from '@chipi-stack/shared';
 import CryptoES from 'crypto-es';
 import { RpcProvider, ec, hash, Account, num, CairoCustomEnum, CairoOption, CairoOptionVariant, CallData, cairo, typedData } from 'starknet';
-import { STARKNET_CONTRACTS } from '@chipi-stack/types';
+import { STARKNET_CONTRACTS, Chain } from '@chipi-stack/types';
 export { Chain, ChainToken } from '@chipi-stack/types';
 
 // src/chipi-sdk.ts
@@ -14,7 +14,7 @@ var ChipiClient = class {
     this.customAlphaUrl = config.alphaUrl;
     this.baseUrl = this.getBaseUrl();
     this.nodeUrl = config.nodeUrl || STARKNET_NETWORKS.MAINNET;
-    this.sdkVersion = "11.21.0";
+    this.sdkVersion = "14.0.0";
   }
   /**
    * Get the API public key (for internal SDK use)
@@ -25,7 +25,7 @@ var ChipiClient = class {
   getBaseUrl() {
     const version = `v${API_VERSIONING.VERSION}`;
     if (this.customAlphaUrl) {
-      const cleanUrl = this.customAlphaUrl.replace(/\/v\d+$/, "").replace(/\/$/, "");
+      const cleanUrl = this.customAlphaUrl.replace(/\/v\d+\/?$/, "").replace(/\/$/, "");
       return `${cleanUrl}/${version}`;
     }
     return `https://celebrated-vision-production-66a5.up.railway.app/${version}`;
@@ -95,7 +95,6 @@ var ChipiClient = class {
       });
       const data = await response.json();
       if (!response.ok) {
-        console.error("there was an error", data);
         const errorData = validateErrorResponse(data);
         throw new ChipiApiError(
           errorData.message,
@@ -135,6 +134,33 @@ var ChipiClient = class {
       throw handleApiError(error);
     }
   }
+  async patch({
+    endpoint,
+    bearerToken,
+    body
+  }) {
+    try {
+      const url = new URL(`${this.baseUrl}${endpoint}`);
+      this.addVersionParams(url);
+      const response = await fetch(url.toString(), {
+        method: "PATCH",
+        headers: this.getHeaders(bearerToken),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        const errorData = validateErrorResponse(data);
+        throw new ChipiApiError(
+          errorData.message,
+          errorData.code || `HTTP_${response.status}`,
+          response.status
+        );
+      }
+      return data;
+    } catch (error) {
+      throw handleApiError(error);
+    }
+  }
   async delete({
     endpoint,
     bearerToken
@@ -162,16 +188,26 @@ var ChipiClient = class {
   }
 };
 var encryptPrivateKey = (privateKey, password) => {
+  if (!privateKey || !password) {
+    throw new Error("Private key and password are required");
+  }
   return CryptoES.AES.encrypt(privateKey, password).toString();
 };
 var decryptPrivateKey = (encryptedPrivateKey, password) => {
+  if (!encryptedPrivateKey || !password) {
+    throw new Error("Encrypted private key and password are required");
+  }
   try {
     const bytes = CryptoES.AES.decrypt(encryptedPrivateKey, password);
     const decrypted = bytes.toString(CryptoES.enc.Utf8);
-    if (!decrypted) throw new Error("Decryption failed");
+    if (!decrypted) {
+      throw new Error("Decryption resulted in empty string");
+    }
     return decrypted;
   } catch (error) {
-    console.error("Decryption failed:", error);
+    if (error instanceof Error) {
+      throw error;
+    }
     throw new Error(`Decryption failed: ${error}`);
   }
 };
@@ -216,10 +252,7 @@ var ChipiWallets = class {
       const privateKeyAX = this.getPrivateKeyAX();
       const starkKeyPubAX = ec.starkCurve.getStarkKey(privateKeyAX);
       const accountClassHash = walletType === "READY" ? WALLET_CLASS_HASHES.READY : WALLET_CLASS_HASHES.CHIPI;
-      const constructorCallData = this.buildConstructorCallData(
-        walletType,
-        starkKeyPubAX
-      );
+      const constructorCallData = this.buildConstructorCallData(walletType, starkKeyPubAX);
       const publicKey = hash.calculateContractAddressFromHash(
         starkKeyPubAX,
         accountClassHash,
@@ -331,8 +364,22 @@ var ChipiWallets = class {
       if (err instanceof ChipiApiError && err.status === 404) {
         return null;
       }
-      throw new Error(`getWallet error: ${String(err)}`);
+      throw err;
+    }
+  }
+  async updateWalletEncryption(params, bearerToken) {
+    const body = {
+      externalUserId: params.externalUserId,
+      newEncryptedPrivateKey: params.newEncryptedPrivateKey
+    };
+    if (params.publicKey != null) {
+      body.publicKey = params.publicKey;
     }
+    return this.client.patch({
+      endpoint: `${API_ENDPOINTS.CHIPI_WALLETS}/update-encryption-details`,
+      bearerToken,
+      body
+    });
   }
   async getTokenBalance({
     params,
@@ -360,12 +407,11 @@ var executePaymasterTransaction = async ({
     }
     const rpcUrl = WALLET_RPC_ENDPOINTS.READY;
     const accountClassHash = WALLET_CLASS_HASHES.READY;
-    const privateKeyDecrypted = decryptPrivateKey(
-      wallet.encryptedPrivateKey,
-      encryptKey
-    );
-    if (!privateKeyDecrypted) {
-      throw new Error("Failed to decrypt private key");
+    let privateKeyDecrypted;
+    try {
+      privateKeyDecrypted = decryptPrivateKey(wallet.encryptedPrivateKey, encryptKey);
+    } catch {
+      throw new Error("Failed to decrypt private key. Verify the encryptKey is correct.");
     }
     const provider = new RpcProvider({ nodeUrl: rpcUrl });
     const account = new Account({
@@ -438,16 +484,13 @@ var executePaymasterTransactionWithSession = async ({
 }) => {
   const { encryptKey, wallet, session, calls, saveToDatabase } = params;
   if (wallet.walletType !== "CHIPI") {
-    console.error(
-      "[ChipiSDK:Session:Execute] Invalid wallet type for session execution",
-      {
-        provided: wallet.walletType,
-        required: "CHIPI",
-        expectedClassHash: WALLET_CLASS_HASHES.CHIPI,
-        walletAddress: wallet.publicKey?.slice(0, 15) + "...",
-        hint: "Session keys only work with CHIPI wallets (SNIP-9 compatible)"
-      }
-    );
+    console.error("[ChipiSDK:Session:Execute] Invalid wallet type for session execution", {
+      provided: wallet.walletType,
+      required: "CHIPI",
+      expectedClassHash: WALLET_CLASS_HASHES.CHIPI,
+      walletAddress: wallet.publicKey?.slice(0, 15) + "...",
+      hint: "Session keys only work with CHIPI wallets (SNIP-9 compatible)"
+    });
     throw new ChipiSessionError(
       `Session execution requires CHIPI wallet type. Got: "${wallet.walletType || "undefined"}"`,
       SESSION_ERRORS.INVALID_WALLET_TYPE_FOR_SESSION
@@ -466,18 +509,14 @@ var executePaymasterTransactionWithSession = async ({
     );
   }
   try {
-    const sessionPrivateKey = decryptPrivateKey(
-      session.encryptedPrivateKey,
-      encryptKey
-    );
-    if (!sessionPrivateKey) {
-      console.error(
-        "[ChipiSDK:Session:Execute] Failed to decrypt session private key",
-        {
-          sessionPubKey: session.publicKey?.slice(0, 15) + "...",
-          hint: "Ensure the encryptKey matches the one used when creating the session"
-        }
-      );
+    let sessionPrivateKey;
+    try {
+      sessionPrivateKey = decryptPrivateKey(session.encryptedPrivateKey, encryptKey);
+    } catch {
+      console.error("[ChipiSDK:Session:Execute] Failed to decrypt session private key", {
+        sessionPubKey: session.publicKey?.slice(0, 15) + "...",
+        hint: "Ensure the encryptKey matches the one used when creating the session"
+      });
       throw new ChipiSessionError(
         "Failed to decrypt session private key. Verify the encryptKey is correct.",
         SESSION_ERRORS.SESSION_DECRYPTION_FAILED
@@ -529,12 +568,9 @@ var executePaymasterTransactionWithSession = async ({
       }
     });
     if (!result.transactionHash) {
-      console.error(
-        "[ChipiSDK:Session:Execute] No transaction hash in response",
-        {
-          result
-        }
-      );
+      console.error("[ChipiSDK:Session:Execute] No transaction hash in response", {
+        result
+      });
       throw new Error("Response does not contain transaction hash");
     }
     return result.transactionHash;
@@ -701,32 +737,21 @@ var ChipiSkuPurchases = class {
    * @returns Promise<SkuPurchaseResponse> - The purchase response with transaction details
    */
   async purchaseSku(params, bearerToken) {
-    const {
-      skuId,
-      skuReference,
-      currencyAmount,
-      currency,
-      chain,
-      token,
-      encryptKey,
-      wallet
-    } = params;
-    const usdAmount = await this.exchanges.getUsdAmount(
-      currencyAmount,
-      currency,
-      bearerToken
-    );
-    const tokenAddress = STARKNET_CONTRACTS[token].contractAddress;
-    if (usdAmount <= 0) {
-      throw new Error(
-        `Invalid USD amount: ${usdAmount}. Amount must be positive.`
-      );
+    const { skuId, skuReference, currencyAmount, currency, chain, token, encryptKey, wallet } = params;
+    if (chain !== Chain.STARKNET) {
+      throw new Error(`Unsupported chain for SKU purchases: ${chain}`);
+    }
+    const tokenConfig = STARKNET_CONTRACTS[token];
+    if (!tokenConfig?.contractAddress) {
+      throw new Error(`Unsupported token for Starknet SKU purchases: ${token}`);
+    }
+    const usdAmount = await this.exchanges.getUsdAmount(currencyAmount, currency, bearerToken);
+    const tokenAddress = tokenConfig.contractAddress;
+    if (!Number.isFinite(usdAmount) || usdAmount <= 0) {
+      throw new Error(`Invalid USD amount: ${usdAmount}. Amount must be positive.`);
     }
     const minUsdAmount = Math.max(usdAmount, 1e-6);
-    const parsedAmount = formatAmount(
-      minUsdAmount.toString(),
-      STARKNET_CONTRACTS[token].decimals
-    );
+    const parsedAmount = formatAmount(minUsdAmount.toString(), tokenConfig.decimals);
     const calls = [
       {
         contractAddress: tokenAddress,
@@ -888,6 +913,12 @@ var ChipiSessions = class {
    */
   createSessionKey(params) {
     const { encryptKey, durationSeconds = SESSION_DEFAULTS.DURATION_SECONDS } = params;
+    if (typeof durationSeconds !== "number" || !Number.isFinite(durationSeconds) || !Number.isInteger(durationSeconds) || durationSeconds <= 0) {
+      throw new ChipiSessionError(
+        `Invalid session duration: ${durationSeconds}. Must be a positive integer.`,
+        SESSION_ERRORS.SESSION_CREATION_FAILED
+      );
+    }
     try {
       const rawPrivateKey = ec.starkCurve.utils.randomPrivateKey();
       const privateKeyHex = this.toHex(rawPrivateKey);
@@ -901,13 +932,10 @@ var ChipiSessions = class {
       };
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      console.error(
-        "[ChipiSDK:Session:Create] Failed to generate session key",
-        {
-          error: err.message,
-          durationRequested: durationSeconds
-        }
-      );
+      console.error("[ChipiSDK:Session:Create] Failed to generate session key", {
+        error: err.message,
+        durationRequested: durationSeconds
+      });
       throw new ChipiSessionError(
         `Failed to create session key: ${err.message}`,
         SESSION_ERRORS.SESSION_CREATION_FAILED
@@ -942,22 +970,15 @@ var ChipiSessions = class {
    */
   async addSessionKeyToContract(params, bearerToken) {
     const { encryptKey, wallet, sessionConfig } = params;
-    this.validateChipiWallet(
-      wallet.walletType,
-      "AddToContract",
-      wallet.publicKey
-    );
+    this.validateChipiWallet(wallet.walletType, "AddToContract", wallet.publicKey);
     try {
-      console.log(
-        "[ChipiSDK:Session:AddToContract] Registering session on-chain",
-        {
-          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
-        }
-      );
+      console.log("[ChipiSDK:Session:AddToContract] Registering session on-chain", {
+        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
+      });
       const calldata = [
         sessionConfig.sessionPublicKey,
         num.toHex(sessionConfig.validUntil),
@@ -983,13 +1004,10 @@ var ChipiSessions = class {
         bearerToken,
         client: this.client
       });
-      console.log(
-        "[ChipiSDK:Session:AddToContract] Session registered successfully",
-        {
-          txHash,
-          sessionPubKey: sessionConfig.sessionPublicKey.slice(0, 15) + "..."
-        }
-      );
+      console.log("[ChipiSDK:Session:AddToContract] Session registered successfully", {
+        txHash,
+        sessionPubKey: sessionConfig.sessionPublicKey.slice(0, 15) + "..."
+      });
       return txHash;
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
@@ -1137,17 +1155,33 @@ var ChipiSessions = class {
       return sessionData;
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[ChipiSDK:Session:GetData] Query failed", {
+      const sessionNotFoundPatterns = [
+        /entry point.*not found/i,
+        /requested entrypoint was not found/i,
+        /invalid message selector/i,
+        /contract not found/i,
+        /is not deployed/i,
+        /revert.*get_session_data/i
+      ];
+      const isSessionNotFound = sessionNotFoundPatterns.some((p) => p.test(err.message));
+      if (isSessionNotFound) {
+        console.log("[ChipiSDK:Session:GetData] Session not found on contract", {
+          walletAddress: walletAddress?.slice(0, 15) + "...",
+          sessionPubKey: sessionPublicKey?.slice(0, 15) + "..."
+        });
+        return {
+          isActive: false,
+          validUntil: 0,
+          remainingCalls: 0,
+          allowedEntrypoints: []
+        };
+      }
+      console.error("[ChipiSDK:Session:GetData] RPC/network error", {
         error: err.message,
         walletAddress: walletAddress?.slice(0, 15) + "...",
         sessionPubKey: sessionPublicKey?.slice(0, 15) + "..."
       });
-      return {
-        isActive: false,
-        validUntil: 0,
-        remainingCalls: 0,
-        allowedEntrypoints: []
-      };
+      throw err;
     }
   }
   /**
@@ -1360,7 +1394,6 @@ var ChipiSDK = class {
     params,
     bearerToken
   }) {
-    console.log("createWallet params:", params);
     return this.wallets.createWallet({
       ...params,
       bearerToken: this.resolveBearerToken(bearerToken)
@@ -1376,10 +1409,7 @@ var ChipiSDK = class {
     });
   }
   async getTransactionList(query, bearerToken) {
-    return this.transactions.getTransactionList(
-      query,
-      this.resolveBearerToken(bearerToken)
-    );
+    return this.transactions.getTransactionList(query, this.resolveBearerToken(bearerToken));
   }
   async getWallet(params, bearerToken) {
     return this.wallets.getWallet(params, this.resolveBearerToken(bearerToken));
@@ -1397,19 +1427,13 @@ var ChipiSDK = class {
     params,
     bearerToken
   }) {
-    return this.skuPurchases.purchaseSku(
-      params,
-      this.resolveBearerToken(bearerToken)
-    );
+    return this.skuPurchases.purchaseSku(params, this.resolveBearerToken(bearerToken));
   }
   /**
    * Get a SKU purchase by id
    */
   async getSkuPurchase(id, bearerToken) {
-    return this.skuPurchases.getSkuPurchase(
-      id,
-      this.resolveBearerToken(bearerToken)
-    );
+    return this.skuPurchases.getSkuPurchase(id, this.resolveBearerToken(bearerToken));
   }
   /// SKUS
   async getSkuList(params, bearerToken) {