anymal-protocol 1.0.117 → 1.0.119

package/dist/index.mjs

@@ -1,13 +1,18 @@
 import {
   AUTH_API_ENDPOINTS,
+  FIREBASE_WEB_API_KEYS,
+  FIREBASE_WEB_AUTH_API_ENDPOINTS,
   NETWORK_HOSTS,
   Network,
+  createApp,
   createAuthEnvelope,
+  flattenFirestoreData,
   generateAppSignature,
   generateJWT,
+  getFirebaseTokenForApp,
   loadExistingSecp256k1PrivateKey,
   serializePublicKeyCompressed
-} from "./chunk-F72KTNHS.mjs";
+} from "./chunk-OBXCSRGF.mjs";
 
 // src/utils/account/useVerifyAccount.ts
 import { useCallback } from "react";
@@ -1211,35 +1216,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
-      };
     }
   };
 }
@@ -1265,7 +1271,7 @@ function useMintAnymalNFT() {
           anymalTxId
         ]
       });
-      applyBundlerGasEstimator(smartAccount, bundlerClient);
+      await applyBundlerGasEstimator(smartAccount, bundlerClient);
       const userOpHash = await bundlerClient.sendUserOperation({
         account: smartAccount,
         calls: [
@@ -1659,8 +1665,104 @@ function useFetchAnymals() {
 }
 
 // src/utils/marketplace/useProcessPartialKibblePayment.ts
-import { encodeFunctionData as encodeFunctionData2 } from "viem";
 import { useCallback as useCallback17 } from "react";
+
+// src/helpers/ProcessDirectPartialPayment.tsx
+import { encodeFunctionData as encodeFunctionData2, erc20Abi } from "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: erc20Abi,
+      address: marketplaceContract,
+      functionName: "allowance",
+      args: [smartAccount.address, marketplaceContract]
+    });
+    if (allowance < amountInTokens) {
+      return { success: false, message: "Insufficient allowance for direct partial payment." };
+    }
+    const partialPayCalldata = encodeFunctionData2({
+      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 useCallback17(
     async (pid, nftId, orderId, dbAuthToken, marketplaceContract, smartAccount, bundlerClient, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
@@ -1688,31 +1790,25 @@ function useProcessPartialKibblePayment() {
           backendSignature
           // bytes
         ];
-        console.info({ args });
-        const callData = encodeFunctionData2({
-          abi: MARKETPLACE_ABI,
-          functionName: "partialPay",
-          args
-        });
-        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}`
@@ -1724,41 +1820,53 @@ function useProcessPartialKibblePayment() {
 }
 
 // src/utils/marketplace/useApproveKibbleToken.ts
-import { encodeFunctionData as encodeFunctionData3, erc20Abi } from "viem";
 import { useCallback as useCallback18 } from "react";
+
+// src/helpers/ProcessDirectKibbleApproval.tsx
+import { encodeFunctionData as encodeFunctionData3, erc20Abi as erc20Abi2 } from "viem";
+async function processDirectKibbleApproval(kibbleTokenAddress, spenderAddress, smartAccount, bundlerClient, approveAmount) {
+  try {
+    const approveCalldata = encodeFunctionData3({
+      abi: erc20Abi2,
+      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 useCallback18(
     async (kibbleTokenAddress, marketplaceContract, amount, smartAccount, bundlerClient) => {
       try {
-        const callData = encodeFunctionData3({
-          abi: erc20Abi,
-          functionName: "approve",
-          args: [
-            marketplaceContract,
-            // spender address
-            BigInt(amount)
-            // amount to approve
-          ]
-        });
-        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";
@@ -1801,7 +1909,7 @@ function useCreateOrganizationBase() {
           functionName: "createOrganizationProxy",
           args: [ownerAddress, orgName, orgPid]
         });
-        applyBundlerGasEstimator(adminSmartAccount, bundlerClient);
+        await applyBundlerGasEstimator(adminSmartAccount, bundlerClient);
         const userOpHash = await bundlerClient.sendUserOperation({
           account: adminSmartAccount,
           calls: [
@@ -1863,7 +1971,92 @@ function useCreateOrganizationBase() {
 
 // src/utils/organization/useApproveOrgKibbleToken.ts
 import { useCallback as useCallback20 } from "react";
-import { encodeFunctionData as encodeFunctionData5, erc20Abi as erc20Abi2 } from "viem";
+
+// src/helpers/ProcessOrgKibbleApproval.tsx
+import { encodeFunctionData as encodeFunctionData5, erc20Abi as erc20Abi4 } from "viem";
+
+// src/helpers/WaitForAllowance.tsx
+import { erc20Abi as erc20Abi3 } from "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: erc20Abi3,
+        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 = encodeFunctionData5({
+      abi: erc20Abi4,
+      functionName: "approve",
+      args: [partialPaymentModuleAddress, approveAmount]
+    });
+    const executeApproveCalldata = encodeFunctionData5({
+      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 useCallback20(
     async (orgContractAddress, kibbleTokenAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, approveAmount) => {
@@ -1874,37 +2067,22 @@ function useApproveOrgPartialPayment() {
         };
       }
       try {
-        const approveCalldata = encodeFunctionData5({
-          abi: erc20Abi2,
-          functionName: "approve",
-          args: [partialPaymentModuleAddress, approveAmount]
-        });
-        const executeApproveCalldata = encodeFunctionData5({
-          abi: ORGANIZATION_IMPL_ABI,
-          functionName: "executeCall",
-          args: [kibbleTokenAddress, approveCalldata]
-        });
-        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}` };
       }
     },
     []
@@ -1913,7 +2091,52 @@ function useApproveOrgPartialPayment() {
 
 // src/utils/organization/useProcessOrgPartialKibblePayment.ts
 import { useCallback as useCallback21 } from "react";
+
+// src/helpers/ProcessOrgPartialPayment.tsx
 import { encodeFunctionData as encodeFunctionData6 } from "viem";
+async function processOrgPartialPayment(orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) {
+  try {
+    const partialPayCalldata = encodeFunctionData6({
+      abi: MARKETPLACE_ABI,
+      functionName: "partialPay",
+      args: [
+        orderId,
+        anymalNftId,
+        pid,
+        amountInTokens,
+        maxTokenPayment,
+        nonce,
+        deadline,
+        backendSignature
+      ]
+    });
+    const executePartialPayCalldata = encodeFunctionData6({
+      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 useCallback21(
     async (orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
@@ -1924,46 +2147,28 @@ function useProcessOrgPartialKibblePayment() {
         };
       }
       try {
-        const partialPayCalldata = encodeFunctionData6({
-          abi: MARKETPLACE_ABI,
-          functionName: "partialPay",
-          args: [
-            orderId,
-            anymalNftId,
-            pid,
-            amountInTokens,
-            maxTokenPayment,
-            nonce,
-            deadline,
-            backendSignature
-          ]
-        });
-        const executePartialPayCalldata = encodeFunctionData6({
-          abi: ORGANIZATION_IMPL_ABI,
-          functionName: "executeCall",
-          args: [partialPaymentModuleAddress, partialPayCalldata]
-        });
-        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}` };
       }
     },
     []
@@ -2289,14 +2494,14 @@ function useCreateOrganizationAppData() {
 
 // src/utils/balance/useFetchBalance.ts
 import { useCallback as useCallback27 } from "react";
-import { erc20Abi as erc20Abi3, getAddress } from "viem";
+import { erc20Abi as erc20Abi5, getAddress } from "viem";
 function useFetchBalance() {
   return useCallback27(
     async (publicClient, walletAddress, kibbleTokenAddress) => {
       try {
         const balance = await publicClient.readContract({
           address: getAddress(kibbleTokenAddress),
-          abi: erc20Abi3,
+          abi: erc20Abi5,
           functionName: "balanceOf",
           args: [getAddress(walletAddress)]
         });
@@ -2326,7 +2531,7 @@ function useClaimActionReward() {
         functionName: "claimByIndex",
         args: [actionId, claimIndex]
       });
-      applyBundlerGasEstimator(smartAccount, bundlerClient);
+      await applyBundlerGasEstimator(smartAccount, bundlerClient);
       const userOpHash = await bundlerClient.sendUserOperation({
         account: smartAccount,
         calls: [
@@ -2370,7 +2575,7 @@ function useClaimOrgActionReward() {
         functionName: "executeCall",
         args: [rewardableActionContractAddress, claimCallData]
       });
-      applyBundlerGasEstimator(smartAccount, bundlerClient);
+      await applyBundlerGasEstimator(smartAccount, bundlerClient);
       const userOpHash = await bundlerClient.sendUserOperation({
         account: smartAccount,
         calls: [
@@ -2515,6 +2720,8 @@ export {
   ActionSourceType,
   ActionStatus,
   ActionType,
+  FIREBASE_WEB_API_KEYS,
+  FIREBASE_WEB_AUTH_API_ENDPOINTS,
   MarketplacePaymentType,
   NETWORK_HOSTS,
   Network,
@@ -2522,12 +2729,20 @@ export {
   convertToActionRecord,
   convertToMultipleActionDefinitions,
   convertToMultipleActionRecords,
+  createApp,
   createAuthEnvelope,
   fetchAnymals,
+  flattenFirestoreData,
   generateAppSignature,
   generateBytes32Nonce,
   generateJWT,
+  getFirebaseTokenForApp,
   loadExistingSecp256k1PrivateKey,
+  processDirectKibbleApproval,
+  processDirectPartialPayment,
+  processOrgKibbleApproval,
+  processOrgPartialPayment,
+  sendUserOpWithRetries,
   serializePublicKeyCompressed,
   submitAction,
   useAddAnymalToDatabase,
@@ -2559,5 +2774,7 @@ export {
   useUpdateUserPid,
   useUploadAnymalImage,
   useVerifyAccount,
-  useVerifyWeb3AuthSession
+  useVerifyWeb3AuthSession,
+  waitForAllowance,
+  waitForReceiptWithRetries
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anymal-protocol",
-  "version": "1.0.117",
+  "version": "1.0.119",
   "description": "A React/TypeScript-based utility library for reusable functions and hooks inside of the Anymal Ecosystem.",
   "main": "dist/index.js",
   "bin": {