@zing-protocol/zing-sdk 0.0.14 → 0.0.16

package/dist/bcs.d.ts

@@ -1,4 +1,3 @@
-import type { ObjectOwner } from "@mysten/sui/client";
 export declare const BlobId: import("@mysten/sui/bcs").BcsType<string, string | bigint, "u256">;
 export declare const QuiltPatchId: import("@mysten/sui/bcs").BcsStruct<{
     quiltId: import("@mysten/sui/bcs").BcsType<string, string | bigint, "u256">;
@@ -46,16 +45,3 @@ export declare const MoveObjectType: import("@mysten/sui/bcs").BcsEnum<{
     StakedSui: null;
     Coin: import("@mysten/sui/bcs").BcsType<string, string | import("@mysten/sui/bcs").TypeTag, string>;
 }, "MoveObjectType">;
-export declare const SuiMoveObject: import("@mysten/sui/bcs").BcsStruct<{
-    data: import("@mysten/sui/bcs").BcsEnum<{
-        MoveObject: import("@mysten/sui/bcs").BcsStruct<{
-            type: import("@mysten/sui/bcs").BcsType<any, string, string>;
-            hasPublicTransfer: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
-            version: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
-            contents: import("@mysten/sui/bcs").BcsType<any, string, string>;
-        }, string>;
-    }, "Data">;
-    owner: import("@mysten/sui/bcs").BcsType<any, ObjectOwner, string>;
-    previousTransaction: import("@mysten/sui/bcs").BcsType<string, string, "ObjectDigest">;
-    storageRebate: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
-}, string>;

package/dist/bcs.js

@@ -1,5 +1,4 @@
-import { bcs, TypeTagSerializer } from "@mysten/sui/bcs";
-import { fromBase64, normalizeStructTag, parseStructTag, SUI_FRAMEWORK_ADDRESS, SUI_SYSTEM_ADDRESS, } from "@mysten/sui/utils";
+import { bcs } from "@mysten/sui/bcs";
 import { blobIdFromInt, blobIdToInt } from "@mysten/walrus";
 function compareBcsBytes(a, b) {
     // sort by length first, because bcs bytes prefix length
@@ -44,66 +43,3 @@ export const MoveObjectType = bcs.enum("MoveObjectType", {
     StakedSui: null,
     Coin: bcs.TypeTag,
 });
-export const SuiMoveObject = bcs.struct("SuiMoveObject", {
-    data: bcs.enum("Data", {
-        MoveObject: bcs.struct("MoveObject", {
-            type: MoveObjectType.transform({
-                input: (objectType) => {
-                    const structTag = parseStructTag(objectType);
-                    if (structTag.address === SUI_FRAMEWORK_ADDRESS &&
-                        structTag.module === "coin" &&
-                        structTag.name === "Coin" &&
-                        typeof structTag.typeParams[0] === "object") {
-                        const innerStructTag = structTag.typeParams[0];
-                        if (innerStructTag.address === SUI_FRAMEWORK_ADDRESS &&
-                            innerStructTag.module === "sui" &&
-                            innerStructTag.name === "SUI") {
-                            return { GasCoin: true, $kind: "GasCoin" };
-                        }
-                        return { Coin: normalizeStructTag(innerStructTag), $kind: "Coin" };
-                    }
-                    else if (structTag.address === SUI_SYSTEM_ADDRESS &&
-                        structTag.module === "staking_pool" &&
-                        structTag.name === "StakedSui") {
-                        return { StakedSui: true, $kind: "StakedSui" };
-                    }
-                    return {
-                        Other: {
-                            ...structTag,
-                            typeParams: structTag.typeParams.map((typeParam) => TypeTagSerializer.parseFromStr(normalizeStructTag(typeParam))),
-                        },
-                        $kind: "Other",
-                    };
-                },
-            }),
-            hasPublicTransfer: bcs.bool(),
-            version: bcs.u64(),
-            contents: bcs.byteVector().transform({ input: fromBase64 }),
-        }),
-    }),
-    owner: bcs.Owner.transform({
-        input: (objectOwner) => {
-            if (objectOwner === "Immutable") {
-                return { Immutable: null };
-            }
-            else if ("Shared" in objectOwner) {
-                return {
-                    Shared: {
-                        initialSharedVersion: objectOwner.Shared.initial_shared_version,
-                    },
-                };
-            }
-            else if ("ConsensusAddressOwner" in objectOwner) {
-                return {
-                    ConsensusAddressOwner: {
-                        owner: objectOwner.ConsensusAddressOwner.owner,
-                        startVersion: objectOwner.ConsensusAddressOwner.start_version,
-                    },
-                };
-            }
-            return objectOwner;
-        },
-    }),
-    previousTransaction: bcs.ObjectDigest,
-    storageRebate: bcs.u64(),
-});

package/dist/client/index.d.ts

@@ -6,18 +6,15 @@ 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";
-import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 interface Params {
     network: SuiNetwork;
     suiGrpcClient: SuiGrpcClient;
-    suiJsonRpcClient: SuiJsonRpcClient;
 }
 export declare class ZingClient {
     suiGrpcClient: SuiGrpcClient;
-    suiJsonRpcClient: SuiJsonRpcClient;
     network: SuiNetwork;
     config: Config;
-    constructor({ network, suiGrpcClient, suiJsonRpcClient }: Params);
+    constructor({ network, suiGrpcClient }: Params);
     getConfig(): Config;
     getDerivedStudioID(address: string): string;
     getDerivedStorageID(address: string): string;
@@ -266,8 +263,8 @@ export declare class ZingClient {
             }[];
         };
     }[]>;
-    getBalance(owner: string, coinSymbol: CoinSymbol): Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
-    getSessionKey(saltServerUrl: string, signer: ZKLoginSignerState, owner: string): Promise<SessionKey>;
+    getBalance(owner: string, coinSymbol: CoinSymbol): Promise<import("node_modules/@mysten/sui/dist/grpc/proto/sui/rpc/v2/state_service.mjs").GetBalanceResponse>;
+    getSessionKey(saltServerUrl: string, signer: ZKLoginSignerState, owner: string): Promise<SessionKey | null>;
     buildSealApproveTransactionBytes(owner: string): Promise<Uint8Array<ArrayBuffer>>;
     getFileKey(sealClient: SealClient, sessionKey: SessionKey, owner: string, encryptedFileKeyBytes: number[]): Promise<CryptoKey>;
     subscribeToStudioTransaction({ sender, creatorAddress, subscriptionAmount, level, }: SubscribeParams): (tx: Transaction) => void;

package/dist/client/index.js

@@ -11,9 +11,8 @@ 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 }) {
+    constructor({ network, suiGrpcClient }) {
         this.suiGrpcClient = suiGrpcClient;
-        this.suiJsonRpcClient = suiJsonRpcClient;
         this.network = network || "testnet";
         this.config = getConfig(network);
     }
@@ -99,24 +98,31 @@ export class ZingClient {
             .then((res) => res.response);
     }
     async getSessionKey(saltServerUrl, signer, owner) {
-        const { suiAddress, ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } = signer;
-        if (!suiAddress ||
-            !ephemeralKeyPair ||
-            !decodedJwt ||
-            !zkProof ||
-            !maxEpoch) {
-            throw new Error("Missing required wallet data for session key creation");
+        try {
+            const { suiAddress, ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } = signer;
+            if (!suiAddress ||
+                !ephemeralKeyPair ||
+                !decodedJwt ||
+                !zkProof ||
+                !maxEpoch) {
+                throw new Error("Missing required wallet data for session key creation");
+            }
+            const sessionKey = await SessionKey.create({
+                address: owner,
+                packageId: this.config.zing.ZING_STUDIO_V0_PACKAGE_ADDRESS,
+                ttlMin: 10,
+                suiClient: this.suiGrpcClient,
+            });
+            const message = sessionKey.getPersonalMessage();
+            const { zkLoginSignature } = await signPersonalMessage(saltServerUrl, signer, message);
+            await sessionKey.setPersonalMessageSignature(zkLoginSignature);
+            return sessionKey;
+        }
+        catch (error) {
+            console.error("Fail to get SessionKey");
+            console.error({ error });
+            return null;
         }
-        const sessionKey = await SessionKey.create({
-            address: owner,
-            packageId: this.config.zing.ZING_STUDIO_V0_PACKAGE_ADDRESS,
-            ttlMin: 10,
-            suiClient: this.suiJsonRpcClient,
-        });
-        const message = sessionKey.getPersonalMessage();
-        const { zkLoginSignature } = await signPersonalMessage(saltServerUrl, signer, message);
-        sessionKey.setPersonalMessageSignature(zkLoginSignature);
-        return sessionKey;
     }
     async buildSealApproveTransactionBytes(owner) {
         const tx = new Transaction();
@@ -131,17 +137,19 @@ export class ZingClient {
             },
         }));
         return tx.build({
-            client: this.suiJsonRpcClient,
+            client: this.suiGrpcClient,
             onlyTransactionKind: true,
         });
     }
     async getFileKey(sealClient, sessionKey, owner, encryptedFileKeyBytes) {
         const txBytes = await this.buildSealApproveTransactionBytes(owner);
+        console.log({ txBytes });
         const decryptedKey = await sealClient.decrypt({
             data: new Uint8Array(encryptedFileKeyBytes),
             sessionKey,
             txBytes,
         });
+        console.log({ decryptedKey });
         return await importFileKey(decryptedKey);
     }
     // --- Transaction Builders ---

package/dist/components/walrus-provider.js

@@ -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, saltServerUrl, signer, onProgress);
+        }, zingClient.suiGrpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, saltServerUrl, signer, onProgress);
     }, [walrusClient]);
     const calculateQuiltSize = useCallback((walrusSystem, files, ivSize = 12) => {
         const numShards = walrusSystem.committee.n_shards;

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

@@ -1,12 +1,10 @@
 import { ZingClient } from "../client/index.js";
 import type { SuiNetwork } from "../types.js";
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
-import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 import type { ReactNode } from "react";
 interface ZingClientProviderProps {
     network: SuiNetwork;
     suiGrpcClient: SuiGrpcClient;
-    suiJsonRpcClient: SuiJsonRpcClient;
     children: ReactNode;
 }
 export declare const ZingClientProvider: React.FC<ZingClientProviderProps>;

package/dist/components/zing-provider.js

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

package/dist/config/testnet.js

@@ -1,7 +1,7 @@
 export const testnetZingConfig = {
     ZING_FRAMEWORK_PACKAGE_ADDRESS: "0xd851eb5b907b60aa5fd958dd74044d809c49ee60001cad621726f03ea138f943",
     ZING_IDENTITY_PACKAGE_ADDRESS: "0xaaf27a90890ac1efface4fbb22597e95829cbe6cbb771df02f0d2cc93f067c70",
-    ZING_STUDIO_PACKAGE_ADDRESS: "0x4e497b857da8adcd084fd39a887c36801499a1314bb94e026d9e93d13f8f40e5",
+    ZING_STUDIO_PACKAGE_ADDRESS: "0x200e858488929b31f7dbfa87ea85a1ada811945f33fb00aefe600762855507db",
     ZING_STUDIO_V0_PACKAGE_ADDRESS: "0x3502955f106ee334653443005b37ebc6d1ddf7b9c704d39090263ae136ba599d",
     ZING_TREASURY_SHARED_OBJECT_REF: {
         objectId: "0xca56bc3982525decbd4b025d3d4ae4de07259d6efc187577bfc3ab212e20574f",

package/dist/getters.d.ts

@@ -1,6 +1,5 @@
 import { QuiltPatchId } from "./bcs.js";
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
-import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 import type { EncodingType, WalrusClient } from "@mysten/walrus";
 export declare function getDerivedStudioID(studioConfigId: string, address: string): string;
 export declare function getDerivedStorageID(studioConfigId: string, address: string): string;
@@ -257,7 +256,7 @@ export declare function getWorksByObjectIds(suiGrpcClient: SuiGrpcClient, workOb
         }[];
     };
 }[]>;
-export declare function getPublishedArticleAndBlobId(suiGrpcClient: SuiGrpcClient, suiClient: SuiJsonRpcClient, walrusClient: WalrusClient, digest: string, blobRegisteredEventType: string, publishArticleEventType: string): Promise<{
+export declare function getPublishedArticleAndBlobId(suiGrpcClient: SuiGrpcClient, walrusClient: WalrusClient, digest: string, blobRegisteredEventType: string, publishArticleEventType: string): Promise<{
     parsedPublishArticleEvent: {
         article_id: string;
         owner: string;

package/dist/getters.js

@@ -7,7 +7,7 @@ import { BlobRegistered } from "./_generated/zing_studio/deps/walrus/events.js";
 import { Referral } from "./_generated/zing_studio/referral.js";
 import { StorageSpace, StorageTreasury, } from "./_generated/zing_studio/storage.js";
 import { Member, Studio } from "./_generated/zing_studio/studio.js";
-import { QuiltPatchId, SuiMoveObject } from "./bcs.js";
+import { QuiltPatchId } from "./bcs.js";
 import { bcs } from "@mysten/sui/bcs";
 import { deriveDynamicFieldID, deriveObjectID, fromBase64, normalizeStructTag, toBase64, } from "@mysten/sui/utils";
 // Walrus
@@ -48,8 +48,10 @@ export async function getIdentifierByAddress(suiGrpcClient, addressToIdentifierD
     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);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const field = Field(bcs.Address, bcs.String).parse(suiMoveObject.data.Move.contents);
     return field.value;
 }
 export async function getIdentifierInfoByIdentifier(suiGrpcClient, identifierInfoDynamicFieldId, identifier) {
@@ -63,8 +65,10 @@ export async function getIdentifierInfoByIdentifier(suiGrpcClient, identifierInf
     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);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const field = Field(bcs.String, IdentifierInfo).parse(suiMoveObject.data.Move.contents);
     return field.value;
 }
 export async function getDonationByIdentifier(suiGrpcClient, donationTableId, identifier) {
@@ -78,8 +82,10 @@ export async function getDonationByIdentifier(suiGrpcClient, donationTableId, id
     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);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const field = Field(bcs.String, VecMap(TypeName, bcs.U64)).parse(suiMoveObject.data.Move.contents);
     return field.value;
 }
 export async function getStudio(suiGrpcClient, studioId) {
@@ -93,8 +99,10 @@ export async function getStudio(suiGrpcClient, studioId) {
         if (!res.response.object?.bcs?.value) {
             return null;
         }
-        const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
-        return Studio.parse(suiMoveObject.data.MoveObject.contents);
+        const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+        if (suiMoveObject.data.$kind === "Package")
+            throw new Error("Move Object is Package");
+        return Studio.parse(suiMoveObject.data.Move.contents);
     }
     catch (error) {
         console.error(error);
@@ -112,8 +120,10 @@ export async function getStorageSpace(suiGrpcClient, storageSpaceId) {
         if (!res.response.object?.bcs?.value) {
             return null;
         }
-        const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
-        return StorageSpace.parse(suiMoveObject.data.MoveObject.contents);
+        const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+        if (suiMoveObject.data.$kind === "Package")
+            throw new Error("Move Object is Package");
+        return StorageSpace.parse(suiMoveObject.data.Move.contents);
     }
     catch (error) {
         console.error(error);
@@ -130,8 +140,10 @@ export async function getStorageTreasury(suiGrpcClient, storageTreasuryId) {
     if (!res.response.object?.bcs?.value) {
         return null;
     }
-    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
-    return StorageTreasury.parse(suiMoveObject.data.MoveObject.contents);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    return StorageTreasury.parse(suiMoveObject.data.Move.contents);
 }
 export async function getMember(suiGrpcClient, membershipTableId, member) {
     const dfObjectId = deriveDynamicFieldID(membershipTableId, "address", bcs.Address.serialize(member).toBytes());
@@ -144,8 +156,10 @@ export async function getMember(suiGrpcClient, membershipTableId, member) {
     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);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const field = Field(bcs.Address, Member).parse(suiMoveObject.data.Move.contents);
     return field.value;
 }
 export async function getMembers(suiGrpcClient, membershipTableId, cursor, limit = 20) {
@@ -160,9 +174,11 @@ export async function getMembers(suiGrpcClient, membershipTableId, cursor, limit
     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);
+        const suiMoveObject = bcs.Object.parse(df.fieldObject.bcs.value);
         // Wrapped in dynamicFields
-        const field = Field(bcs.Address, Member).parse(suiMoveObject.data.MoveObject.contents);
+        if (suiMoveObject.data.$kind === "Package")
+            throw new Error("Move Object is Package");
+        const field = Field(bcs.Address, Member).parse(suiMoveObject.data.Move.contents);
         return {
             member: field.name,
             level: field.value.level,
@@ -187,8 +203,10 @@ export async function getReferral(suiGrpcClient, referralID) {
     if (!res.response.object?.bcs?.value) {
         return null;
     }
-    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
-    const field = Field(bcs.vector(bcs.u8()), Referral).parse(suiMoveObject.data.MoveObject.contents);
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const field = Field(bcs.vector(bcs.u8()), Referral).parse(suiMoveObject.data.Move.contents);
     return field.value;
 }
 export async function getWork(suiGrpcClient, workId, workType) {
@@ -201,13 +219,14 @@ export async function getWork(suiGrpcClient, workId, workType) {
     if (!res.response.object?.bcs?.value) {
         return null;
     }
-    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
-    const type = suiMoveObject.data.MoveObject
-        .type;
+    const suiMoveObject = bcs.Object.parse(res.response.object.bcs.value);
+    if (suiMoveObject.data.$kind === "Package")
+        throw new Error("Move Object is Package");
+    const type = suiMoveObject.data.Move.type;
     if (type.$kind !== "Other" ||
         normalizeStructTag(type.Other) !== workType)
         return null;
-    return Article.parse(suiMoveObject.data.MoveObject.contents);
+    return Article.parse(suiMoveObject.data.Move.contents);
 }
 export async function getWorks(suiGrpcClient, workTableId, workType, cursor, limit = 20) {
     const res = await suiGrpcClient.stateService.listDynamicFields({
@@ -248,19 +267,24 @@ export async function getWorksByObjectIds(suiGrpcClient, workObjectIds, workType
     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 suiMoveObject = bcs.Object.parse(obj.result.object.bcs.value);
+            if (suiMoveObject.data.$kind === "Package")
+                throw new Error("Move Object is Package");
+            const type = suiMoveObject.data.Move.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));
+    return suiMoveObjects.map((obj) => {
+        if (obj.data.$kind === "Package")
+            throw new Error("Move Object is Package");
+        return Article.parse(obj.data.Move.contents);
+    });
 }
-export async function getPublishedArticleAndBlobId(suiGrpcClient, suiClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType) {
+export async function getPublishedArticleAndBlobId(suiGrpcClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType) {
     // suiGrpcClient waitForTransaction calling core.getTransaction which is broken
-    await suiClient.waitForTransaction({
+    await suiGrpcClient.core.waitForTransaction({
         digest,
     });
     if (!digest)

package/dist/hooks/useReclaim.d.ts

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

package/dist/hooks/useReclaim.js

@@ -32,20 +32,27 @@ export function useCommitProof() {
             });
             if (!commitTransactionResponse)
                 throw new Error("fail to commit proof");
-            const commitTransactionObjectChanges = (await suiClient.waitForTransaction({
+            const settledCommitTransactionResult = await suiClient.waitForTransaction({
                 digest: commitTransactionResponse.transactionDigest,
-                options: {
-                    showObjectChanges: true,
+                include: {
+                    effects: true,
+                    objectTypes: true,
                 },
-            })).objectChanges;
+            });
+            const commitTransactionObjectChanges = settledCommitTransactionResult.Transaction?.effects.changedObjects ||
+                [];
             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")
+            const commitment = commitTransactionObjectChanges.find((objChange) => {
+                if (objChange.idOperation !== "Created")
+                    return false;
+                const type = settledCommitTransactionResult.Transaction?.objectTypes[objChange.objectId];
+                return type === config.zing.PROOF_COMMITMENT_TYPE;
+            });
+            if (!commitment || commitment.idOperation !== "Created")
                 throw new Error("fail to commit proof");
             const revealTransaction = new Transaction();
-            const [signers, proofObj] = revealTransaction.add(revealAndVerifyProof({
+            const [, proofObj] = revealTransaction.add(revealAndVerifyProof({
                 package: config.zing.ZING_IDENTITY_PACKAGE_ADDRESS,
                 typeArguments: [identityPlatform.PLATFORM_TYPE],
                 arguments: {

package/dist/hooks/useSignAndExecuteTransaction.d.ts

@@ -2,5 +2,5 @@ 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 declare const useSignAndExecuteTransaction: () => import("@tanstack/react-query").UseMutationResult<import("@mysten/sui/jsonRpc").TransactionEffects | null, Error, SignAndExecuteTransactionParams, unknown>;
 export {};

package/dist/hooks/useSignAndExecuteTransaction.js

@@ -18,11 +18,14 @@ export const useSignAndExecuteTransaction = () => {
             // for Debug usage
             transaction.setSender(signer.suiAddress);
             transaction.setGasOwner(GAS_POOL_OWNER);
-            const dryRunResponse = await suiClient.dryRunTransactionBlock({
-                transactionBlock: await transaction.build({ client: suiClient }),
+            const dryRunResponse = await suiClient.simulateTransaction({
+                transaction: await transaction.build({ client: suiClient }),
+                include: {
+                    effects: true,
+                },
             });
             console.log({ dryRunResponse });
-            if (dryRunResponse.effects.status.status === "success") {
+            if (dryRunResponse.Transaction?.effects.status.success) {
                 const effects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiClient, transaction);
                 // TODO: handle error message by code
                 if (!effects)

package/dist/hooks/useZingMutation.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from "@mysten/sui/transactions";
 import type { ZingClient } from "../client/index.js";
-import type { TransactionEffects } from "@mysten/sui/client";
+import type { TransactionEffects } from "@mysten/sui/jsonRpc";
 declare const zingMutationMethodMap: (zingClient: ZingClient) => {
     subscribeToStudioTransaction: ({ sender, creatorAddress, subscriptionAmount, level, }: import("../client/types.js").SubscribeParams) => (tx: Transaction) => void;
     purchaseStorageTierTransaction: ({ sender, objs, newTierIdx, balance, referrer, }: import("../client/types.js").PurchaseStorageTierParams) => (tx: Transaction) => void;

package/dist/hooks/useZingMutation.js

@@ -28,7 +28,7 @@ export function useZingMutation() {
         },
         onSuccess: async (effects) => {
             if (effects?.transactionDigest) {
-                await zingClient.suiJsonRpcClient.waitForTransaction({
+                await zingClient.suiGrpcClient.waitForTransaction({
                     digest: effects.transactionDigest,
                 });
             }

package/dist/hooks/useZingQueries.d.ts

@@ -111,7 +111,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         level: number;
         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>;
+    getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/grpc/proto/sui/rpc/v2/state_service.mjs").GetBalanceResponse>;
 };
 type ZingQueryMethods = ReturnType<typeof zingQueryMethodMap>;
 type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;

package/dist/hooks/useZingQuery.d.ts

@@ -117,7 +117,7 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
         referrer: string;
         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>;
+    getBalance: (owner: string, coinSymbol: import("../index.js").CoinSymbol) => Promise<import("node_modules/@mysten/sui/dist/grpc/proto/sui/rpc/v2/state_service.mjs").GetBalanceResponse>;
     getWork: (workId: string, workType?: import("../index.js").WorkType) => Promise<{
         id: {
             id: string;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from "./bcs.js";
 export * from "./_generated/index.js";
 export * from "./components/index.js";
 export * from "./client/index.js";
+export * from "./stores/index.js";
 export type * from "./types.js";
 export type InfiniteQueryResult<TData> = {
     pages: TData[];

package/dist/index.js

@@ -8,3 +8,4 @@ export * from "./bcs.js";
 export * from "./_generated/index.js";
 export * from "./components/index.js";
 export * from "./client/index.js";
+export * from "./stores/index.js";

package/dist/lib/oauth-pwa.d.ts

@@ -0,0 +1,11 @@
+export interface OAuthState {
+    ephemeralSecretKey: string;
+    maxEpoch: number;
+    randomness: string;
+    authProvider: string;
+    timestamp: number;
+}
+export declare function isIOSPWA(): boolean;
+export declare function saveOAuthState(state: OAuthState): void;
+export declare function getOAuthState(): OAuthState | null;
+export declare function clearOAuthState(): void;

package/dist/lib/oauth-pwa.js

@@ -0,0 +1,55 @@
+// Storage keys for OAuth state
+const OAUTH_STATE_KEY = "zing:oauth:state";
+// Helper to detect iOS (Safari or PWA) where popups are unreliable
+export function isIOSPWA() {
+    // Check if it's iOS device
+    const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
+    if (!isIOS)
+        return false;
+    // In iOS, we should use redirect for:
+    // 1. PWA/Standalone mode (home screen apps)
+    // 2. Regular Safari (popups are blocked by default)
+    const isStandalone = window.navigator.standalone === true;
+    const isSafari = /Safari/.test(navigator.userAgent) &&
+        !/CriOS|FxiOS|EdgiOS/.test(navigator.userAgent);
+    // Use redirect-based flow for iOS Safari or standalone mode
+    return isStandalone || isSafari;
+}
+export function saveOAuthState(state) {
+    try {
+        localStorage.setItem(OAUTH_STATE_KEY, JSON.stringify(state));
+    }
+    catch (error) {
+        console.error("Failed to save OAuth state:", error);
+    }
+}
+export function getOAuthState() {
+    try {
+        const data = localStorage.getItem(OAUTH_STATE_KEY);
+        if (!data) {
+            console.error("No OAuth state found in localStorage");
+            return null;
+        }
+        const state = JSON.parse(data);
+        // Check if state is not too old (5 minutes max)
+        const now = Date.now();
+        if (now - state.timestamp > 5 * 60 * 1000) {
+            console.error("OAuth state expired");
+            clearOAuthState();
+            return null;
+        }
+        return state;
+    }
+    catch (error) {
+        console.error("Failed to get OAuth state:", error);
+        return null;
+    }
+}
+export function clearOAuthState() {
+    try {
+        localStorage.removeItem(OAUTH_STATE_KEY);
+    }
+    catch (error) {
+        console.error("Failed to clear OAuth state:", error);
+    }
+}

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

@@ -5,3 +5,4 @@ export declare const formatBalance: (balance: string | number | bigint, decimal:
 export declare const formatBytes: (bytes: number) => string;
 export declare const getDaysRemaining: (comp: number) => number;
 export declare const bytesToGB: (bytes: number) => number;
+export declare function isIOSPWA(): boolean;

package/dist/lib/utils/helpers.js

@@ -23,3 +23,12 @@ export const getDaysRemaining = (comp) => {
     return diffDays;
 };
 export const bytesToGB = (bytes) => bytes / (1024 * 1024 * 1024);
+export function isIOSPWA() {
+    const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
+    if (!isIOS)
+        return false;
+    const isStandalone = window.navigator.standalone === true;
+    const isSafari = /Safari/.test(navigator.userAgent) &&
+        !/CriOS|FxiOS|EdgiOS/.test(navigator.userAgent);
+    return isStandalone || isSafari;
+}

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

@@ -1,4 +1,4 @@
-import type { EncodingType } from "@mysten/walrus";
+type EncodingType = "RS2" | "RedStuff";
 export interface QuiltSizeInput {
     blobs: {
         size: number;
@@ -59,3 +59,4 @@ export declare function calculateEncryptedQuiltSize(files: Array<{
     identifier: string;
     tags?: Record<string, string>;
 }>, numShards: number, ivSize?: number, encodingType?: EncodingType): QuiltSizeResult;
+export {};

package/dist/mutations/signer.d.ts

@@ -1,8 +1,9 @@
 import type { ZkLoginProofParams, ZkLoginProofResponse, ZKLoginSignerState } from "../types.js";
-import type { SuiClient } from "@mysten/sui/client";
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { TransactionEffects } from "@mysten/sui/jsonRpc";
 import type { Transaction } from "@mysten/sui/transactions";
-export declare function getSigner(suiClient: SuiClient): Promise<ZKLoginSignerState>;
-export declare function signAndExecuteGasPoolTransaction(saltServerUrl: string, signer: ZKLoginSignerState, suiClient: SuiClient, tx: Transaction, gasBudget?: number, reserveDurationSecs?: number): Promise<any>;
+export declare function getSigner(suiClient: SuiGrpcClient): Promise<ZKLoginSignerState>;
+export declare function signAndExecuteGasPoolTransaction(saltServerUrl: string, signer: ZKLoginSignerState, suiClient: SuiGrpcClient, tx: Transaction, gasBudget?: number, reserveDurationSecs?: number): Promise<TransactionEffects | undefined>;
 export declare function signPersonalMessage(saltServerUrl: string, signer: ZKLoginSignerState, message: Uint8Array): Promise<{
     zkLoginSignature: any;
     bytes: Uint8Array<ArrayBuffer>;

package/dist/mutations/signer.js

@@ -4,7 +4,7 @@ import { fromBase64 } from "@mysten/sui/utils";
 import { decodeJwt } from "@mysten/sui/zklogin";
 export async function getSigner(suiClient) {
     const zkLoginStorage = await zkloginStorage.getState();
-    const { epoch: currentEpoch } = await suiClient.getLatestSuiSystemState();
+    const { systemState: { epoch: currentEpoch }, } = await suiClient.core.getCurrentSystemState();
     if (!zkLoginStorage?.jwt ||
         !zkLoginStorage?.maxEpoch ||
         !zkLoginStorage.ephemeralSecretKey ||

package/dist/mutations/walrus.d.ts

@@ -4,7 +4,6 @@ import type { WalrusUploadFlowStage } from "../config/common.js";
 import type { SharedObjectRef, WalrusSystemState } from "../config/types.js";
 import type { ZKLoginSignerState } from "../types.js";
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
-import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
 import type { CertifyBlobOptions, WalrusClient, WalrusFile, WriteFilesFlowOptions, WriteFilesFlowRegisterOptions, WriteFilesFlowUploadOptions } from "@mysten/walrus";
 type ZingWriteFlowConfig = {
     zingStudioPackageId: string;
@@ -28,7 +27,7 @@ export declare function buildCertifyArticleBlobTransaction(config: {
     zingStudioConfigSharedObjectRef: SharedObjectRef;
     walrusSystemSharedObjectRef: SharedObjectRef;
 }, walrusClient: WalrusClient, owner: string, articleId: string, { blobId, blobObjectId, confirmations, certificate, deletable, }: CertifyBlobOptions): (tx: Transaction) => Promise<void>;
-export declare const zingWriteFlow: (config: ZingWriteFlowConfig, suiGrpcClient: SuiGrpcClient, suiJsonRpcClient: SuiJsonRpcClient, walrusClient: WalrusClient, walrusSystem: WalrusSystemState, walTreasury: string, storageByEpoch: Record<number, number>, fileKey: CryptoKey, studioObjectId: string, owner: string, subscriptionLevel: null | number, articleMetadata: {
+export declare const zingWriteFlow: (config: ZingWriteFlowConfig, suiGrpcClient: SuiGrpcClient, walrusClient: WalrusClient, walrusSystem: WalrusSystemState, walTreasury: string, storageByEpoch: Record<number, number>, fileKey: CryptoKey, studioObjectId: string, owner: string, subscriptionLevel: null | number, articleMetadata: {
     identifier: string;
     tags: {
         "content-type": string;
@@ -64,7 +63,7 @@ export declare const zingWriteFlow: (config: ZingWriteFlowConfig, suiGrpcClient:
         blobObjectId: string;
     }[]>;
 };
-export declare function uploadFileToWalrus(zingWriteFlowConfig: ZingWriteFlowConfig, suiGrpcClient: SuiGrpcClient, suiJsonRpcClient: SuiJsonRpcClient, walrusClient: WalrusClient, walrusSystem: WalrusSystemState, walTreasury: string, storageByEpoch: Record<number, number>, fileKey: CryptoKey, walrusFiles: WalrusFile[], subscriptionLevel: null | number, metadata: {
+export declare function uploadFileToWalrus(zingWriteFlowConfig: ZingWriteFlowConfig, suiGrpcClient: SuiGrpcClient, walrusClient: WalrusClient, walrusSystem: WalrusSystemState, walTreasury: string, storageByEpoch: Record<number, number>, fileKey: CryptoKey, walrusFiles: WalrusFile[], subscriptionLevel: null | number, metadata: {
     identifier: string;
     tags: {
         "content-type": string;

package/dist/mutations/walrus.js

@@ -131,7 +131,7 @@ export function buildCertifyArticleBlobTransaction(config, walrusClient, owner,
         }));
     };
 }
-export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, studioObjectId, owner, subscriptionLevel, articleMetadata, options, withUploadRelayClient, blobRegisteredEventType, publishArticleEventType) => {
+export const zingWriteFlow = (config, suiGrpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, studioObjectId, owner, subscriptionLevel, articleMetadata, options, withUploadRelayClient, blobRegisteredEventType, publishArticleEventType) => {
     const { files } = options;
     const encode = async () => {
         const { quilt, index } = await walrusClient.encodeQuilt({
@@ -180,7 +180,7 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
         };
     };
     const upload = async ({ index, data, metadata, deletable }, { digest }) => {
-        const { parsedPublishArticleEvent, blobObjectId } = await getPublishedArticleAndBlobId(suiGrpcClient, suiJsonRpcClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType);
+        const { parsedPublishArticleEvent, blobObjectId } = await getPublishedArticleAndBlobId(suiGrpcClient, walrusClient, digest, blobRegisteredEventType, publishArticleEventType);
         const articleId = parsedPublishArticleEvent.article_id;
         if (withUploadRelayClient) {
             const meta = metadata;
@@ -295,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, saltServerUrl, signer, onProgress) {
+export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, saltServerUrl, signer, onProgress) {
     const report = (stage) => {
         if (onProgress)
             onProgress(stage);
@@ -304,7 +304,7 @@ export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, sui
     if (!owner)
         throw new Error("no signer");
     // Step 1: Create and encode the flow (can be done immediately when file is selected)
-    const flow = zingWriteFlow(zingWriteFlowConfig, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, getDerivedStudioID(zingWriteFlowConfig.zingStudioConfigSharedObjectRef.objectId, owner), owner, subscriptionLevel, metadata, {
+    const flow = zingWriteFlow(zingWriteFlowConfig, suiGrpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, getDerivedStudioID(zingWriteFlowConfig.zingStudioConfigSharedObjectRef.objectId, owner), owner, subscriptionLevel, metadata, {
         files: walrusFiles,
     }, true, zingWriteFlowConfig.blobRegisteredEventType, zingWriteFlowConfig.publishArticleEventType);
     report("encode");
@@ -319,17 +319,19 @@ export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, sui
             owner,
             deletable: true,
         });
-        const registerTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiJsonRpcClient, registerTx);
+        const registerTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiGrpcClient, registerTx);
         if (!registerTxEffects?.transactionDigest)
             throw new Error("fail to execute register Blob transaction");
-        const finalizedTransaction = await suiJsonRpcClient.waitForTransaction({
+        const finalizedTransaction = await suiGrpcClient.waitForTransaction({
             digest: registerTxEffects.transactionDigest,
         });
+        if (!finalizedTransaction?.Transaction?.digest)
+            throw new Error("Fail to get finalizedTransaction digest when waiting");
         // Step 3: Upload the data to storage nodes
         // This can be done immediately after the register step, or as a separate step the user initiates
         report("upload");
         return await flow.upload({
-            digest: finalizedTransaction.digest,
+            digest: finalizedTransaction.Transaction?.digest,
         });
     }
     const parsedPublishArticleEvent = await handleRegister();
@@ -337,10 +339,10 @@ export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, sui
     async function handleCertify() {
         report("certify_blob");
         const certifyTx = flow.certify();
-        const certifyTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiJsonRpcClient, certifyTx);
+        const certifyTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiGrpcClient, certifyTx);
         if (!certifyTxEffects?.transactionDigest)
             throw new Error("fail to execute certify Blob transaction");
-        await suiJsonRpcClient.waitForTransaction({
+        await suiGrpcClient.waitForTransaction({
             digest: certifyTxEffects.transactionDigest,
         });
         report("publish");

package/dist/stores/walletStore.d.ts

@@ -2,7 +2,7 @@ import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { decodeJwt } from "@mysten/sui/zklogin";
 import type { AuthProvider } from "../config/common.js";
 import type { PartialZkLoginSignature, ZKLoginSignerState } from "../types.js";
-import type { SuiClient } from "@mysten/sui/client";
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
 import type { StoreApi } from "zustand";
 export interface WalletAccount {
     jwt: ReturnType<typeof decodeJwt> & {
@@ -15,7 +15,7 @@ export interface WalletAccount {
     };
 }
 export interface WalletState {
-    suiClient: SuiClient;
+    suiClient: SuiGrpcClient;
     isConnected: boolean;
     isLoading: boolean;
     account: WalletAccount | null;
@@ -41,7 +41,7 @@ export type WalletActions = {
 };
 export type WalletStore = WalletState & WalletActions;
 export type WalletStoreConfig = {
-    suiClient: SuiClient;
+    suiClient: SuiGrpcClient;
     oAuthClientId: string;
     saltServerUrl: string;
     network?: string;

package/dist/stores/walletStore.js

@@ -1,4 +1,5 @@
 import { zkloginStorage } from "./zkloginStore.js";
+import { isIOSPWA } from "../lib/utils/helpers.js";
 import { createZkLoginProof } from "../mutations/signer.js";
 import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
@@ -36,9 +37,9 @@ export function createWalletStore(config) {
         async login(provider) {
             try {
                 set({ isLoading: true, error: null, authProvider: provider });
-                // 1?? Generate ephemeral keypair and maxEpoch
+                // Generate ephemeral keypair and maxEpoch
                 const ephemeralKeyPair = new Ed25519Keypair();
-                const { epoch } = await suiClient.getLatestSuiSystemState();
+                const { systemState: { epoch }, } = await suiClient.core.getCurrentSystemState();
                 const maxEpoch = Number(epoch) + 10;
                 const randomness = generateRandomness();
                 const nonce = generateNonce(ephemeralKeyPair.getPublicKey(), maxEpoch, randomness);
@@ -51,96 +52,123 @@ export function createWalletStore(config) {
                     nonce,
                 });
                 const loginURL = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
-                const idToken = await new Promise((resolve, reject) => {
-                    const width = 500;
-                    const height = 600;
-                    const left = window.screenX + (window.innerWidth - width) / 2;
-                    const top = window.screenY + (window.innerHeight - height) / 2;
-                    const popup = window.open(loginURL, "oauth2-login", `width=${width},height=${height},top=${top},left=${left}`);
-                    if (!popup)
-                        return reject(new Error("Failed to open popup"));
-                    let resolved = false;
-                    // Listen for postMessage from the callback page
-                    const messageHandler = (event) => {
-                        // Security: verify origin
-                        if (event.origin !== window.location.origin)
-                            return;
-                        if (event.data?.type !== "oauth-callback")
-                            return;
-                        if (resolved)
-                            return;
-                        resolved = true;
-                        window.removeEventListener("message", messageHandler);
-                        clearInterval(checkClosed);
-                        if (event.data.error) {
-                            return reject(new Error(event.data.error));
-                        }
-                        if (event.data.idToken) {
-                            resolve(event.data.idToken);
-                        }
-                        else {
-                            reject(new Error("No ID token received"));
+                // Save OAuth state for BOTH popup and redirect flows
+                const ephemeralSecretKey = toBase64(decodeSuiPrivateKey(ephemeralKeyPair.getSecretKey()).secretKey);
+                localStorage.setItem("zing:oauth:state", JSON.stringify({
+                    ephemeralSecretKey,
+                    maxEpoch,
+                    randomness,
+                    authProvider: provider,
+                    timestamp: Date.now(),
+                }));
+                // Check if iOS (Safari or PWA) - use redirect flow
+                const shouldUseRedirect = isIOSPWA();
+                if (shouldUseRedirect) {
+                    // Redirect to OAuth provider
+                    window.location.href = loginURL;
+                    return;
+                }
+                // Desktop/regular browsers: use popup flow
+                try {
+                    const idToken = await new Promise((resolve, reject) => {
+                        const width = 500;
+                        const height = 600;
+                        const left = window.screenX + (window.innerWidth - width) / 2;
+                        const top = window.screenY + (window.innerHeight - height) / 2;
+                        const popup = window.open(loginURL, "oauth2-login", `width=${width},height=${height},top=${top},left=${left}`);
+                        // If popup was blocked, fall back to redirect
+                        if (!popup) {
+                            console.warn("Popup blocked, falling back to redirect flow");
+                            window.location.href = loginURL;
+                            return; // Don't reject, just redirect
                         }
-                    };
-                    window.addEventListener("message", messageHandler);
-                    // Check if popup was closed without completing auth
-                    const checkClosed = setInterval(() => {
-                        if (!popup || popup.closed) {
+                        let resolved = false;
+                        // Listen for postMessage from the callback page
+                        const messageHandler = (event) => {
+                            // Security: verify origin
+                            if (event.origin !== window.location.origin)
+                                return;
+                            if (event.data?.type !== "oauth-callback")
+                                return;
+                            if (resolved)
+                                return;
+                            resolved = true;
+                            window.removeEventListener("message", messageHandler);
+                            clearInterval(checkClosed);
+                            if (event.data.error) {
+                                return reject(new Error(event.data.error));
+                            }
+                            if (event.data.idToken) {
+                                resolve(event.data.idToken);
+                            }
+                            else {
+                                reject(new Error("No ID token received"));
+                            }
+                        };
+                        window.addEventListener("message", messageHandler);
+                        // Check if popup was closed without completing auth
+                        const checkClosed = setInterval(() => {
+                            if (!popup || popup.closed) {
+                                if (!resolved) {
+                                    resolved = true;
+                                    clearInterval(checkClosed);
+                                    window.removeEventListener("message", messageHandler);
+                                    reject(new Error("Login popup closed before completing authentication"));
+                                }
+                            }
+                        }, 1000);
+                        // Timeout after 5 minutes
+                        setTimeout(() => {
                             if (!resolved) {
                                 resolved = true;
                                 clearInterval(checkClosed);
                                 window.removeEventListener("message", messageHandler);
-                                reject(new Error("Login popup closed before completing authentication"));
+                                if (popup && !popup.closed)
+                                    popup.close();
+                                reject(new Error("Login timeout"));
                             }
-                        }
-                    }, 1000);
-                    // Timeout after 5 minutes
-                    setTimeout(() => {
-                        if (!resolved) {
-                            resolved = true;
-                            clearInterval(checkClosed);
-                            window.removeEventListener("message", messageHandler);
-                            if (popup && !popup.closed)
-                                popup.close();
-                            reject(new Error("Login timeout"));
-                        }
-                    }, 5 * 60 * 1000);
-                });
-                // 4?? Decode JWT
-                const decoded = decodeJwt(idToken);
-                // 5?? Persist ephemeral secret / salt / jwt / maxEpoch
-                zkloginStorage
-                    .getState()
-                    .setEphemeralSecretKey(toBase64(decodeSuiPrivateKey(ephemeralKeyPair.getSecretKey()).secretKey));
-                zkloginStorage.getState().setJWT(idToken);
-                zkloginStorage.getState().setMaxEpoch(maxEpoch);
-                const extendedEphemeralPublicKey = getExtendedEphemeralPublicKey(ephemeralKeyPair.getPublicKey());
-                const zkProofResponse = await createZkLoginProof(config.saltServerUrl, {
-                    jwtTokenString: idToken,
-                    maxEpoch: String(maxEpoch),
-                    extendedEphemeralPublicKey,
-                    jwtRandomness: randomness,
-                });
-                if (!zkProofResponse || !zkProofResponse.zkProof) {
-                    throw new Error("Invalid response from proof server: Missing zkProof");
+                        }, 5 * 60 * 1000);
+                    });
+                    // Popup flow completed - process the token
+                    const decoded = decodeJwt(idToken);
+                    // Persist ephemeral secret
+                    zkloginStorage.getState().setEphemeralSecretKey(ephemeralSecretKey);
+                    zkloginStorage.getState().setJWT(idToken);
+                    zkloginStorage.getState().setMaxEpoch(maxEpoch);
+                    const extendedEphemeralPublicKey = getExtendedEphemeralPublicKey(ephemeralKeyPair.getPublicKey());
+                    const zkProofResponse = await createZkLoginProof(config.saltServerUrl, {
+                        jwtTokenString: idToken,
+                        maxEpoch: String(maxEpoch),
+                        extendedEphemeralPublicKey,
+                        jwtRandomness: randomness,
+                    });
+                    if (!zkProofResponse || !zkProofResponse.zkProof) {
+                        throw new Error("Invalid response from proof server: Missing zkProof");
+                    }
+                    const { zkProof, suiAddress } = zkProofResponse;
+                    zkloginStorage.getState().setZKProof(JSON.stringify(zkProof));
+                    zkloginStorage.getState().setSuiAddress(suiAddress);
+                    // Clear OAuth state
+                    localStorage.removeItem("zing:oauth:state");
+                    const account = { jwt: decoded };
+                    set({
+                        jwtTokenString: idToken,
+                        decodedJwt: decoded,
+                        ephemeralKeyPair,
+                        suiAddress,
+                        zkProof,
+                        maxEpoch,
+                        account,
+                        isConnected: true,
+                        isLoading: false,
+                        error: null,
+                    });
+                }
+                catch (popupError) {
+                    // Clean up OAuth state on popup error
+                    localStorage.removeItem("zing:oauth:state");
+                    throw popupError;
                 }
-                // 2. Access keys directly from the response (no .result nesting)
-                const { zkProof, suiAddress } = zkProofResponse;
-                zkloginStorage.getState().setZKProof(JSON.stringify(zkProof));
-                zkloginStorage.getState().setSuiAddress(suiAddress);
-                const account = { jwt: decoded };
-                set({
-                    jwtTokenString: idToken,
-                    decodedJwt: decoded,
-                    ephemeralKeyPair,
-                    suiAddress,
-                    zkProof,
-                    maxEpoch,
-                    account,
-                    isConnected: true,
-                    isLoading: false,
-                    error: null,
-                });
             }
             catch (err) {
                 set({ error: err?.message ?? String(err), isLoading: false });
@@ -185,7 +213,7 @@ export function createWalletStore(config) {
         async initFromStorage() {
             try {
                 set({ isLoading: true });
-                const { epoch: currentEpoch } = await suiClient.getLatestSuiSystemState();
+                const { systemState: { epoch: currentEpoch }, } = await suiClient.core.getCurrentSystemState();
                 const stored = {
                     jwt: zkloginStorage.getState().jwt,
                     maxEpoch: zkloginStorage.getState().maxEpoch,

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { PlatformType } from "./config/common.js";
-import type { SuiObjectRef, TransactionEffects } from "@mysten/sui/client";
+import type { SuiObjectRef, TransactionEffects } from "@mysten/sui/jsonRpc";
 import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import type { decodeJwt, getZkLoginSignature } from "@mysten/sui/zklogin";
 export type SuiNetwork = "mainnet" | "testnet";

package/package.json

@@ -2,7 +2,7 @@
   "name": "@zing-protocol/zing-sdk",
   "sideEffects": false,
   "type": "module",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -16,9 +16,9 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@mysten/seal": "^0.9.3",
-    "@mysten/sui": "^1.45.0",
-    "@mysten/walrus": "^0.9.0",
+    "@mysten/seal": "^1.0.1",
+    "@mysten/sui": "^2.4.0",
+    "@mysten/walrus": "^1.0.3",
     "@tanstack/react-query": "5.90.5",
     "@reclaimprotocol/js-sdk": "^4.5.1",
     "js-sha3": "^0.9.3",