anymal-protocol 1.0.13 → 1.0.15

package/src/helpers/UploadImageHelper.tsx

@@ -1,63 +0,0 @@
-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,20 +0,0 @@
-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/account/useUpdateUserAsVerified";
-export * from "./utils/account/useUpdateUserName";
-
-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/application/useCreateUserAppData";
-
-export * from "./utils/balance/useFetchBalance";
-export * from "./types/Anymal";

package/src/types/Anymal.ts

@@ -1,8 +0,0 @@
-export interface CreateAnymalInputData {}
-
-export interface AnymalNftMetadataInputData {
-  name: string;
-  description: string;
-  image: string;
-  nft_id: string;
-}

package/src/utils/account/useCreateWeb3Account.ts

@@ -1,24 +0,0 @@
-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

@@ -1,44 +0,0 @@
-import { useCallback } from "react";
-
-export function useFetchUserData() {
-  return useCallback(async (dbAuthToken: string, endpoint: string) => {
-    try {
-      const query = `
-        query User {
-          User {
-            _docID
-            pid
-            email
-            name
-            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/useUpdateUserAsVerified.ts

@@ -1,52 +0,0 @@
-import { useCallback } from "react";
-
-export function useUpdateUserAsVerified() {
-  return useCallback(
-    async (
-      recaptchaToken: string | null,
-      docID: string,
-      dbAuthToken: string,
-      endpoint: string
-    ) => {
-      if (!docID || !dbAuthToken || recaptchaToken === null) return;
-
-      try {
-        const mutation = `
-          mutation Update_User($docID: [ID], $input: UserMutationInputArg) {
-            update_User(docID: $docID, input: $input) {
-              isVerified
-            }
-          }
-        `;
-
-        const variables = {
-          docId: [docID],
-          input: {
-            isVerified: true,
-          },
-        };
-
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${dbAuthToken}`,
-          },
-          body: JSON.stringify({
-            query: mutation,
-            variables,
-          }),
-        });
-
-        const responseMessage = response.ok
-          ? "Your account has been verified!"
-          : "An error has occured, try again.";
-
-        return { success: response.ok, message: responseMessage };
-      } catch (error) {
-        return { success: false, message: (error as Error).message };
-      }
-    },
-    []
-  );
-}

package/src/utils/account/useUpdateUserEmail.ts

@@ -1,48 +0,0 @@
-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/useUpdateUserName.ts

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

package/src/utils/account/useUpdateUserPid.ts

@@ -1,48 +0,0 @@
-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/account/useVerifyAccount.ts

@@ -1,61 +0,0 @@
-import { useCallback } from "react";
-import { encodeFunctionData, parseGwei } from "viem";
-import { VERIFY_ACCOUNT_ABI } from "../../helpers/BlockchainAbiHelper";
-
-export function useVerifyAccount() {
-  return useCallback(
-    async (
-      pid: string,
-      dbAuthToken: string,
-      bundlerClient: any,
-      smartAccount: any,
-      accountRewardsContractAddress: `0x${string}`
-    ): Promise<{
-      success: boolean;
-      message: string;
-    }> => {
-      if (
-        !dbAuthToken ||
-        !bundlerClient ||
-        !smartAccount ||
-        !accountRewardsContractAddress ||
-        !pid
-      ) {
-        return {
-          success: false,
-          message: "Missing crucial information",
-        };
-      }
-
-      const callData = encodeFunctionData({
-        abi: VERIFY_ACCOUNT_ABI,
-        functionName: "claimRewardByName",
-        args: ["petastic-signup-campaign-1", pid],
-      });
-
-      try {
-        const userOpHash = await bundlerClient.sendUserOperation({
-          account: smartAccount,
-          calls: [
-            {
-              to: accountRewardsContractAddress,
-              data: callData,
-            },
-          ],
-          maxPriorityFeePerGas: parseGwei("0.099"),
-          maxFeePerGas: parseGwei("0.099"),
-        });
-
-        await bundlerClient.waitForUserOperationReceipt({
-          hash: userOpHash,
-        });
-
-        return { success: true, message: "Registration kibble awarded" };
-      } catch (error) {
-        console.error(error);
-        return { success: false, message: (error as Error).message };
-      }
-    },
-    []
-  );
-}

package/src/utils/account/useVerifyWeb3AuthSession.ts

@@ -1,24 +0,0 @@
-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/useAddAnymalToDatabase.ts

@@ -1,82 +0,0 @@
-import { useCallback } from "react";
-import { CreateAnymalInputData } from "../../types/Anymal";
-
-export function useAddAnymalToDatabase() {
-  return useCallback(
-    async (
-      dbAuthToken: string,
-      endpoint: string,
-      anymalData: CreateAnymalInputData
-    ): Promise<{
-      _docID: string | null;
-      success: boolean;
-      message: string;
-    }> => {
-      if (!dbAuthToken) {
-        return {
-          success: false,
-          message: "Authentication token is missing.",
-          _docID: null,
-        };
-      }
-
-      let anymalDocID: string | null = null;
-
-      try {
-        const mutation = `
-                mutation Create_Anymal($input: [AnymalMutationInputArg!]) {
-                    create_Anymal(input: $input) {
-                      _docID
-                      name
-                      passportID
-                    }
-                }
-            `;
-
-        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; // Capture the petDocID if possible
-            throw new Error("Document with the given ID already exists.");
-          }
-          throw new Error(`GraphQL error: ${errorMessage}`);
-        }
-
-        anymalDocID = data.create_Anymal[0]._docID;
-        return {
-          success: true,
-          _docID: anymalDocID,
-          message: "Anymal added to account",
-        };
-      } catch (error) {
-        return {
-          success: false,
-          _docID: null,
-          message: "Error adding anymal to account",
-        };
-      }
-    },
-    []
-  );
-}

package/src/utils/anymals/useDeleteAnymalFromDatabase.ts

@@ -1,47 +0,0 @@
-import { useCallback } from "react";
-
-export function useDeleteAnymalFromDatabase() {
-  return useCallback(
-    async (
-      dbAuthToken: string,
-      endpoint: string,
-      anymalDocID: string
-    ): Promise<void> => {
-      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;
-      }
-    },
-    []
-  );
-}

package/src/utils/anymals/useMintAnymalNFT.ts

@@ -1,63 +0,0 @@
-import { encodeFunctionData, parseGwei } from "viem";
-import { PET_NFT_ABI } from "../../helpers/BlockchainAbiHelper";
-import { useCallback } from "react";
-
-export function useMintAnymalNFT() {
-  return useCallback(
-    async (
-      pid: string,
-      nftId: string,
-      dbAuthToken: string,
-      validationContractAddress: string,
-      smartAccount: any,
-      bundlerClient: any
-    ): Promise<{
-      success: boolean;
-      message: string;
-    }> => {
-      if (
-        !dbAuthToken ||
-        !nftId ||
-        !bundlerClient ||
-        !smartAccount ||
-        !pid ||
-        !validationContractAddress
-      ) {
-        return {
-          success: false,
-          message: "Missing authentication token OR NFT ID.",
-        };
-      }
-
-      const callData = encodeFunctionData({
-        abi: PET_NFT_ABI,
-        functionName: "submitMetadataByCampaignName",
-        args: [
-          pid,
-          nftId,
-          `https://dev-nft.petastic.com/metadata/${nftId}`,
-          "petastic-signup-campaign-1",
-        ],
-      });
-
-      const userOpHash = await bundlerClient.sendUserOperation({
-        account: smartAccount,
-        calls: [
-          {
-            to: validationContractAddress,
-            data: callData,
-          },
-        ],
-        maxPriorityFeePerGas: parseGwei("0.001"),
-        maxFeePerGas: parseGwei("0.001"),
-      });
-
-      await bundlerClient.waitForUserOperationReceipt({
-        hash: userOpHash,
-      });
-
-      return { success: true, message: "Pet Passport Created!" };
-    },
-    []
-  );
-}

package/src/utils/anymals/useSaveAnymalMetadata.ts

@@ -1,37 +0,0 @@
-import { useCallback } from "react";
-import { AnymalNftMetadataInputData } from "../../types/Anymal";
-
-export function useSaveAnymalMetadata() {
-  return useCallback(
-    async (
-      idToken: string,
-      publicKey: string,
-      nftMetadataInput: AnymalNftMetadataInputData,
-      authServiceBaseUrl: string
-    ) => {
-      const response = await fetch(`${authServiceBaseUrl}/process-nft`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + idToken,
-        },
-        body: JSON.stringify({
-          appPubKey: publicKey,
-          nftMetadataInput: nftMetadataInput,
-        }),
-      });
-
-      const data = await response.json();
-
-      if (data.errors) {
-        throw new Error(`GraphQL error: ${JSON.stringify(data.errors)}`);
-      }
-
-      return {
-        success: true,
-        message: data[0],
-      };
-    },
-    []
-  );
-}