anymal-protocol 1.0.118 → 1.0.119

package/dist/index.js

@@ -24,6 +24,8 @@ __export(index_exports, {
   ActionSourceType: () => ActionSourceType,
   ActionStatus: () => ActionStatus,
   ActionType: () => ActionType,
+  FIREBASE_WEB_API_KEYS: () => FIREBASE_WEB_API_KEYS,
+  FIREBASE_WEB_AUTH_API_ENDPOINTS: () => FIREBASE_WEB_AUTH_API_ENDPOINTS,
   MarketplacePaymentType: () => MarketplacePaymentType,
   NETWORK_HOSTS: () => NETWORK_HOSTS,
   Network: () => Network,
@@ -31,12 +33,20 @@ __export(index_exports, {
   convertToActionRecord: () => convertToActionRecord,
   convertToMultipleActionDefinitions: () => convertToMultipleActionDefinitions,
   convertToMultipleActionRecords: () => convertToMultipleActionRecords,
+  createApp: () => createApp,
   createAuthEnvelope: () => createAuthEnvelope,
   fetchAnymals: () => fetchAnymals,
+  flattenFirestoreData: () => flattenFirestoreData,
   generateAppSignature: () => generateAppSignature,
   generateBytes32Nonce: () => generateBytes32Nonce,
   generateJWT: () => generateJWT,
+  getFirebaseTokenForApp: () => getFirebaseTokenForApp,
   loadExistingSecp256k1PrivateKey: () => loadExistingSecp256k1PrivateKey,
+  processDirectKibbleApproval: () => processDirectKibbleApproval,
+  processDirectPartialPayment: () => processDirectPartialPayment,
+  processOrgKibbleApproval: () => processOrgKibbleApproval,
+  processOrgPartialPayment: () => processOrgPartialPayment,
+  sendUserOpWithRetries: () => sendUserOpWithRetries,
   serializePublicKeyCompressed: () => serializePublicKeyCompressed,
   submitAction: () => submitAction,
   useAddAnymalToDatabase: () => useAddAnymalToDatabase,
@@ -68,7 +78,9 @@ __export(index_exports, {
   useUpdateUserPid: () => useUpdateUserPid,
   useUploadAnymalImage: () => useUploadAnymalImage,
   useVerifyAccount: () => useVerifyAccount,
-  useVerifyWeb3AuthSession: () => useVerifyWeb3AuthSession
+  useVerifyWeb3AuthSession: () => useVerifyWeb3AuthSession,
+  waitForAllowance: () => waitForAllowance,
+  waitForReceiptWithRetries: () => waitForReceiptWithRetries
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -1274,35 +1286,36 @@ async function applyBundlerGasEstimator(account, bundlerClient, options) {
     verificationGasMultiplier = 1.2,
     preVerificationGasMultiplier = 2,
     maxCallGasPercentOfBlock = 0.1,
-    // 10% for now?
     debug = true
   } = options || {};
   const publicClient = bundlerClient.client;
   const blockGasLimit = (await publicClient.getBlock()).gasLimit;
   const dynamicCallGasCap = blockGasLimit * BigInt(Math.floor(maxCallGasPercentOfBlock * 100)) / 100n;
   account.userOperation = {
+    ...account.userOperation,
     estimateGas: async (userOp) => {
-      const estimate = await bundlerClient.estimateUserOperationGas(userOp);
-      const paddedCallGasLimit = estimate.callGasLimit * BigInt(Math.ceil(callGasMultiplier * 100)) / 100n;
-      const cappedCallGasLimit = paddedCallGasLimit > dynamicCallGasCap ? dynamicCallGasCap : paddedCallGasLimit;
-      const paddedVerificationGasLimit = estimate.verificationGasLimit * BigInt(Math.ceil(verificationGasMultiplier * 100)) / 100n;
-      const paddedPreVerificationGas = estimate.preVerificationGas * BigInt(Math.ceil(preVerificationGasMultiplier * 100)) / 100n;
-      if (debug) {
-        console.log("\u{1F4E6} Bundler Gas Estimates:");
-        console.log("  blockGasLimit:", blockGasLimit.toString());
-        console.log("  maxCallGasLimit (% cap):", dynamicCallGasCap.toString());
-        console.log("  original callGasLimit:", estimate.callGasLimit.toString());
-        console.log("  padded callGasLimit:", paddedCallGasLimit.toString());
-        console.log("  capped callGasLimit:", cappedCallGasLimit.toString());
-        console.log("  verificationGasLimit:", paddedVerificationGasLimit.toString());
-        console.log("  preVerificationGas:", paddedPreVerificationGas.toString());
+      try {
+        const estimate = await bundlerClient.estimateUserOperationGas(userOp);
+        const paddedCallGasLimit = estimate.callGasLimit * BigInt(Math.ceil(callGasMultiplier * 100)) / 100n;
+        const cappedCallGasLimit = paddedCallGasLimit > dynamicCallGasCap ? dynamicCallGasCap : paddedCallGasLimit;
+        const paddedVerificationGasLimit = estimate.verificationGasLimit * BigInt(Math.ceil(verificationGasMultiplier * 100)) / 100n;
+        const paddedPreVerificationGas = estimate.preVerificationGas * BigInt(Math.ceil(preVerificationGasMultiplier * 100)) / 100n;
+        if (debug) {
+          console.log("\u2705 Gas Estimation Success:");
+          console.log("  callGasLimit (capped):", cappedCallGasLimit.toString());
+          console.log("  verificationGasLimit:", paddedVerificationGasLimit.toString());
+          console.log("  preVerificationGas:", paddedPreVerificationGas.toString());
+        }
+        return {
+          ...estimate,
+          callGasLimit: cappedCallGasLimit,
+          verificationGasLimit: paddedVerificationGasLimit,
+          preVerificationGas: paddedPreVerificationGas
+        };
+      } catch (error) {
+        console.error("\u274C Gas estimation failed!", error);
+        throw error;
       }
-      return {
-        ...estimate,
-        callGasLimit: cappedCallGasLimit,
-        verificationGasLimit: paddedVerificationGasLimit,
-        preVerificationGas: paddedPreVerificationGas
-      };
     }
   };
 }
@@ -1722,8 +1735,104 @@ function useFetchAnymals() {
 }
 
 // src/utils/marketplace/useProcessPartialKibblePayment.ts
-var import_viem2 = require("viem");
 var import_react17 = require("react");
+
+// src/helpers/ProcessDirectPartialPayment.tsx
+var import_viem2 = require("viem");
+
+// src/helpers/SendUserOpWithRetries.tsx
+async function sendUserOpWithRetries(bundlerClient, params, retries = 3, delay = 1e3) {
+  let attempt = 0;
+  let lastError;
+  while (attempt < retries) {
+    try {
+      return await bundlerClient.sendUserOperation(params);
+    } catch (err) {
+      lastError = err;
+      console.warn(`\u{1F6D1} sendUserOperation failed (attempt ${attempt + 1}):`, err);
+      attempt++;
+      if (attempt < retries) await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw new Error(`sendUserOperation failed after ${retries} attempts: ${lastError}`);
+}
+
+// src/helpers/WaitForReceiptWithRetries.tsx
+async function waitForReceiptWithRetries(bundlerClient, hash, retries = 3, delay = 2e3) {
+  let attempt = 0;
+  let lastError;
+  while (attempt < retries) {
+    try {
+      const receipt = await bundlerClient.waitForUserOperationReceipt(
+        {
+          hash,
+          timeout: 3e4,
+          retryCount: 10
+        }
+      );
+      if (!receipt.success) {
+        throw new Error(`UserOperation reverted: ${receipt.reason || "unknown"}`);
+      }
+      return receipt;
+    } catch (err) {
+      lastError = err;
+      console.warn(`\u{1F6D1} waitForUserOperationReceipt failed (attempt ${attempt + 1}):`, err);
+      attempt++;
+      if (attempt < retries) await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw new Error(`waitForUserOperationReceipt failed after ${retries} attempts: ${lastError}`);
+}
+
+// src/helpers/ProcessDirectPartialPayment.tsx
+async function processDirectPartialPayment(marketplaceContract, smartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) {
+  try {
+    const publicClient = bundlerClient.client;
+    const allowance = await publicClient.readContract({
+      abi: import_viem2.erc20Abi,
+      address: marketplaceContract,
+      functionName: "allowance",
+      args: [smartAccount.address, marketplaceContract]
+    });
+    if (allowance < amountInTokens) {
+      return { success: false, message: "Insufficient allowance for direct partial payment." };
+    }
+    const partialPayCalldata = (0, import_viem2.encodeFunctionData)({
+      abi: MARKETPLACE_ABI,
+      functionName: "partialPay",
+      args: [
+        orderId,
+        anymalNftId,
+        pid,
+        amountInTokens,
+        maxTokenPayment,
+        nonce,
+        deadline,
+        backendSignature
+      ]
+    });
+    await applyBundlerGasEstimator(smartAccount, bundlerClient);
+    const userOpHash = await sendUserOpWithRetries(bundlerClient, {
+      account: smartAccount,
+      calls: [{ to: marketplaceContract, data: partialPayCalldata }],
+      paymaster: true
+    });
+    await waitForReceiptWithRetries(bundlerClient, userOpHash);
+    return {
+      success: true,
+      message: "Direct partial payment UserOperation executed successfully.",
+      opHash: userOpHash
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+    return {
+      success: false,
+      message: `Error during direct payment processing: ${errorMessage}`
+    };
+  }
+}
+
+// src/utils/marketplace/useProcessPartialKibblePayment.ts
 function useProcessPartialKibblePayment() {
   return (0, import_react17.useCallback)(
     async (pid, nftId, orderId, dbAuthToken, marketplaceContract, smartAccount, bundlerClient, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
@@ -1751,31 +1860,25 @@ function useProcessPartialKibblePayment() {
           backendSignature
           // bytes
         ];
-        console.info({ args });
-        const callData = (0, import_viem2.encodeFunctionData)({
-          abi: MARKETPLACE_ABI,
-          functionName: "partialPay",
-          args
-        });
-        await applyBundlerGasEstimator(smartAccount, bundlerClient);
-        const userOpHash = await bundlerClient.sendUserOperation({
-          account: smartAccount,
-          calls: [
-            {
-              to: marketplaceContract,
-              data: callData
-            }
-          ],
-          paymaster: true
-        });
-        const receipt = await bundlerClient.waitForUserOperationReceipt({
-          hash: userOpHash,
-          timeout: 3e4,
-          retryCount: 10
-        });
-        return { success: true, message: receipt.userOpHash };
+        const result = await processDirectPartialPayment(
+          marketplaceContract,
+          smartAccount,
+          bundlerClient,
+          orderId,
+          nftId,
+          pid,
+          amountInTokens,
+          maxTokenPayment,
+          nonce,
+          deadline,
+          backendSignature
+        );
+        return {
+          success: result.success,
+          message: result.message
+        };
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
+        const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
         return {
           success: false,
           message: `Error processing payment: ${errorMessage}`
@@ -1787,41 +1890,53 @@ function useProcessPartialKibblePayment() {
 }
 
 // src/utils/marketplace/useApproveKibbleToken.ts
-var import_viem3 = require("viem");
 var import_react18 = require("react");
+
+// src/helpers/ProcessDirectKibbleApproval.tsx
+var import_viem3 = require("viem");
+async function processDirectKibbleApproval(kibbleTokenAddress, spenderAddress, smartAccount, bundlerClient, approveAmount) {
+  try {
+    const approveCalldata = (0, import_viem3.encodeFunctionData)({
+      abi: import_viem3.erc20Abi,
+      functionName: "approve",
+      args: [spenderAddress, approveAmount]
+    });
+    await applyBundlerGasEstimator(smartAccount, bundlerClient);
+    const userOpHash = await sendUserOpWithRetries(bundlerClient, {
+      account: smartAccount,
+      calls: [{ to: kibbleTokenAddress, data: approveCalldata }],
+      paymaster: true
+    });
+    await waitForReceiptWithRetries(bundlerClient, userOpHash);
+    return {
+      success: true,
+      message: "Direct approval UserOperation executed successfully.",
+      opHash: userOpHash
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+    return {
+      success: false,
+      message: `Error during direct approval processing: ${errorMessage}`
+    };
+  }
+}
+
+// src/utils/marketplace/useApproveKibbleToken.ts
 function useApproveKibbleToken() {
   return (0, import_react18.useCallback)(
     async (kibbleTokenAddress, marketplaceContract, amount, smartAccount, bundlerClient) => {
       try {
-        const callData = (0, import_viem3.encodeFunctionData)({
-          abi: import_viem3.erc20Abi,
-          functionName: "approve",
-          args: [
-            marketplaceContract,
-            // spender address
-            BigInt(amount)
-            // amount to approve
-          ]
-        });
-        await applyBundlerGasEstimator(smartAccount, bundlerClient);
-        const userOpHash = await bundlerClient.sendUserOperation({
-          account: smartAccount,
-          calls: [
-            {
-              to: kibbleTokenAddress,
-              data: callData
-            }
-          ],
-          paymaster: true
-        });
-        await bundlerClient.waitForUserOperationReceipt({
-          hash: userOpHash,
-          timeout: 3e4,
-          retryCount: 10
-        });
+        const result = await processDirectKibbleApproval(
+          kibbleTokenAddress,
+          marketplaceContract,
+          smartAccount,
+          bundlerClient,
+          amount
+        );
         return {
-          success: true,
-          message: "Approval transaction completed successfully."
+          success: result.success,
+          message: result.message
         };
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
@@ -1926,7 +2041,92 @@ function useCreateOrganizationBase() {
 
 // src/utils/organization/useApproveOrgKibbleToken.ts
 var import_react20 = require("react");
+
+// src/helpers/ProcessOrgKibbleApproval.tsx
+var import_viem6 = require("viem");
+
+// src/helpers/WaitForAllowance.tsx
 var import_viem5 = require("viem");
+async function waitForAllowance(publicClient, tokenAddress, ownerAddress, spenderAddress, expectedAmount) {
+  const MAX_RETRIES = 10;
+  const RETRY_INTERVAL = 2e3;
+  console.log(` MDEBUG: Polling for allowance of ${expectedAmount} for spender ${spenderAddress}...`);
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      const currentAllowance = await publicClient.readContract({
+        address: tokenAddress,
+        abi: import_viem5.erc20Abi,
+        functionName: "allowance",
+        args: [ownerAddress, spenderAddress]
+      });
+      console.log(` MDEBUG: (Attempt ${i + 1}) Current allowance is ${currentAllowance.toString()}`);
+      if (currentAllowance >= expectedAmount) {
+        console.log(` MDEBUG: \u2705 Allowance confirmed on-chain. ${currentAllowance}`);
+        return true;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred waiting for allowance.";
+      console.log(` MDEBUG: Error polling for allowance: ${errorMessage}`);
+    }
+    await new Promise((res) => setTimeout(res, RETRY_INTERVAL));
+  }
+  console.log(" MDEBUG: \u274C Timed out waiting for allowance confirmation.");
+  return false;
+}
+
+// src/helpers/ProcessOrgKibbleApproval.tsx
+async function processOrgKibbleApproval(orgContractAddress, kibbleTokenAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, approveAmount) {
+  try {
+    if (approveAmount <= 0n) {
+      return { success: false, message: "Approval amount must be greater than zero." };
+    }
+    const approveCalldata = (0, import_viem6.encodeFunctionData)({
+      abi: import_viem6.erc20Abi,
+      functionName: "approve",
+      args: [partialPaymentModuleAddress, approveAmount]
+    });
+    const executeApproveCalldata = (0, import_viem6.encodeFunctionData)({
+      abi: ORGANIZATION_IMPL_ABI,
+      functionName: "executeCall",
+      args: [kibbleTokenAddress, approveCalldata]
+    });
+    await applyBundlerGasEstimator(managerSmartAccount, bundlerClient);
+    const userOpApproveHash = await sendUserOpWithRetries(bundlerClient, {
+      account: managerSmartAccount,
+      calls: [{ to: orgContractAddress, data: executeApproveCalldata }],
+      paymaster: true
+    });
+    await waitForReceiptWithRetries(bundlerClient, userOpApproveHash);
+    const publicClient = bundlerClient.client;
+    const allowanceConfirmed = await waitForAllowance(
+      publicClient,
+      kibbleTokenAddress,
+      orgContractAddress,
+      partialPaymentModuleAddress,
+      approveAmount
+    );
+    if (!allowanceConfirmed) {
+      console.error("\u274C Halting iteration because on-chain allowance could not be confirmed.");
+      return {
+        success: false,
+        message: `Error waiting for allowance`
+      };
+    }
+    return {
+      success: true,
+      message: "Approval UserOperation executed successfully.",
+      opHash: userOpApproveHash
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+    return {
+      success: false,
+      message: `Error during approval processing: ${errorMessage}`
+    };
+  }
+}
+
+// src/utils/organization/useApproveOrgKibbleToken.ts
 function useApproveOrgPartialPayment() {
   return (0, import_react20.useCallback)(
     async (orgContractAddress, kibbleTokenAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, approveAmount) => {
@@ -1937,37 +2137,22 @@ function useApproveOrgPartialPayment() {
         };
       }
       try {
-        const approveCalldata = (0, import_viem5.encodeFunctionData)({
-          abi: import_viem5.erc20Abi,
-          functionName: "approve",
-          args: [partialPaymentModuleAddress, approveAmount]
-        });
-        const executeApproveCalldata = (0, import_viem5.encodeFunctionData)({
-          abi: ORGANIZATION_IMPL_ABI,
-          functionName: "executeCall",
-          args: [kibbleTokenAddress, approveCalldata]
-        });
-        await applyBundlerGasEstimator(managerSmartAccount, bundlerClient);
-        const userOpApproveHash = await bundlerClient.sendUserOperation({
-          account: managerSmartAccount,
-          calls: [
-            {
-              to: orgContractAddress,
-              data: executeApproveCalldata
-            }
-          ],
-          paymaster: true
-        });
-        await bundlerClient.waitForUserOperationReceipt({
-          hash: userOpApproveHash
-        });
-        return { success: true, message: "Approval processed successfully." };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred.";
+        const result = await processOrgKibbleApproval(
+          orgContractAddress,
+          kibbleTokenAddress,
+          partialPaymentModuleAddress,
+          managerSmartAccount,
+          bundlerClient,
+          approveAmount
+        );
         return {
-          success: false,
-          message: `Error processing approval: ${errorMessage}`
+          success: result.success,
+          message: result.message
         };
+      } catch (error) {
+        console.error(" MDEBUG: Uncaught error in `useApproveOrgPartialPayment` hook:", error);
+        const message = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+        return { success: false, message: `Approval failed: ${message}` };
       }
     },
     []
@@ -1976,7 +2161,52 @@ function useApproveOrgPartialPayment() {
 
 // src/utils/organization/useProcessOrgPartialKibblePayment.ts
 var import_react21 = require("react");
-var import_viem6 = require("viem");
+
+// src/helpers/ProcessOrgPartialPayment.tsx
+var import_viem7 = require("viem");
+async function processOrgPartialPayment(orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) {
+  try {
+    const partialPayCalldata = (0, import_viem7.encodeFunctionData)({
+      abi: MARKETPLACE_ABI,
+      functionName: "partialPay",
+      args: [
+        orderId,
+        anymalNftId,
+        pid,
+        amountInTokens,
+        maxTokenPayment,
+        nonce,
+        deadline,
+        backendSignature
+      ]
+    });
+    const executePartialPayCalldata = (0, import_viem7.encodeFunctionData)({
+      abi: ORGANIZATION_IMPL_ABI,
+      functionName: "executeCall",
+      args: [partialPaymentModuleAddress, partialPayCalldata]
+    });
+    await applyBundlerGasEstimator(managerSmartAccount, bundlerClient);
+    const userOpHash = await sendUserOpWithRetries(bundlerClient, {
+      account: managerSmartAccount,
+      calls: [{ to: orgContractAddress, data: executePartialPayCalldata }],
+      paymaster: true
+    });
+    await waitForReceiptWithRetries(bundlerClient, userOpHash);
+    return {
+      success: true,
+      message: "Partial payment UserOperation executed successfully.",
+      opHash: userOpHash
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+    return {
+      success: false,
+      message: `Error during payment processing: ${errorMessage}`
+    };
+  }
+}
+
+// src/utils/organization/useProcessOrgPartialKibblePayment.ts
 function useProcessOrgPartialKibblePayment() {
   return (0, import_react21.useCallback)(
     async (orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
@@ -1987,46 +2217,28 @@ function useProcessOrgPartialKibblePayment() {
         };
       }
       try {
-        const partialPayCalldata = (0, import_viem6.encodeFunctionData)({
-          abi: MARKETPLACE_ABI,
-          functionName: "partialPay",
-          args: [
-            orderId,
-            anymalNftId,
-            pid,
-            amountInTokens,
-            maxTokenPayment,
-            nonce,
-            deadline,
-            backendSignature
-          ]
-        });
-        const executePartialPayCalldata = (0, import_viem6.encodeFunctionData)({
-          abi: ORGANIZATION_IMPL_ABI,
-          functionName: "executeCall",
-          args: [partialPaymentModuleAddress, partialPayCalldata]
-        });
-        await applyBundlerGasEstimator(managerSmartAccount, bundlerClient);
-        const userOpPartialPayHash = await bundlerClient.sendUserOperation({
-          account: managerSmartAccount,
-          calls: [
-            {
-              to: orgContractAddress,
-              data: executePartialPayCalldata
-            }
-          ],
-          paymaster: true
-        });
-        const receipt = await bundlerClient.waitForUserOperationReceipt({
-          hash: userOpPartialPayHash
-        });
-        return { success: true, message: receipt.userOpHash };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "An unknown error occurred.";
+        const result = await processOrgPartialPayment(
+          orgContractAddress,
+          partialPaymentModuleAddress,
+          managerSmartAccount,
+          bundlerClient,
+          orderId,
+          anymalNftId,
+          pid,
+          amountInTokens,
+          maxTokenPayment,
+          nonce,
+          deadline,
+          backendSignature
+        );
         return {
-          success: false,
-          message: `Error processing partial payment: ${errorMessage}`
+          success: result.success,
+          message: result.message
         };
+      } catch (error) {
+        console.error(" MDEBUG: Uncaught error in `useProcessOrgPartialKibblePayment`:", error);
+        const errorMessage = error instanceof Error ? error.cause?.message || error.message : "An unknown error occurred.";
+        return { success: false, message: `Partial payment failed: ${errorMessage}` };
       }
     },
     []
@@ -2076,10 +2288,10 @@ function useUpdateOrgWalletAddress() {
 
 // src/helpers/NonceHelper.tsx
 var import_uuid = require("uuid");
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 var generateBytes32Nonce = () => {
   const uuid3 = (0, import_uuid.v4)().replace(/-/g, "");
-  return (0, import_viem7.padHex)(`0x${uuid3}`, { size: 32 });
+  return (0, import_viem8.padHex)(`0x${uuid3}`, { size: 32 });
 };
 
 // src/helpers/CryptoUtils.tsx
@@ -2098,6 +2310,14 @@ var AUTH_API_ENDPOINTS = {
   ["testnet" /* Testnet */]: "https://dev-auth-api.petastic.com",
   ["localnet" /* Localnet */]: "http://localhost:3005"
 };
+var FIREBASE_WEB_API_KEYS = {
+  ["testnet" /* Testnet */]: "AIzaSyC7Q-uzAzNSx6-cj_-LyNkFCWzB6RsmYzI",
+  ["localnet" /* Localnet */]: "AIzaSyC7Q-uzAzNSx6-cj_-LyNkFCWzB6RsmYzI"
+};
+var FIREBASE_WEB_AUTH_API_ENDPOINTS = {
+  ["testnet" /* Testnet */]: "https://identitytoolkit.googleapis.com/v1/accounts",
+  ["localnet" /* Localnet */]: "http://localhost:9099/identitytoolkit.googleapis.com/v1/accounts"
+};
 function loadExistingSecp256k1PrivateKey(hexKey) {
   if (!hexKey) {
     throw new Error("Private key hex must be provided");
@@ -2162,6 +2382,101 @@ async function generateAppSignature(privateKeyHex, clientId, redirectUri, state)
   return Buffer.from(signatureDER).toString("hex");
 }
 
+// src/helpers/AppHelpers.tsx
+async function createApp(privateKeyHex, name, metadataURI, ownerEmail, network = "testnet" /* Testnet */, options) {
+  const { publicKey, token } = await createAuthEnvelope(
+    privateKeyHex,
+    network,
+    options
+  );
+  const host = AUTH_API_ENDPOINTS[network];
+  if (!host) {
+    throw new Error(`Unsupported network: ${network}`);
+  }
+  const url = `${host}/create-app`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      name,
+      publicKey,
+      metadataURI,
+      ownerEmail
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Error creating app (${response.status}): ${text}`);
+  }
+  return response.json();
+}
+async function getFirebaseTokenForApp(privateKeyHex, appId, network = "testnet" /* Testnet */) {
+  const { token } = await createAuthEnvelope(privateKeyHex, network);
+  const host = AUTH_API_ENDPOINTS[network];
+  if (!host) {
+    throw new Error(`Unsupported network: ${network}`);
+  }
+  const response = await fetch(`${host}/exchange-jwt-for-app-token`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({
+      appId
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to get Firebase token: ${response.status} ${text}`);
+  }
+  const { firebaseToken: customToken } = await response.json();
+  const firebaseApiKey = FIREBASE_WEB_API_KEYS[network];
+  if (!firebaseApiKey) {
+    throw new Error("FIREBASE_WEB_API_KEY is not set");
+  }
+  const fbAuthEndpoint = FIREBASE_WEB_AUTH_API_ENDPOINTS[network];
+  const firebaseResponse = await fetch(
+    `${fbAuthEndpoint}:signInWithCustomToken?key=${firebaseApiKey}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        token: customToken,
+        returnSecureToken: true
+      })
+    }
+  );
+  if (!firebaseResponse.ok) {
+    const text = await firebaseResponse.text();
+    throw new Error(`Firebase token exchange failed: ${firebaseResponse.status} ${text}`);
+  }
+  const { idToken } = await firebaseResponse.json();
+  return { firebaseToken: idToken };
+}
+function flattenFirestoreData(fields) {
+  const parseValue = (val) => {
+    if (val === null || typeof val !== "object") return val;
+    if ("stringValue" in val) return val.stringValue;
+    if ("integerValue" in val) return parseInt(val.integerValue, 10);
+    if ("doubleValue" in val) return parseFloat(val.doubleValue);
+    if ("booleanValue" in val) return val.booleanValue;
+    if ("timestampValue" in val) return val.timestampValue;
+    if ("nullValue" in val) return null;
+    if ("mapValue" in val) return flattenFirestoreData(val.mapValue.fields || {});
+    if ("arrayValue" in val)
+      return (val.arrayValue.values || []).map(parseValue);
+    return val;
+  };
+  return Object.fromEntries(
+    Object.entries(fields).map(([key, value]) => [key, parseValue(value)])
+  );
+}
+
 // src/helpers/ActionHelpers.tsx
 async function submitAction(idToken, pid, sourceType, payload, endpointBaseUrl) {
   const api = endpointBaseUrl + "/actions";
@@ -2432,16 +2747,16 @@ function useCreateOrganizationAppData() {
 
 // src/utils/balance/useFetchBalance.ts
 var import_react27 = require("react");
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 function useFetchBalance() {
   return (0, import_react27.useCallback)(
     async (publicClient, walletAddress, kibbleTokenAddress) => {
       try {
         const balance = await publicClient.readContract({
-          address: (0, import_viem8.getAddress)(kibbleTokenAddress),
-          abi: import_viem8.erc20Abi,
+          address: (0, import_viem9.getAddress)(kibbleTokenAddress),
+          abi: import_viem9.erc20Abi,
           functionName: "balanceOf",
-          args: [(0, import_viem8.getAddress)(walletAddress)]
+          args: [(0, import_viem9.getAddress)(walletAddress)]
         });
         return Number(balance);
       } catch (error) {
@@ -2453,7 +2768,7 @@ function useFetchBalance() {
 }
 
 // src/utils/actions/useClaimActionReward.ts
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 var import_react28 = require("react");
 function useClaimActionReward() {
   return (0, import_react28.useCallback)(
@@ -2464,7 +2779,7 @@ function useClaimActionReward() {
           message: "Missing web3auth account info or contract address."
         };
       }
-      const callData = (0, import_viem9.encodeFunctionData)({
+      const callData = (0, import_viem10.encodeFunctionData)({
         abi: REWARDABLE_ACTIONS_ABI,
         functionName: "claimByIndex",
         args: [actionId, claimIndex]
@@ -2492,7 +2807,7 @@ function useClaimActionReward() {
 }
 
 // src/utils/actions/useClaimOrgActionReward.ts
-var import_viem10 = require("viem");
+var import_viem11 = require("viem");
 var import_react29 = require("react");
 function useClaimOrgActionReward() {
   return (0, import_react29.useCallback)(
@@ -2503,12 +2818,12 @@ function useClaimOrgActionReward() {
           message: "Missing web3auth account info or contract address."
         };
       }
-      const claimCallData = (0, import_viem10.encodeFunctionData)({
+      const claimCallData = (0, import_viem11.encodeFunctionData)({
         abi: REWARDABLE_ACTIONS_ABI,
         functionName: "claimByIndex",
         args: [actionId, claimIndex]
       });
-      const executeClaimCalldata = (0, import_viem10.encodeFunctionData)({
+      const executeClaimCalldata = (0, import_viem11.encodeFunctionData)({
         abi: ORGANIZATION_IMPL_ABI,
         functionName: "executeCall",
         args: [rewardableActionContractAddress, claimCallData]
@@ -2659,6 +2974,8 @@ function isMarketplacePurchaseAction(payload) {
   ActionSourceType,
   ActionStatus,
   ActionType,
+  FIREBASE_WEB_API_KEYS,
+  FIREBASE_WEB_AUTH_API_ENDPOINTS,
   MarketplacePaymentType,
   NETWORK_HOSTS,
   Network,
@@ -2666,12 +2983,20 @@ function isMarketplacePurchaseAction(payload) {
   convertToActionRecord,
   convertToMultipleActionDefinitions,
   convertToMultipleActionRecords,
+  createApp,
   createAuthEnvelope,
   fetchAnymals,
+  flattenFirestoreData,
   generateAppSignature,
   generateBytes32Nonce,
   generateJWT,
+  getFirebaseTokenForApp,
   loadExistingSecp256k1PrivateKey,
+  processDirectKibbleApproval,
+  processDirectPartialPayment,
+  processOrgKibbleApproval,
+  processOrgPartialPayment,
+  sendUserOpWithRetries,
   serializePublicKeyCompressed,
   submitAction,
   useAddAnymalToDatabase,
@@ -2703,5 +3028,7 @@ function isMarketplacePurchaseAction(payload) {
   useUpdateUserPid,
   useUploadAnymalImage,
   useVerifyAccount,
-  useVerifyWeb3AuthSession
+  useVerifyWeb3AuthSession,
+  waitForAllowance,
+  waitForReceiptWithRetries
 });