@chipi-stack/backend 0.1.0

package/dist/index.js

@@ -0,0 +1,722 @@
+'use strict';
+
+var shared = require('@chipi-stack/shared');
+var starknet = require('starknet');
+var CryptoJS2 = require('crypto-js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var CryptoJS2__default = /*#__PURE__*/_interopDefault(CryptoJS2);
+
+// src/chipi-sdk.ts
+var ChipiClient = class {
+  constructor(config) {
+    if (!shared.isValidApiKey(config.apiPublicKey)) {
+      throw new shared.ChipiAuthError("Invalid API key format");
+    }
+    this.apiPublicKey = config.apiPublicKey;
+    this.environment = config.environment || "production";
+    this.baseUrl = this.getBaseUrl();
+  }
+  /**
+   * Get the API public key (for internal SDK use)
+   */
+  getApiPublicKey() {
+    return this.apiPublicKey;
+  }
+  getBaseUrl() {
+    if (this.environment === "development") {
+      return "http://localhost:3000/v1";
+    }
+    return "https://api.chipipay.com/v1";
+  }
+  getHeaders(bearerToken) {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiPublicKey
+    };
+    if (bearerToken) {
+      headers["Authorization"] = `Bearer ${bearerToken}`;
+    }
+    return headers;
+  }
+  async get(endpoint, params, bearerToken) {
+    try {
+      const url = new URL(`${this.baseUrl}${endpoint}`);
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          if (value !== void 0 && value !== null) {
+            url.searchParams.append(key, String(value));
+          }
+        });
+      }
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: this.getHeaders(bearerToken)
+      });
+      const rawData = await response.json();
+      if (!response.ok) {
+        const errorData = shared.validateErrorResponse(rawData);
+        throw new shared.ChipiApiError(
+          errorData.message,
+          errorData.code || `HTTP_${response.status}`,
+          response.status
+        );
+      }
+      return {
+        success: true,
+        data: shared.validateApiResponse(rawData)
+      };
+    } catch (error) {
+      throw shared.handleApiError(error);
+    }
+  }
+  async post(endpoint, body, bearerToken) {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "POST",
+        headers: this.getHeaders(bearerToken),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const rawData = await response.json();
+      if (!response.ok) {
+        const errorData = shared.validateErrorResponse(rawData);
+        throw new shared.ChipiApiError(
+          errorData.message,
+          errorData.code || `HTTP_${response.status}`,
+          response.status
+        );
+      }
+      return {
+        success: true,
+        data: shared.validateApiResponse(rawData)
+      };
+    } catch (error) {
+      throw shared.handleApiError(error);
+    }
+  }
+  async put(endpoint, body, bearerToken) {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "PUT",
+        headers: this.getHeaders(bearerToken),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const rawData = await response.json();
+      if (!response.ok) {
+        const errorData = shared.validateErrorResponse(rawData);
+        throw new shared.ChipiApiError(
+          errorData.message,
+          errorData.code || `HTTP_${response.status}`,
+          response.status
+        );
+      }
+      return {
+        success: true,
+        data: shared.validateApiResponse(rawData)
+      };
+    } catch (error) {
+      throw shared.handleApiError(error);
+    }
+  }
+  async delete(endpoint, bearerToken) {
+    try {
+      const response = await fetch(`${this.baseUrl}${endpoint}`, {
+        method: "DELETE",
+        headers: this.getHeaders(bearerToken)
+      });
+      const rawData = await response.json();
+      if (!response.ok) {
+        const errorData = shared.validateErrorResponse(rawData);
+        throw new shared.ChipiApiError(
+          errorData.message,
+          errorData.code || `HTTP_${response.status}`,
+          response.status
+        );
+      }
+      return {
+        success: true,
+        data: shared.validateApiResponse(rawData)
+      };
+    } catch (error) {
+      throw shared.handleApiError(error);
+    }
+  }
+};
+var ChipiWallets = class {
+  constructor(client) {
+    this.client = client;
+    this.encryptPrivateKey = (privateKey, password) => {
+      if (!privateKey || !password) {
+        throw new Error("Private key and password are required");
+      }
+      return CryptoJS2__default.default.AES.encrypt(privateKey, password).toString();
+    };
+  }
+  /**
+   * Prepare wallet creation data
+   */
+  // async prepareWalletCreation(
+  //   params: Omit<PrepareWalletCreationParams, 'apiPublicKey'>
+  // ): Promise<PrepareWalletCreationResponse> {
+  //   const response = await this.client.post<PrepareWalletCreationResponse>(
+  //     `${API_ENDPOINTS.CHIPI_WALLETS}/prepare-creation`,
+  //     params
+  //   );
+  //   return response.data!;
+  // }
+  /**
+   * Create a new wallet
+   */
+  // async createWallet(
+  //   params: Omit<CreateWalletParams, 'apiPublicKey' | 'nodeUrl'>,
+  //   nodeUrl?: string
+  // ): Promise<CreateWalletResponse> {
+  //   const response = await this.client.post<CreateWalletResponse>(
+  //     API_ENDPOINTS.CHIPI_WALLETS,
+  //     {
+  //       ...params,
+  //       nodeUrl,
+  //     },
+  //     params.bearerToken
+  //   );
+  //   return response.data!;
+  // }
+  async createWallet(params) {
+    try {
+      const { encryptKey, apiPublicKey, bearerToken, nodeUrl, backendUrl } = params;
+      const provider = new starknet.RpcProvider({ nodeUrl });
+      const privateKeyAX = starknet.stark.randomAddress();
+      const starkKeyPubAX = starknet.ec.starkCurve.getStarkKey(privateKeyAX);
+      const accountClassHash = "0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f";
+      const axSigner = new starknet.CairoCustomEnum({
+        Starknet: { pubkey: starkKeyPubAX }
+      });
+      const axGuardian = new starknet.CairoOption(starknet.CairoOptionVariant.None);
+      const AXConstructorCallData = starknet.CallData.compile({
+        owner: axSigner,
+        guardian: axGuardian
+      });
+      const publicKey = starknet.hash.calculateContractAddressFromHash(
+        starkKeyPubAX,
+        accountClassHash,
+        AXConstructorCallData,
+        0
+      );
+      const account = new starknet.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({
+          publicKey
+        })
+      });
+      const { typeData, accountClassHash: accountClassHashResponse } = await typeDataResponse.json();
+      const userSignature = await account.signMessage(typeData);
+      const deploymentData = {
+        class_hash: accountClassHashResponse,
+        salt: starkKeyPubAX,
+        unique: `${starknet.num.toHex(0)}`,
+        calldata: AXConstructorCallData.map((value) => starknet.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,
+          publicKey,
+          userSignature: {
+            r: userSignature.r.toString(),
+            s: userSignature.s.toString(),
+            recovery: userSignature.recovery
+          },
+          typeData,
+          encryptedPrivateKey,
+          deploymentData: {
+            ...deploymentData,
+            salt: `${deploymentData.salt}`,
+            calldata: deploymentData.calldata.map((data) => `${data}`)
+          }
+        })
+      });
+      const executeTransaction = await executeTransactionResponse.json();
+      if (executeTransaction.success) {
+        return {
+          success: true,
+          txHash: executeTransaction.txHash,
+          walletPublicKey: executeTransaction.walletPublicKey,
+          wallet: executeTransaction.wallet
+        };
+      } else {
+        return {
+          success: false,
+          txHash: "",
+          walletPublicKey: "",
+          wallet: {
+            publicKey: "",
+            encryptedPrivateKey: ""
+          }
+        };
+      }
+    } 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"
+        );
+      }
+      throw new shared.ChipiTransactionError(
+        `Failed to create wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "WALLET_CREATION_FAILED"
+      );
+    }
+  }
+  /**
+   * Create a custodial merchant wallet
+   */
+  async createCustodialWallet(params, orgId) {
+    const response = await this.client.post(
+      `${shared.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(
+      `${shared.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(
+      shared.API_ENDPOINTS.CHIPI_WALLETS,
+      query
+    );
+    return response.data;
+  }
+};
+var encryptPrivateKey = (privateKey, password) => {
+  if (!privateKey || !password) {
+    throw new Error("Private key and password are required");
+  }
+  return CryptoJS2__default.default.AES.encrypt(privateKey, password).toString();
+};
+var decryptPrivateKey = (encryptedPrivateKey, password) => {
+  if (!encryptedPrivateKey || !password) {
+    console.error("Encrypted private key and password are required");
+    return null;
+  }
+  try {
+    const bytes = CryptoJS2__default.default.AES.decrypt(encryptedPrivateKey, password);
+    const decrypted = bytes.toString(CryptoJS2__default.default.enc.Utf8);
+    if (!decrypted) {
+      return null;
+    }
+    return decrypted;
+  } catch (error) {
+    console.error("Decryption failed:", error);
+    return null;
+  }
+};
+
+// src/gasless.ts
+var executePaymasterTransaction = async (params) => {
+  try {
+    const { encryptKey, wallet, calls, apiPublicKey, bearerToken, backendUrl } = params;
+    const privateKeyDecrypted = decryptPrivateKey(
+      wallet.encryptedPrivateKey,
+      encryptKey
+    );
+    if (!privateKeyDecrypted) {
+      throw new Error("Failed to decrypt private key");
+    }
+    const provider = new starknet.RpcProvider({
+      nodeUrl: "https://cloud.argent-api.com/v1/starknet/mainnet/rpc/v0.7"
+    });
+    const account = new starknet.Account(
+      provider,
+      wallet.publicKey,
+      privateKeyDecrypted
+    );
+    const typeDataResponse = await fetch(`${backendUrl}/transactions/prepare-typed-data`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${bearerToken}`,
+        "X-API-Key": apiPublicKey
+      },
+      body: JSON.stringify({
+        publicKey: wallet.publicKey,
+        calls,
+        accountClassHash: "0x036078334509b514626504edc9fb252328d1a240e4e948bef8d0c08dff45927f"
+      })
+    });
+    if (!typeDataResponse.ok) {
+      const errorText = await typeDataResponse.text();
+      throw new Error(`Error en la API: ${errorText}`);
+    }
+    const typeData = await typeDataResponse.json();
+    const userSignature = await account.signMessage(typeData);
+    const executeTransaction = await fetch(`${backendUrl}/transactions/execute-sponsored-transaction`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${bearerToken}`,
+        "X-API-Key": apiPublicKey
+      },
+      body: JSON.stringify({
+        publicKey: wallet.publicKey,
+        typeData,
+        userSignature: {
+          r: userSignature.r.toString(),
+          s: userSignature.s.toString(),
+          recovery: userSignature.recovery
+        }
+      })
+    });
+    if (!executeTransaction.ok) {
+      const errorText = await executeTransaction.text();
+      throw new Error(`Error en la API de ejecuci\xF3n: ${errorText}`);
+    }
+    const result = await executeTransaction.json();
+    if (!result.transactionHash) {
+      throw new Error("La respuesta no contiene el hash de la transacci\xF3n");
+    }
+    return result.transactionHash;
+  } catch (error) {
+    console.error("Error sending transaction with paymaster", error);
+    throw error;
+  }
+};
+
+// src/transactions.ts
+var ChipiTransactions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Execute a gasless transaction using paymaster
+   */
+  async executeTransaction(params) {
+    return executePaymasterTransaction({
+      ...params,
+      apiPublicKey: this.client.getApiPublicKey(),
+      backendUrl: this.client.baseUrl
+    });
+  }
+  /**
+   * Transfer tokens
+   */
+  async transfer(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: "transfer",
+          calldata: [
+            params.recipient,
+            formattedAmount,
+            "0x0"
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Approve token spending
+   */
+  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"
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Call any contract method
+   */
+  async callAnyContract(params) {
+    return this.executeTransaction({
+      encryptKey: params.encryptKey,
+      wallet: params.wallet,
+      bearerToken: params.bearerToken,
+      calls: params.calls
+    });
+  }
+};
+var ChipiSkus = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Find available SKUs
+   */
+  async findSkus(params = {}) {
+    const response = await this.client.get(
+      shared.API_ENDPOINTS.SKUS,
+      {
+        categories: params.categories
+      }
+    );
+    return response.data;
+  }
+  /**
+   * Get SKU by ID
+   */
+  async getSku(skuId) {
+    const response = await this.client.get(
+      `${shared.API_ENDPOINTS.SKUS}/${skuId}`
+    );
+    return response.data;
+  }
+  /**
+   * Create a SKU transaction
+   */
+  async createSkuTransaction(params) {
+    const response = await this.client.post(
+      shared.API_ENDPOINTS.SKU_TRANSACTIONS,
+      params
+    );
+    return response.data;
+  }
+  /**
+   * Get SKU transaction by ID
+   */
+  async getSkuTransaction(transactionId) {
+    const response = await this.client.get(
+      `${shared.API_ENDPOINTS.SKU_TRANSACTIONS}/${transactionId}`
+    );
+    return response.data;
+  }
+  /**
+   * Get SKU transactions for a wallet
+   */
+  async getSkuTransactionsByWallet(walletAddress, params = {}) {
+    const response = await this.client.get(
+      shared.API_ENDPOINTS.SKU_TRANSACTIONS,
+      {
+        walletAddress,
+        ...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/chipi-sdk.ts
+var ChipiSDK = class {
+  constructor(config) {
+    this.client = new ChipiClient(config);
+    this.nodeUrl = config.nodeUrl || shared.STARKNET_NETWORKS.MAINNET;
+    this.wallets = new ChipiWallets(this.client);
+    this.transactions = new ChipiTransactions(this.client);
+    this.skus = new ChipiSkus(this.client);
+    this.executeTransaction = this.executeTransaction.bind(this);
+    this.transfer = this.transfer.bind(this);
+    this.approve = this.approve.bind(this);
+    this.stakeVesuUsdc = this.stakeVesuUsdc.bind(this);
+    this.withdrawVesuUsdc = this.withdrawVesuUsdc.bind(this);
+    this.callAnyContract = this.callAnyContract.bind(this);
+    this.createWallet = this.createWallet.bind(this);
+  }
+  /**
+   * Execute a gasless transaction
+   */
+  async executeTransaction(input) {
+    return this.transactions.executeTransaction(input);
+  }
+  /**
+   * Transfer tokens
+   */
+  async transfer(params) {
+    const { encryptKey, wallet, contractAddress, recipient, amount, decimals, bearerToken } = params;
+    const formattedAmount = shared.formatAmount(amount, decimals);
+    return this.executeTransaction({
+      encryptKey,
+      wallet,
+      bearerToken,
+      calls: [
+        {
+          contractAddress,
+          entrypoint: "transfer",
+          calldata: [
+            recipient,
+            formattedAmount,
+            "0x0"
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Approve token spending
+   */
+  async approve(params) {
+    const { encryptKey, wallet, contractAddress, spender, amount, decimals, bearerToken } = params;
+    return this.executeTransaction({
+      encryptKey,
+      wallet,
+      bearerToken,
+      calls: [
+        {
+          contractAddress,
+          entrypoint: "approve",
+          calldata: [
+            spender,
+            shared.formatAmount(amount, decimals),
+            "0x0"
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Stake USDC in Vesu protocol
+   */
+  async stakeVesuUsdc(params) {
+    const { encryptKey, wallet, amount, receiverWallet, bearerToken } = 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
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Withdraw USDC from Vesu protocol
+   */
+  async withdrawVesuUsdc(params) {
+    const { encryptKey, wallet, amount, recipient, bearerToken } = 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"
+          ]
+        }
+      ]
+    });
+  }
+  /**
+   * Call any contract method
+   */
+  async callAnyContract(params) {
+    const { encryptKey, wallet, calls, bearerToken } = params;
+    return this.executeTransaction({
+      encryptKey,
+      wallet,
+      bearerToken,
+      calls
+    });
+  }
+  /**
+   * Create a new wallet
+   */
+  async createWallet(params) {
+    const { encryptKey, bearerToken } = params;
+    return this.wallets.createWallet({
+      encryptKey,
+      apiPublicKey: this.client.getApiPublicKey(),
+      bearerToken,
+      nodeUrl: this.nodeUrl,
+      backendUrl: this.client.baseUrl
+    });
+  }
+};
+
+exports.ChipiClient = ChipiClient;
+exports.ChipiSDK = ChipiSDK;
+exports.ChipiSkus = ChipiSkus;
+exports.ChipiTransactions = ChipiTransactions;
+exports.ChipiWallets = ChipiWallets;
+exports.decryptPrivateKey = decryptPrivateKey;
+exports.encryptPrivateKey = encryptPrivateKey;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map