@chipi-stack/backend 11.5.0 → 11.7.0

package/dist/index.mjs

@@ -1,7 +1,8 @@
-import { isValidApiKey, ChipiAuthError, STARKNET_NETWORKS, validateErrorResponse, ChipiApiError, handleApiError, API_ENDPOINTS, ChipiTransactionError, formatAmount, CONTRACT_ADDRESSES } from '@chipi-stack/shared';
+import { isValidApiKey, ChipiAuthError, STARKNET_NETWORKS, validateErrorResponse, ChipiApiError, handleApiError, API_ENDPOINTS, ChipiTransactionError, formatAmount, getUsdAmount, SKU_CONTRACTS, CARRIER_IDS, SERVICE_TYPES, CHAIN_TOKEN_TYPES, CHAIN_TYPES, CONTRACT_ADDRESSES } from '@chipi-stack/shared';
 import CryptoES from 'crypto-es';
-import { RpcProvider, stark, ec, CairoCustomEnum, CairoOption, CairoOptionVariant, CallData, hash, Account, num } from 'starknet';
+import { RpcProvider, stark, ec, CairoCustomEnum, CairoOption, CairoOptionVariant, CallData, hash, Account, num, cairo } from 'starknet';
 import { STARKNET_CONTRACTS } from '@chipi-stack/types';
+import { createHash, randomUUID } from 'crypto';
 
 // src/chipi-sdk.ts
 var ChipiClient = class {
@@ -291,9 +292,14 @@ var ChipiWallets = class {
     return getBalanceResponse;
   }
 };
-var executePaymasterTransaction = async (params) => {
+var executePaymasterTransaction = async ({
+  params,
+  bearerToken,
+  apiPublicKey,
+  backendUrl
+}) => {
   try {
-    const { encryptKey, wallet, calls, apiPublicKey, bearerToken, backendUrl } = params;
+    const { encryptKey, wallet, calls } = params;
     const privateKeyDecrypted = decryptPrivateKey(
       wallet.encryptedPrivateKey,
       encryptKey
@@ -374,9 +380,13 @@ var ChipiTransactions = class {
   /**
    * Execute a gasless transaction using paymaster
    */
-  async executeTransaction(params) {
+  async executeTransaction({
+    params,
+    bearerToken
+  }) {
     return executePaymasterTransaction({
-      ...params,
+      params,
+      bearerToken,
       backendUrl: this.client.baseUrl,
       apiPublicKey: this.client.getApiPublicKey()
     });
@@ -401,16 +411,18 @@ var ChipiTransactions = class {
     }
     const formattedAmount = formatAmount(amount, decimals);
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress,
-          entrypoint: "transfer",
-          calldata: [recipient, formattedAmount, "0x0"]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress,
+            entrypoint: "transfer",
+            calldata: [recipient, formattedAmount, "0x0"]
+          }
+        ]
+      },
+      bearerToken
     });
   }
   /**
@@ -419,27 +431,36 @@ var ChipiTransactions = class {
   async approve(params) {
     const formattedAmount = formatAmount(params.amount, params.decimals);
     return this.executeTransaction({
-      encryptKey: params.encryptKey,
-      wallet: params.wallet,
-      bearerToken: params.bearerToken,
-      calls: [
-        {
-          contractAddress: params.contractAddress,
-          entrypoint: "approve",
-          calldata: [params.spender, formattedAmount, "0x0"]
-        }
-      ]
+      params: {
+        encryptKey: params.encryptKey,
+        wallet: params.wallet,
+        calls: [
+          {
+            contractAddress: params.contractAddress,
+            entrypoint: "approve",
+            calldata: [params.spender, formattedAmount, "0x0"]
+          }
+        ]
+      },
+      bearerToken: params.bearerToken
     });
   }
   /**
    * Call any contract method
    */
-  async callAnyContract(params) {
+  // {
+  //   encryptKey: string;
+  //   wallet: any;
+  //   calls: any[];
+  //   bearerToken: string;
+  // }
+  async callAnyContract({
+    params,
+    bearerToken
+  }) {
     return this.executeTransaction({
-      encryptKey: params.encryptKey,
-      wallet: params.wallet,
-      bearerToken: params.bearerToken,
-      calls: params.calls
+      params,
+      bearerToken
     });
   }
   /**
@@ -457,12 +478,119 @@ var ChipiTransactions = class {
     return response;
   }
 };
-
-// src/skus.ts
+var ChipiSkuTransactions = class {
+  constructor(client) {
+    this.client = client;
+    this.transactions = new ChipiTransactions(client);
+  }
+  /**
+   * Creates a SKU transaction with gasless execution
+   * @param params - Transaction parameters including amount, SKU ID, wallet, etc.
+   * @param bearerToken - Authentication token for API calls
+   * @returns Promise<SkuTransaction> - The created transaction record
+   */
+  async createSkuTransaction(params, bearerToken) {
+    const { mxnAmount, skuId, wallet, reference, externalUserId } = params;
+    this.client.baseUrl;
+    const usdAmount = await getUsdAmount(mxnAmount, bearerToken, this.client);
+    const tokenAddress = STARKNET_CONTRACTS.USDC.contractAddress;
+    if (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.USDC.decimals);
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "approve",
+        calldata: CallData.compile({
+          spender: SKU_CONTRACTS.RECHARGER_WITH_STRK_MAINNET,
+          amount: cairo.uint256(parsedAmount)
+        })
+      },
+      {
+        contractAddress: SKU_CONTRACTS.RECHARGER_WITH_STRK_MAINNET,
+        entrypoint: "newRecharge",
+        calldata: CallData.compile({
+          token_address: tokenAddress,
+          amount: cairo.uint256(parsedAmount),
+          rechargeId: createHash("sha256").update(randomUUID()).digest("hex").slice(0, 20),
+          productId: skuId,
+          carrierId: CARRIER_IDS.CHIPI_PAY
+        })
+      },
+      {
+        contractAddress: SKU_CONTRACTS.CHIPI_BILL_SERVICE,
+        entrypoint: "mint_item",
+        calldata: CallData.compile({
+          recipient: wallet.publicKey,
+          metadata: {
+            service_type: SERVICE_TYPES.BUY_SERVICE,
+            timestamp: Date.now(),
+            chipi_user_id: hash.starknetKeccak(externalUserId || "0x0").toString(),
+            kyc: true,
+            amount: cairo.uint256(parsedAmount)
+          }
+        })
+      }
+    ];
+    const transactionHash = await this.transactions.executeTransaction({
+      params: {
+        encryptKey: params.encryptKey,
+        wallet,
+        calls
+      },
+      bearerToken
+    });
+    const input = {
+      walletAddress: wallet.publicKey,
+      skuId,
+      chain: CHAIN_TYPES.STARKNET,
+      chainToken: CHAIN_TOKEN_TYPES.USDC,
+      mxnAmount,
+      reference,
+      transactionHash,
+      usdAmount: minUsdAmount
+    };
+    const response = await this.client.post({
+      endpoint: `${API_ENDPOINTS.SKU_TRANSACTIONS}`,
+      bearerToken,
+      body: input
+    });
+    return response;
+  }
+  /**
+   * Get a SKU transaction by transaction id
+   * @param id - The SKU transaction id
+   * @param bearerToken - Authentication token for API calls
+   * @returns Promise<SkuTransaction> - Single SKU transaction
+   */
+  async getSkuTransactionById(id, bearerToken) {
+    const response = await this.client.get({
+      endpoint: `${API_ENDPOINTS.SKU_TRANSACTIONS}/${id}`,
+      bearerToken
+    });
+    return response;
+  }
+};
 var ChipiSkus = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+  * Get available SKUs for purchase with pagination
+  * @param bearerToken - Authentication token for API calls
+  * @param query - Pagination query parameters
+  * @returns Promise<PaginatedResponse<Sku>> - Paginated list of available SKUs
+  */
+  async getSkus(bearerToken, query) {
+    const response = await this.client.get({
+      endpoint: `${API_ENDPOINTS.SKUS}/available`,
+      params: query,
+      bearerToken
+    });
+    return response;
+  }
 };
 
 // src/chipi-sdk.ts
@@ -470,8 +598,10 @@ var ChipiSDK = class {
   constructor(config) {
     this.client = new ChipiClient(config);
     this.nodeUrl = config.nodeUrl || STARKNET_NETWORKS.MAINNET;
+    this.apiSecretKey = config.apiSecretKey;
     this.wallets = new ChipiWallets(this.client);
     this.transactions = new ChipiTransactions(this.client);
+    this.skuTransactions = new ChipiSkuTransactions(this.client);
     this.skus = new ChipiSkus(this.client);
     this.executeTransaction = this.executeTransaction.bind(this);
     this.transfer = this.transfer.bind(this);
@@ -481,12 +611,31 @@ var ChipiSDK = class {
     this.callAnyContract = this.callAnyContract.bind(this);
     this.createWallet = this.createWallet.bind(this);
     this.recordSendTransaction = this.recordSendTransaction.bind(this);
+    this.createSkuTransaction = this.createSkuTransaction.bind(this);
+  }
+  /**
+   * Resolve bearer token - uses provided token or falls back to apiSecretKey
+   */
+  resolveBearerToken(bearerToken) {
+    const token = bearerToken ?? this.apiSecretKey;
+    if (!token) {
+      throw new Error(
+        "Authentication required: either pass a bearerToken or configure the SDK with an apiSecretKey"
+      );
+    }
+    return token;
   }
   /**
    * Execute a gasless transaction
    */
-  async executeTransaction(params) {
-    return this.transactions.executeTransaction(params);
+  async executeTransaction({
+    params,
+    bearerToken
+  }) {
+    return this.transactions.executeTransaction({
+      params,
+      bearerToken: this.resolveBearerToken(bearerToken)
+    });
   }
   /**
    * Transfer tokens
@@ -497,28 +646,30 @@ var ChipiSDK = class {
   }) {
     return this.transactions.transfer({
       params,
-      bearerToken
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
-   * Approve token spending
-   */
+  * Approve token spending
+  */
   async approve({
     params,
     bearerToken
   }) {
     const { encryptKey, wallet, contractAddress, spender, amount, decimals } = params;
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress,
-          entrypoint: "approve",
-          calldata: [spender, formatAmount(amount, decimals), "0x0"]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress,
+            entrypoint: "approve",
+            calldata: [spender, formatAmount(amount, decimals), "0x0"]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -531,25 +682,27 @@ var ChipiSDK = class {
     const { encryptKey, wallet, amount, receiverWallet } = params;
     const formattedAmount = formatAmount(amount, 6);
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress: CONTRACT_ADDRESSES.USDC_MAINNET,
-          entrypoint: "approve",
-          calldata: [
-            CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-            formattedAmount,
-            "0x0"
-          ]
-        },
-        {
-          contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-          entrypoint: "deposit",
-          calldata: [formattedAmount, "0x0", receiverWallet]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress: CONTRACT_ADDRESSES.USDC_MAINNET,
+            entrypoint: "approve",
+            calldata: [
+              CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+              formattedAmount,
+              "0x0"
+            ]
+          },
+          {
+            contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+            entrypoint: "deposit",
+            calldata: [formattedAmount, "0x0", receiverWallet]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -562,16 +715,18 @@ var ChipiSDK = class {
     const { encryptKey, wallet, amount, recipient } = params;
     const formattedAmount = formatAmount(amount, 6);
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-          entrypoint: "withdraw",
-          calldata: [formattedAmount, recipient, "0x0"]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+            entrypoint: "withdraw",
+            calldata: [formattedAmount, recipient, "0x0"]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -583,10 +738,12 @@ var ChipiSDK = class {
   }) {
     const { encryptKey, wallet, calls } = params;
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls
+      params: {
+        encryptKey,
+        wallet,
+        calls
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -598,7 +755,7 @@ var ChipiSDK = class {
   }) {
     return this.wallets.createWallet({
       ...params,
-      bearerToken
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   async recordSendTransaction({
@@ -607,20 +764,52 @@ var ChipiSDK = class {
   }) {
     return this.transactions.recordSendTransaction({
       params,
-      bearerToken
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   async getWallet(params, bearerToken) {
-    return this.wallets.getWallet(params, bearerToken);
+    return this.wallets.getWallet(params, this.resolveBearerToken(bearerToken));
   }
   async getTokenBalance(params, bearerToken) {
     return this.wallets.getTokenBalance({
       params,
-      bearerToken
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
+  /**
+   * Create a SKU transaction
+   */
+  async createSkuTransaction({
+    params,
+    bearerToken
+  }) {
+    return this.skuTransactions.createSkuTransaction(params, bearerToken);
+  }
+};
+
+// src/chipi-server-sdk.ts
+var ChipiServerSDK = class extends ChipiSDK {
+  constructor(config) {
+    if (!config.apiSecretKey) {
+      throw new Error(
+        "apiSecretKey is required for ChipiServerSDK. Use ChipiBrowserSDK for client-side applications."
+      );
+    }
+    super(config);
+  }
+  // All methods are inherited from ChipiSDK
+  // The apiSecretKey from config is automatically used via resolveBearerToken()
+};
+
+// src/chipi-browser-sdk.ts
+var ChipiBrowserSDK = class extends ChipiSDK {
+  constructor(config) {
+    super(config);
+  }
+  // All methods are inherited from ChipiSDK
+  // bearerToken parameter is required for each authenticated request
 };
 
-export { ChipiClient, ChipiSDK, ChipiSkus, ChipiTransactions, ChipiWallets, decryptPrivateKey, encryptPrivateKey };
+export { ChipiBrowserSDK, ChipiClient, ChipiSDK, ChipiServerSDK, ChipiSkuTransactions, ChipiSkus, ChipiTransactions, ChipiWallets, decryptPrivateKey, encryptPrivateKey };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map