@zing-protocol/zing-sdk 0.0.17 → 0.1.1

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];

package/dist/hooks/useZingQuery.d.ts

@@ -2,17 +2,10 @@ import type { ZingClient } from "../client/index.js";
 import type { SuiNetwork } from "../types.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;
@@ -20,15 +13,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;
@@ -40,9 +29,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         };
     } | null>;
     getStorageSpace: (owner: string) => Promise<{
-        id: {
-            id: string;
-        };
+        id: string;
         owner: string;
         tier: number | null;
         storage_used: {
@@ -58,9 +45,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         };
     } | null>;
     getStorageTreasury: () => Promise<{
-        id: {
-            id: string;
-        };
+        id: string;
         tier_plan: {
             contents: {
                 key: number;
@@ -75,9 +60,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             contents: {
                 key: number;
                 value: {
-                    id: {
-                        id: string;
-                    };
+                    id: string;
                     start_epoch: number;
                     end_epoch: number;
                     storage_size: string;
@@ -91,9 +74,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             }[];
         };
         wal_treasury: {
-            id: {
-                id: string;
-            };
+            id: string;
             balance: {
                 value: string;
             };
@@ -119,26 +100,20 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
     } | null>;
     getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/grpc/proto/sui/rpc/v2/state_service.mjs").GetBalanceResponse>;
     getWork: (workId: string, workType?: import("../index.js").WorkType) => Promise<{
-        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/useZingQuery.js

@@ -4,8 +4,6 @@ import { useQuery } from "@tanstack/react-query";
 // Method map
 // ---------------------------------------------
 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),
@@ -22,6 +20,7 @@ export function useZingQuery(input, options = {}, memo = []) {
     const methodMap = zingQueryMethodMap(zingClient);
     const { method, params } = input;
     return useQuery({
+        // eslint-disable-next-line @tanstack/query/exhaustive-deps
         queryKey: [zingClient.network, method, memo],
         gcTime: options.gcTime,
         staleTime: options.staleTime,

package/dist/lib/utils/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./helpers.js";
-export * from "./reclaim.js";
 export * from "./colorful-logger.js";
 export * from "./init-app-with-shadow.js";
 export type * from "./types.js";

package/dist/lib/utils/index.js

@@ -1,4 +1,3 @@
 export * from "./helpers.js";
-export * from "./reclaim.js";
 export * from "./colorful-logger.js";
 export * from "./init-app-with-shadow.js";

package/dist/lib/utils/reclaim.d.ts

@@ -1,29 +1 @@
-export declare function hexToBytes(hex: string): Uint8Array;
-export declare function bytesToHex(bytes: Uint8Array): string;
-export declare function textToBytes(text: string): Uint8Array;
-export declare function bytesToText(bytes: Uint8Array): string;
-export declare function startVerification({ reclaimAppId, reclaimAppSecret, reclaimProviderId, }: {
-    reclaimAppId: string;
-    reclaimAppSecret: string;
-    reclaimProviderId: string;
-}): Promise<unknown>;
-export declare function generateCommitNonce(userAddress: string, claimIdentifier: string): number[];
-export declare function generateCommitmentHash(proof: ReclaimProof, nonce: number[]): Uint8Array<ArrayBufferLike>;
-export type ReclaimProof = {
-    identifier: string;
-    claimData: {
-        provider: string;
-        parameters: string;
-        owner: string;
-        timestampS: number;
-        context: string;
-        identifier: string;
-        epoch: number;
-    };
-    signatures: string[];
-    witnesses: {
-        id: string;
-        url: string;
-    }[];
-    publicData: string | null;
-};
+export {};