@zing-protocol/zing-sdk 0.0.4 → 0.0.6

package/dist/client/index.d.ts

@@ -2,7 +2,7 @@ import { SessionKey } from "@mysten/seal";
 import { Transaction } from "@mysten/sui/transactions";
 import type { PurchaseStorageTierParams, SetMonthlySubscriptionFeeParams, SubscribeParams } from "./types.js";
 import type { CoinSymbol, PlatformType, WorkType } from "../config/index.js";
-import type { Config, WalrusSystemState } from "../config/types.js";
+import type { Config } from "../config/types.js";
 import type { SuiNetwork, ZKLoginSignerState } from "../types.js";
 import type { SealClient } from "@mysten/seal";
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
@@ -11,15 +11,13 @@ interface Params {
     network: SuiNetwork;
     suiGrpcClient: SuiGrpcClient;
     suiJsonRpcClient: SuiJsonRpcClient;
-    gasPoolBearerToken: string;
 }
 export declare class ZingClient {
     suiGrpcClient: SuiGrpcClient;
     suiJsonRpcClient: SuiJsonRpcClient;
     network: SuiNetwork;
     config: Config;
-    gasPoolBearerToken: string;
-    constructor({ network, suiGrpcClient, suiJsonRpcClient, gasPoolBearerToken, }: Params);
+    constructor({ network, suiGrpcClient, suiJsonRpcClient }: Params);
     getConfig(): Config;
     getDerivedStudioID(address: string): string;
     getDerivedStorageID(address: string): string;
@@ -119,7 +117,7 @@ export declare class ZingClient {
         nextCursor: string | undefined;
         hasNextPage: boolean;
     }>;
-    getWork(walrusSystem: WalrusSystemState, workId: string, workType?: WorkType): Promise<{
+    getWork(workId: string, workType?: WorkType): Promise<{
         id: {
             id: string;
         };
@@ -157,7 +155,7 @@ export declare class ZingClient {
             }[];
         };
     } | null>;
-    getWorks(walrusSystem: WalrusSystemState, owner: string, workType?: WorkType, cursor?: string, limit?: number): Promise<{
+    getWorks(owner: string, workType?: WorkType, cursor?: string, limit?: number): Promise<{
         data: {
             id: {
                 id: string;
@@ -199,14 +197,48 @@ export declare class ZingClient {
         nextCursor: string | undefined;
         hasNextPage: boolean;
     }>;
+    getWorksByObjectIds(owner: string, workObjectIds: string[], workType?: WorkType): Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        deleted: boolean;
+        created_at: string;
+        subscription_level: number | null;
+        blobs: {
+            id: {
+                id: string;
+            };
+            registered_epoch: number;
+            blob_id: string;
+            size: string;
+            encoding_type: number;
+            certified_epoch: number | null;
+            storage: {
+                id: {
+                    id: string;
+                };
+                start_epoch: number;
+                end_epoch: number;
+                storage_size: string;
+            };
+            deletable: boolean;
+        }[];
+        files: {
+            contents: {
+                key: string;
+                value: {
+                    blob_index: string;
+                    mime_type: string;
+                    size: string;
+                };
+            }[];
+        };
+    }[]>;
     getBalance(owner: string, coinSymbol: CoinSymbol): Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
     getSessionKey(signer: ZKLoginSignerState, owner: string): Promise<SessionKey>;
     buildSealApproveTransactionBytes(owner: string): Promise<Uint8Array<ArrayBuffer>>;
     getFileKey(sealClient: SealClient, sessionKey: SessionKey, owner: string, encryptedFileKeyBytes: number[]): Promise<CryptoKey>;
-    /**
-     * Constructs the transaction for subscribing to a studio.
-     * Does not execute; returns the Transaction object to be signed.
-     */
     subscribeToStudioTransaction({ sender, creatorAddress, subscriptionAmount, level, }: SubscribeParams): (tx: Transaction) => void;
     purchaseStorageTierTransaction({ sender, objs, newTierIdx, balance, referrer, }: PurchaseStorageTierParams): (tx: Transaction) => void;
     setMonthlySubscriptionFeeTransaction({ sender, monthlyFee, level, }: SetMonthlySubscriptionFeeParams): (tx: Transaction) => void;

package/dist/client/index.js

@@ -4,19 +4,18 @@ import { addReferralToStudio } from "../_generated/zing_studio/referral.js";
 import { shareStorageSpace } from "../_generated/zing_studio/storage.js";
 import { _new as newStudio, sealApproveStudioOwner, shareStudio, } from "../_generated/zing_studio/studio.js";
 import { getConfig } from "../config/index.js";
-import { getDerivedMembershipID, getDerivedStorageID, getDerivedStudioID, getDerivedWorksID, getIdentifierByAddress, getIdentifierInfoByIdentifier, getMember, getMembers, getStorageSpace, getStorageTreasury, getStudio, getWork, getWorks, } from "../getters.js";
+import { getDerivedMembershipID, getDerivedStorageID, getDerivedStudioID, getDerivedWorksID, getIdentifierByAddress, getIdentifierInfoByIdentifier, getMember, getMembers, getStorageSpace, getStorageTreasury, getStudio, getWork, getWorks, getWorksByObjectIds, } from "../getters.js";
 import { importFileKey } from "../mutations/seal.js";
 import { signPersonalMessage } from "../mutations/signer.js";
 import { SessionKey } from "@mysten/seal";
 import { Transaction, coinWithBalance } from "@mysten/sui/transactions";
 import { fromHex } from "@mysten/sui/utils";
 export class ZingClient {
-    constructor({ network, suiGrpcClient, suiJsonRpcClient, gasPoolBearerToken, }) {
+    constructor({ network, suiGrpcClient, suiJsonRpcClient }) {
         this.suiGrpcClient = suiGrpcClient;
         this.suiJsonRpcClient = suiJsonRpcClient;
         this.network = network || "testnet";
         this.config = getConfig(network);
-        this.gasPoolBearerToken = gasPoolBearerToken;
     }
     getConfig() {
         return this.config;
@@ -76,11 +75,14 @@ export class ZingClient {
     async getMembers(owner, cursor, limit = 20) {
         return getMembers(this.suiGrpcClient, this.getDerivedMembershipID(owner), cursor, limit);
     }
-    async getWork(walrusSystem, workId, workType) {
-        return getWork(this.suiGrpcClient, walrusSystem, workId, workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined);
+    async getWork(workId, workType) {
+        return getWork(this.suiGrpcClient, workId, workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined);
     }
-    async getWorks(walrusSystem, owner, workType, cursor, limit = 20) {
-        return getWorks(this.suiGrpcClient, walrusSystem, this.getDerivedWorksID(owner), workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined, cursor, limit);
+    async getWorks(owner, workType, cursor, limit = 20) {
+        return getWorks(this.suiGrpcClient, this.getDerivedWorksID(owner), workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined, cursor, limit);
+    }
+    async getWorksByObjectIds(owner, workObjectIds, workType) {
+        return getWorksByObjectIds(this.suiGrpcClient, workObjectIds, workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined);
     }
     async getBalance(owner, coinSymbol) {
         return this.suiGrpcClient.stateService
@@ -137,10 +139,6 @@ export class ZingClient {
         return await importFileKey(decryptedKey);
     }
     // --- Transaction Builders ---
-    /**
-     * Constructs the transaction for subscribing to a studio.
-     * Does not execute; returns the Transaction object to be signed.
-     */
     subscribeToStudioTransaction({ sender, creatorAddress, subscriptionAmount, level, }) {
         return (tx) => {
             const usdcCoin = tx.add(coinWithBalance({

package/dist/components/walrus-provider.d.ts

@@ -22,7 +22,7 @@ export declare function useWalrusUpload(): (zingClient: ZingClient, fileKey: Cry
         "content-type": string;
     };
     size: number;
-}[], signer: ZKLoginSignerState, gasPoolBearerToken: string, onProgress?: (stage: WalrusUploadFlowStage) => void) => Promise<typeof PublishArticleEvent.$inferType>;
+}[], signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void) => Promise<typeof PublishArticleEvent.$inferType>;
 export declare function useWalrusQuiltSize(): (walrusSystem: WalrusSystemState, files: Array<{
     size: number;
     identifier: string;

package/dist/components/walrus-provider.js

@@ -27,7 +27,7 @@ export const WalrusProvider = ({ walrusClient, sealClient, children, autoInit =
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [store]);
-    const uploadFile = useCallback(async (zingClient, fileKey, walrusSystem, walTreasury, storageByEpoch, walrusFiles, subscriptionLevel, metadata, signer, gasPoolBearerToken, onProgress) => {
+    const uploadFile = useCallback(async (zingClient, fileKey, walrusSystem, walTreasury, storageByEpoch, walrusFiles, subscriptionLevel, metadata, signer, onProgress) => {
         const config = zingClient.config;
         return uploadFileToWalrus({
             zingStudioPackageId: config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
@@ -38,7 +38,7 @@ export const WalrusProvider = ({ walrusClient, sealClient, children, autoInit =
             zingStorageTreasurySharedObjectRef: config.zing.ZING_STORAGE_TREASURY_SHARED_OBJECT_REF,
             blobRegisteredEventType: config.walrus.EVENT_TYPES.blobRegistered,
             publishArticleEventType: config.zing.EVENT_TYPES.publishArticleEvent,
-        }, zingClient.suiGrpcClient, zingClient.suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, gasPoolBearerToken, onProgress);
+        }, zingClient.suiGrpcClient, zingClient.suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, onProgress);
     }, [walrusClient]);
     const calculateQuiltSize = useCallback((walrusSystem, files, ivSize = 12) => {
         const numShards = walrusSystem.committee.n_shards;

package/dist/components/zing-provider.d.ts

@@ -7,7 +7,6 @@ interface ZingClientProviderProps {
     network: SuiNetwork;
     suiGrpcClient: SuiGrpcClient;
     suiJsonRpcClient: SuiJsonRpcClient;
-    gasPoolBearerToken: string;
     children: ReactNode;
 }
 export declare const ZingClientProvider: React.FC<ZingClientProviderProps>;

package/dist/components/zing-provider.js

@@ -4,13 +4,12 @@ import { createContext, useContext, useMemo } from "react";
 const ZingClientContext = createContext({
     client: null,
 });
-export const ZingClientProvider = ({ network, suiGrpcClient, suiJsonRpcClient, children, gasPoolBearerToken, }) => {
+export const ZingClientProvider = ({ network, suiGrpcClient, suiJsonRpcClient, children, }) => {
     const client = useMemo(() => new ZingClient({
         network,
         suiGrpcClient,
         suiJsonRpcClient,
-        gasPoolBearerToken,
-    }), [network, suiGrpcClient, suiJsonRpcClient, gasPoolBearerToken]);
+    }), [network, suiGrpcClient, suiJsonRpcClient]);
     return (_jsx(ZingClientContext.Provider, { value: { client }, children: children }));
 };
 export const useZingClient = () => {

package/dist/config/common.d.ts

@@ -17,7 +17,7 @@ export type ProviderInfo = {
 };
 export declare const PLATFORM_PROVIDER_INFO: Record<PlatformType, ProviderInfo>;
 export declare const PLATFORMS_HOSTNAME: Record<PlatformType, string>;
-export declare const LEVEL_FEATURES: Record<number, {
-    name: string;
-    features: string[];
+export declare const MEMBERSHIP_LEVELS: Record<number, {
+    nameKey: string;
+    featureKeys: string[];
 }>;

package/dist/config/common.js

@@ -43,19 +43,26 @@ export const PLATFORMS_HOSTNAME = {
     // substack: 'https://substack.com',
     // instagram: 'https://www.instagram.com',
 };
-export const LEVEL_FEATURES = {
-    0: { name: "Supporter", features: ["Basic Support", "Standard Features"] },
+export const MEMBERSHIP_LEVELS = {
+    0: {
+        nameKey: "membershipTier.0.name",
+        featureKeys: ["membershipTier.0.features.0", "membershipTier.0.features.1"],
+    },
     1: {
-        name: "Premium",
-        features: ["Priority Support", "Advanced Features", "Analytics"],
+        nameKey: "membershipTier.1.name",
+        featureKeys: [
+            "membershipTier.1.features.0",
+            "membershipTier.1.features.1",
+            "membershipTier.1.features.2",
+        ],
     },
     2: {
-        name: "VIP",
-        features: [
-            "24/7 Support",
-            "All Features",
-            "Custom Integration",
-            "White Label",
+        nameKey: "membershipTier.2.name",
+        featureKeys: [
+            "membershipTier.2.features.0",
+            "membershipTier.2.features.1",
+            "membershipTier.2.features.2",
+            "membershipTier.2.features.3",
         ],
     },
 };

package/dist/getters.d.ts

@@ -1,5 +1,4 @@
 import { QuiltPatchId } from "./bcs.js";
-import type { WalrusSystemState } from "./config/types.js";
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
 import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 import type { EncodingType, WalrusClient } from "@mysten/walrus";
@@ -109,7 +108,7 @@ export declare function getMembers(suiGrpcClient: SuiGrpcClient, membershipTable
     nextCursor: string | undefined;
     hasNextPage: boolean;
 }>;
-export declare function getWork(suiGrpcClient: SuiGrpcClient, walrusSystem: WalrusSystemState, workId: string, workType?: string): Promise<{
+export declare function getWork(suiGrpcClient: SuiGrpcClient, workId: string, workType?: string): Promise<{
     id: {
         id: string;
     };
@@ -147,7 +146,7 @@ export declare function getWork(suiGrpcClient: SuiGrpcClient, walrusSystem: Walr
         }[];
     };
 } | null>;
-export declare function getWorks(suiGrpcClient: SuiGrpcClient, walrusSystem: WalrusSystemState, workTableId: string, workType?: string, cursor?: string, limit?: number): Promise<{
+export declare function getWorks(suiGrpcClient: SuiGrpcClient, workTableId: string, workType?: string, cursor?: string, limit?: number): Promise<{
     data: {
         id: {
             id: string;
@@ -189,6 +188,44 @@ export declare function getWorks(suiGrpcClient: SuiGrpcClient, walrusSystem: Wal
     nextCursor: string | undefined;
     hasNextPage: boolean;
 }>;
+export declare function getWorksByObjectIds(suiGrpcClient: SuiGrpcClient, workObjectIds: string[], workType?: string): Promise<{
+    id: {
+        id: string;
+    };
+    owner: string;
+    deleted: boolean;
+    created_at: string;
+    subscription_level: number | null;
+    blobs: {
+        id: {
+            id: string;
+        };
+        registered_epoch: number;
+        blob_id: string;
+        size: string;
+        encoding_type: number;
+        certified_epoch: number | null;
+        storage: {
+            id: {
+                id: string;
+            };
+            start_epoch: number;
+            end_epoch: number;
+            storage_size: string;
+        };
+        deletable: boolean;
+    }[];
+    files: {
+        contents: {
+            key: string;
+            value: {
+                blob_index: string;
+                mime_type: string;
+                size: string;
+            };
+        }[];
+    };
+}[]>;
 export declare function getPublishedArticleAndBlobId(suiGrpcClient: SuiGrpcClient, suiClient: SuiJsonRpcClient, walrusClient: WalrusClient, digest: string, blobRegisteredEventType: string, publishArticleEventType: string): Promise<{
     parsedPublishArticleEvent: {
         article_id: string;

package/dist/getters.js

@@ -171,7 +171,7 @@ export async function getMembers(suiGrpcClient, membershipTableId, cursor, limit
         hasNextPage: res.response.nextPageToken !== undefined,
     };
 }
-export async function getWork(suiGrpcClient, walrusSystem, workId, workType) {
+export async function getWork(suiGrpcClient, workId, workType) {
     const res = await suiGrpcClient.ledgerService.getObject({
         objectId: workId,
         readMask: {
@@ -189,7 +189,7 @@ export async function getWork(suiGrpcClient, walrusSystem, workId, workType) {
         return null;
     return Article.parse(suiMoveObject.data.MoveObject.contents);
 }
-export async function getWorks(suiGrpcClient, walrusSystem, workTableId, workType, cursor, limit = 20) {
+export async function getWorks(suiGrpcClient, workTableId, workType, cursor, limit = 20) {
     const res = await suiGrpcClient.stateService.listDynamicFields({
         parent: workTableId,
         pageToken: cursor ? fromBase64(cursor) : undefined,
@@ -208,14 +208,8 @@ export async function getWorks(suiGrpcClient, walrusSystem, workTableId, workTyp
         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;
-    })
+        .filter((d) => Boolean(d))
         .sort((a, b) => Number(b.created_at) - Number(a.created_at));
-    console.log({ getWorksData: data });
     return {
         data,
         nextCursor: res.response.nextPageToken
@@ -224,6 +218,26 @@ export async function getWorks(suiGrpcClient, walrusSystem, workTableId, workTyp
         hasNextPage: res.response.nextPageToken !== undefined,
     };
 }
+export async function getWorksByObjectIds(suiGrpcClient, workObjectIds, workType) {
+    const res = await suiGrpcClient.ledgerService.batchGetObjects({
+        requests: workObjectIds.map((id) => ({ objectId: id })),
+        readMask: {
+            paths: ["bcs"],
+        },
+    });
+    const suiMoveObjects = [];
+    res.response.objects.forEach((obj) => {
+        if (obj.result.oneofKind === "object" && obj.result.object.bcs?.value) {
+            const suiMoveObject = SuiMoveObject.parse(obj.result.object.bcs.value);
+            const type = suiMoveObject.data.MoveObject
+                .type;
+            const workType_ = normalizeStructTag(type.Other);
+            if (type.$kind === "Other" && workType_ === workType)
+                suiMoveObjects.push(suiMoveObject);
+        }
+    });
+    return suiMoveObjects.map((obj) => Article.parse(obj.data.MoveObject.contents));
+}
 export async function getPublishedArticleAndBlobId(suiGrpcClient, suiClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType) {
     // suiGrpcClient waitForTransaction calling core.getTransaction which is broken
     await suiClient.waitForTransaction({
@@ -300,14 +314,6 @@ export function encodedSliverSize(unencodedLength, nShards, encodingType = "RS2"
         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") {

package/dist/hooks/index.d.ts

@@ -5,7 +5,6 @@ export * from "./useZingMutation.js";
 export * from "./useZingQuery.js";
 export * from "./useZingQueries.js";
 export * from "./useZingInfiniteQueries.js";
-export * from "./useGetTierPlan.js";
 export * from "./useSignPersonalMessage.js";
 export type InfiniteQueryResult<TData> = {
     pages: TData[];

package/dist/hooks/index.js

@@ -5,5 +5,4 @@ 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/useReclaim.d.ts

@@ -6,7 +6,6 @@ interface CommitProofParams {
     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

@@ -11,7 +11,7 @@ export function useCommitProof() {
     const zingClient = useZingClient();
     const config = zingClient.config;
     return useMutation({
-        mutationFn: async ({ suiClient, walletAddress, platform, proof, gasPoolBearerToken, }) => {
+        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)));
@@ -65,7 +65,6 @@ export function useCommitProof() {
                     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,
@@ -80,7 +79,6 @@ export function useCommitProof() {
             const transactionResponse = await signAndExecuteTransaction({
                 transaction: revealTransaction,
             });
-            console.log({ transactionResponse });
             return transactionResponse;
         },
     });

package/dist/hooks/useSignAndExecuteTransaction.js

@@ -33,7 +33,7 @@ export const useSignAndExecuteTransaction = () => {
             }
         },
         onError: (error, variables) => {
-            console.log({ transaction: variables.transaction });
+            console.error("Transaction Variables", variables);
             console.error("Transaction execution failed:", error);
         },
     });

package/dist/hooks/useZingInfiniteQueries.d.ts

@@ -11,7 +11,7 @@ declare const zingInfiniteQueryMethodMap: (zingClient: ZingClient) => {
         nextCursor: string | undefined;
         hasNextPage: boolean;
     }>;
-    getWorks: (walrusSystem: import("../index.js").WalrusSystemState, owner: string, workType?: import("../index.js").WorkType, cursor?: string, limit?: number) => Promise<{
+    getWorks: (owner: string, workType?: import("../index.js").WorkType, cursor?: string, limit?: number) => Promise<{
         data: {
             id: {
                 id: string;
@@ -66,7 +66,7 @@ type UseZingInfiniteQueryParams<K extends keyof InfiniteMethodParamsMap> = {
     params: InfiniteMethodParamsMap[K];
     limit?: number;
 };
-type ExtraInfiniteQueryOptions<TData = unknown> = Partial<Pick<UseInfiniteQueryOptions<TData, Error, InfiniteData<TData>, readonly unknown[], string | undefined>, "enabled" | "gcTime" | "staleTime" | "retry">>;
+type ExtraInfiniteQueryOptions<TData = unknown> = Partial<Pick<UseInfiniteQueryOptions<TData, Error, InfiniteData<TData>, readonly unknown[], string | undefined>, "enabled" | "gcTime" | "staleTime" | "retry" | "refetchOnWindowFocus" | "refetchOnReconnect" | "refetchOnMount">>;
 export type InfiniteMethodReturnMap = {
     [K in keyof ZingInfiniteQueryMethods]: UnwrapPromise<ExtractReturnType<ZingInfiniteQueryMethods[K]>>;
 };

package/dist/hooks/useZingQuery.d.ts

@@ -88,7 +88,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         expired_at: string;
     } | null>;
     getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
-    getWork: (walrusSystem: import("../index.js").WalrusSystemState, workId: string, workType?: import("../index.js").WorkType) => Promise<{
+    getWork: (workId: string, workType?: import("../index.js").WorkType) => Promise<{
         id: {
             id: string;
         };

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

@@ -1,10 +1,7 @@
 import type { ExcludeValuesFromBaseArrayType } from "./types.js";
 export declare const excludeValuesFromBaseArray: <B extends string[], E extends (string | number)[]>(baseArray: B, excludeArray: E) => ExcludeValuesFromBaseArrayType<B, E>;
 export declare const sleep: (time: number) => Promise<unknown>;
-export declare const formatDate: (date: Date) => string;
 export declare const formatBalance: (balance: string | number | bigint, decimal: number, digits?: number) => string;
-export declare const formatTimeAgo: (date: Date) => string;
-export declare function formatDaysAuto(days: number): string;
 export declare const formatBytes: (bytes: number) => string;
 export declare const getDaysRemaining: (comp: number) => number;
 export declare const bytesToGB: (bytes: number) => number;

package/dist/lib/utils/helpers.js

@@ -1,44 +1,20 @@
 export const excludeValuesFromBaseArray = (baseArray, excludeArray) => baseArray.filter((value) => !excludeArray.includes(value));
 export const sleep = async (time) => new Promise((r) => setTimeout(r, time));
-export const formatDate = (date) => date.toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-});
 export const formatBalance = (balance, decimal, digits = 4) => {
     const normalizedBalance = Number(balance) / Math.pow(10, decimal);
     const fixed = normalizedBalance.toFixed(digits);
     return fixed.replace(/\.?0+$/, "");
 };
-export const formatTimeAgo = (date) => {
-    const now = new Date();
-    const diffInHours = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60));
-    if (diffInHours < 1)
-        return "Just now";
-    if (diffInHours < 24)
-        return `${diffInHours}h ago`;
-    if (diffInHours < 168)
-        return `${Math.floor(diffInHours / 24)}d ago`;
-    return formatDate(date);
-};
-export function formatDaysAuto(days) {
-    if (days < 30)
-        return `${days} day${days === 1 ? "" : "s"}`;
-    const months = days / 30;
-    if (months < 12) {
-        const rounded = Math.floor(months);
-        return `${rounded} month${rounded === 1 ? "" : "s"}`;
-    }
-    const years = Math.floor(days / 365);
-    return `${years} year${years === 1 ? "" : "s"}`;
-}
 export const formatBytes = (bytes) => {
-    if (bytes === 0)
-        return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB", "TB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+    // 62.97 MB base (62.97 * 1024 * 1024)
+    const BASE_UNIT_BYTES = 66028830.72;
+    if (!bytes || bytes <= 0)
+        return "0";
+    const points = bytes / BASE_UNIT_BYTES;
+    return new Intl.NumberFormat("en-US", {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 2,
+    }).format(points);
 };
 export const getDaysRemaining = (comp) => {
     const now = new Date();

package/dist/lib/utils/reclaim.js

@@ -28,7 +28,6 @@ export async function startVerification({ reclaimAppId, reclaimAppSecret, reclai
         const proofs = await new Promise((resolve, reject) => {
             reclaimProofRequest.startSession({
                 onSuccess: (proofs) => {
-                    console.log("Verification successful:", proofs);
                     resolve(proofs);
                 },
                 onError: (error) => {

package/dist/mutations/seal.js

@@ -35,7 +35,6 @@ export async function decryptData(key, encrypted) {
     const bytes = encrypted instanceof Uint8Array ? encrypted : new Uint8Array(encrypted);
     const iv = bytes.slice(0, 12);
     const ciphertext = bytes.slice(12);
-    console.log({ iv, ciphertext });
     const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
     return new Uint8Array(plaintext);
 }

package/dist/mutations/signer.js

@@ -2,7 +2,9 @@ import { zkloginStorage } from "../stores/zkloginStore.js";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { fromBase64 } from "@mysten/sui/utils";
 import { decodeJwt } from "@mysten/sui/zklogin";
-const SALT_SERVER_BASE_URL = "https://salt-server-production.up.railway.app";
+const SALT_SERVER_BASE_URL = 
+// "https://salt-server-production.up.railway.app";
+"http://localhost:3001";
 export async function getSigner(suiClient) {
     const zkLoginStorage = await zkloginStorage.getState();
     const { epoch: currentEpoch } = await suiClient.getLatestSuiSystemState();
@@ -14,6 +16,7 @@ export async function getSigner(suiClient) {
         return {
             ephemeralKeyPair: null,
             suiAddress: null,
+            jwtTokenString: null,
             decodedJwt: null,
             zkProof: null,
             maxEpoch: null,
@@ -22,6 +25,7 @@ export async function getSigner(suiClient) {
         return {
             ephemeralKeyPair: null,
             suiAddress: null,
+            jwtTokenString: null,
             decodedJwt: null,
             zkProof: null,
             maxEpoch: null,
@@ -30,13 +34,14 @@ export async function getSigner(suiClient) {
     return {
         suiAddress: zkLoginStorage.suiAddress,
         ephemeralKeyPair,
+        jwtTokenString: zkLoginStorage.jwt,
         decodedJwt: decodeJwt(zkLoginStorage.jwt),
         zkProof: JSON.parse(zkLoginStorage.zkProof),
         maxEpoch: zkLoginStorage.maxEpoch,
     };
 }
 export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, gasBudget = 0.1 * 10 ** 9, reserveDurationSecs = 30) {
-    const { ephemeralKeyPair, suiAddress, decodedJwt, zkProof, maxEpoch } = signer;
+    const { ephemeralKeyPair, suiAddress, decodedJwt, zkProof, maxEpoch, jwtTokenString, } = signer;
     if (!ephemeralKeyPair || !suiAddress || !decodedJwt || !zkProof || !maxEpoch)
         return;
     try {
@@ -47,12 +52,10 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
         const prepareResponse = await fetch(`${SALT_SERVER_BASE_URL}/prepare_tx`, {
             method: "POST",
             headers: {
+                Authorization: `Bearer ${jwtTokenString}`,
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                sub: decodedJwt.sub,
-                iss: decodedJwt.iss,
-                aud: Array.isArray(decodedJwt.aud) ? decodedJwt.aud[0] : decodedJwt.aud,
                 gasBudget,
                 reserveDurationSecs,
             }),
@@ -78,12 +81,10 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
         const executeResponse = await fetch(`${SALT_SERVER_BASE_URL}/execute_tx`, {
             method: "POST",
             headers: {
+                Authorization: `Bearer ${jwtTokenString}`,
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                sub: decodedJwt.sub,
-                iss: decodedJwt.iss,
-                aud: Array.isArray(decodedJwt.aud) ? decodedJwt.aud[0] : decodedJwt.aud,
                 reservationId: prepareData.result.reservation_id,
                 txBytes: bytes,
                 ephemeralSignature,
@@ -106,13 +107,13 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
     }
 }
 export async function signPersonalMessage(signer, message) {
-    const { ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } = signer;
+    const { ephemeralKeyPair, decodedJwt, zkProof, maxEpoch, jwtTokenString } = signer;
     if (!ephemeralKeyPair || !decodedJwt || !zkProof || !maxEpoch) {
         throw new Error("Missing required params");
     }
     try {
-        if (!decodedJwt.sub || !decodedJwt.iss || !decodedJwt.aud) {
-            throw new Error("JWT claims (sub, iss, aud) not found");
+        if (!jwtTokenString) {
+            throw new Error("jwtTokenString not found");
         }
         // Sign message with ephemeral key
         const { bytes, signature } = await ephemeralKeyPair.signPersonalMessage(message);
@@ -120,14 +121,10 @@ export async function signPersonalMessage(signer, message) {
         const response = await fetch(`${SALT_SERVER_BASE_URL}/sign_personal_message`, {
             method: "POST",
             headers: {
+                Authorization: `Bearer ${jwtTokenString}`,
                 "Content-Type": "application/json",
             },
             body: JSON.stringify({
-                sub: decodedJwt.sub,
-                iss: decodedJwt.iss,
-                aud: Array.isArray(decodedJwt.aud)
-                    ? decodedJwt.aud[0]
-                    : decodedJwt.aud,
                 messageBytes: bytes,
                 ephemeralSignature: signature,
                 maxEpoch,
@@ -157,9 +154,14 @@ export async function createZkLoginProof(params) {
         const response = await fetch(`${SALT_SERVER_BASE_URL}/zklogin-proof`, {
             method: "POST",
             headers: {
+                Authorization: `Bearer ${params.jwtTokenString}`,
                 "Content-Type": "application/json",
             },
-            body: JSON.stringify(params),
+            body: JSON.stringify({
+                maxEpoch: params.maxEpoch,
+                extendedEphemeralPublicKey: params.extendedEphemeralPublicKey,
+                jwtRandomness: params.jwtRandomness,
+            }),
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));

package/dist/mutations/walrus.d.ts

@@ -69,7 +69,7 @@ export declare function uploadFileToWalrus(zingWriteFlowConfig: ZingWriteFlowCon
         "content-type": string;
     };
     size: number;
-}[], signer: ZKLoginSignerState, gasPoolBearerToken: string, onProgress?: (stage: WalrusUploadFlowStage) => void): Promise<typeof PublishArticleEvent.$inferType>;
+}[], signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void): Promise<typeof PublishArticleEvent.$inferType>;
 export declare function downloadImagesFromMarkdown<T extends "blob" | "uint8array">(markdown: string, as?: T): Promise<{
     url: string;
     data: T extends "blob" ? Blob : Uint8Array;

package/dist/mutations/walrus.js

@@ -17,7 +17,6 @@ export function buildPublishArticleTransaction(config, walrusSystem, walTreasury
     const { zingStudioPackageId, walrusPackageId, zingStudioConfigSharedObjectRef, walrusSystemSharedObjectRef, zingStorageTreasurySharedObjectRef, } = config;
     return (tx) => {
         const { encodedSize, writeCost } = storageCost(walrusSystem, fileSize, 2);
-        console.log({ encodedSize });
         const currentEpoch = walrusSystem.committee.epoch;
         if (!storageByEpoch?.[currentEpoch]) {
             throw new Error(`No Epochs Found for ${currentEpoch}`);
@@ -34,8 +33,6 @@ export function buildPublishArticleTransaction(config, walrusSystem, walTreasury
         if (BigInt(walTreasury) < writeCost) {
             throw new Error(`Insufficient walTreasury Balance ${walTreasury} for writeCost: ${writeCost}`);
         }
-        console.log({ fileSize, encodedSize });
-        console.log({ articleMetadata });
         const [article, publishReceipt] = tx.add(startPublishArticle({
             package: zingStudioPackageId,
             arguments: {
@@ -148,8 +145,6 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
                 };
             })),
         });
-        console.log({ walrus_system: await walrusClient.systemState() });
-        console.log({ quiltlength: quilt.length });
         // store encryptedBytes
         const metadata = withUploadRelayClient
             ? await walrusClient.computeBlobMetadata({
@@ -176,7 +171,6 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
         }
         // 1. rent storage space and publish article
         transaction.add(buildPublishArticleTransaction(config, walrusSystem, walTreasury, storageByEpoch, size, owner, subscriptionLevel, metadata.blobId, metadata.rootHash, articleMetadata, { _walrusBlobType: "quilt", ...attributes }, null));
-        console.log({ registerTransaction: transaction });
         return {
             registerTransaction: transaction,
             index,
@@ -226,7 +220,6 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
         };
     };
     const certify = ({ index, metadata, confirmations, certificate, articleId, blobObjectId, deletable, }) => {
-        console.log({ confirmations });
         const tx = new Transaction();
         if (confirmations) {
             tx.add(buildCertifyArticleBlobTransaction({
@@ -302,7 +295,7 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
         listFiles: async () => listFiles(getResults("certify", "listFiles")),
     };
 };
-export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, gasPoolBearerToken, onProgress) {
+export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, onProgress) {
     const report = (stage) => {
         if (onProgress)
             onProgress(stage);

package/dist/stores/walletStore.d.ts

@@ -21,7 +21,7 @@ export interface WalletState {
     account: WalletAccount | null;
     error: string | null;
     network: string;
-    jwt: string | null;
+    jwtTokenString: string | null;
     decodedJwt: ReturnType<typeof decodeJwt> | null;
     authProvider: AuthProvider | null;
     ephemeralKeyPair: Ed25519Keypair | null;

package/dist/stores/walletStore.js

@@ -15,7 +15,7 @@ export function createWalletStore(config) {
         account: null,
         error: null,
         network,
-        jwt: null,
+        jwtTokenString: null,
         decodedJwt: null,
         authProvider: null,
         ephemeralKeyPair: null,
@@ -115,7 +115,7 @@ export function createWalletStore(config) {
                 zkloginStorage.getState().setMaxEpoch(maxEpoch);
                 const extendedEphemeralPublicKey = getExtendedEphemeralPublicKey(ephemeralKeyPair.getPublicKey());
                 const zkProofResponse = await createZkLoginProof({
-                    jwt: idToken,
+                    jwtTokenString: idToken,
                     maxEpoch: String(maxEpoch),
                     extendedEphemeralPublicKey,
                     jwtRandomness: randomness,
@@ -129,7 +129,7 @@ export function createWalletStore(config) {
                 zkloginStorage.getState().setSuiAddress(suiAddress);
                 const account = { jwt: decoded };
                 set({
-                    jwt: idToken,
+                    jwtTokenString: idToken,
                     decodedJwt: decoded,
                     ephemeralKeyPair,
                     suiAddress,
@@ -155,7 +155,7 @@ export function createWalletStore(config) {
                 // ignore storage errors
             }
             set({
-                jwt: null,
+                jwtTokenString: null,
                 decodedJwt: null,
                 ephemeralKeyPair: null,
                 suiAddress: null,
@@ -169,13 +169,14 @@ export function createWalletStore(config) {
             });
         },
         getSigner() {
-            const { jwt, maxEpoch, ephemeralKeyPair, zkProof, suiAddress, decodedJwt, } = get();
+            const { jwtTokenString: jwt, maxEpoch, ephemeralKeyPair, zkProof, suiAddress, decodedJwt, } = get();
             if (!jwt || !maxEpoch || !ephemeralKeyPair || !zkProof)
                 return null;
             return {
                 ephemeralKeyPair,
                 suiAddress,
                 decodedJwt,
+                jwtTokenString: jwt,
                 zkProof,
                 maxEpoch,
             };
@@ -203,8 +204,10 @@ export function createWalletStore(config) {
                 const ephemeralKeyPair = Ed25519Keypair.fromSecretKey(fromBase64(stored.ephemeralSecretKey));
                 const decoded = decodeJwt(stored.jwt);
                 const zkProofParsed = JSON.parse(stored.zkProof);
+                console.log({ decodeJwt: decoded });
+                console.log({ zkProofParsed: zkProofParsed });
                 set({
-                    jwt: stored.jwt,
+                    jwtTokenString: stored.jwt,
                     decodedJwt: decoded,
                     ephemeralKeyPair,
                     suiAddress: stored.suiAddress,

package/dist/types.d.ts

@@ -7,6 +7,7 @@ export type PartialZkLoginSignature = Omit<Parameters<typeof getZkLoginSignature
 export interface ZKLoginSignerState {
     ephemeralKeyPair: Ed25519Keypair | null;
     suiAddress: string | null;
+    jwtTokenString: string | null;
     decodedJwt: ReturnType<typeof decodeJwt> | null;
     zkProof: PartialZkLoginSignature | null;
     maxEpoch: number | null;
@@ -74,7 +75,7 @@ export interface ExecuteSponsoredTxResponse {
 }
 export type PlatformIdentifiers = Record<PlatformType, string>;
 export interface ZkLoginProofParams {
-    jwt: string;
+    jwtTokenString: string;
     maxEpoch: string;
     extendedEphemeralPublicKey: string;
     jwtRandomness: string;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@zing-protocol/zing-sdk",
   "sideEffects": false,
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {

package/dist/hooks/useGetTierPlan.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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]);
-}