@chipi-stack/backend 11.5.0 → 11.7.0

package/dist/index.js

@@ -4,6 +4,7 @@ var shared = require('@chipi-stack/shared');
 var CryptoES = require('crypto-es');
 var starknet = require('starknet');
 var types = require('@chipi-stack/types');
+var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -297,9 +298,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
@@ -380,9 +386,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()
     });
@@ -407,16 +417,18 @@ var ChipiTransactions = class {
     }
     const formattedAmount = shared.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
     });
   }
   /**
@@ -425,27 +437,36 @@ var ChipiTransactions = class {
   async approve(params) {
     const formattedAmount = shared.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
     });
   }
   /**
@@ -463,12 +484,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 shared.getUsdAmount(mxnAmount, bearerToken, this.client);
+    const tokenAddress = types.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 = shared.formatAmount(minUsdAmount.toString(), types.STARKNET_CONTRACTS.USDC.decimals);
+    const calls = [
+      {
+        contractAddress: tokenAddress,
+        entrypoint: "approve",
+        calldata: starknet.CallData.compile({
+          spender: shared.SKU_CONTRACTS.RECHARGER_WITH_STRK_MAINNET,
+          amount: starknet.cairo.uint256(parsedAmount)
+        })
+      },
+      {
+        contractAddress: shared.SKU_CONTRACTS.RECHARGER_WITH_STRK_MAINNET,
+        entrypoint: "newRecharge",
+        calldata: starknet.CallData.compile({
+          token_address: tokenAddress,
+          amount: starknet.cairo.uint256(parsedAmount),
+          rechargeId: crypto.createHash("sha256").update(crypto.randomUUID()).digest("hex").slice(0, 20),
+          productId: skuId,
+          carrierId: shared.CARRIER_IDS.CHIPI_PAY
+        })
+      },
+      {
+        contractAddress: shared.SKU_CONTRACTS.CHIPI_BILL_SERVICE,
+        entrypoint: "mint_item",
+        calldata: starknet.CallData.compile({
+          recipient: wallet.publicKey,
+          metadata: {
+            service_type: shared.SERVICE_TYPES.BUY_SERVICE,
+            timestamp: Date.now(),
+            chipi_user_id: starknet.hash.starknetKeccak(externalUserId || "0x0").toString(),
+            kyc: true,
+            amount: starknet.cairo.uint256(parsedAmount)
+          }
+        })
+      }
+    ];
+    const transactionHash = await this.transactions.executeTransaction({
+      params: {
+        encryptKey: params.encryptKey,
+        wallet,
+        calls
+      },
+      bearerToken
+    });
+    const input = {
+      walletAddress: wallet.publicKey,
+      skuId,
+      chain: shared.CHAIN_TYPES.STARKNET,
+      chainToken: shared.CHAIN_TOKEN_TYPES.USDC,
+      mxnAmount,
+      reference,
+      transactionHash,
+      usdAmount: minUsdAmount
+    };
+    const response = await this.client.post({
+      endpoint: `${shared.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: `${shared.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: `${shared.API_ENDPOINTS.SKUS}/available`,
+      params: query,
+      bearerToken
+    });
+    return response;
+  }
 };
 
 // src/chipi-sdk.ts
@@ -476,8 +604,10 @@ var ChipiSDK = class {
   constructor(config) {
     this.client = new ChipiClient(config);
     this.nodeUrl = config.nodeUrl || shared.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);
@@ -487,12 +617,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
@@ -503,28 +652,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, shared.formatAmount(amount, decimals), "0x0"]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress,
+            entrypoint: "approve",
+            calldata: [spender, shared.formatAmount(amount, decimals), "0x0"]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -537,25 +688,27 @@ var ChipiSDK = class {
     const { encryptKey, wallet, amount, receiverWallet } = params;
     const formattedAmount = shared.formatAmount(amount, 6);
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress: shared.CONTRACT_ADDRESSES.USDC_MAINNET,
-          entrypoint: "approve",
-          calldata: [
-            shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-            formattedAmount,
-            "0x0"
-          ]
-        },
-        {
-          contractAddress: shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-          entrypoint: "deposit",
-          calldata: [formattedAmount, "0x0", receiverWallet]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress: shared.CONTRACT_ADDRESSES.USDC_MAINNET,
+            entrypoint: "approve",
+            calldata: [
+              shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+              formattedAmount,
+              "0x0"
+            ]
+          },
+          {
+            contractAddress: shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+            entrypoint: "deposit",
+            calldata: [formattedAmount, "0x0", receiverWallet]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -568,16 +721,18 @@ var ChipiSDK = class {
     const { encryptKey, wallet, amount, recipient } = params;
     const formattedAmount = shared.formatAmount(amount, 6);
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress: shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
-          entrypoint: "withdraw",
-          calldata: [formattedAmount, recipient, "0x0"]
-        }
-      ]
+      params: {
+        encryptKey,
+        wallet,
+        calls: [
+          {
+            contractAddress: shared.CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
+            entrypoint: "withdraw",
+            calldata: [formattedAmount, recipient, "0x0"]
+          }
+        ]
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -589,10 +744,12 @@ var ChipiSDK = class {
   }) {
     const { encryptKey, wallet, calls } = params;
     return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls
+      params: {
+        encryptKey,
+        wallet,
+        calls
+      },
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   /**
@@ -604,7 +761,7 @@ var ChipiSDK = class {
   }) {
     return this.wallets.createWallet({
       ...params,
-      bearerToken
+      bearerToken: this.resolveBearerToken(bearerToken)
     });
   }
   async recordSendTransaction({
@@ -613,22 +770,57 @@ 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
 };
 
+exports.ChipiBrowserSDK = ChipiBrowserSDK;
 exports.ChipiClient = ChipiClient;
 exports.ChipiSDK = ChipiSDK;
+exports.ChipiServerSDK = ChipiServerSDK;
+exports.ChipiSkuTransactions = ChipiSkuTransactions;
 exports.ChipiSkus = ChipiSkus;
 exports.ChipiTransactions = ChipiTransactions;
 exports.ChipiWallets = ChipiWallets;