anymal-protocol 1.0.59 → 1.0.61

package/dist/index.js

@@ -20,7 +20,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AUTH_API_ENDPOINTS: () => AUTH_API_ENDPOINTS,
+  ActionType: () => ActionType,
+  NETWORK_HOSTS: () => NETWORK_HOSTS,
+  Network: () => Network,
+  createAuthEnvelope: () => createAuthEnvelope,
+  fetchAnymals: () => fetchAnymals,
+  generateAppSignature: () => generateAppSignature,
   generateBytes32Nonce: () => generateBytes32Nonce,
+  generateJWT: () => generateJWT,
+  loadExistingSecp256k1PrivateKey: () => loadExistingSecp256k1PrivateKey,
+  serializePublicKeyCompressed: () => serializePublicKeyCompressed,
+  submitAction: () => submitAction,
   useAddAnymalToDatabase: () => useAddAnymalToDatabase,
   useApproveKibbleToken: () => useApproveKibbleToken,
   useApproveOrgPartialPayment: () => useApproveOrgPartialPayment,
@@ -29,6 +40,8 @@ __export(index_exports, {
   useCreateUserAppData: () => useCreateUserAppData,
   useCreateWeb3Account: () => useCreateWeb3Account,
   useDeleteAnymalFromDatabase: () => useDeleteAnymalFromDatabase,
+  useFetchActions: () => useFetchActions,
+  useFetchAnymals: () => useFetchAnymals,
   useFetchBalance: () => useFetchBalance,
   useFetchNotifications: () => useFetchNotifications,
   useFetchUserData: () => useFetchUserData,
@@ -1308,10 +1321,12 @@ function useAddAnymalToDatabase() {
         return {
           success: false,
           message: "Authentication token is missing.",
-          _docID: null
+          _docID: null,
+          dbCid: null
         };
       }
       let anymalDocID = null;
+      let dbCid = null;
       try {
         const mutation = `
                 mutation Create_Anymal($input: [AnymalMutationInputArg!]) {
@@ -1319,6 +1334,9 @@ function useAddAnymalToDatabase() {
                       _docID
                       name
                       passportID
+                      _version {
+                       cid
+                      }
                     }
                 }
             `;
@@ -1349,15 +1367,18 @@ function useAddAnymalToDatabase() {
           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"
         };
       }
@@ -1598,11 +1619,68 @@ function useUploadAnymalImage() {
   );
 }
 
+// src/utils/anymals/useFetchAnymals.ts
+var import_react16 = require("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 (0, import_react16.useCallback)(fetchAnymals, []);
+}
+
 // src/utils/marketplace/useProcessPartialKibblePayment.ts
 var import_viem3 = require("viem");
-var import_react16 = require("react");
+var import_react17 = require("react");
 function useProcessPartialKibblePayment() {
-  return (0, import_react16.useCallback)(
+  return (0, import_react17.useCallback)(
     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 {
@@ -1665,9 +1743,9 @@ function useProcessPartialKibblePayment() {
 
 // src/utils/marketplace/useApproveKibbleToken.ts
 var import_viem4 = require("viem");
-var import_react17 = require("react");
+var import_react18 = require("react");
 function useApproveKibbleToken() {
-  return (0, import_react17.useCallback)(
+  return (0, import_react18.useCallback)(
     async (kibbleTokenAddress, marketplaceContract, amount, smartAccount, bundlerClient) => {
       try {
         const callData = (0, import_viem4.encodeFunctionData)({
@@ -1717,10 +1795,10 @@ function useApproveKibbleToken() {
 }
 
 // src/utils/organization/useCreateOrganizationBase.ts
-var import_react18 = require("react");
+var import_react19 = require("react");
 var import_viem5 = require("viem");
 function useCreateOrganizationBase() {
-  return (0, import_react18.useCallback)(
+  return (0, import_react19.useCallback)(
     /**
      * Creates a new organization on-chain.
      *
@@ -1806,10 +1884,10 @@ function useCreateOrganizationBase() {
 }
 
 // src/utils/organization/useApproveOrgKibbleToken.ts
-var import_react19 = require("react");
+var import_react20 = require("react");
 var import_viem6 = require("viem");
 function useApproveOrgPartialPayment() {
-  return (0, import_react19.useCallback)(
+  return (0, import_react20.useCallback)(
     async (orgContractAddress, kibbleTokenAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, approveAmount) => {
       if (!orgContractAddress || !kibbleTokenAddress || !partialPaymentModuleAddress || !managerSmartAccount || !bundlerClient || !approveAmount) {
         return {
@@ -1851,10 +1929,10 @@ function useApproveOrgPartialPayment() {
 }
 
 // src/utils/organization/useProcessOrgPartialKibblePayment.ts
-var import_react20 = require("react");
+var import_react21 = require("react");
 var import_viem7 = require("viem");
 function useProcessOrgPartialKibblePayment() {
-  return (0, import_react20.useCallback)(
+  return (0, import_react21.useCallback)(
     async (orgContractAddress, partialPaymentModuleAddress, managerSmartAccount, bundlerClient, orderId, anymalNftId, pid, amountInTokens, maxTokenPayment, nonce, deadline, backendSignature) => {
       if (!orgContractAddress || !partialPaymentModuleAddress || !managerSmartAccount || !bundlerClient || !orderId || !pid || !nonce || !backendSignature) {
         return {
@@ -1905,9 +1983,9 @@ function useProcessOrgPartialKibblePayment() {
 }
 
 // src/utils/organization/useUpdateOrgWalletAddress.ts
-var import_react21 = require("react");
+var import_react22 = require("react");
 function useUpdateOrgWalletAddress() {
-  return (0, import_react21.useCallback)(
+  return (0, import_react22.useCallback)(
     async (dbAuthToken, docID, baseWalletAddress, endpoint) => {
       try {
         const mutation = `
@@ -1953,11 +2031,145 @@ var generateBytes32Nonce = () => {
   return (0, import_viem8.padHex)(`0x${uuid3}`, { size: 32 });
 };
 
+// src/helpers/CryptoUtils.tsx
+var import_elliptic = require("elliptic");
+var ec = new import_elliptic.ec("secp256k1");
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["Testnet"] = "testnet";
+  Network2["Localnet"] = "localnet";
+  return Network2;
+})(Network || {});
+var NETWORK_HOSTS = {
+  ["testnet" /* Testnet */]: "dev-db.petastic.com",
+  ["localnet" /* Localnet */]: "host.docker.internal:9181"
+};
+var AUTH_API_ENDPOINTS = {
+  ["testnet" /* Testnet */]: "https://dev-auth-api.petastic.com",
+  ["localnet" /* Localnet */]: "http://localhost:3005"
+};
+function loadExistingSecp256k1PrivateKey(hexKey) {
+  if (!hexKey) {
+    throw new Error("Private key hex must be provided");
+  }
+  return ec.keyFromPrivate(hexKey, "hex");
+}
+function serializePublicKeyCompressed(keyPair) {
+  return keyPair.getPublic(true, "hex");
+}
+function base64url(input) {
+  let buf;
+  if (typeof input === "string") buf = Buffer.from(input);
+  else if (input instanceof ArrayBuffer) buf = Buffer.from(input);
+  else buf = input;
+  return buf.toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function sha256HashNode(data) {
+  const { createHash } = require("crypto");
+  return createHash("sha256").update(data).digest();
+}
+async function hashInput(data) {
+  if (typeof window !== "undefined" && window.crypto?.subtle) {
+    const encoder = new TextEncoder();
+    const encoded = encoder.encode(data);
+    const hashBuffer = await window.crypto.subtle.digest("SHA-256", encoded);
+    return Buffer.from(hashBuffer);
+  } else {
+    return sha256HashNode(data);
+  }
+}
+async function generateJWT(sub, aud, keyPair, expiresInSeconds = 24 * 60 * 60) {
+  const iat = Math.floor(Date.now() / 1e3);
+  const exp = iat + expiresInSeconds;
+  const header = { alg: "ES256", typ: "JWT" };
+  const payload = { sub, aud, iat, exp };
+  const encodedHeader = base64url(JSON.stringify(header));
+  const encodedPayload = base64url(JSON.stringify(payload));
+  const signingInput = `${encodedHeader}.${encodedPayload}`;
+  const hash = await hashInput(signingInput);
+  const signature = keyPair.sign(hash, { canonical: true });
+  const rBuf = signature.r.toArrayLike(Buffer, "be", 32);
+  const sBuf = signature.s.toArrayLike(Buffer, "be", 32);
+  const rawSig = Buffer.concat([rBuf, sBuf]);
+  const encodedSig = base64url(rawSig);
+  return `${signingInput}.${encodedSig}`;
+}
+async function createAuthEnvelope(privateKeyHex, network = "testnet" /* Testnet */, options) {
+  const keyPair = loadExistingSecp256k1PrivateKey(privateKeyHex);
+  const publicKey = serializePublicKeyCompressed(keyPair);
+  const host = NETWORK_HOSTS[network];
+  if (!host) {
+    throw new Error(`Unsupported network: ${network}`);
+  }
+  const token = await generateJWT(publicKey, host, keyPair, options?.expiresInSeconds);
+  return { publicKey, token };
+}
+async function generateAppSignature(privateKeyHex, clientId, redirectUri, state) {
+  const keyPair = loadExistingSecp256k1PrivateKey(privateKeyHex);
+  const message = `${clientId}:${redirectUri}:${state}`;
+  const hash = await hashInput(message);
+  const signatureDER = keyPair.sign(hash, { canonical: true }).toDER();
+  return Buffer.from(signatureDER).toString("hex");
+}
+
+// src/helpers/ActionHelpers.tsx
+async function submitAction(idToken, pid, payload, endpointBaseUrl) {
+  const api = endpointBaseUrl + "/actions";
+  const response = await fetch(api, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Authorization": "Bearer " + idToken },
+    body: JSON.stringify({ actionId: payload.actionId, pid, payload })
+  });
+  if (!response.ok) {
+    const err = await response.json();
+    throw new Error(err.error || "Failed to submit action");
+  }
+  return response.json();
+}
+
+// src/utils/actions/useFetchActions.ts
+var import_react23 = require("react");
+function useFetchActions() {
+  return (0, import_react23.useCallback)(
+    async (idToken, actionsServiceBaseUrl, pid, status, limit, offset) => {
+      const params = new URLSearchParams({ pid });
+      if (status) params.set("status", status);
+      if (limit != null) params.set("limit", `${limit}`);
+      if (offset != null) params.set("offset", `${offset}`);
+      try {
+        const response = await fetch(
+          `${actionsServiceBaseUrl}/actions?${params.toString()}`,
+          {
+            method: "GET",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: "Bearer " + idToken
+            }
+          }
+        );
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        return await response.json();
+      } catch (error) {
+        console.error("useFetchActions error:", error);
+        return null;
+      }
+    },
+    []
+  );
+}
+
+// src/types/Actions.ts
+var ActionType = /* @__PURE__ */ ((ActionType2) => {
+  ActionType2["GRAPHQL"] = "GRAPHQL";
+  ActionType2["CONTRACT"] = "CONTRACT";
+  ActionType2["EXTERNAL"] = "EXTERNAL";
+  return ActionType2;
+})(ActionType || {});
+
 // src/utils/application/useCreateUserAppData.ts
-var import_react22 = require("react");
+var import_react24 = require("react");
 var import_uuid2 = require("uuid");
 function useCreateUserAppData() {
-  return (0, import_react22.useCallback)(
+  return (0, import_react24.useCallback)(
     async (appId, pid, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !pid || !dbAuthToken || !endpoint) return;
       const appValues = {
@@ -2012,10 +2224,10 @@ function useCreateUserAppData() {
 }
 
 // src/utils/application/useCreateOrganizationAppData.ts
-var import_react23 = require("react");
+var import_react25 = require("react");
 var import_uuid3 = require("uuid");
 function useCreateOrganizationAppData() {
-  return (0, import_react23.useCallback)(
+  return (0, import_react25.useCallback)(
     async (appId, pid, dbAuthToken, endpoint) => {
       if (!dbAuthToken || !pid || !dbAuthToken || !endpoint) return;
       const appValues = {
@@ -2069,10 +2281,10 @@ function useCreateOrganizationAppData() {
 }
 
 // src/utils/balance/useFetchBalance.ts
-var import_react24 = require("react");
+var import_react26 = require("react");
 var import_viem9 = require("viem");
 function useFetchBalance() {
-  return (0, import_react24.useCallback)(
+  return (0, import_react26.useCallback)(
     async (publicClient, walletAddress, kibbleTokenAddress) => {
       try {
         const balance = await publicClient.readContract({
@@ -2091,7 +2303,18 @@ function useFetchBalance() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AUTH_API_ENDPOINTS,
+  ActionType,
+  NETWORK_HOSTS,
+  Network,
+  createAuthEnvelope,
+  fetchAnymals,
+  generateAppSignature,
   generateBytes32Nonce,
+  generateJWT,
+  loadExistingSecp256k1PrivateKey,
+  serializePublicKeyCompressed,
+  submitAction,
   useAddAnymalToDatabase,
   useApproveKibbleToken,
   useApproveOrgPartialPayment,
@@ -2100,6 +2323,8 @@ function useFetchBalance() {
   useCreateUserAppData,
   useCreateWeb3Account,
   useDeleteAnymalFromDatabase,
+  useFetchActions,
+  useFetchAnymals,
   useFetchBalance,
   useFetchNotifications,
   useFetchUserData,