anymal-protocol 1.0.124 → 1.0.126

package/dist/index.mjs

@@ -414,6 +414,9 @@ function useSendCoinbaseUserOperation() {
   return { sendOperationFn, data, status, error };
 }
 
+// src/utils/coinbase/useCoinbaseClaimActionReward.ts
+import { encodeFunctionData } from "viem";
+
 // src/helpers/BlockchainAbiHelper.tsx
 import { parseAbi } from "viem";
 var PET_NFT_ABI = [{ "inputs": [], "stateMutability": "nonpayable", "type": "constructor" }, {
@@ -2845,9 +2848,70 @@ var OZ_ERROR_FRAGMENTS = [
 var ERROR_ABI = [...LOCAL_ERRORS, parseAbi([...OZ_ERROR_FRAGMENTS])];
 var ORG_FUNCTION = "executeCall";
 
-// src/utils/anymals/useMintAnymalNFT.ts
-import { encodeFunctionData } from "viem";
+// src/utils/coinbase/useCoinbaseClaimActionReward.ts
 import { useCallback as useCallback11 } from "react";
+function useCoinbaseClaimActionReward() {
+  const { sendOperationFn, status } = useSendCoinbaseUserOperation();
+  return useCallback11(
+    async (evmAddress, actionId, claimIndex, validationContractAddress) => {
+      if (!evmAddress || !actionId || claimIndex === void 0 || !validationContractAddress) {
+        return {
+          success: false,
+          message: "Missing information",
+          status: "error"
+        };
+      }
+      const args = [actionId, claimIndex];
+      const functionName = "claimByIndex";
+      const callData = encodeFunctionData({
+        abi: REWARDABLE_ACTIONS_ABI,
+        functionName,
+        args
+      });
+      await sendOperationFn(evmAddress, callData, validationContractAddress);
+      return { success: true, message: "Reward claimed", status };
+    },
+    []
+  );
+}
+
+// src/utils/coinbase/useCoinbaseMintAnymalNFT.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+import { useCallback as useCallback12 } from "react";
+function useCoinbaseMintAnymalNFT() {
+  const { sendOperationFn, status } = useSendCoinbaseUserOperation();
+  return useCallback12(
+    async (evmAddress, pid, nftId, anymalTxId, validationContractAddress) => {
+      if (!nftId || !pid || !validationContractAddress) {
+        return {
+          success: false,
+          message: "Coinbase Mint NFT: Missing authentication token OR NFT ID.",
+          status: "error"
+        };
+      }
+      const functionName = "submitMetadataByCampaignName";
+      const args = [
+        pid,
+        nftId,
+        `https://dev-nft.petastic.com/metadata/${nftId}`,
+        "petastic-signup-campaign-1",
+        anymalTxId
+      ];
+      const callData = encodeFunctionData2({
+        abi: PET_NFT_ABI,
+        functionName,
+        args
+      });
+      await sendOperationFn(evmAddress, callData, validationContractAddress);
+      return { success: true, message: "Pet Passport Created", status };
+    },
+    []
+  );
+}
+
+// src/utils/anymals/useMintAnymalNFT.ts
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+import { useCallback as useCallback13 } from "react";
 
 // src/helpers/GasEstimateHelper.tsx
 async function applyBundlerGasEstimator(account, bundlerClient, options) {
@@ -2928,12 +2992,12 @@ async function simulateCall(publicClient, target, abi, functionName, args, calle
 
 // src/utils/anymals/useMintAnymalNFT.ts
 function useMintAnymalNFT() {
-  return useCallback11(
+  return useCallback13(
     async (pid, nftId, anymalTxId, dbAuthToken, validationContractAddress, smartAccount, bundlerClient) => {
       if (!dbAuthToken || !nftId || !bundlerClient || !smartAccount || !pid || !validationContractAddress) {
         return {
           success: false,
-          message: "Missing authentication token OR NFT ID."
+          message: "Mint NFT: Missing authentication token OR NFT ID."
         };
       }
       const functionName = "submitMetadataByCampaignName";
@@ -2944,7 +3008,7 @@ function useMintAnymalNFT() {
         "petastic-signup-campaign-1",
         anymalTxId
       ];
-      const callData = encodeFunctionData({
+      const callData = encodeFunctionData3({
         abi: PET_NFT_ABI,
         functionName,
         args
@@ -2979,126 +3043,11 @@ function useMintAnymalNFT() {
   );
 }
 
-// src/utils/anymals/useAddAnymalToDatabase.ts
-import { useCallback as useCallback12 } from "react";
-function useAddAnymalToDatabase() {
-  return useCallback12(
-    async (dbAuthToken, endpoint, anymalData) => {
-      if (!dbAuthToken) {
-        return {
-          success: false,
-          message: "Authentication token is missing.",
-          _docID: null,
-          dbCid: null
-        };
-      }
-      let anymalDocID = null;
-      let dbCid = null;
-      try {
-        const mutation = `
-                mutation Create_Anymal($input: [AnymalMutationInputArg!]) {
-                    create_Anymal(input: $input) {
-                      _docID
-                      name
-                      passportID
-                      _version {
-                       cid
-                      }
-                    }
-                }
-            `;
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${dbAuthToken}`
-          },
-          body: JSON.stringify({
-            query: mutation,
-            variables: { input: [anymalData] }
-          })
-        });
-        if (!response.ok) {
-          throw new Error(
-            `Failed to create pet. HTTP status ${response.status}`
-          );
-        }
-        const { data, errors } = await response.json();
-        if (errors) {
-          const errorMessage = JSON.stringify(errors);
-          if (errorMessage.includes("given ID already exists")) {
-            console.warn("Duplicate document ID detected.");
-            anymalDocID = data?.create_Anymal[0]?._docID || null;
-            throw new Error("Document with the given ID already exists.");
-          }
-          throw new Error(`GraphQL error: ${errorMessage}`);
-        }
-        anymalDocID = data.create_Anymal[0]._docID;
-        dbCid = data.create_Anymal[0]._version[0].cid;
-        return {
-          success: true,
-          _docID: anymalDocID,
-          dbCid,
-          message: "Anymal added to account"
-        };
-      } catch (error) {
-        return {
-          success: false,
-          _docID: null,
-          dbCid: null,
-          message: "Error adding anymal to account"
-        };
-      }
-    },
-    []
-  );
-}
-
-// src/utils/anymals/useDeleteAnymalFromDatabase.ts
-import { useCallback as useCallback13 } from "react";
-function useDeleteAnymalFromDatabase() {
-  return useCallback13(
-    async (dbAuthToken, endpoint, anymalDocID) => {
-      if (!dbAuthToken || !endpoint || !anymalDocID) return;
-      try {
-        const mutation = `
-          mutation Delete_Anymal($docId: [ID]) {
-            delete_Anymal(docID: $docId) {
-              _docID
-            }
-          }
-        `;
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${dbAuthToken}`
-          },
-          body: JSON.stringify({
-            query: mutation,
-            variables: { docID: [anymalDocID] }
-          })
-        });
-        if (!response.ok)
-          throw new Error(
-            `Failed to delete anymal. HTTP status ${response.status}`
-          );
-        const { errors } = await response.json();
-        if (errors) throw new Error(`GraphQL error: ${JSON.stringify(errors)}`);
-      } catch (error) {
-        console.error("Error deleting anymal from database:", error);
-        throw error;
-      }
-    },
-    []
-  );
-}
-
 // src/utils/anymals/useSaveAnymalMetadata.ts
 import { useCallback as useCallback14 } from "react";
 function useSaveAnymalMetadata() {
   return useCallback14(
-    async (userPid, anymalTxId, idToken, publicKey, nftMetadataInput, authServiceBaseUrl) => {
+    async (userPid, anymalTxId, idToken, nftMetadataInput, authServiceBaseUrl) => {
       const response = await fetch(`${authServiceBaseUrl}/process-nft`, {
         method: "POST",
         headers: {
@@ -3106,7 +3055,6 @@ function useSaveAnymalMetadata() {
           Authorization: "Bearer " + idToken
         },
         body: JSON.stringify({
-          appPubKey: publicKey,
           nftMetadataInput,
           pid: userPid,
           anymalTxId
@@ -3125,57 +3073,8 @@ function useSaveAnymalMetadata() {
   );
 }
 
-// src/utils/anymals/useUpdateAnymalWithNFT.ts
-import { useCallback as useCallback15 } from "react";
-function useUpdateAnymalWithNFT() {
-  return useCallback15(
-    async (anymalPassportId, anymalDocId, dbAuthToken, endpoint) => {
-      if (!dbAuthToken || !anymalPassportId || !anymalDocId || !endpoint) {
-        return {
-          success: false
-        };
-      }
-      try {
-        const mutation = `
-          mutation {
-            update_Anymal(
-              docID: [${JSON.stringify(anymalDocId)}],
-              input: {
-                passportID: "${anymalPassportId}"
-              }
-            ) {
-              passportID
-            }
-          }
-        `;
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${dbAuthToken}`
-          },
-          body: JSON.stringify({ query: mutation })
-        });
-        if (!response.ok) {
-          return { success: false };
-        }
-        const { errors } = await response.json();
-        if (errors) {
-          console.log(`GQL error: ${JSON.stringify(errors)}`);
-          return { success: false };
-        }
-        return { success: true };
-      } catch (error) {
-        console.error("Error updating Anymal with NFT ID:", error);
-        return { success: false };
-      }
-    },
-    []
-  );
-}
-
 // src/utils/anymals/useUploadAnymalImage.ts
-import { useCallback as useCallback16 } from "react";
+import { useCallback as useCallback15 } from "react";
 
 // src/helpers/UploadImageHelper.tsx
 function resizeImage(file, maxWidth = 800, maxHeight = 800, quality = 0.7) {
@@ -3232,8 +3131,8 @@ function toBase64(file) {
 
 // src/utils/anymals/useUploadAnymalImage.ts
 function useUploadAnymalImage() {
-  return useCallback16(
-    async (imageFile, type, idToken, publicKey, authServiceBaseUrl, petType, breed, lifestage, anymalPid) => {
+  return useCallback15(
+    async (imageFile, type, idToken, authServiceBaseUrl, petType, breed, lifestage, anymalPid) => {
       if (!imageFile || !idToken) {
         return {
           success: false,
@@ -3245,7 +3144,6 @@ function useUploadAnymalImage() {
       try {
         const base64Image = await prepareImage(imageFile);
         const payload = {
-          appPubKey: publicKey,
           imageData: base64Image,
           imageName: imageFile.name.split(".")[0],
           petType,
@@ -3293,68 +3191,11 @@ function useUploadAnymalImage() {
   );
 }
 
-// src/utils/anymals/useFetchAnymals.ts
-import { useCallback as useCallback17 } from "react";
-
-// src/utils/anymals/fetchAnymals.ts
-async function fetchAnymals({
-  dbAuthToken,
-  endpoint,
-  userPid
-}) {
-  const query = `
-    query Anymal($filter: AnymalFilterArg, $order: [AnymalOrderArg]) {
-      Anymal(filter: $filter, order: $order) {
-        _docID
-        name
-        breed
-        passportID
-        profileImageUrl
-        caregiverNearId
-        caregiverId
-        lifestage
-        gender
-        petType
-        products
-        timeAddedUtc
-      }
-    }
-  `;
-  const variables = {
-    filter: {
-      caregiverId: { _eq: userPid }
-    },
-    order: [
-      {
-        timeAddedUtc: "ASC"
-      }
-    ]
-  };
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${dbAuthToken}`
-    },
-    body: JSON.stringify({ query, variables })
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP error! Status: ${response.status}`);
-  }
-  const data = await response.json();
-  return data?.data?.Anymal ?? [];
-}
-
-// src/utils/anymals/useFetchAnymals.ts
-function useFetchAnymals() {
-  return useCallback17(fetchAnymals, []);
-}
-
 // src/utils/marketplace/useProcessPartialKibblePayment.ts
-import { useCallback as useCallback18 } from "react";
+import { useCallback as useCallback16 } from "react";
 
 // src/helpers/ProcessDirectPartialPayment.tsx
-import { encodeFunctionData as encodeFunctionData2 } from "viem";
+import { encodeFunctionData as encodeFunctionData4 } from "viem";
 
 // src/helpers/SendUserOpWithRetries.tsx
 async function sendUserOpWithRetries(bundlerClient, params, retries = 3, delay = 1e3) {
@@ -3414,7 +3255,7 @@ async function processDirectPartialPayment(marketplaceContract, smartAccount, bu
       deadline,
       backendSignature
     ];
-    const partialPayCalldata = encodeFunctionData2({
+    const partialPayCalldata = encodeFunctionData4({
       abi: MARKETPLACE_ABI,
       functionName,
       args
@@ -3451,7 +3292,7 @@ async function processDirectPartialPayment(marketplaceContract, smartAccount, bu
 
 // src/utils/marketplace/useProcessPartialKibblePayment.ts
 function useProcessPartialKibblePayment() {
-  return useCallback18(
+  return useCallback16(
     async (pid, nftId, orderId, dbAuthToken, marketplaceContract, smartAccount, bundlerClient, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
       if (!orderId || !dbAuthToken || !nftId || !bundlerClient || !smartAccount || !pid || !marketplaceContract || !amountInTokens || !maxTokenPayment || !nonce || !deadline) {
         return {
@@ -3507,15 +3348,15 @@ function useProcessPartialKibblePayment() {
 }
 
 // src/utils/marketplace/useApproveKibbleToken.ts
-import { useCallback as useCallback19 } from "react";
+import { useCallback as useCallback17 } from "react";
 
 // src/helpers/ProcessDirectKibbleApproval.tsx
-import { encodeFunctionData as encodeFunctionData3, erc20Abi } from "viem";
+import { encodeFunctionData as encodeFunctionData5, erc20Abi } from "viem";
 async function processDirectKibbleApproval(kibbleTokenAddress, spenderAddress, smartAccount, bundlerClient, approveAmount) {
   try {
     const functionName = "approve";
     const args = [spenderAddress, approveAmount];
-    const approveCalldata = encodeFunctionData3({
+    const approveCalldata = encodeFunctionData5({
       abi: erc20Abi,
       functionName,
       args
@@ -3552,7 +3393,7 @@ async function processDirectKibbleApproval(kibbleTokenAddress, spenderAddress, s
 
 // src/utils/marketplace/useApproveKibbleToken.ts
 function useApproveKibbleToken() {
-  return useCallback19(
+  return useCallback17(
     async (kibbleTokenAddress, marketplaceContract, amount, smartAccount, bundlerClient) => {
       try {
         const result = await processDirectKibbleApproval(
@@ -3579,10 +3420,10 @@ function useApproveKibbleToken() {
 }
 
 // src/utils/organization/useCreateOrganizationBase.ts
-import { useCallback as useCallback20 } from "react";
-import { decodeEventLog, encodeFunctionData as encodeFunctionData4 } from "viem";
+import { useCallback as useCallback18 } from "react";
+import { decodeEventLog, encodeFunctionData as encodeFunctionData6 } from "viem";
 function useCreateOrganizationBase() {
-  return useCallback20(
+  return useCallback18(
     /**
      * Creates a new organization on-chain.
      *
@@ -3604,7 +3445,7 @@ function useCreateOrganizationBase() {
       try {
         const functionName = "createOrganizationProxy";
         const args = [ownerAddress, orgName, orgPid];
-        const callData = encodeFunctionData4({
+        const callData = encodeFunctionData6({
           abi: ORGANIZATION_BEACON_ABI,
           functionName,
           args
@@ -3678,10 +3519,10 @@ function useCreateOrganizationBase() {
 }
 
 // src/utils/organization/useApproveOrgKibbleToken.ts
-import { useCallback as useCallback21 } from "react";
+import { useCallback as useCallback19 } from "react";
 
 // src/helpers/ProcessOrgKibbleApproval.tsx
-import { encodeFunctionData as encodeFunctionData5, erc20Abi as erc20Abi3 } from "viem";
+import { encodeFunctionData as encodeFunctionData7, erc20Abi as erc20Abi3 } from "viem";
 
 // src/helpers/WaitForAllowance.tsx
 import { erc20Abi as erc20Abi2 } from "viem";
@@ -3718,13 +3559,13 @@ async function processOrgKibbleApproval(orgContractAddress, kibbleTokenAddress,
     if (approveAmount <= 0n) {
       return { success: false, message: "Approval amount must be greater than zero." };
     }
-    const approveCalldata = encodeFunctionData5({
+    const approveCalldata = encodeFunctionData7({
       abi: erc20Abi3,
       functionName: "approve",
       args: [partialPaymentModuleAddress, approveAmount]
     });
     const args = [kibbleTokenAddress, approveCalldata];
-    const executeApproveCalldata = encodeFunctionData5({
+    const executeApproveCalldata = encodeFunctionData7({
       abi: ORGANIZATION_IMPL_ABI,
       functionName: ORG_FUNCTION,
       args
@@ -3776,7 +3617,7 @@ async function processOrgKibbleApproval(orgContractAddress, kibbleTokenAddress,
 
 // src/utils/organization/useApproveOrgKibbleToken.ts
 function useApproveOrgPartialPayment() {
-  return useCallback21(
+  return useCallback19(
     async (orgContractAddress, kibbleTokenAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, approveAmount) => {
       if (!orgContractAddress || !kibbleTokenAddress || !partialPaymentModuleAddress || !managerSmartAccount || !bundlerClient || !approveAmount) {
         return {
@@ -3808,13 +3649,13 @@ function useApproveOrgPartialPayment() {
 }
 
 // src/utils/organization/useProcessOrgPartialKibblePayment.ts
-import { useCallback as useCallback22 } from "react";
+import { useCallback as useCallback20 } from "react";
 
 // src/helpers/ProcessOrgPartialPayment.tsx
-import { encodeFunctionData as encodeFunctionData6 } from "viem";
+import { encodeFunctionData as encodeFunctionData8 } from "viem";
 async function processOrgPartialPayment(orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) {
   try {
-    const partialPayCalldata = encodeFunctionData6({
+    const partialPayCalldata = encodeFunctionData8({
       abi: MARKETPLACE_ABI,
       functionName: "partialPay",
       args: [
@@ -3829,7 +3670,7 @@ async function processOrgPartialPayment(orgContractAddress, partialPaymentModule
       ]
     });
     const args = [partialPaymentModuleAddress, partialPayCalldata];
-    const executePartialPayCalldata = encodeFunctionData6({
+    const executePartialPayCalldata = encodeFunctionData8({
       abi: ORGANIZATION_IMPL_ABI,
       functionName: ORG_FUNCTION,
       args
@@ -3866,7 +3707,7 @@ async function processOrgPartialPayment(orgContractAddress, partialPaymentModule
 
 // src/utils/organization/useProcessOrgPartialKibblePayment.ts
 function useProcessOrgPartialKibblePayment() {
-  return useCallback22(
+  return useCallback20(
     async (orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
       if (!orgContractAddress || !partialPaymentModuleAddress || !managerSmartAccount || !bundlerClient || !orderId || !pid || !nonce || !backendSignature) {
         return {
@@ -3904,9 +3745,9 @@ function useProcessOrgPartialKibblePayment() {
 }
 
 // src/utils/organization/useUpdateOrgWalletAddress.ts
-import { useCallback as useCallback23 } from "react";
+import { useCallback as useCallback21 } from "react";
 function useUpdateOrgWalletAddress() {
-  return useCallback23(
+  return useCallback21(
     async (dbAuthToken, docID, baseWalletAddress, endpoint) => {
       try {
         const mutation = `
@@ -3945,15 +3786,15 @@ function useUpdateOrgWalletAddress() {
 }
 
 // src/utils/organization/useMintOrgAnymalNFT.ts
-import { encodeFunctionData as encodeFunctionData7 } from "viem";
-import { useCallback as useCallback24 } from "react";
+import { encodeFunctionData as encodeFunctionData9 } from "viem";
+import { useCallback as useCallback22 } from "react";
 function useMintOrgAnymalNFT() {
-  return useCallback24(
+  return useCallback22(
     async (orgContractAddress, pid, nftId, anymalTxId, dbAuthToken, validationContractAddress, managerSmartAccount, bundlerClient) => {
       if (!dbAuthToken || !nftId || !bundlerClient || !managerSmartAccount || !pid || !validationContractAddress || !orgContractAddress) {
         return {
           success: false,
-          message: "Missing authentication token OR NFT ID."
+          message: "Mint Org NFT: Missing authentication token OR NFT ID."
         };
       }
       const functionName = "submitMetadataByCampaignName";
@@ -3964,13 +3805,13 @@ function useMintOrgAnymalNFT() {
         "petastic-signup-campaign-1",
         anymalTxId
       ];
-      const callData = encodeFunctionData7({
+      const callData = encodeFunctionData9({
         abi: PET_NFT_ABI,
         functionName,
         args
       });
       const executeArgs = [validationContractAddress, callData];
-      const executeSubmitMetaCalldata = encodeFunctionData7({
+      const executeSubmitMetaCalldata = encodeFunctionData9({
         abi: ORGANIZATION_IMPL_ABI,
         functionName: ORG_FUNCTION,
         args: executeArgs
@@ -3986,7 +3827,12 @@ function useMintOrgAnymalNFT() {
       await applyBundlerGasEstimator(managerSmartAccount, bundlerClient);
       const userOpHash = await sendUserOpWithRetries(bundlerClient, {
         account: managerSmartAccount,
-        calls: [{ to: orgContractAddress, data: executeSubmitMetaCalldata }],
+        calls: [
+          {
+            to: orgContractAddress,
+            data: executeSubmitMetaCalldata
+          }
+        ],
         paymaster: true
       });
       await waitForReceiptWithRetries(bundlerClient, userOpHash);
@@ -4028,9 +3874,9 @@ async function submitAction(idToken, pid, sourceType, payload, endpointBaseUrl)
 }
 
 // src/utils/actions/useFetchActions.ts
-import { useCallback as useCallback25 } from "react";
+import { useCallback as useCallback23 } from "react";
 function useFetchActions() {
-  return useCallback25(
+  return useCallback23(
     async (idToken, actionsServiceBaseUrl, pid, status, limit, offset) => {
       const params = new URLSearchParams({ pid });
       if (status) params.set("status", status);
@@ -4059,9 +3905,9 @@ function useFetchActions() {
 }
 
 // src/utils/actions/useFetchActionDefinitions.ts
-import { useCallback as useCallback26 } from "react";
+import { useCallback as useCallback24 } from "react";
 function useFetchActionDefinitions() {
-  return useCallback26(
+  return useCallback24(
     async (idToken, actionsServiceBaseUrl) => {
       try {
         const response = await fetch(
@@ -4158,10 +4004,10 @@ var convertToMultipleActionRecords = (frs) => frs.map(convertToActionRecord);
 var convertToMultipleActionDefinitions = (frs) => frs.map(convertToActionDefinition);
 
 // src/utils/application/useCreateUserAppData.ts
-import { useCallback as useCallback27 } from "react";
+import { useCallback as useCallback25 } from "react";
 import { v4 as uuid } from "uuid";
 function useCreateUserAppData() {
-  return useCallback27(
+  return useCallback25(
     async (appId, pid, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !pid || !dbAuthToken || !endpoint) return;
       const appValues = {
@@ -4216,10 +4062,10 @@ function useCreateUserAppData() {
 }
 
 // src/utils/application/useCreateOrganizationAppData.ts
-import { useCallback as useCallback28 } from "react";
+import { useCallback as useCallback26 } from "react";
 import { v4 as uuid2 } from "uuid";
 function useCreateOrganizationAppData() {
-  return useCallback28(
+  return useCallback26(
     async (appId, pid, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !pid || !dbAuthToken || !endpoint) return;
       const appValues = {
@@ -4273,10 +4119,10 @@ function useCreateOrganizationAppData() {
 }
 
 // src/utils/balance/useFetchBalance.ts
-import { useCallback as useCallback29 } from "react";
+import { useCallback as useCallback27 } from "react";
 import { erc20Abi as erc20Abi4, getAddress } from "viem";
 function useFetchBalance() {
-  return useCallback29(
+  return useCallback27(
     async (publicClient, walletAddress, kibbleTokenAddress) => {
       try {
         const balance = await publicClient.readContract({
@@ -4295,10 +4141,10 @@ function useFetchBalance() {
 }
 
 // src/utils/actions/useClaimActionReward.ts
-import { encodeFunctionData as encodeFunctionData8 } from "viem";
-import { useCallback as useCallback30 } from "react";
+import { encodeFunctionData as encodeFunctionData10 } from "viem";
+import { useCallback as useCallback28 } from "react";
 function useClaimActionReward() {
-  return useCallback30(
+  return useCallback28(
     async (actionId, claimIndex, rewardableActionContractAddress, smartAccount, bundlerClient) => {
       if (!actionId || claimIndex === void 0 || !bundlerClient || !smartAccount || !rewardableActionContractAddress) {
         return {
@@ -4308,7 +4154,7 @@ function useClaimActionReward() {
       }
       const args = [actionId, claimIndex];
       const functionName = "claimByIndex";
-      const callData = encodeFunctionData8({
+      const callData = encodeFunctionData10({
         abi: REWARDABLE_ACTIONS_ABI,
         functionName,
         args
@@ -4344,10 +4190,10 @@ function useClaimActionReward() {
 }
 
 // src/utils/actions/useClaimOrgActionReward.ts
-import { encodeFunctionData as encodeFunctionData9 } from "viem";
-import { useCallback as useCallback31 } from "react";
+import { encodeFunctionData as encodeFunctionData11 } from "viem";
+import { useCallback as useCallback29 } from "react";
 function useClaimOrgActionReward() {
-  return useCallback31(
+  return useCallback29(
     async (orgContractAddress, rewardableActionContractAddress, actionId, claimIndex, smartAccount, bundlerClient) => {
       if (!orgContractAddress || !actionId || claimIndex === void 0 || !bundlerClient || !smartAccount) {
         return {
@@ -4355,13 +4201,13 @@ function useClaimOrgActionReward() {
           message: "Missing web3auth account info or contract address."
         };
       }
-      const claimCallData = encodeFunctionData9({
+      const claimCallData = encodeFunctionData11({
         abi: REWARDABLE_ACTIONS_ABI,
         functionName: "claimByIndex",
         args: [actionId, claimIndex]
       });
       const args = [rewardableActionContractAddress, claimCallData];
-      const executeClaimCalldata = encodeFunctionData9({
+      const executeClaimCalldata = encodeFunctionData11({
         abi: ORGANIZATION_IMPL_ABI,
         functionName: ORG_FUNCTION,
         args
@@ -4397,9 +4243,9 @@ function useClaimOrgActionReward() {
 }
 
 // src/utils/actions/useSubmitContractAction.ts
-import { useCallback as useCallback32 } from "react";
+import { useCallback as useCallback30 } from "react";
 function useSubmitContractAction() {
-  return useCallback32(
+  return useCallback30(
     (idToken, pid, source, endpoint, payload) => {
       if (!idToken || !pid || !source || !endpoint || !payload) return;
       let sourceTypePayload = {};
@@ -4538,7 +4384,6 @@ export {
   convertToMultipleActionRecords,
   createApp,
   createAuthEnvelope,
-  fetchAnymals,
   flattenFirestoreData,
   generateAppSignature,
   generateBytes32Nonce,
@@ -4553,19 +4398,18 @@ export {
   sendUserOpWithRetries,
   serializePublicKeyCompressed,
   submitAction,
-  useAddAnymalToDatabase,
   useApproveKibbleToken,
   useApproveOrgPartialPayment,
   useClaimActionReward,
   useClaimOrgActionReward,
+  useCoinbaseClaimActionReward,
+  useCoinbaseMintAnymalNFT,
   useCreateOrganizationAppData,
   useCreateOrganizationBase,
   useCreateUserAppData,
   useCreateWeb3Account,
-  useDeleteAnymalFromDatabase,
   useFetchActionDefinitions,
   useFetchActions,
-  useFetchAnymals,
   useFetchBalance,
   useFetchNotifications,
   useFetchUserData,
@@ -4576,7 +4420,6 @@ export {
   useSaveAnymalMetadata,
   useSendCoinbaseUserOperation,
   useSubmitContractAction,
-  useUpdateAnymalWithNFT,
   useUpdateOrgWalletAddress,
   useUpdateUserAsVerified,
   useUpdateUserEmail,