@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/dist/getters.js

@@ -0,0 +1,317 @@
+import { TypeName } from "./_generated/zing_identity/deps/std/type_name.js";
+import { IdentifierInfo } from "./_generated/zing_identity/identity.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 { StorageSpace, StorageTreasury, } from "./_generated/zing_studio/storage.js";
+import { Member, Studio } from "./_generated/zing_studio/studio.js";
+import { QuiltPatchId, SuiMoveObject } from "./bcs.js";
+import { bcs } from "@mysten/sui/bcs";
+import { deriveDynamicFieldID, deriveObjectID, fromBase64, normalizeStructTag, toBase64, } from "@mysten/sui/utils";
+// Walrus
+const DIGEST_LEN = 32;
+const BLOB_ID_LEN = 32;
+// Zing
+export function getDerivedStudioID(studioConfigId, address) {
+    return deriveObjectID(studioConfigId, "address", bcs.Address.serialize(address).toBytes());
+}
+export function getDerivedStorageID(studioConfigId, address) {
+    const studioId = getDerivedStudioID(studioConfigId, address);
+    const key = new TextEncoder().encode("storage");
+    return deriveObjectID(studioId, "vector<u8>", bcs.vector(bcs.u8()).serialize(key).toBytes());
+}
+export function getDerivedWorksID(studioConfigId, address) {
+    const studioId = getDerivedStudioID(studioConfigId, address);
+    const key = new TextEncoder().encode("works");
+    return deriveObjectID(studioId, "vector<u8>", bcs.vector(bcs.u8()).serialize(key).toBytes());
+}
+export function getDerivedMembershipID(studioConfigId, address) {
+    const studioId = getDerivedStudioID(studioConfigId, address);
+    const key = new TextEncoder().encode("membership");
+    return deriveObjectID(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 = SuiMoveObject.parse(res.response.object.bcs.value);
+    const field = Field(bcs.Address, bcs.String).parse(suiMoveObject.data.MoveObject.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 = SuiMoveObject.parse(res.response.object.bcs.value);
+    const field = Field(bcs.String, IdentifierInfo).parse(suiMoveObject.data.MoveObject.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 = SuiMoveObject.parse(res.response.object.bcs.value);
+    const field = Field(bcs.String, VecMap(TypeName, bcs.U64)).parse(suiMoveObject.data.MoveObject.contents);
+    return field.value;
+}
+export async function getStudio(suiGrpcClient, studioId) {
+    try {
+        const res = await suiGrpcClient.ledgerService.getObject({
+            objectId: studioId,
+            readMask: {
+                paths: ["bcs"],
+            },
+        });
+        if (!res.response.object?.bcs?.value) {
+            return null;
+        }
+        const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+        return Studio.parse(suiMoveObject.data.MoveObject.contents);
+    }
+    catch (error) {
+        console.error(error);
+        return null;
+    }
+}
+export async function getStorageSpace(suiGrpcClient, storageSpaceId) {
+    try {
+        const res = await suiGrpcClient.ledgerService.getObject({
+            objectId: storageSpaceId,
+            readMask: {
+                paths: ["bcs"],
+            },
+        });
+        if (!res.response.object?.bcs?.value) {
+            return null;
+        }
+        const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+        return StorageSpace.parse(suiMoveObject.data.MoveObject.contents);
+    }
+    catch (error) {
+        console.error(error);
+        return null;
+    }
+}
+export async function getStorageTreasury(suiGrpcClient, storageTreasuryId) {
+    const res = await suiGrpcClient.ledgerService.getObject({
+        objectId: storageTreasuryId,
+        readMask: {
+            paths: ["bcs"],
+        },
+    });
+    if (!res.response.object?.bcs?.value) {
+        return null;
+    }
+    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+    return StorageTreasury.parse(suiMoveObject.data.MoveObject.contents);
+}
+export async function getMember(suiGrpcClient, membershipTableId, member) {
+    const dfObjectId = deriveDynamicFieldID(membershipTableId, "address", bcs.Address.serialize(member).toBytes());
+    const res = await suiGrpcClient.ledgerService.getObject({
+        objectId: dfObjectId,
+        readMask: {
+            paths: ["bcs"],
+        },
+    });
+    if (!res.response.object?.bcs?.value) {
+        return null;
+    }
+    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+    const field = Field(bcs.Address, Member).parse(suiMoveObject.data.MoveObject.contents);
+    return field.value;
+}
+export async function getMembers(suiGrpcClient, membershipTableId, cursor, limit = 20) {
+    const res = await suiGrpcClient.stateService.listDynamicFields({
+        parent: membershipTableId,
+        pageToken: cursor ? fromBase64(cursor) : undefined,
+        pageSize: limit,
+        readMask: {
+            paths: ["field_object.bcs"],
+        },
+    });
+    const data = res.response.dynamicFields.map((df) => {
+        if (!df.fieldObject?.bcs?.value)
+            throw new Error("Wrong readMask for reading members");
+        const suiMoveObject = SuiMoveObject.parse(df.fieldObject.bcs.value);
+        // Wrapped in dynamicFields
+        const field = Field(bcs.Address, Member).parse(suiMoveObject.data.MoveObject.contents);
+        return {
+            member: field.name,
+            level: field.value.level,
+            expiredAt: field.value.expired_at,
+        };
+    });
+    return {
+        data,
+        nextCursor: res.response.nextPageToken
+            ? toBase64(res.response.nextPageToken)
+            : undefined,
+        hasNextPage: res.response.nextPageToken !== undefined,
+    };
+}
+export async function getWork(suiGrpcClient, walrusSystem, workId, workType) {
+    const res = await suiGrpcClient.ledgerService.getObject({
+        objectId: workId,
+        readMask: {
+            paths: ["bcs"],
+        },
+    });
+    if (!res.response.object?.bcs?.value) {
+        return null;
+    }
+    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+    const type = suiMoveObject.data.MoveObject
+        .type;
+    if (type.$kind !== "Other" ||
+        normalizeStructTag(type.Other) !== workType)
+        return null;
+    return Article.parse(suiMoveObject.data.MoveObject.contents);
+}
+export async function getWorks(suiGrpcClient, walrusSystem, workTableId, workType, cursor, limit = 20) {
+    const res = await suiGrpcClient.stateService.listDynamicFields({
+        parent: workTableId,
+        pageToken: cursor ? fromBase64(cursor) : undefined,
+        pageSize: limit,
+        readMask: {
+            paths: ["child_object"],
+        },
+    });
+    const works = res.response.dynamicFields.map((df) => {
+        if (!df.childObject?.contents?.value)
+            throw new Error("Wrong readMask for reading members");
+        // Wrapped in dynamicObjectFields
+        const objectType = df.childObject.objectType;
+        if (objectType !== workType)
+            return null;
+        return Article.parse(df.childObject.contents.value);
+    });
+    const data = works
+        .filter((d) => {
+        if (!d || d.blobs.length === 0 || d.deleted)
+            return false;
+        const minEndEpoch = Math.min(...d.blobs.map((b) => b.storage.end_epoch));
+        return minEndEpoch > walrusSystem.committee.epoch;
+    })
+        .sort((a, b) => Number(b.created_at) - Number(a.created_at));
+    console.log({ getWorksData: data });
+    return {
+        data,
+        nextCursor: res.response.nextPageToken
+            ? toBase64(res.response.nextPageToken)
+            : undefined,
+        hasNextPage: res.response.nextPageToken !== undefined,
+    };
+}
+export async function getPublishedArticleAndBlobId(suiGrpcClient, suiClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType) {
+    // suiGrpcClient waitForTransaction calling core.getTransaction which is broken
+    await suiClient.waitForTransaction({
+        digest,
+    });
+    if (!digest)
+        throw new Error("fail to get transaction hash");
+    const res = await suiGrpcClient.ledgerService.getTransaction({
+        digest,
+        readMask: {
+            paths: ["events"],
+        },
+    });
+    const blobRegisteredEvent = res.response.transaction?.events?.events?.find((e) => e.contents?.name === blobRegisteredEventType);
+    const publishArticleEvent = res.response.transaction?.events?.events?.find((e) => e.contents?.name === publishArticleEventType);
+    if (!blobRegisteredEvent || !blobRegisteredEvent.contents?.value) {
+        throw new Error("fail to get blobRegisteredEvent");
+    }
+    if (!publishArticleEvent || !publishArticleEvent.contents?.value) {
+        throw new Error("fail to get publishArticleEvent");
+    }
+    const blobObjectId = BlobRegistered.parse(blobRegisteredEvent.contents?.value).object_id;
+    const parsedPublishArticleEvent = PublishArticleEvent.parse(publishArticleEvent.contents.value);
+    return { parsedPublishArticleEvent, blobObjectId };
+}
+export function encodeQuiltPatchId(id) {
+    return urlSafeBase64(QuiltPatchId.serialize(id).toBytes());
+}
+export function urlSafeBase64(bytes) {
+    return toBase64(bytes).replace(/=*$/, "").replace("+", "-").replace("/", "_");
+}
+export function getMaxFaultyNodes(nShards) {
+    return Math.floor((nShards - 1) / 3);
+}
+export function decodingSafetyLimit(nShards, encodingType) {
+    switch (encodingType) {
+        case "RedStuff":
+            return Math.min(5, Math.floor(getMaxFaultyNodes(nShards) / 5));
+        case "RS2":
+            return 0;
+        default:
+            throw new Error(`Encountered unknown encoding type of ${encodingType}`);
+    }
+}
+export function signersToBitmap(signers, committeeSize) {
+    const bitmapSize = Math.ceil(committeeSize / 8);
+    const bitmap = new Uint8Array(bitmapSize);
+    for (const signer of signers) {
+        const byteIndex = Math.floor(signer / 8);
+        const bitIndex = signer % 8;
+        bitmap[byteIndex] |= 1 << bitIndex;
+    }
+    return bitmap;
+}
+export function getSourceSymbols(nShards, encodingType = "RS2") {
+    const safetyLimit = decodingSafetyLimit(nShards, encodingType);
+    const maxFaulty = getMaxFaultyNodes(nShards);
+    const minCorrect = nShards - maxFaulty;
+    return {
+        primarySymbols: minCorrect - maxFaulty - safetyLimit,
+        secondarySymbols: minCorrect - safetyLimit,
+    };
+}
+/**
+ * Calculate the encoded sliver size.
+ * This matches the Walrus SDK's encodedSliverSize function.
+ */
+export function encodedSliverSize(unencodedLength, nShards, encodingType = "RS2") {
+    const { primarySymbols, secondarySymbols } = getSourceSymbols(nShards, encodingType);
+    // Calculate symbol size with proper rounding
+    let symbolSize = Math.floor((Math.max(unencodedLength, 1) - 1) / (primarySymbols * secondarySymbols)) + 1;
+    // RS2 requires even symbol sizes
+    if (encodingType === "RS2" && symbolSize % 2 === 1) {
+        symbolSize = symbolSize + 1;
+    }
+    const singleShardSize = (primarySymbols + secondarySymbols) * symbolSize;
+    console.log("encodedSliverSize breakdown:", {
+        unencodedLength,
+        primarySymbols,
+        secondarySymbols,
+        calculatedSymbolSize: symbolSize,
+        singleShardSize,
+        totalSliverSize: singleShardSize * nShards,
+    });
+    return singleShardSize * nShards;
+}
+export function encodedBlobLength(unencodedLength, nShards, encodingType = "RS2") {
+    const sliverSize = encodedSliverSize(unencodedLength, nShards, encodingType);
+    const metadata = nShards * DIGEST_LEN * 2 + BLOB_ID_LEN;
+    return nShards * metadata + sliverSize;
+}

package/{src/hooks/index.ts → dist/hooks/index.d.ts}

@@ -7,8 +7,7 @@ export * from "./useZingQueries.js";
 export * from "./useZingInfiniteQueries.js";
 export * from "./useGetTierPlan.js";
 export * from "./useSignPersonalMessage.js";
-
 export type InfiniteQueryResult<TData> = {
-  pages: TData[];
-  pageParams: number[];
+    pages: TData[];
+    pageParams: number[];
 };

package/dist/hooks/index.js

@@ -0,0 +1,9 @@
+export * from "./useSignAndExecuteTransaction.js";
+export * from "./useReclaim.js";
+export * from "./useGetStudio.js";
+export * from "./useZingMutation.js";
+export * from "./useZingQuery.js";
+export * from "./useZingQueries.js";
+export * from "./useZingInfiniteQueries.js";
+export * from "./useGetTierPlan.js";
+export * from "./useSignPersonalMessage.js";

package/dist/hooks/useGetStudio.d.ts

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

package/dist/hooks/useGetStudio.js

@@ -0,0 +1,17 @@
+import { useZingQuery } from "./useZingQuery.js";
+export function useGetStudio(suiAddress) {
+    return useZingQuery({
+        method: "getStudio",
+        params: [suiAddress || ""],
+    }, {
+        enabled: !!suiAddress,
+        retry: (failureCount, error) => {
+            if (error instanceof Error && error.message.includes("notExists")) {
+                return false;
+            }
+            return failureCount < 1;
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        gcTime: 10 * 60 * 1000, // 10 minutes (formerly cacheTime)
+    }, [suiAddress || ""]);
+}

package/dist/hooks/useGetTierPlan.d.ts

@@ -0,0 +1,7 @@
+import type { TierPlan } from "../types.js";
+export declare function useGetTierPlan(): {
+    tierPlans: Record<number, TierPlan>;
+    storageByEpoch: Record<number, number>;
+    walTreasury: string;
+    isLoading: boolean;
+};

package/dist/hooks/useGetTierPlan.js

@@ -0,0 +1,85 @@
+import { useZingQuery } from "./useZingQuery.js";
+import { useMemo } from "react";
+const tierInfos = {
+    0: {
+        name: "Basic",
+        features: ["Post/Article publishing", "Image protection"],
+    },
+    1: {
+        name: "Premium",
+        features: [
+            "Larger storage size",
+            "Comments for post",
+            "Analytics dashboard",
+        ],
+    },
+    // 2: {
+    //   name: "Premium+",
+    //   features: [
+    //     "Advanced publishing",
+    //     "Priority support",
+    //     "Unlimited platforms",
+    //     "Analytics dashboard",
+    //   ],
+    // },
+};
+export function useGetTierPlan() {
+    const { data: storageTreasury, isPending } = useZingQuery({
+        method: "getStorageTreasury",
+        params: [],
+    }, {
+        staleTime: 0,
+        refetchOnMount: "always",
+        refetchOnWindowFocus: false,
+    });
+    return useMemo(() => {
+        if (isPending || !storageTreasury) {
+            return {
+                tierPlans: {},
+                storageByEpoch: {},
+                walTreasury: "0",
+                isLoading: isPending,
+            };
+        }
+        if (!storageTreasury.tier_plan ||
+            !Array.isArray(storageTreasury.tier_plan.contents) ||
+            storageTreasury.tier_plan.contents.length === 0) {
+            return {
+                tierPlans: {},
+                storageByEpoch: {},
+                walTreasury: storageTreasury.wal_treasury?.balance?.value || "0",
+                isLoading: isPending,
+            };
+        }
+        const tierPlans = storageTreasury.tier_plan.contents.reduce((acc, tier) => {
+            const tierIndex = Number(tier.key);
+            const info = tierInfos?.[tierIndex];
+            if (!info) {
+                return acc;
+            }
+            acc[tierIndex] = {
+                name: info.name,
+                duration: tier.value.duration_days,
+                price: Number(tier.value.price),
+                storage: Number(tier.value.storage_limit),
+                features: info.features,
+            };
+            return acc;
+        }, {});
+        // Process storageByEpoch
+        const storageByEpoch = storageTreasury.storages_by_epoch?.contents?.reduce((acc, storage) => {
+            const epoch = Number(storage.key);
+            const size = Number(storage.value.storage_size);
+            acc[epoch] = size;
+            return acc;
+        }, {}) || {};
+        // Get walTreasury balance
+        const walTreasury = storageTreasury.wal_treasury?.balance?.value || "0";
+        return {
+            tierPlans,
+            storageByEpoch,
+            walTreasury,
+            isLoading: isPending,
+        };
+    }, [storageTreasury, isPending]);
+}

package/dist/hooks/useReclaim.d.ts

@@ -0,0 +1,12 @@
+import type { PlatformType } from "../config/common.js";
+import type { ReclaimProof } from "../lib/utils/reclaim.js";
+import type { SuiClient } from "@mysten/sui/client";
+interface CommitProofParams {
+    suiClient: SuiClient;
+    walletAddress: string;
+    platform: PlatformType;
+    proof: ReclaimProof;
+    gasPoolBearerToken: string;
+}
+export declare function useCommitProof(): import("@tanstack/react-query").UseMutationResult<any, Error, CommitProofParams, unknown>;
+export {};

package/dist/hooks/useReclaim.js

@@ -0,0 +1,87 @@
+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, gasPoolBearerToken, }) => {
+            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 commitTransactionObjectChanges = (await suiClient.waitForTransaction({
+                digest: commitTransactionResponse.transactionDigest,
+                options: {
+                    showObjectChanges: true,
+                },
+            })).objectChanges;
+            if (!commitTransactionObjectChanges)
+                throw new Error("fail to commit proof");
+            const commitment = commitTransactionObjectChanges.find((objChanges) => objChanges.type === "created" &&
+                objChanges.objectType === config.zing.PROOF_COMMITMENT_TYPE);
+            if (!commitment || commitment.type !== "created")
+                throw new Error("fail to commit proof");
+            const revealTransaction = new Transaction();
+            const [signers, 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)),
+                },
+            }));
+            console.log({ signers });
+            // 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,
+            });
+            console.log({ transactionResponse });
+            return transactionResponse;
+        },
+    });
+}

package/dist/hooks/useSignAndExecuteTransaction.d.ts

@@ -0,0 +1,6 @@
+import type { Transaction } from "@mysten/sui/transactions";
+interface SignAndExecuteTransactionParams {
+    transaction: Transaction;
+}
+export declare const useSignAndExecuteTransaction: () => import("@tanstack/react-query").UseMutationResult<any, Error, SignAndExecuteTransactionParams, unknown>;
+export {};

package/dist/hooks/useSignAndExecuteTransaction.js

@@ -0,0 +1,40 @@
+import { useWalletStore } from "../components/wallet-provider.js";
+import { signAndExecuteGasPoolTransaction } from "../mutations/signer.js";
+import { useMutation } from "@tanstack/react-query";
+const GAS_POOL_OWNER = "0x3198c7da350bf15c48fc598e5b03a0b6e13356801c71b4d1a18b92b09966e5da";
+export const useSignAndExecuteTransaction = () => {
+    const getSigner = useWalletStore((s) => s.getSigner);
+    const suiClient = useWalletStore((s) => s.suiClient);
+    return useMutation({
+        mutationFn: async ({ transaction }) => {
+            const signer = getSigner();
+            if (!signer) {
+                throw new Error("Wallet not properly initialized");
+            }
+            if (!signer.suiAddress) {
+                throw new Error("Signer suiAddress not properly initialized");
+            }
+            // for Debug usage
+            transaction.setSender(signer.suiAddress);
+            transaction.setGasOwner(GAS_POOL_OWNER);
+            const dryRunResponse = await suiClient.dryRunTransactionBlock({
+                transactionBlock: await transaction.build({ client: suiClient }),
+            });
+            console.log({ dryRunResponse });
+            if (dryRunResponse.effects.status.status === "success") {
+                const effects = await signAndExecuteGasPoolTransaction(signer, suiClient, transaction);
+                // TODO: handle error message by code
+                if (!effects)
+                    throw new Error("fail to get Transaction Effects");
+                return effects;
+            }
+            else {
+                return null;
+            }
+        },
+        onError: (error, variables) => {
+            console.log({ transaction: variables.transaction });
+            console.error("Transaction execution failed:", error);
+        },
+    });
+};

package/dist/hooks/useSignPersonalMessage.d.ts

@@ -0,0 +1,8 @@
+interface SignPersonalMessageParams {
+    message: Uint8Array;
+}
+export declare const useSignPersonalMessage: () => import("@tanstack/react-query").UseMutationResult<{
+    zkLoginSignature: any;
+    bytes: Uint8Array<ArrayBuffer>;
+}, Error, SignPersonalMessageParams, unknown>;
+export {};

package/dist/hooks/useSignPersonalMessage.js

@@ -0,0 +1,21 @@
+import { useWalletStore } from "../components/wallet-provider.js";
+import { signPersonalMessage } from "../mutations/signer.js";
+import { useMutation } from "@tanstack/react-query";
+export const useSignPersonalMessage = () => {
+    const getSigner = useWalletStore((s) => s.getSigner);
+    return useMutation({
+        mutationFn: async ({ message }) => {
+            const signer = getSigner();
+            if (!signer) {
+                throw new Error("Wallet not properly initialized");
+            }
+            if (!signer.suiAddress) {
+                throw new Error("Signer suiAddress not properly initialized");
+            }
+            return await signPersonalMessage(signer, message);
+        },
+        onError: (error) => {
+            console.error("Sign Personal Message failed:", error);
+        },
+    });
+};