@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/src/hooks/useGetTierPlan.ts

@@ -1,115 +0,0 @@
-import { useZingQuery } from "./useZingQuery.js";
-import { useMemo } from "react";
-import type { TierPlan } from "../types.js";
-
-const tierInfos: Record<number, { name: string; features: string[] }> = {
-  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((): {
-    tierPlans: Record<number, TierPlan>;
-    storageByEpoch: Record<number, number>;
-    walTreasury: string;
-    isLoading: boolean;
-  } => {
-    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<
-      Record<number, TierPlan>
-    >(
-      (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;
-      },
-      {} as Record<number, TierPlan>,
-    );
-
-    // Process storageByEpoch
-    const storageByEpoch =
-      storageTreasury.storages_by_epoch?.contents?.reduce<
-        Record<number, number>
-      >((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/src/hooks/useReclaim.ts

@@ -1,165 +0,0 @@
-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 { SuiClient } from "@mysten/sui/client";
-
-interface CommitProofParams {
-  suiClient: SuiClient;
-  walletAddress: string;
-  platform: PlatformType;
-  proof: ReclaimProof;
-  gasPoolBearerToken: string;
-}
-
-export function useCommitProof() {
-  const { mutateAsync: signAndExecuteTransaction } =
-    useSignAndExecuteTransaction();
-  const zingClient = useZingClient();
-  const config = zingClient.config;
-
-  return useMutation({
-    mutationFn: async ({
-      suiClient,
-      walletAddress,
-      platform,
-      proof,
-      gasPoolBearerToken,
-    }: 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 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/src/hooks/useSignAndExecuteTransaction.ts

@@ -1,57 +0,0 @@
-import { useWalletStore } from "../components/wallet-provider.js";
-import { signAndExecuteGasPoolTransaction } from "../mutations/signer.js";
-import { useMutation } from "@tanstack/react-query";
-import type { Transaction } from "@mysten/sui/transactions";
-
-interface SignAndExecuteTransactionParams {
-  transaction: Transaction;
-}
-
-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 }: SignAndExecuteTransactionParams) => {
-      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/src/hooks/useSignPersonalMessage.ts

@@ -1,28 +0,0 @@
-import { useWalletStore } from "../components/wallet-provider.js";
-import { signPersonalMessage } from "../mutations/signer.js";
-import { useMutation } from "@tanstack/react-query";
-
-interface SignPersonalMessageParams {
-  message: Uint8Array;
-}
-
-export const useSignPersonalMessage = () => {
-  const getSigner = useWalletStore((s) => s.getSigner);
-
-  return useMutation({
-    mutationFn: async ({ message }: SignPersonalMessageParams) => {
-      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);
-    },
-  });
-};

package/src/hooks/useZingInfiniteQueries.ts

@@ -1,92 +0,0 @@
-import { useZingClient } from "../components/zing-provider.js";
-import { useInfiniteQuery } from "@tanstack/react-query";
-import type { ZingClient } from "../client/index.js";
-import type { SuiNetwork } from "../types.js";
-import type {
-  UseInfiniteQueryOptions,
-  InfiniteData,
-} from "@tanstack/react-query";
-
-const zingInfiniteQueryMethodMap = (zingClient: ZingClient) => ({
-  getMembers: zingClient.getMembers.bind(zingClient),
-  getWorks: zingClient.getWorks.bind(zingClient),
-});
-
-type ZingInfiniteQueryMethods = ReturnType<typeof zingInfiniteQueryMethodMap>;
-
-type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
-type InfiniteMethodParamsMap = {
-  [K in keyof ZingInfiniteQueryMethods]: ExtractParams<
-    ZingInfiniteQueryMethods[K]
-  >;
-};
-
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-
-type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-type UseZingInfiniteQueryParams<K extends keyof InfiniteMethodParamsMap> = {
-  method: K;
-  params: InfiniteMethodParamsMap[K];
-  limit?: number;
-};
-
-type ExtraInfiniteQueryOptions<TData = unknown> = Partial<
-  Pick<
-    UseInfiniteQueryOptions<
-      TData,
-      Error,
-      InfiniteData<TData>,
-      readonly unknown[],
-      string | undefined
-    >,
-    "enabled" | "gcTime" | "staleTime" | "retry"
-  >
->;
-export type InfiniteMethodReturnMap = {
-  [K in keyof ZingInfiniteQueryMethods]: UnwrapPromise<
-    ExtractReturnType<ZingInfiniteQueryMethods[K]>
-  >;
-};
-
-export function getZingInfiniteQueryKey<
-  K extends keyof ZingInfiniteQueryMethods,
->(
-  network: SuiNetwork,
-  method: K,
-  memo: string[],
-): readonly [string, K, string[]] {
-  return [network, method, memo] as const;
-}
-
-export function useZingInfiniteQuery<K extends keyof InfiniteMethodParamsMap>(
-  input: UseZingInfiniteQueryParams<K>,
-  options: ExtraInfiniteQueryOptions<InfiniteMethodReturnMap[K]> = {},
-  memo: string[] = [],
-) {
-  const zingClient = useZingClient();
-  const methodMap = zingInfiniteQueryMethodMap(zingClient);
-  const { method, params, limit = 20 } = input;
-
-  return useInfiniteQuery<
-    InfiniteMethodReturnMap[K],
-    Error,
-    InfiniteData<InfiniteMethodReturnMap[K]>,
-    readonly unknown[],
-    string | undefined
-  >({
-    queryKey: [zingClient.network, method, memo],
-    queryFn: async ({ pageParam }) => {
-      const fn = methodMap[method as keyof typeof methodMap];
-      // Call the function with spread params, cursor, and limit
-      return (fn as any)(...params, pageParam, limit) as Promise<
-        InfiniteMethodReturnMap[K]
-      >;
-    },
-    initialPageParam: undefined as string | undefined,
-    getNextPageParam: (lastPage) => {
-      const nextCursor = (lastPage as any)?.nextCursor;
-      return nextCursor ?? undefined; // Convert null to undefined
-    },
-    ...options,
-  });
-}

package/src/hooks/useZingMutation.ts

@@ -1,66 +0,0 @@
-import { useSignAndExecuteTransaction } from "./useSignAndExecuteTransaction.js";
-import { useZingClient } from "../components/zing-provider.js";
-import { Transaction } from "@mysten/sui/transactions";
-import { useMutation } from "@tanstack/react-query";
-import type { ZingClient } from "../client/index.js";
-import type { TransactionEffects } from "@mysten/sui/client";
-
-// Only allows Transaction methods
-const zingMutationMethodMap = (zingClient: ZingClient) => ({
-  subscribeToStudioTransaction:
-    zingClient.subscribeToStudioTransaction.bind(zingClient),
-  purchaseStorageTierTransaction:
-    zingClient.purchaseStorageTierTransaction.bind(zingClient),
-  setMonthlySubscriptionFeeTransaction:
-    zingClient.setMonthlySubscriptionFeeTransaction.bind(zingClient),
-  updateArticleSubscriptionLevelTransaction:
-    zingClient.updateArticleSubscriptionLevelTransaction.bind(zingClient),
-  deleteArticleTransaction:
-    zingClient.deleteArticleTransaction.bind(zingClient),
-  donateTransaction: zingClient.donateTransaction.bind(zingClient),
-});
-
-type ZingMutationMethods = ReturnType<typeof zingMutationMethodMap>;
-
-type ExtractParams<T> = T extends (arg: infer P) => any ? P : never;
-
-type MethodParamsMap = {
-  [K in keyof ZingMutationMethods]: ExtractParams<ZingMutationMethods[K]>;
-};
-
-type UseZingMutationParams = {
-  [K in keyof ZingMutationMethods]: {
-    method: K;
-    params: MethodParamsMap[K];
-  };
-}[keyof ZingMutationMethods];
-
-export function useZingMutation() {
-  const zingClient = useZingClient();
-  const methodMap = zingMutationMethodMap(zingClient);
-  const { mutateAsync: signAndExecute } = useSignAndExecuteTransaction();
-
-  return useMutation<TransactionEffects | null, Error, UseZingMutationParams>({
-    mutationFn: async ({ method, params }) => {
-      const tx = new Transaction();
-
-      const builderFn = methodMap[method] as any;
-
-      // builderFn receives a structured params object, not an array
-      const buildTx = builderFn(params);
-
-      buildTx(tx);
-
-      return signAndExecute({
-        transaction: tx,
-      });
-    },
-    onSuccess: async (effects) => {
-      if (effects?.transactionDigest) {
-        await zingClient.suiJsonRpcClient.waitForTransaction({
-          digest: effects.transactionDigest,
-        });
-      }
-    },
-  });
-}

package/src/hooks/useZingQueries.ts

@@ -1,107 +0,0 @@
-import { useZingClient } from "../components/zing-provider.js";
-import { useQueries } from "@tanstack/react-query";
-import type { ZingClient } from "../client/index.js";
-import type { UseQueryOptions } from "@tanstack/react-query";
-
-// ---------------------------------------------
-// Method map (shared with useZingQuery)
-// ---------------------------------------------
-const zingQueryMethodMap = (zingClient: 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),
-  getMember: zingClient.getMember.bind(zingClient),
-  getBalance: zingClient.getBalance.bind(zingClient),
-});
-
-type ZingQueryMethods = ReturnType<typeof zingQueryMethodMap>;
-type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
-type MethodParamsMap = {
-  [K in keyof ZingQueryMethods]: ExtractParams<ZingQueryMethods[K]>;
-};
-type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-type MethodReturnMap = {
-  [K in keyof ZingQueryMethods]: UnwrapPromise<
-    ExtractReturnType<ZingQueryMethods[K]>
-  >;
-};
-
-// ---------------------------------------------
-// useZingQueries types
-// ---------------------------------------------
-type ZingQueryConfig = {
-  [K in keyof ZingQueryMethods]: {
-    method: K;
-    params: MethodParamsMap[K];
-  } & Omit<
-    UseQueryOptions<
-      MethodReturnMap[K],
-      Error,
-      MethodReturnMap[K],
-      readonly unknown[]
-    >,
-    "queryKey" | "queryFn"
-  >;
-}[keyof ZingQueryMethods];
-
-type UseZingQueriesOptions<
-  T extends readonly ZingQueryConfig[],
-  TCombinedResult = QueriesResults<T>,
-> = {
-  queries: readonly [...T];
-  combine?: (results: QueriesResults<T>) => TCombinedResult;
-};
-
-// Helper type to extract query results
-type QueryResult<T> = T extends { method: infer K; params: any }
-  ? K extends keyof ZingQueryMethods
-    ? {
-        data: MethodReturnMap[K] | undefined;
-        error: Error | null;
-        isLoading: boolean;
-        isError: boolean;
-        isSuccess: boolean;
-        status: "pending" | "error" | "success";
-        fetchStatus: "fetching" | "paused" | "idle";
-      }
-    : never
-  : never;
-
-type QueriesResults<T extends readonly ZingQueryConfig[]> = {
-  [K in keyof T]: QueryResult<T[K]>;
-};
-
-// ---------------------------------------------
-// Hook
-// ---------------------------------------------
-export function useZingQueries<
-  T extends readonly ZingQueryConfig[],
-  TCombinedResult = QueriesResults<T>,
->(options: UseZingQueriesOptions<T, TCombinedResult>): TCombinedResult {
-  const zingClient = useZingClient();
-  const methodMap = zingQueryMethodMap(zingClient);
-
-  const queryConfigs = options.queries.map((queryConfig) => {
-    const { method, params, ...queryOptions } = queryConfig;
-
-    return {
-      queryKey: [zingClient.network, method, params] as const,
-      queryFn: async () => {
-        const fn = methodMap[method];
-        return (fn as (...args: any[]) => any)(...(params as any[]));
-      },
-      ...queryOptions,
-    } as const;
-  }) as any;
-
-  const results = useQueries({
-    queries: queryConfigs,
-    combine: options.combine as any,
-  } as any);
-
-  return results as TCombinedResult;
-}