@chipi-stack/backend 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { isValidApiKey, ChipiAuthError, validateErrorResponse, ChipiApiError, validateApiResponse, handleApiError, ChipiTransactionError, API_ENDPOINTS, formatAmount, STARKNET_NETWORKS, CONTRACT_ADDRESSES } from '@chipi-stack/shared';
+import { isValidApiKey, ChipiAuthError, validateErrorResponse, ChipiApiError, validateApiResponse, handleApiError, API_ENDPOINTS, ChipiTransactionError, formatAmount, STARKNET_NETWORKS, CONTRACT_ADDRESSES } from '@chipi-stack/shared';
 import { RpcProvider, stark, ec, CairoCustomEnum, CairoOption, CairoOptionVariant, CallData, hash, Account, num } from 'starknet';
 import CryptoJS2 from 'crypto-js';
+import { STARKNET_CONTRACTS } from '@chipi-stack/types';
 
 // src/chipi-sdk.ts
 var ChipiClient = class {
@@ -34,7 +35,11 @@ var ChipiClient = class {
     }
     return headers;
   }
-  async get(endpoint, params, bearerToken) {
+  async get({
+    endpoint,
+    params,
+    bearerToken
+  }) {
     try {
       const url = new URL(`${this.baseUrl}${endpoint}`);
       if (params) {
@@ -65,7 +70,11 @@ var ChipiClient = class {
       throw handleApiError(error);
     }
   }
-  async post(endpoint, body, bearerToken) {
+  async post({
+    endpoint,
+    bearerToken,
+    body
+  }) {
     try {
       const response = await fetch(`${this.baseUrl}${endpoint}`, {
         method: "POST",
@@ -89,7 +98,11 @@ var ChipiClient = class {
       throw handleApiError(error);
     }
   }
-  async put(endpoint, body, bearerToken) {
+  async put({
+    endpoint,
+    bearerToken,
+    body
+  }) {
     try {
       const response = await fetch(`${this.baseUrl}${endpoint}`, {
         method: "PUT",
@@ -113,7 +126,10 @@ var ChipiClient = class {
       throw handleApiError(error);
     }
   }
-  async delete(endpoint, bearerToken) {
+  async delete({
+    endpoint,
+    bearerToken
+  }) {
     try {
       const response = await fetch(`${this.baseUrl}${endpoint}`, {
         method: "DELETE",
@@ -178,7 +194,7 @@ var ChipiWallets = class {
   // }
   async createWallet(params) {
     try {
-      const { encryptKey, apiPublicKey, bearerToken, nodeUrl, backendUrl } = params;
+      const { encryptKey, nodeUrl, externalUserId, bearerToken } = params;
       const provider = new RpcProvider({ nodeUrl });
       const privateKeyAX = stark.randomAddress();
       const starkKeyPubAX = ec.starkCurve.getStarkKey(privateKeyAX);
@@ -198,19 +214,14 @@ var ChipiWallets = class {
         0
       );
       const account = new Account(provider, publicKey, privateKeyAX);
-      console.log("apiPublicKey", apiPublicKey);
-      const typeDataResponse = await fetch(`${backendUrl}/chipi-wallets/prepare-creation`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${bearerToken}`,
-          "x-api-key": apiPublicKey
-        },
-        body: JSON.stringify({
+      const typeDataResponse = await this.client.post({
+        endpoint: `${API_ENDPOINTS.CHIPI_WALLETS}/prepare-creation`,
+        bearerToken,
+        body: {
           publicKey
-        })
+        }
       });
-      const { typeData, accountClassHash: accountClassHashResponse } = await typeDataResponse.json();
+      const { typeData, accountClassHash: accountClassHashResponse } = typeDataResponse.data;
       const userSignature = await account.signMessage(typeData);
       const deploymentData = {
         class_hash: accountClassHashResponse,
@@ -218,16 +229,15 @@ var ChipiWallets = class {
         unique: `${num.toHex(0)}`,
         calldata: AXConstructorCallData.map((value) => num.toHex(value))
       };
-      const encryptedPrivateKey = this.encryptPrivateKey(privateKeyAX, encryptKey);
-      const executeTransactionResponse = await fetch(`${backendUrl}/chipi-wallets`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${bearerToken}`,
-          "x-api-key": apiPublicKey
-        },
-        body: JSON.stringify({
-          apiPublicKey,
+      const encryptedPrivateKey = this.encryptPrivateKey(
+        privateKeyAX,
+        encryptKey
+      );
+      const executeTransactionResponse = await this.client.post({
+        endpoint: `${API_ENDPOINTS.CHIPI_WALLETS}`,
+        bearerToken,
+        body: {
+          externalUserId,
           publicKey,
           userSignature: {
             r: userSignature.r.toString(),
@@ -241,9 +251,9 @@ var ChipiWallets = class {
             salt: `${deploymentData.salt}`,
             calldata: deploymentData.calldata.map((data) => `${data}`)
           }
-        })
+        }
       });
-      const executeTransaction = await executeTransactionResponse.json();
+      const executeTransaction = executeTransactionResponse.data;
       if (executeTransaction.success) {
         return {
           success: true,
@@ -252,21 +262,16 @@ var ChipiWallets = class {
           wallet: executeTransaction.wallet
         };
       } else {
-        return {
-          success: false,
-          txHash: "",
-          walletPublicKey: "",
-          wallet: {
-            publicKey: "",
-            encryptedPrivateKey: ""
-          }
-        };
+        throw new ChipiTransactionError(
+          `Failed to create wallet: ${executeTransaction.message}`,
+          "WALLET_CREATION_FAILED"
+        );
       }
     } catch (error) {
       console.error("Error detallado:", error);
       if (error instanceof Error && error.message.includes("SSL")) {
         throw new Error(
-          "Error de conexi\xF3n SSL. Intenta usando NODE_TLS_REJECT_UNAUTHORIZED=0 o verifica la URL del RPC"
+          "SSL connection error. Try using NODE_TLS_REJECT_UNAUTHORIZED=0 or verify the RPC URL"
         );
       }
       throw new ChipiTransactionError(
@@ -278,37 +283,15 @@ var ChipiWallets = class {
   /**
    * Create a custodial merchant wallet
    */
-  async createCustodialWallet(params, orgId) {
-    const response = await this.client.post(
-      `${API_ENDPOINTS.CHIPI_WALLETS}/merchant`,
-      {
-        ...params,
-        orgId
-      }
-    );
-    return response.data;
-  }
-  /**
-   * Get merchant wallet by API key and chain
-   */
-  async getMerchantWallet(params) {
-    const response = await this.client.get(
-      `${API_ENDPOINTS.CHIPI_WALLETS}/merchant`,
-      {
-        apiKeyId: params.apiKeyId,
-        chain: params.chain
-      }
-    );
-    return response.data;
-  }
-  /**
-   * Get wallets for an organization
-   */
-  async getWallets(query) {
-    const response = await this.client.get(
-      API_ENDPOINTS.CHIPI_WALLETS,
-      query
-    );
+  async createCustodialWallet({
+    params,
+    bearerToken
+  }) {
+    const response = await this.client.post({
+      endpoint: `${API_ENDPOINTS.CHIPI_WALLETS}/custodial`,
+      bearerToken,
+      body: params
+    });
     return response.data;
   }
 };
@@ -424,18 +407,32 @@ var ChipiTransactions = class {
   /**
    * Transfer tokens
    */
-  async transfer(params) {
-    const formattedAmount = formatAmount(params.amount, params.decimals);
+  async transfer({
+    params,
+    bearerToken
+  }) {
+    const { encryptKey, wallet, token, otherToken, recipient, amount } = params;
+    const contract = STARKNET_CONTRACTS[token];
+    let contractAddress = contract.contractAddress;
+    let decimals = contract.decimals;
+    if (token === "OTHER") {
+      if (!otherToken) {
+        throw new Error("Other token is required when token is OTHER");
+      }
+      contractAddress = otherToken.contractAddress;
+      decimals = otherToken.decimals;
+    }
+    const formattedAmount = formatAmount(amount, decimals);
     return this.executeTransaction({
-      encryptKey: params.encryptKey,
-      wallet: params.wallet,
-      bearerToken: params.bearerToken,
+      encryptKey,
+      wallet,
+      bearerToken,
       calls: [
         {
-          contractAddress: params.contractAddress,
+          contractAddress,
           entrypoint: "transfer",
           calldata: [
-            params.recipient,
+            recipient,
             formattedAmount,
             "0x0"
           ]
@@ -476,83 +473,26 @@ var ChipiTransactions = class {
       calls: params.calls
     });
   }
-};
-var ChipiSkus = class {
-  constructor(client) {
-    this.client = client;
-  }
   /**
-   * Find available SKUs
+   * Record a send transaction
    */
-  async findSkus(params = {}) {
-    const response = await this.client.get(
-      API_ENDPOINTS.SKUS,
-      {
-        categories: params.categories
-      }
-    );
-    return response.data;
-  }
-  /**
-   * Get SKU by ID
-   */
-  async getSku(skuId) {
-    const response = await this.client.get(
-      `${API_ENDPOINTS.SKUS}/${skuId}`
-    );
-    return response.data;
-  }
-  /**
-   * Create a SKU transaction
-   */
-  async createSkuTransaction(params) {
-    const response = await this.client.post(
-      API_ENDPOINTS.SKU_TRANSACTIONS,
-      params
-    );
-    return response.data;
-  }
-  /**
-   * Get SKU transaction by ID
-   */
-  async getSkuTransaction(transactionId) {
-    const response = await this.client.get(
-      `${API_ENDPOINTS.SKU_TRANSACTIONS}/${transactionId}`
-    );
-    return response.data;
-  }
-  /**
-   * Get SKU transactions for a wallet
-   */
-  async getSkuTransactionsByWallet(walletAddress, params = {}) {
-    const response = await this.client.get(
-      API_ENDPOINTS.SKU_TRANSACTIONS,
-      {
-        walletAddress,
-        ...params
-      }
-    );
+  async recordSendTransaction({
+    params,
+    bearerToken
+  }) {
+    const response = await this.client.post({
+      endpoint: `${API_ENDPOINTS.TRANSACTIONS}/record-send`,
+      bearerToken,
+      body: params
+    });
     return response.data;
   }
-  /**
-   * Purchase a SKU
-   * This is a convenience method that combines finding a SKU and creating a transaction
-   */
-  async purchaseSku(params) {
-    const sku = await this.getSku(params.skuId);
-    const transaction = await this.createSkuTransaction({
-      walletAddress: params.walletAddress,
-      skuId: params.skuId,
-      chain: params.chain,
-      chainToken: params.chainToken,
-      mxnAmount: params.mxnAmount,
-      reference: params.reference,
-      transactionHash: params.transactionHash
-    });
-    return {
-      sku,
-      transaction
-    };
+};
+
+// src/skus.ts
+var ChipiSkus = class {
+  constructor(client) {
+    this.client = client;
   }
 };
 
@@ -571,6 +511,7 @@ var ChipiSDK = class {
     this.withdrawVesuUsdc = this.withdrawVesuUsdc.bind(this);
     this.callAnyContract = this.callAnyContract.bind(this);
     this.createWallet = this.createWallet.bind(this);
+    this.recordSendTransaction = this.recordSendTransaction.bind(this);
   }
   /**
    * Execute a gasless transaction
@@ -581,31 +522,28 @@ var ChipiSDK = class {
   /**
    * Transfer tokens
    */
-  async transfer(params) {
-    const { encryptKey, wallet, contractAddress, recipient, amount, decimals, bearerToken } = params;
-    const formattedAmount = formatAmount(amount, decimals);
-    return this.executeTransaction({
-      encryptKey,
-      wallet,
-      bearerToken,
-      calls: [
-        {
-          contractAddress,
-          entrypoint: "transfer",
-          calldata: [
-            recipient,
-            formattedAmount,
-            "0x0"
-          ]
-        }
-      ]
+  async transfer({
+    params,
+    bearerToken
+  }) {
+    return this.transactions.transfer({
+      params,
+      bearerToken
     });
   }
   /**
    * Approve token spending
    */
   async approve(params) {
-    const { encryptKey, wallet, contractAddress, spender, amount, decimals, bearerToken } = params;
+    const {
+      encryptKey,
+      wallet,
+      contractAddress,
+      spender,
+      amount,
+      decimals,
+      bearerToken
+    } = params;
     return this.executeTransaction({
       encryptKey,
       wallet,
@@ -614,11 +552,7 @@ var ChipiSDK = class {
         {
           contractAddress,
           entrypoint: "approve",
-          calldata: [
-            spender,
-            formatAmount(amount, decimals),
-            "0x0"
-          ]
+          calldata: [spender, formatAmount(amount, decimals), "0x0"]
         }
       ]
     });
@@ -646,11 +580,7 @@ var ChipiSDK = class {
         {
           contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
           entrypoint: "deposit",
-          calldata: [
-            formattedAmount,
-            "0x0",
-            receiverWallet
-          ]
+          calldata: [formattedAmount, "0x0", receiverWallet]
         }
       ]
     });
@@ -669,11 +599,7 @@ var ChipiSDK = class {
         {
           contractAddress: CONTRACT_ADDRESSES.VESU_USDC_MAINNET,
           entrypoint: "withdraw",
-          calldata: [
-            formattedAmount,
-            recipient,
-            "0x0"
-          ]
+          calldata: [formattedAmount, recipient, "0x0"]
         }
       ]
     });
@@ -693,14 +619,22 @@ var ChipiSDK = class {
   /**
    * Create a new wallet
    */
-  async createWallet(params) {
-    const { encryptKey, bearerToken } = params;
+  async createWallet({
+    params,
+    bearerToken
+  }) {
     return this.wallets.createWallet({
-      encryptKey,
-      apiPublicKey: this.client.getApiPublicKey(),
-      bearerToken,
-      nodeUrl: this.nodeUrl,
-      backendUrl: this.client.baseUrl
+      ...params,
+      bearerToken
+    });
+  }
+  async recordSendTransaction({
+    params,
+    bearerToken
+  }) {
+    return this.transactions.recordSendTransaction({
+      params,
+      bearerToken
     });
   }
 };