@zing-protocol/zing-sdk 0.0.17 → 0.1.0

package/dist/getters.js

@@ -1,8 +1,5 @@
-import { TypeName } from "./_generated/zing_identity/deps/std/type_name.js";
-import { IdentifierInfo } from "./_generated/zing_identity/identity.js";
-import { Article, PublishArticleEventV1, } from "./_generated/zing_studio/article.js";
+import { Article, PublishArticleEvent, } from "./_generated/zing_studio/article.js";
 import { Field } from "./_generated/zing_studio/deps/sui/dynamic_field.js";
-import { VecMap } from "./_generated/zing_studio/deps/sui/vec_map.js";
 import { BlobRegistered } from "./_generated/zing_studio/deps/walrus/events.js";
 import { Referral } from "./_generated/zing_studio/referral.js";
 import { StorageSpace, StorageTreasury, } from "./_generated/zing_studio/storage.js";
@@ -37,57 +34,66 @@ export function getReferralID(studioConfigId, address) {
     const key = new TextEncoder().encode("referral");
     return deriveDynamicFieldID(studioId, "vector<u8>", bcs.vector(bcs.u8()).serialize(key).toBytes());
 }
-export async function getIdentifierByAddress(suiGrpcClient, addressToIdentifierDynamicFieldId, address) {
-    const dfObjectId = deriveDynamicFieldID(addressToIdentifierDynamicFieldId, "address", bcs.Address.serialize(address).toBytes());
-    const res = await suiGrpcClient.ledgerService.getObject({
-        objectId: dfObjectId,
-        readMask: {
-            paths: ["bcs"],
-        },
-    });
-    if (!res.response.object?.bcs?.value) {
-        return null;
-    }
-    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
-    if (suiMoveObject.data.$kind === "Package")
-        throw new Error("Move Object is Package");
-    const field = Field(bcs.Address, bcs.String).parse(suiMoveObject.data.Move.contents);
-    return field.value;
-}
-export async function getIdentifierInfoByIdentifier(suiGrpcClient, identifierInfoDynamicFieldId, identifier) {
-    const dfObjectId = deriveDynamicFieldID(identifierInfoDynamicFieldId, "0x1::ascii::String", bcs.Address.serialize(identifier).toBytes());
-    const res = await suiGrpcClient.ledgerService.getObject({
-        objectId: dfObjectId,
-        readMask: {
-            paths: ["bcs"],
-        },
-    });
-    if (!res.response.object?.bcs?.value) {
-        return null;
-    }
-    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
-    if (suiMoveObject.data.$kind === "Package")
-        throw new Error("Move Object is Package");
-    const field = Field(bcs.String, IdentifierInfo).parse(suiMoveObject.data.Move.contents);
-    return field.value;
-}
-export async function getDonationByIdentifier(suiGrpcClient, donationTableId, identifier) {
-    const dfObjectId = deriveDynamicFieldID(donationTableId, "0x1::ascii::String", bcs.Address.serialize(identifier).toBytes());
-    const res = await suiGrpcClient.ledgerService.getObject({
-        objectId: dfObjectId,
-        readMask: {
-            paths: ["bcs"],
-        },
-    });
-    if (!res.response.object?.bcs?.value) {
-        return null;
-    }
-    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
-    if (suiMoveObject.data.$kind === "Package")
-        throw new Error("Move Object is Package");
-    const field = Field(bcs.String, VecMap(TypeName, bcs.U64)).parse(suiMoveObject.data.Move.contents);
-    return field.value;
-}
+// export async function getIdentifierByAddress(
+//   suiGrpcClient: SuiGrpcClient,
+//   addressToIdentifierDynamicFieldId: string,
+//   address: string,
+// ) {
+//   const dfObjectId = deriveDynamicFieldID(
+//     addressToIdentifierDynamicFieldId,
+//     "address",
+//     bcs.Address.serialize(address).toBytes(),
+//   );
+//   const res = await suiGrpcClient.ledgerService.getObject({
+//     objectId: dfObjectId,
+//     readMask: {
+//       paths: ["bcs"],
+//     },
+//   });
+//   if (!res.response.object?.bcs?.value) {
+//     return null;
+//   }
+//
+//   const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+//   if (suiMoveObject.data.$kind === "Package")
+//     throw new Error("Move Object is Package");
+//
+//   const field = Field(bcs.Address, bcs.String).parse(
+//     suiMoveObject.data.Move.contents,
+//   );
+//
+//   return field.value;
+// }
+// export async function getIdentifierInfoByIdentifier(
+//   suiGrpcClient: SuiGrpcClient,
+//   identifierInfoDynamicFieldId: string,
+//   identifier: string,
+// ) {
+//   const dfObjectId = deriveDynamicFieldID(
+//     identifierInfoDynamicFieldId,
+//     "0x1::ascii::String",
+//     bcs.Address.serialize(identifier).toBytes(),
+//   );
+//   const res = await suiGrpcClient.ledgerService.getObject({
+//     objectId: dfObjectId,
+//     readMask: {
+//       paths: ["bcs"],
+//     },
+//   });
+//   if (!res.response.object?.bcs?.value) {
+//     return null;
+//   }
+//
+//   const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+//   if (suiMoveObject.data.$kind === "Package")
+//     throw new Error("Move Object is Package");
+//
+//   const field = Field(bcs.String, IdentifierInfo).parse(
+//     suiMoveObject.data.Move.contents,
+//   );
+//
+//   return field.value;
+// }
 export async function getStudio(suiGrpcClient, studioId) {
     try {
         const res = await suiGrpcClient.ledgerService.getObject({
@@ -304,7 +310,7 @@ export async function getPublishedArticleAndBlobId(suiGrpcClient, walrusClient,
         throw new Error("fail to get publishArticleEvent");
     }
     const blobObjectId = BlobRegistered.parse(blobRegisteredEvent.contents?.value).object_id;
-    const parsedPublishArticleEvent = PublishArticleEventV1.parse(publishArticleEvent.contents.value);
+    const parsedPublishArticleEvent = PublishArticleEvent.parse(publishArticleEvent.contents.value);
     return { parsedPublishArticleEvent, blobObjectId };
 }
 export function encodeQuiltPatchId(id) {

package/dist/hooks/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./useSignAndExecuteTransaction.js";
-export * from "./useReclaim.js";
 export * from "./useGetStudio.js";
 export * from "./useZingMutation.js";
 export * from "./useZingQuery.js";

package/dist/hooks/index.js

@@ -1,5 +1,5 @@
 export * from "./useSignAndExecuteTransaction.js";
-export * from "./useReclaim.js";
+// export * from "./useReclaim.js";
 export * from "./useGetStudio.js";
 export * from "./useZingMutation.js";
 export * from "./useZingQuery.js";

package/dist/hooks/useGetStudio.d.ts

@@ -1,9 +1,7 @@
 export declare function useGetStudio(suiAddress?: string): import("@tanstack/react-query").UseQueryResult<{
-    id: {
-        id: string;
-    };
+    id: string;
     owner: string;
-    period: string[];
+    period: [string, string];
     monthly_subscription_fee: {
         contents: {
             key: number;
@@ -11,15 +9,11 @@ export declare function useGetStudio(suiAddress?: string): import("@tanstack/rea
         }[];
     };
     membership: {
-        id: {
-            id: string;
-        };
+        id: string;
         size: string;
     };
     works: {
-        id: {
-            id: string;
-        };
+        id: string;
         size: string;
     };
     encrypted_file_key: number[] | null;

package/dist/hooks/useReclaim.d.ts

@@ -1,11 +1 @@
-import type { PlatformType } from "../config/common.js";
-import type { ReclaimProof } from "../lib/utils/reclaim.js";
-import type { SuiGrpcClient } from "@mysten/sui/grpc";
-interface CommitProofParams {
-    suiClient: SuiGrpcClient;
-    walletAddress: string;
-    platform: PlatformType;
-    proof: ReclaimProof;
-}
-export declare function useCommitProof(): import("@tanstack/react-query").UseMutationResult<import("@mysten/sui/jsonRpc").TransactionEffects | null, Error, CommitProofParams, unknown>;
 export {};

package/dist/hooks/useReclaim.js

@@ -1,92 +1,169 @@
-import { useSignAndExecuteTransaction } from "./useSignAndExecuteTransaction.js";
-import { commitProof, revealAndVerifyProof, } from "../_generated/zing_identity/reclaim.js";
-import { useZingClient } from "../components/zing-provider.js";
-import { hexToBytes, textToBytes, generateCommitmentHash, generateCommitNonce, } from "../lib/utils/reclaim.js";
-import { bcs } from "@mysten/sui/bcs";
-import { Transaction } from "@mysten/sui/transactions";
-import { useMutation } from "@tanstack/react-query";
-import sha3 from "js-sha3";
-export function useCommitProof() {
-    const { mutateAsync: signAndExecuteTransaction } = useSignAndExecuteTransaction();
-    const zingClient = useZingClient();
-    const config = zingClient.config;
-    return useMutation({
-        mutationFn: async ({ suiClient, walletAddress, platform, proof, }) => {
-            const nonce = generateCommitNonce(walletAddress, proof.identifier);
-            const commitmentHash = generateCommitmentHash(proof, nonce);
-            const identifierHash = hexToBytes(sha3.keccak256(textToBytes(proof.identifier)));
-            const identityPlatform = config.zing.IDENTITY_PLATFORMS[platform];
-            const commitProofTransaction = new Transaction();
-            commitProofTransaction.add(commitProof({
-                package: config.zing.ZING_IDENTITY_PACKAGE_ADDRESS,
-                typeArguments: [identityPlatform.PLATFORM_TYPE],
-                arguments: {
-                    self: commitProofTransaction.sharedObjectRef(identityPlatform.RECLAIM_MANAGER_SHARED_OBJECT_REF),
-                    config: commitProofTransaction.sharedObjectRef(config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF),
-                    commitmentHash: commitProofTransaction.pure(bcs.vector(bcs.u8()).serialize(commitmentHash)),
-                    identifierHash: commitProofTransaction.pure(bcs.vector(bcs.u8()).serialize(identifierHash)),
-                },
-            }));
-            const commitTransactionResponse = await signAndExecuteTransaction({
-                transaction: commitProofTransaction,
-            });
-            if (!commitTransactionResponse)
-                throw new Error("fail to commit proof");
-            const settledCommitTransactionResult = await suiClient.waitForTransaction({
-                digest: commitTransactionResponse.transactionDigest,
-                include: {
-                    effects: true,
-                    objectTypes: true,
-                },
-            });
-            const commitTransactionObjectChanges = settledCommitTransactionResult.Transaction?.effects.changedObjects ||
-                [];
-            if (!commitTransactionObjectChanges)
-                throw new Error("fail to commit proof");
-            const commitment = commitTransactionObjectChanges.find((objChange) => {
-                if (objChange.idOperation !== "Created")
-                    return false;
-                const type = settledCommitTransactionResult.Transaction?.objectTypes[objChange.objectId];
-                return type === config.zing.PROOF_COMMITMENT_TYPE;
-            });
-            if (!commitment || commitment.idOperation !== "Created")
-                throw new Error("fail to commit proof");
-            const revealTransaction = new Transaction();
-            const [, proofObj] = revealTransaction.add(revealAndVerifyProof({
-                package: config.zing.ZING_IDENTITY_PACKAGE_ADDRESS,
-                typeArguments: [identityPlatform.PLATFORM_TYPE],
-                arguments: {
-                    self: revealTransaction.sharedObjectRef(identityPlatform.RECLAIM_MANAGER_SHARED_OBJECT_REF),
-                    config: revealTransaction.sharedObjectRef(config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF),
-                    commitmentId: revealTransaction.pure.id(commitment.objectId),
-                    provider: revealTransaction.pure.string(proof.claimData.provider),
-                    parameters: revealTransaction.pure.string(proof.claimData.parameters),
-                    context: revealTransaction.pure.string(proof.claimData.context),
-                    identifier: revealTransaction.pure.string(proof.claimData.identifier),
-                    owner: revealTransaction.pure.string(proof.claimData.owner),
-                    epoch: revealTransaction.pure.string(proof.claimData.epoch.toString()),
-                    timestampS: revealTransaction.pure.u64(proof.claimData.timestampS),
-                    signatures: revealTransaction.pure(bcs
-                        .vector(bcs.vector(bcs.u8()))
-                        .serialize(proof.signatures.map((sig) => hexToBytes(sig.substring(2))))),
-                    nonce: revealTransaction.pure(bcs.vector(bcs.u8()).serialize(nonce)),
-                },
-            }));
-            // Call extract parameters customizaed functions; this interface should identical for different platforms
-            revealTransaction.moveCall({
-                target: identityPlatform.PLATFORM_UPDATE_PROOF_TARGET,
-                arguments: [
-                    // IdentityManager
-                    revealTransaction.sharedObjectRef(identityPlatform.IDENTITY_MANAGER_SHARED_OBJECT_REF),
-                    // IdentityConfig
-                    revealTransaction.sharedObjectRef(config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF),
-                    proofObj,
-                ],
-            });
-            const transactionResponse = await signAndExecuteTransaction({
-                transaction: revealTransaction,
-            });
-            return transactionResponse;
-        },
-    });
-}
+export {};
+// import { useSignAndExecuteTransaction } from "./useSignAndExecuteTransaction.js";
+// import {
+//   commitProof,
+//   revealAndVerifyProof,
+// } from "../_generated/zing_identity/reclaim.js";
+// import { useZingClient } from "../components/zing-provider.js";
+// import {
+//   hexToBytes,
+//   textToBytes,
+//   generateCommitmentHash,
+//   generateCommitNonce,
+// } from "../lib/utils/reclaim.js";
+// import { bcs } from "@mysten/sui/bcs";
+// import { Transaction } from "@mysten/sui/transactions";
+// import { useMutation } from "@tanstack/react-query";
+// import sha3 from "js-sha3";
+// import type { PlatformType } from "../config/common.js";
+// import type { ReclaimProof } from "../lib/utils/reclaim.js";
+// import type { SuiGrpcClient } from "@mysten/sui/grpc";
+//
+// interface CommitProofParams {
+//   suiClient: SuiGrpcClient;
+//   walletAddress: string;
+//   platform: PlatformType;
+//   proof: ReclaimProof;
+// }
+//
+// export function useCommitProof() {
+//   const { mutateAsync: signAndExecuteTransaction } =
+//     useSignAndExecuteTransaction();
+//   const zingClient = useZingClient();
+//   const config = zingClient.config;
+//
+//   return useMutation({
+//     mutationFn: async ({
+//       suiClient,
+//       walletAddress,
+//       platform,
+//       proof,
+//     }: CommitProofParams) => {
+//       const nonce = generateCommitNonce(walletAddress, proof.identifier);
+//       const commitmentHash = generateCommitmentHash(proof, nonce);
+//       const identifierHash = hexToBytes(
+//         sha3.keccak256(textToBytes(proof.identifier)),
+//       );
+//
+//       const identityPlatform = config.zing.IDENTITY_PLATFORMS[platform];
+//       const commitProofTransaction = new Transaction();
+//
+//       commitProofTransaction.add(
+//         commitProof({
+//           package: config.zing.ZING_IDENTITY_PACKAGE_ADDRESS,
+//           typeArguments: [identityPlatform.PLATFORM_TYPE],
+//           arguments: {
+//             self: commitProofTransaction.sharedObjectRef(
+//               identityPlatform.RECLAIM_MANAGER_SHARED_OBJECT_REF,
+//             ),
+//             config: commitProofTransaction.sharedObjectRef(
+//               config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF,
+//             ),
+//             commitmentHash: commitProofTransaction.pure(
+//               bcs.vector(bcs.u8()).serialize(commitmentHash),
+//             ),
+//             identifierHash: commitProofTransaction.pure(
+//               bcs.vector(bcs.u8()).serialize(identifierHash),
+//             ),
+//           },
+//         }),
+//       );
+//
+//       const commitTransactionResponse = await signAndExecuteTransaction({
+//         transaction: commitProofTransaction,
+//       });
+//       if (!commitTransactionResponse) throw new Error("fail to commit proof");
+//
+//       const settledCommitTransactionResult = await suiClient.waitForTransaction(
+//         {
+//           digest: commitTransactionResponse.transactionDigest,
+//           include: {
+//             effects: true,
+//             objectTypes: true,
+//           },
+//         },
+//       );
+//
+//       const commitTransactionObjectChanges =
+//         settledCommitTransactionResult.Transaction?.effects.changedObjects ||
+//         [];
+//
+//       if (!commitTransactionObjectChanges)
+//         throw new Error("fail to commit proof");
+//
+//       const commitment = commitTransactionObjectChanges.find((objChange) => {
+//         if (objChange.idOperation !== "Created") return false;
+//         const type =
+//           settledCommitTransactionResult.Transaction?.objectTypes![
+//             objChange.objectId
+//           ];
+//         return type === config.zing.PROOF_COMMITMENT_TYPE;
+//       });
+//
+//       if (!commitment || commitment.idOperation !== "Created")
+//         throw new Error("fail to commit proof");
+//
+//       const revealTransaction = new Transaction();
+//
+//       const [, proofObj] = revealTransaction.add(
+//         revealAndVerifyProof({
+//           package: config.zing.ZING_IDENTITY_PACKAGE_ADDRESS,
+//           typeArguments: [identityPlatform.PLATFORM_TYPE],
+//           arguments: {
+//             self: revealTransaction.sharedObjectRef(
+//               identityPlatform.RECLAIM_MANAGER_SHARED_OBJECT_REF,
+//             ),
+//             config: revealTransaction.sharedObjectRef(
+//               config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF,
+//             ),
+//             commitmentId: revealTransaction.pure.id(commitment.objectId),
+//             provider: revealTransaction.pure.string(proof.claimData.provider),
+//             parameters: revealTransaction.pure.string(
+//               proof.claimData.parameters,
+//             ),
+//             context: revealTransaction.pure.string(proof.claimData.context),
+//             identifier: revealTransaction.pure.string(
+//               proof.claimData.identifier,
+//             ),
+//             owner: revealTransaction.pure.string(proof.claimData.owner),
+//             epoch: revealTransaction.pure.string(
+//               proof.claimData.epoch.toString(),
+//             ),
+//             timestampS: revealTransaction.pure.u64(proof.claimData.timestampS),
+//             signatures: revealTransaction.pure(
+//               bcs
+//                 .vector(bcs.vector(bcs.u8()))
+//                 .serialize(
+//                   proof.signatures.map((sig) => hexToBytes(sig.substring(2))),
+//                 ),
+//             ),
+//             nonce: revealTransaction.pure(
+//               bcs.vector(bcs.u8()).serialize(nonce),
+//             ),
+//           },
+//         }),
+//       );
+//
+//       // Call extract parameters customizaed functions; this interface should identical for different platforms
+//       revealTransaction.moveCall({
+//         target: identityPlatform.PLATFORM_UPDATE_PROOF_TARGET,
+//         arguments: [
+//           // IdentityManager
+//           revealTransaction.sharedObjectRef(
+//             identityPlatform.IDENTITY_MANAGER_SHARED_OBJECT_REF,
+//           ),
+//           // IdentityConfig
+//           revealTransaction.sharedObjectRef(
+//             config.zing.ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF,
+//           ),
+//           proofObj,
+//         ],
+//       });
+//
+//       const transactionResponse = await signAndExecuteTransaction({
+//         transaction: revealTransaction,
+//       });
+//       return transactionResponse;
+//     },
+//   });
+// }

package/dist/hooks/useSignAndExecuteTransaction.js

@@ -1,7 +1,9 @@
 import { useWalletStore } from "../components/wallet-provider.js";
 import { signAndExecuteGasPoolTransaction } from "../mutations/signer.js";
+import { SUI_DECIMALS } from "@mysten/sui/utils";
 import { useMutation } from "@tanstack/react-query";
 const GAS_POOL_OWNER = "0x3198c7da350bf15c48fc598e5b03a0b6e13356801c71b4d1a18b92b09966e5da";
+const GAS_BUDGET = 0.2 * 10 ** SUI_DECIMALS;
 export const useSignAndExecuteTransaction = () => {
     const getSigner = useWalletStore((s) => s.getSigner);
     const suiClient = useWalletStore((s) => s.suiClient);
@@ -18,6 +20,7 @@ export const useSignAndExecuteTransaction = () => {
             // for Debug usage
             transaction.setSender(signer.suiAddress);
             transaction.setGasOwner(GAS_POOL_OWNER);
+            transaction.setGasBudget(GAS_BUDGET);
             const dryRunResponse = await suiClient.simulateTransaction({
                 transaction: await transaction.build({ client: suiClient }),
                 include: {
@@ -26,7 +29,7 @@ export const useSignAndExecuteTransaction = () => {
             });
             console.log({ dryRunResponse });
             if (dryRunResponse.Transaction?.effects.status.success) {
-                const effects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiClient, transaction);
+                const effects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiClient, transaction, GAS_BUDGET);
                 // TODO: handle error message by code
                 if (!effects)
                     throw new Error("fail to get Transaction Effects");

package/dist/hooks/useZingInfiniteQueries.d.ts

@@ -13,26 +13,20 @@ declare const zingInfiniteQueryMethodMap: (zingClient: ZingClient) => {
     }>;
     getWorks: (owner: string, workType?: import("../index.js").WorkType, cursor?: string, limit?: number) => Promise<{
         data: {
-            id: {
-                id: string;
-            };
+            id: string;
             owner: string;
             deleted: boolean;
             created_at: string;
             subscription_level: number | null;
             blobs: {
-                id: {
-                    id: string;
-                };
+                id: string;
                 registered_epoch: number;
                 blob_id: string;
                 size: string;
                 encoding_type: number;
                 certified_epoch: number | null;
                 storage: {
-                    id: {
-                        id: string;
-                    };
+                    id: string;
                     start_epoch: number;
                     end_epoch: number;
                     storage_size: string;

package/dist/hooks/useZingInfiniteQueries.js

@@ -12,6 +12,7 @@ export function useZingInfiniteQuery(input, options = {}, memo = []) {
     const methodMap = zingInfiniteQueryMethodMap(zingClient);
     const { method, params, limit = 20 } = input;
     return useInfiniteQuery({
+        // eslint-disable-next-line @tanstack/query/exhaustive-deps
         queryKey: [zingClient.network, method, memo],
         queryFn: async ({ pageParam }) => {
             const fn = methodMap[method];

package/dist/hooks/useZingQueries.d.ts

@@ -1,17 +1,10 @@
 import type { ZingClient } from "../client/index.js";
 import type { UseQueryOptions } from "@tanstack/react-query";
 declare const zingQueryMethodMap: (zingClient: ZingClient) => {
-    getIdentifierByAddress: (platform: import("../index.js").PlatformType, address: string) => Promise<string | null>;
-    getIdentifierInfoByIdentifier: (platform: import("../index.js").PlatformType, identifier: string) => Promise<{
-        owner: string;
-        updated_at: string;
-    } | null>;
     getStudio: (owner: string) => Promise<{
-        id: {
-            id: string;
-        };
+        id: string;
         owner: string;
-        period: string[];
+        period: [string, string];
         monthly_subscription_fee: {
             contents: {
                 key: number;
@@ -19,15 +12,11 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             }[];
         };
         membership: {
-            id: {
-                id: string;
-            };
+            id: string;
             size: string;
         };
         works: {
-            id: {
-                id: string;
-            };
+            id: string;
             size: string;
         };
         encrypted_file_key: number[] | null;
@@ -39,9 +28,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         };
     } | null>;
     getStorageSpace: (owner: string) => Promise<{
-        id: {
-            id: string;
-        };
+        id: string;
         owner: string;
         tier: number | null;
         storage_used: {
@@ -57,9 +44,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         };
     } | null>;
     getStorageTreasury: () => Promise<{
-        id: {
-            id: string;
-        };
+        id: string;
         tier_plan: {
             contents: {
                 key: number;
@@ -74,9 +59,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             contents: {
                 key: number;
                 value: {
-                    id: {
-                        id: string;
-                    };
+                    id: string;
                     start_epoch: number;
                     end_epoch: number;
                     storage_size: string;
@@ -90,9 +73,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             }[];
         };
         wal_treasury: {
-            id: {
-                id: string;
-            };
+            id: string;
             balance: {
                 value: string;
             };

package/dist/hooks/useZingQueries.js

@@ -4,8 +4,6 @@ import { useQueries } from "@tanstack/react-query";
 // Method map (shared with useZingQuery)
 // ---------------------------------------------
 const zingQueryMethodMap = (zingClient) => ({
-    getIdentifierByAddress: zingClient.getIdentifierByAddress.bind(zingClient),
-    getIdentifierInfoByIdentifier: zingClient.getIdentifierInfoByIdentifier.bind(zingClient),
     getStudio: zingClient.getStudio.bind(zingClient),
     getStorageSpace: zingClient.getStorageSpace.bind(zingClient),
     getStorageTreasury: zingClient.getStorageTreasury.bind(zingClient),
@@ -21,6 +19,7 @@ export function useZingQueries(options) {
     const queryConfigs = options.queries.map((queryConfig) => {
         const { method, params, ...queryOptions } = queryConfig;
         return {
+            // eslint-disable-next-line @tanstack/query/exhaustive-deps
             queryKey: [zingClient.network, method, params],
             queryFn: async () => {
                 const fn = methodMap[method];