anymal-protocol 1.0.1 → 1.0.2

package/package.json

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

package/src/index.ts

@@ -1 +1,6 @@
 export * from "./utils/useVerifyAccount";
+export * from "./utils/anymals/useMintAnymalNFT";
+export * from "./utils/anymals/useAddAnymalToDatabase";
+export * from "./utils/anymals/useDeleteAnymalFromDatabase";
+export * from "./utils/anymals/useSaveAnymalMetadata";
+export * from "./types/Anymal";

package/src/types/Anymal.ts

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

package/src/utils/anymals/useAddAnymalToDatabase.ts

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

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

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

@@ -0,0 +1,37 @@
+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],
+      };
+    },
+    []
+  );
+}

package/src/utils/anymals/useUpdateAnymalWithNFT.ts

@@ -0,0 +1,59 @@
+import { useCallback } from "react";
+
+export function useUpdateAnymalWithNFT() {
+  return useCallback(
+    async (
+      anymalPassportId: string,
+      anymalDocId: string,
+      dbAuthToken: string,
+      endpoint: string
+    ): Promise<{ success: boolean }> => {
+      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 };
+      }
+    },
+    []
+  );
+}