anymal-protocol 1.0.3 → 1.0.5

package/dist/index.d.mts

@@ -3,6 +3,16 @@ declare function useVerifyAccount(): (pid: string, dbAuthToken: string, bundlerC
     message: string;
 }>;
 
+declare function useVerifyWeb3AuthSession(): (idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<any>;
+
+declare function useCreateWeb3Account(): (idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<any>;
+
+declare function useFetchUserData(): (dbAuthToken: string, endpoint: string) => Promise<any>;
+
+declare function useUpdateUserEmail(): (dbAuthToken: string, docID: string, email: string, endpoint: string) => Promise<void>;
+
+declare function useUpdateUserPid(): (dbAuthToken: string, docID: string, pid: string, endpoint: string) => Promise<void>;
+
 declare function useMintAnymalNFT(): (pid: string, nftId: string, dbAuthToken: string, validationContractAddress: string, smartAccount: any, bundlerClient: any) => Promise<{
     success: boolean;
     message: string;
@@ -34,4 +44,13 @@ declare function useUpdateAnymalWithNFT(): (anymalPassportId: string, anymalDocI
     success: boolean;
 }>;
 
-export { type AnymalNftMetadataInputData, type CreateAnymalInputData, useAddAnymalToDatabase, useDeleteAnymalFromDatabase, useMintAnymalNFT, useSaveAnymalMetadata, useUpdateAnymalWithNFT, useVerifyAccount };
+declare function useUploadAnymalImage(): (imageFile: File, type: string, idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<{
+    success: boolean;
+    message: string;
+    url: any;
+    type: string;
+}>;
+
+declare function useFetchBalance(): (publicClient: any, walletAddress: string, kibbleTokenAddress: string) => Promise<number | undefined>;
+
+export { type AnymalNftMetadataInputData, type CreateAnymalInputData, useAddAnymalToDatabase, useCreateWeb3Account, useDeleteAnymalFromDatabase, useFetchBalance, useFetchUserData, useMintAnymalNFT, useSaveAnymalMetadata, useUpdateAnymalWithNFT, useUpdateUserEmail, useUpdateUserPid, useUploadAnymalImage, useVerifyAccount, useVerifyWeb3AuthSession };

package/dist/index.d.ts

@@ -3,6 +3,16 @@ declare function useVerifyAccount(): (pid: string, dbAuthToken: string, bundlerC
     message: string;
 }>;
 
+declare function useVerifyWeb3AuthSession(): (idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<any>;
+
+declare function useCreateWeb3Account(): (idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<any>;
+
+declare function useFetchUserData(): (dbAuthToken: string, endpoint: string) => Promise<any>;
+
+declare function useUpdateUserEmail(): (dbAuthToken: string, docID: string, email: string, endpoint: string) => Promise<void>;
+
+declare function useUpdateUserPid(): (dbAuthToken: string, docID: string, pid: string, endpoint: string) => Promise<void>;
+
 declare function useMintAnymalNFT(): (pid: string, nftId: string, dbAuthToken: string, validationContractAddress: string, smartAccount: any, bundlerClient: any) => Promise<{
     success: boolean;
     message: string;
@@ -34,4 +44,13 @@ declare function useUpdateAnymalWithNFT(): (anymalPassportId: string, anymalDocI
     success: boolean;
 }>;
 
-export { type AnymalNftMetadataInputData, type CreateAnymalInputData, useAddAnymalToDatabase, useDeleteAnymalFromDatabase, useMintAnymalNFT, useSaveAnymalMetadata, useUpdateAnymalWithNFT, useVerifyAccount };
+declare function useUploadAnymalImage(): (imageFile: File, type: string, idToken: string, publicKey: string, authServiceBaseUrl: string) => Promise<{
+    success: boolean;
+    message: string;
+    url: any;
+    type: string;
+}>;
+
+declare function useFetchBalance(): (publicClient: any, walletAddress: string, kibbleTokenAddress: string) => Promise<number | undefined>;
+
+export { type AnymalNftMetadataInputData, type CreateAnymalInputData, useAddAnymalToDatabase, useCreateWeb3Account, useDeleteAnymalFromDatabase, useFetchBalance, useFetchUserData, useMintAnymalNFT, useSaveAnymalMetadata, useUpdateAnymalWithNFT, useUpdateUserEmail, useUpdateUserPid, useUploadAnymalImage, useVerifyAccount, useVerifyWeb3AuthSession };

package/dist/index.js

@@ -21,15 +21,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   useAddAnymalToDatabase: () => useAddAnymalToDatabase,
+  useCreateWeb3Account: () => useCreateWeb3Account,
   useDeleteAnymalFromDatabase: () => useDeleteAnymalFromDatabase,
+  useFetchBalance: () => useFetchBalance,
+  useFetchUserData: () => useFetchUserData,
   useMintAnymalNFT: () => useMintAnymalNFT,
   useSaveAnymalMetadata: () => useSaveAnymalMetadata,
   useUpdateAnymalWithNFT: () => useUpdateAnymalWithNFT,
-  useVerifyAccount: () => useVerifyAccount
+  useUpdateUserEmail: () => useUpdateUserEmail,
+  useUpdateUserPid: () => useUpdateUserPid,
+  useUploadAnymalImage: () => useUploadAnymalImage,
+  useVerifyAccount: () => useVerifyAccount,
+  useVerifyWeb3AuthSession: () => useVerifyWeb3AuthSession
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils/useVerifyAccount.ts
+// src/utils/account/useVerifyAccount.ts
 var import_react = require("react");
 var import_viem = require("viem");
 
@@ -590,7 +597,7 @@ var VERIFY_ACCOUNT_ABI = [
   }
 ];
 
-// src/utils/useVerifyAccount.ts
+// src/utils/account/useVerifyAccount.ts
 function useVerifyAccount() {
   return (0, import_react.useCallback)(
     async (pid, dbAuthToken, bundlerClient, smartAccount, accountRewardsContractAddress) => {
@@ -630,11 +637,180 @@ function useVerifyAccount() {
   );
 }
 
+// src/utils/account/useVerifyWeb3AuthSession.ts
+var import_react2 = require("react");
+function useVerifyWeb3AuthSession() {
+  return (0, import_react2.useCallback)(
+    async (idToken, publicKey, authServiceBaseUrl) => {
+      const response = await fetch(
+        `${authServiceBaseUrl}/verify-web3-session`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken
+          },
+          body: JSON.stringify({ appPubKey: publicKey })
+        }
+      );
+      const { jwt } = await response.json();
+      return jwt;
+    },
+    []
+  );
+}
+
+// src/utils/account/useCreateWeb3Account.ts
+var import_react3 = require("react");
+function useCreateWeb3Account() {
+  return (0, import_react3.useCallback)(
+    async (idToken, publicKey, authServiceBaseUrl) => {
+      try {
+        const response = await fetch(`${authServiceBaseUrl}/create-account`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken
+          },
+          body: JSON.stringify({ appPubKey: publicKey })
+        });
+        return await response.json();
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    },
+    []
+  );
+}
+
+// src/utils/account/useFetchUserData.ts
+var import_react4 = require("react");
+function useFetchUserData() {
+  return (0, import_react4.useCallback)(async (dbAuthToken, endpoint) => {
+    try {
+      const query = `
+      query User {
+        User {
+          _docID
+          pid
+          email
+          isVerified
+          accountType
+        }
+      }
+    `;
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${dbAuthToken}`
+        },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      if (data && data.data && data.data.User && data.data.User.length > 0) {
+        return data.data.User[0];
+      } else {
+        return null;
+      }
+    } catch (error) {
+      console.error("Error fetching user data:", error);
+      return null;
+    }
+  }, []);
+}
+
+// src/utils/account/useUpdateUserEmail.ts
+var import_react5 = require("react");
+function useUpdateUserEmail() {
+  return (0, import_react5.useCallback)(
+    async (dbAuthToken, docID, email, endpoint) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              email
+            }
+          }
+        `;
+        const variables = {
+          docId: [docID],
+          input: {
+            email
+          }
+        };
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}
+
+// src/utils/account/useUpdateUserPid.ts
+var import_react6 = require("react");
+function useUpdateUserPid() {
+  return (0, import_react6.useCallback)(
+    async (dbAuthToken, docID, pid, endpoint) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              pid
+            }
+          }
+          `;
+        const variables = {
+          docId: [docID],
+          input: {
+            pid
+          }
+        };
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}
+
 // src/utils/anymals/useMintAnymalNFT.ts
 var import_viem2 = require("viem");
-var import_react2 = require("react");
+var import_react7 = require("react");
 function useMintAnymalNFT() {
-  return (0, import_react2.useCallback)(
+  return (0, import_react7.useCallback)(
     async (pid, nftId, dbAuthToken, validationContractAddress, smartAccount, bundlerClient) => {
       if (!dbAuthToken || !nftId || !bundlerClient || !smartAccount || !pid || !validationContractAddress) {
         return {
@@ -673,9 +849,9 @@ function useMintAnymalNFT() {
 }
 
 // src/utils/anymals/useAddAnymalToDatabase.ts
-var import_react3 = require("react");
+var import_react8 = require("react");
 function useAddAnymalToDatabase() {
-  return (0, import_react3.useCallback)(
+  return (0, import_react8.useCallback)(
     async (dbAuthToken, endpoint, anymalData) => {
       if (!dbAuthToken) {
         return {
@@ -740,9 +916,9 @@ function useAddAnymalToDatabase() {
 }
 
 // src/utils/anymals/useDeleteAnymalFromDatabase.ts
-var import_react4 = require("react");
+var import_react9 = require("react");
 function useDeleteAnymalFromDatabase() {
-  return (0, import_react4.useCallback)(
+  return (0, import_react9.useCallback)(
     async (dbAuthToken, endpoint, anymalDocID) => {
       if (!dbAuthToken || !endpoint || !anymalDocID) return;
       try {
@@ -780,9 +956,9 @@ function useDeleteAnymalFromDatabase() {
 }
 
 // src/utils/anymals/useSaveAnymalMetadata.ts
-var import_react5 = require("react");
+var import_react10 = require("react");
 function useSaveAnymalMetadata() {
-  return (0, import_react5.useCallback)(
+  return (0, import_react10.useCallback)(
     async (idToken, publicKey, nftMetadataInput, authServiceBaseUrl) => {
       const response = await fetch(`${authServiceBaseUrl}/process-nft`, {
         method: "POST",
@@ -809,9 +985,9 @@ function useSaveAnymalMetadata() {
 }
 
 // src/utils/anymals/useUpdateAnymalWithNFT.ts
-var import_react6 = require("react");
+var import_react11 = require("react");
 function useUpdateAnymalWithNFT() {
-  return (0, import_react6.useCallback)(
+  return (0, import_react11.useCallback)(
     async (anymalPassportId, anymalDocId, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !anymalPassportId || !anymalDocId || !endpoint) {
         return {
@@ -856,12 +1032,153 @@ function useUpdateAnymalWithNFT() {
     []
   );
 }
+
+// src/utils/anymals/useUploadAnymalImage.ts
+var import_react12 = require("react");
+
+// src/helpers/UploadImageHelper.tsx
+function resizeImage(file, maxWidth = 800, maxHeight = 800, quality = 0.7) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.src = URL.createObjectURL(file);
+    img.onload = () => {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas 2D context"));
+        return;
+      }
+      let width = img.width;
+      let height = img.height;
+      if (width > height) {
+        if (width > maxWidth) {
+          height = Math.round(height *= maxWidth / width);
+          width = maxWidth;
+        }
+      } else {
+        if (height > maxHeight) {
+          width = Math.round(width *= maxHeight / height);
+          height = maxHeight;
+        }
+      }
+      canvas.width = width;
+      canvas.height = height;
+      ctx.drawImage(img, 0, 0, width, height);
+      canvas.toBlob(
+        (blob) => {
+          if (blob) resolve(blob);
+          else reject(new Error("Image compression failed."));
+        },
+        "image/jpeg",
+        quality
+      );
+    };
+    img.onerror = () => reject(new Error("Failed to load image."));
+  });
+}
+async function prepareImage(imageFile) {
+  const compressedFile = await resizeImage(imageFile);
+  return toBase64(compressedFile);
+}
+function toBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result.split(",")[1]);
+    reader.onerror = (error) => reject(error);
+  });
+}
+
+// src/utils/anymals/useUploadAnymalImage.ts
+function useUploadAnymalImage() {
+  return (0, import_react12.useCallback)(
+    async (imageFile, type, idToken, publicKey, authServiceBaseUrl) => {
+      if (!imageFile || !idToken) {
+        return {
+          success: false,
+          message: "No image file selected or not authenticated.",
+          url: null,
+          type
+        };
+      }
+      try {
+        const base64Image = await prepareImage(imageFile);
+        const payload = {
+          appPubKey: publicKey,
+          imageData: base64Image,
+          imageName: imageFile.name.split(".")[0]
+        };
+        const response = await fetch(`${authServiceBaseUrl}/process-image`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${idToken}`
+          },
+          body: JSON.stringify(payload)
+        });
+        const data = await response.json();
+        if (response.ok) {
+          return {
+            success: true,
+            message: "Image uploaded successfully.",
+            url: data.ipfsUrl,
+            type
+          };
+        } else {
+          return {
+            success: false,
+            message: "Image failed to upload.",
+            url: null,
+            type
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          message: `An error occurred during image upload: ${error.message}`,
+          url: null,
+          type
+        };
+      }
+    },
+    []
+  );
+}
+
+// src/utils/balance/useFetchBalance.ts
+var import_react13 = require("react");
+var import_viem3 = require("viem");
+function useFetchBalance() {
+  return (0, import_react13.useCallback)(
+    async (publicClient, walletAddress, kibbleTokenAddress) => {
+      try {
+        const balance = await publicClient.readContract({
+          address: (0, import_viem3.getAddress)(kibbleTokenAddress),
+          abi: import_viem3.erc20Abi,
+          functionName: "balanceOf",
+          args: [(0, import_viem3.getAddress)(walletAddress)]
+        });
+        return Number(balance);
+      } catch (error) {
+        console.error("Failed to fetch token balance:", error);
+      }
+    },
+    []
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   useAddAnymalToDatabase,
+  useCreateWeb3Account,
   useDeleteAnymalFromDatabase,
+  useFetchBalance,
+  useFetchUserData,
   useMintAnymalNFT,
   useSaveAnymalMetadata,
   useUpdateAnymalWithNFT,
-  useVerifyAccount
+  useUpdateUserEmail,
+  useUpdateUserPid,
+  useUploadAnymalImage,
+  useVerifyAccount,
+  useVerifyWeb3AuthSession
 });

package/dist/index.mjs

@@ -1,4 +1,4 @@
-// src/utils/useVerifyAccount.ts
+// src/utils/account/useVerifyAccount.ts
 import { useCallback } from "react";
 import { encodeFunctionData, parseGwei } from "viem";
 
@@ -559,7 +559,7 @@ var VERIFY_ACCOUNT_ABI = [
   }
 ];
 
-// src/utils/useVerifyAccount.ts
+// src/utils/account/useVerifyAccount.ts
 function useVerifyAccount() {
   return useCallback(
     async (pid, dbAuthToken, bundlerClient, smartAccount, accountRewardsContractAddress) => {
@@ -599,11 +599,180 @@ function useVerifyAccount() {
   );
 }
 
+// src/utils/account/useVerifyWeb3AuthSession.ts
+import { useCallback as useCallback2 } from "react";
+function useVerifyWeb3AuthSession() {
+  return useCallback2(
+    async (idToken, publicKey, authServiceBaseUrl) => {
+      const response = await fetch(
+        `${authServiceBaseUrl}/verify-web3-session`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken
+          },
+          body: JSON.stringify({ appPubKey: publicKey })
+        }
+      );
+      const { jwt } = await response.json();
+      return jwt;
+    },
+    []
+  );
+}
+
+// src/utils/account/useCreateWeb3Account.ts
+import { useCallback as useCallback3 } from "react";
+function useCreateWeb3Account() {
+  return useCallback3(
+    async (idToken, publicKey, authServiceBaseUrl) => {
+      try {
+        const response = await fetch(`${authServiceBaseUrl}/create-account`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken
+          },
+          body: JSON.stringify({ appPubKey: publicKey })
+        });
+        return await response.json();
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    },
+    []
+  );
+}
+
+// src/utils/account/useFetchUserData.ts
+import { useCallback as useCallback4 } from "react";
+function useFetchUserData() {
+  return useCallback4(async (dbAuthToken, endpoint) => {
+    try {
+      const query = `
+      query User {
+        User {
+          _docID
+          pid
+          email
+          isVerified
+          accountType
+        }
+      }
+    `;
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${dbAuthToken}`
+        },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+      const data = await response.json();
+      if (data && data.data && data.data.User && data.data.User.length > 0) {
+        return data.data.User[0];
+      } else {
+        return null;
+      }
+    } catch (error) {
+      console.error("Error fetching user data:", error);
+      return null;
+    }
+  }, []);
+}
+
+// src/utils/account/useUpdateUserEmail.ts
+import { useCallback as useCallback5 } from "react";
+function useUpdateUserEmail() {
+  return useCallback5(
+    async (dbAuthToken, docID, email, endpoint) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              email
+            }
+          }
+        `;
+        const variables = {
+          docId: [docID],
+          input: {
+            email
+          }
+        };
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}
+
+// src/utils/account/useUpdateUserPid.ts
+import { useCallback as useCallback6 } from "react";
+function useUpdateUserPid() {
+  return useCallback6(
+    async (dbAuthToken, docID, pid, endpoint) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              pid
+            }
+          }
+          `;
+        const variables = {
+          docId: [docID],
+          input: {
+            pid
+          }
+        };
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}
+
 // src/utils/anymals/useMintAnymalNFT.ts
 import { encodeFunctionData as encodeFunctionData2, parseGwei as parseGwei2 } from "viem";
-import { useCallback as useCallback2 } from "react";
+import { useCallback as useCallback7 } from "react";
 function useMintAnymalNFT() {
-  return useCallback2(
+  return useCallback7(
     async (pid, nftId, dbAuthToken, validationContractAddress, smartAccount, bundlerClient) => {
       if (!dbAuthToken || !nftId || !bundlerClient || !smartAccount || !pid || !validationContractAddress) {
         return {
@@ -642,9 +811,9 @@ function useMintAnymalNFT() {
 }
 
 // src/utils/anymals/useAddAnymalToDatabase.ts
-import { useCallback as useCallback3 } from "react";
+import { useCallback as useCallback8 } from "react";
 function useAddAnymalToDatabase() {
-  return useCallback3(
+  return useCallback8(
     async (dbAuthToken, endpoint, anymalData) => {
       if (!dbAuthToken) {
         return {
@@ -709,9 +878,9 @@ function useAddAnymalToDatabase() {
 }
 
 // src/utils/anymals/useDeleteAnymalFromDatabase.ts
-import { useCallback as useCallback4 } from "react";
+import { useCallback as useCallback9 } from "react";
 function useDeleteAnymalFromDatabase() {
-  return useCallback4(
+  return useCallback9(
     async (dbAuthToken, endpoint, anymalDocID) => {
       if (!dbAuthToken || !endpoint || !anymalDocID) return;
       try {
@@ -749,9 +918,9 @@ function useDeleteAnymalFromDatabase() {
 }
 
 // src/utils/anymals/useSaveAnymalMetadata.ts
-import { useCallback as useCallback5 } from "react";
+import { useCallback as useCallback10 } from "react";
 function useSaveAnymalMetadata() {
-  return useCallback5(
+  return useCallback10(
     async (idToken, publicKey, nftMetadataInput, authServiceBaseUrl) => {
       const response = await fetch(`${authServiceBaseUrl}/process-nft`, {
         method: "POST",
@@ -778,9 +947,9 @@ function useSaveAnymalMetadata() {
 }
 
 // src/utils/anymals/useUpdateAnymalWithNFT.ts
-import { useCallback as useCallback6 } from "react";
+import { useCallback as useCallback11 } from "react";
 function useUpdateAnymalWithNFT() {
-  return useCallback6(
+  return useCallback11(
     async (anymalPassportId, anymalDocId, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !anymalPassportId || !anymalDocId || !endpoint) {
         return {
@@ -825,11 +994,152 @@ function useUpdateAnymalWithNFT() {
     []
   );
 }
+
+// src/utils/anymals/useUploadAnymalImage.ts
+import { useCallback as useCallback12 } from "react";
+
+// src/helpers/UploadImageHelper.tsx
+function resizeImage(file, maxWidth = 800, maxHeight = 800, quality = 0.7) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.src = URL.createObjectURL(file);
+    img.onload = () => {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        reject(new Error("Failed to get canvas 2D context"));
+        return;
+      }
+      let width = img.width;
+      let height = img.height;
+      if (width > height) {
+        if (width > maxWidth) {
+          height = Math.round(height *= maxWidth / width);
+          width = maxWidth;
+        }
+      } else {
+        if (height > maxHeight) {
+          width = Math.round(width *= maxHeight / height);
+          height = maxHeight;
+        }
+      }
+      canvas.width = width;
+      canvas.height = height;
+      ctx.drawImage(img, 0, 0, width, height);
+      canvas.toBlob(
+        (blob) => {
+          if (blob) resolve(blob);
+          else reject(new Error("Image compression failed."));
+        },
+        "image/jpeg",
+        quality
+      );
+    };
+    img.onerror = () => reject(new Error("Failed to load image."));
+  });
+}
+async function prepareImage(imageFile) {
+  const compressedFile = await resizeImage(imageFile);
+  return toBase64(compressedFile);
+}
+function toBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve(reader.result.split(",")[1]);
+    reader.onerror = (error) => reject(error);
+  });
+}
+
+// src/utils/anymals/useUploadAnymalImage.ts
+function useUploadAnymalImage() {
+  return useCallback12(
+    async (imageFile, type, idToken, publicKey, authServiceBaseUrl) => {
+      if (!imageFile || !idToken) {
+        return {
+          success: false,
+          message: "No image file selected or not authenticated.",
+          url: null,
+          type
+        };
+      }
+      try {
+        const base64Image = await prepareImage(imageFile);
+        const payload = {
+          appPubKey: publicKey,
+          imageData: base64Image,
+          imageName: imageFile.name.split(".")[0]
+        };
+        const response = await fetch(`${authServiceBaseUrl}/process-image`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${idToken}`
+          },
+          body: JSON.stringify(payload)
+        });
+        const data = await response.json();
+        if (response.ok) {
+          return {
+            success: true,
+            message: "Image uploaded successfully.",
+            url: data.ipfsUrl,
+            type
+          };
+        } else {
+          return {
+            success: false,
+            message: "Image failed to upload.",
+            url: null,
+            type
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          message: `An error occurred during image upload: ${error.message}`,
+          url: null,
+          type
+        };
+      }
+    },
+    []
+  );
+}
+
+// src/utils/balance/useFetchBalance.ts
+import { useCallback as useCallback13 } from "react";
+import { erc20Abi, getAddress } from "viem";
+function useFetchBalance() {
+  return useCallback13(
+    async (publicClient, walletAddress, kibbleTokenAddress) => {
+      try {
+        const balance = await publicClient.readContract({
+          address: getAddress(kibbleTokenAddress),
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [getAddress(walletAddress)]
+        });
+        return Number(balance);
+      } catch (error) {
+        console.error("Failed to fetch token balance:", error);
+      }
+    },
+    []
+  );
+}
 export {
   useAddAnymalToDatabase,
+  useCreateWeb3Account,
   useDeleteAnymalFromDatabase,
+  useFetchBalance,
+  useFetchUserData,
   useMintAnymalNFT,
   useSaveAnymalMetadata,
   useUpdateAnymalWithNFT,
-  useVerifyAccount
+  useUpdateUserEmail,
+  useUpdateUserPid,
+  useUploadAnymalImage,
+  useVerifyAccount,
+  useVerifyWeb3AuthSession
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anymal-protocol",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",

package/src/helpers/UploadImageHelper.tsx

@@ -0,0 +1,63 @@
+export function resizeImage(
+  file: File,
+  maxWidth = 800,
+  maxHeight = 800,
+  quality = 0.7
+): Promise<Blob> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.src = URL.createObjectURL(file);
+    img.onload = () => {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+
+      if (!ctx) {
+        reject(new Error("Failed to get canvas 2D context"));
+        return;
+      }
+
+      let width = img.width;
+      let height = img.height;
+
+      if (width > height) {
+        if (width > maxWidth) {
+          height = Math.round((height *= maxWidth / width));
+          width = maxWidth;
+        }
+      } else {
+        if (height > maxHeight) {
+          width = Math.round((width *= maxHeight / height));
+          height = maxHeight;
+        }
+      }
+
+      canvas.width = width;
+      canvas.height = height;
+      ctx.drawImage(img, 0, 0, width, height);
+
+      canvas.toBlob(
+        (blob) => {
+          if (blob) resolve(blob);
+          else reject(new Error("Image compression failed."));
+        },
+        "image/jpeg",
+        quality
+      );
+    };
+    img.onerror = () => reject(new Error("Failed to load image."));
+  });
+}
+
+export async function prepareImage(imageFile: File): Promise<string> {
+  const compressedFile = (await resizeImage(imageFile)) as Blob;
+  return toBase64(compressedFile);
+}
+
+export function toBase64(file: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => resolve((reader.result as string).split(",")[1]);
+    reader.onerror = (error) => reject(error);
+  });
+}

package/src/index.ts

@@ -1,7 +1,16 @@
-export * from "./utils/useVerifyAccount";
+export * from "./utils/account/useVerifyAccount";
+export * from "./utils/account/useVerifyWeb3AuthSession";
+export * from "./utils/account/useCreateWeb3Account";
+export * from "./utils/account/useFetchUserData";
+export * from "./utils/account/useUpdateUserEmail";
+export * from "./utils/account/useUpdateUserPid";
+
 export * from "./utils/anymals/useMintAnymalNFT";
 export * from "./utils/anymals/useAddAnymalToDatabase";
 export * from "./utils/anymals/useDeleteAnymalFromDatabase";
 export * from "./utils/anymals/useSaveAnymalMetadata";
 export * from "./utils/anymals/useUpdateAnymalWithNFT";
+export * from "./utils/anymals/useUploadAnymalImage";
+
+export * from "./utils/balance/useFetchBalance";
 export * from "./types/Anymal";

package/src/utils/account/useCreateWeb3Account.ts

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+
+export function useCreateWeb3Account() {
+  return useCallback(
+    async (idToken: string, publicKey: string, authServiceBaseUrl: string) => {
+      try {
+        const response = await fetch(`${authServiceBaseUrl}/create-account`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken,
+          },
+          body: JSON.stringify({ appPubKey: publicKey }),
+        });
+
+        return await response.json();
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    },
+    []
+  );
+}

package/src/utils/account/useFetchUserData.ts

@@ -0,0 +1,43 @@
+import { useCallback } from "react";
+
+export function useFetchUserData() {
+  return useCallback(async (dbAuthToken: string, endpoint: string) => {
+    try {
+      const query = `
+      query User {
+        User {
+          _docID
+          pid
+          email
+          isVerified
+          accountType
+        }
+      }
+    `;
+
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${dbAuthToken}`,
+        },
+        body: JSON.stringify({ query }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      if (data && data.data && data.data.User && data.data.User.length > 0) {
+        return data.data.User[0];
+      } else {
+        return null;
+      }
+    } catch (error) {
+      console.error("Error fetching user data:", error);
+      return null;
+    }
+  }, []);
+}

package/src/utils/account/useUpdateUserEmail.ts

@@ -0,0 +1,48 @@
+import { useCallback } from "react";
+
+export function useUpdateUserEmail() {
+  return useCallback(
+    async (
+      dbAuthToken: string,
+      docID: string,
+      email: string,
+      endpoint: string
+    ) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              email
+            }
+          }
+        `;
+
+        const variables = {
+          docId: [docID],
+          input: {
+            email: email,
+          },
+        };
+
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`,
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables,
+          }),
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}

package/src/utils/account/useUpdateUserPid.ts

@@ -0,0 +1,48 @@
+import { useCallback } from "react";
+
+export function useUpdateUserPid() {
+  return useCallback(
+    async (
+      dbAuthToken: string,
+      docID: string,
+      pid: string,
+      endpoint: string
+    ) => {
+      try {
+        const mutation = `
+          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
+            update_User(docID: $docID, input: $input) {
+              pid
+            }
+          }
+          `;
+
+        const variables = {
+          docId: [docID],
+          input: {
+            pid: pid,
+          },
+        };
+
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${dbAuthToken}`,
+          },
+          body: JSON.stringify({
+            query: mutation,
+            variables,
+          }),
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+      } catch (error) {
+        console.error("Error updating email:", error);
+      }
+    },
+    []
+  );
+}

package/src/utils/{useVerifyAccount.ts → account/useVerifyAccount.ts}

@@ -1,6 +1,6 @@
 import { useCallback } from "react";
 import { encodeFunctionData, parseGwei } from "viem";
-import { VERIFY_ACCOUNT_ABI } from "../helpers/BlockchainAbiHelper";
+import { VERIFY_ACCOUNT_ABI } from "../../helpers/BlockchainAbiHelper";
 
 export function useVerifyAccount() {
   return useCallback(

package/src/utils/account/useVerifyWeb3AuthSession.ts

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+
+export function useVerifyWeb3AuthSession() {
+  return useCallback(
+    async (idToken: string, publicKey: string, authServiceBaseUrl: string) => {
+      const response = await fetch(
+        `${authServiceBaseUrl}/verify-web3-session`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: "Bearer " + idToken,
+          },
+          body: JSON.stringify({ appPubKey: publicKey }),
+        }
+      );
+
+      const { jwt } = await response.json();
+
+      return jwt;
+    },
+    []
+  );
+}

package/src/utils/anymals/useUploadAnymalImage.ts

@@ -0,0 +1,70 @@
+import { useCallback } from "react";
+import { prepareImage } from "../../helpers/UploadImageHelper";
+
+export function useUploadAnymalImage() {
+  return useCallback(
+    async (
+      imageFile: File,
+      type: string,
+      idToken: string,
+      publicKey: string,
+      authServiceBaseUrl: string
+    ) => {
+      if (!imageFile || !idToken) {
+        return {
+          success: false,
+          message: "No image file selected or not authenticated.",
+          url: null,
+          type,
+        };
+      }
+
+      try {
+        const base64Image = await prepareImage(imageFile);
+
+        const payload = {
+          appPubKey: publicKey,
+          imageData: base64Image,
+          imageName: imageFile.name.split(".")[0],
+        };
+
+        const response = await fetch(`${authServiceBaseUrl}/process-image`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${idToken}`,
+          },
+          body: JSON.stringify(payload),
+        });
+
+        const data = await response.json();
+
+        if (response.ok) {
+          return {
+            success: true,
+            message: "Image uploaded successfully.",
+            url: data.ipfsUrl,
+            type,
+          };
+        } else {
+          return {
+            success: false,
+            message: "Image failed to upload.",
+            url: null,
+            type,
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          message: `An error occurred during image upload: ${
+            (error as Error).message
+          }`,
+          url: null,
+          type,
+        };
+      }
+    },
+    []
+  );
+}

package/src/utils/balance/useFetchBalance.ts

@@ -0,0 +1,26 @@
+import { useCallback } from "react";
+import { erc20Abi, getAddress } from "viem";
+
+export function useFetchBalance() {
+  return useCallback(
+    async (
+      publicClient: any,
+      walletAddress: string,
+      kibbleTokenAddress: string
+    ) => {
+      try {
+        const balance = await publicClient.readContract({
+          address: getAddress(kibbleTokenAddress),
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [getAddress(walletAddress)],
+        });
+
+        return Number(balance);
+      } catch (error) {
+        console.error("Failed to fetch token balance:", error);
+      }
+    },
+    []
+  );
+}