@zing-protocol/zing-sdk 0.0.1

package/src/stores/index.ts

@@ -0,0 +1,3 @@
+export * from "./walrusStore.js";
+export * from "./walletStore.js";
+export * from "./zkloginStore.js";

package/src/stores/walletStore.ts

@@ -0,0 +1,360 @@
+import { zkloginStorage } from "./zkloginStore.js";
+import { createZkLoginProof } from "../mutations/signer.js";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { fromBase64, toBase64 } from "@mysten/sui/utils";
+import {
+  generateNonce,
+  decodeJwt,
+  getExtendedEphemeralPublicKey,
+  generateRandomness,
+} from "@mysten/sui/zklogin";
+import { createStore } from "zustand";
+import type { AuthProvider } from "../config/common.js";
+import type { PartialZkLoginSignature, ZKLoginSignerState } from "../types.js";
+import type { SuiClient } from "@mysten/sui/client";
+import type { StoreApi, StateCreator } from "zustand";
+
+export interface WalletAccount {
+  jwt: ReturnType<typeof decodeJwt> & {
+    email: string;
+    email_verified: boolean;
+    family_name?: string;
+    given_name?: string;
+    name?: string;
+    picture?: string;
+  };
+}
+
+export interface WalletState {
+  suiClient: SuiClient;
+  isConnected: boolean;
+  isLoading: boolean;
+  account: WalletAccount | null;
+  error: string | null;
+  network: string;
+  // zk/login state (kept in memory; secrets persisted in zkloginStorage only)
+  jwt: string | null;
+  decodedJwt: ReturnType<typeof decodeJwt> | null;
+  authProvider: AuthProvider | null;
+  ephemeralKeyPair: Ed25519Keypair | null;
+  suiAddress: string | null;
+  zkProof: PartialZkLoginSignature | null;
+  maxEpoch?: number | null;
+}
+
+export type WalletActions = {
+  // main flows
+  login: (provider: AuthProvider) => Promise<void>;
+  disconnect: () => Promise<void>;
+  getSigner: () => ZKLoginSignerState | null;
+  initFromStorage: () => Promise<void>;
+
+  // helpers
+  setError: (err: string | null) => void;
+  setLoading: (v: boolean) => void;
+  setNetwork: (n: string) => void;
+};
+
+export type WalletStore = WalletState & WalletActions;
+
+export type WalletStoreConfig = {
+  suiClient: SuiClient;
+  oAuthClientId: string;
+  network?: string; // default 'testnet'
+  autoInit?: boolean; // call initFromStorage automatically on creation
+};
+
+export function createWalletStore(
+  config: WalletStoreConfig,
+): StoreApi<WalletStore> {
+  const {
+    suiClient,
+    oAuthClientId,
+    network = "testnet",
+    autoInit = true,
+  } = config;
+
+  const baseCreator: StateCreator<WalletStore> = (set, get) => ({
+    // state
+    suiClient,
+    isConnected: false,
+    isLoading: false,
+    account: null,
+    error: null,
+    network,
+    jwt: null,
+    decodedJwt: null,
+    authProvider: null,
+    ephemeralKeyPair: null,
+    suiAddress: null,
+    zkProof: null,
+    maxEpoch: null,
+
+    // actions
+    setError(err) {
+      set({ error: err });
+    },
+
+    setLoading(v) {
+      set({ isLoading: v });
+    },
+
+    setNetwork(n) {
+      set({ network: n });
+    },
+
+    async login(provider) {
+      try {
+        set({ isLoading: true, error: null, authProvider: provider });
+
+        // 1?? Generate ephemeral keypair and maxEpoch
+        const ephemeralKeyPair = new Ed25519Keypair();
+        const { epoch } = await suiClient.getLatestSuiSystemState();
+        const maxEpoch = Number(epoch) + 10;
+        const randomness = generateRandomness();
+        const nonce = generateNonce(
+          ephemeralKeyPair.getPublicKey(),
+          maxEpoch,
+          randomness,
+        );
+
+        const redirectUri = `${window.location.origin}/oauth-callback`;
+        const params = new URLSearchParams({
+          client_id: oAuthClientId,
+          redirect_uri: redirectUri,
+          response_type: "id_token",
+          scope: "openid profile email",
+          nonce,
+        });
+        const loginURL = `https://accounts.google.com/o/oauth2/v2/auth?${params}`;
+
+        const idToken = await new Promise<string>((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: MessageEvent) => {
+            // 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);
+                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({
+          jwt: idToken,
+          maxEpoch: String(maxEpoch),
+          extendedEphemeralPublicKey,
+          jwtRandomness: randomness,
+        });
+
+        if (!zkProofResponse?.result)
+          throw new Error(`Failed to get zkProof: ${zkProofResponse.error}`);
+
+        zkloginStorage
+          .getState()
+          .setZKProof(JSON.stringify(zkProofResponse.result.zkProof));
+
+        const suiAddress = zkProofResponse.result.suiAddress;
+        zkloginStorage.getState().setSuiAddress(suiAddress);
+        const account: WalletAccount = { jwt: decoded as any };
+
+        set({
+          jwt: idToken,
+          decodedJwt: decoded,
+          ephemeralKeyPair,
+          suiAddress,
+          zkProof: zkProofResponse.result.zkProof,
+          maxEpoch,
+          account,
+          isConnected: true,
+          isLoading: false,
+          error: null,
+        });
+      } catch (err: any) {
+        set({ error: err?.message ?? String(err), isLoading: false });
+        throw err;
+      }
+    },
+
+    async disconnect() {
+      try {
+        // reset zkloginStorage
+        zkloginStorage.getState().reset();
+      } catch {
+        // ignore storage errors
+      }
+
+      set({
+        jwt: null,
+        decodedJwt: null,
+        ephemeralKeyPair: null,
+        suiAddress: null,
+        zkProof: null,
+        maxEpoch: null,
+        account: null,
+        isConnected: false,
+        isLoading: false,
+        authProvider: null,
+        error: null,
+      });
+    },
+
+    getSigner() {
+      const {
+        jwt,
+        maxEpoch,
+        ephemeralKeyPair,
+        zkProof,
+        suiAddress,
+        decodedJwt,
+      } = get();
+      if (!jwt || !maxEpoch || !ephemeralKeyPair || !zkProof) return null;
+      return {
+        ephemeralKeyPair,
+        suiAddress,
+        decodedJwt,
+        zkProof,
+        maxEpoch,
+      } as ZKLoginSignerState;
+    },
+
+    async initFromStorage() {
+      try {
+        set({ isLoading: true });
+        const { epoch: currentEpoch } =
+          await suiClient.getLatestSuiSystemState();
+
+        const stored = {
+          jwt: zkloginStorage.getState().jwt,
+          maxEpoch: zkloginStorage.getState().maxEpoch,
+          ephemeralSecretKey: zkloginStorage.getState().ephemeralSecretKey,
+          zkProof: zkloginStorage.getState().zkProof,
+          suiAddress: zkloginStorage.getState().suiAddress,
+        };
+
+        if (
+          !stored.jwt ||
+          !stored.maxEpoch ||
+          !stored.ephemeralSecretKey ||
+          !stored.zkProof ||
+          !stored.suiAddress
+        ) {
+          throw new Error("Missing required params");
+        }
+
+        if (Number(currentEpoch) >= Number(stored.maxEpoch))
+          throw new Error("Exceed maxEpoch");
+
+        const ephemeralKeyPair = Ed25519Keypair.fromSecretKey(
+          fromBase64(stored.ephemeralSecretKey),
+        );
+        const decoded = decodeJwt(stored.jwt);
+        const zkProofParsed = JSON.parse(stored.zkProof);
+
+        set({
+          jwt: stored.jwt,
+          decodedJwt: decoded,
+          ephemeralKeyPair,
+          suiAddress: stored.suiAddress,
+          zkProof: zkProofParsed,
+          maxEpoch: Number(stored.maxEpoch),
+          account: { jwt: decoded as any },
+          isConnected: true,
+          error: null,
+        });
+      } catch (err: any) {
+        set({ error: err?.message ?? String(err) });
+      }
+      set({ isLoading: false });
+    },
+  });
+
+  const store = createStore<WalletStore>()(baseCreator);
+
+  if (autoInit) {
+    store
+      .getState()
+      .initFromStorage()
+      .catch(() => {});
+  }
+
+  return store;
+}

package/src/stores/walrusStore.ts

@@ -0,0 +1,118 @@
+import { createStore } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+import type { WalrusStakingState, WalrusSystemState } from "../config/types.js";
+import type { SealClient } from "@mysten/seal";
+import type { WalrusClient } from "@mysten/walrus";
+import type { StateCreator, StoreApi } from "zustand";
+import type { StateStorage } from "zustand/middleware";
+
+export type WalrusStore = {
+  walrusClient: WalrusClient;
+  sealClient: SealClient;
+  walrusStakingState?: WalrusStakingState;
+  walrusSystemState?: WalrusSystemState;
+  isLoading: boolean;
+  error?: string | null;
+
+  // actions
+  init: () => Promise<void>;
+  refreshWalrusState: () => Promise<void>;
+  setError: (err?: string | null) => void;
+  setStakingState: (state?: WalrusStakingState) => void;
+  setSystemState: (state?: WalrusSystemState) => void;
+
+  // NEW SETTERS
+  setWalrusClient: (c: WalrusClient) => void;
+  setSealClient: (c: SealClient) => void;
+};
+
+export type WalrusStoreConfig = {
+  walrusClient: WalrusClient;
+  sealClient: SealClient;
+  storage?: StateStorage;
+  storageKey?: string;
+  autoInit?: boolean;
+};
+
+export function createWalrusStore(
+  config: WalrusStoreConfig,
+): StoreApi<WalrusStore> {
+  const {
+    walrusClient,
+    sealClient,
+    storage,
+    storageKey = "walrus-store",
+    autoInit = true,
+  } = config;
+
+  const baseStore: StateCreator<WalrusStore, [], [], WalrusStore> = (
+    set,
+    get,
+  ) => ({
+    walrusClient,
+    sealClient,
+    walrusStakingState: undefined,
+    walrusSystemState: undefined,
+    isLoading: false,
+    error: null,
+
+    setWalrusClient(c) {
+      set(() => ({ walrusClient: c }));
+    },
+
+    setSealClient(c) {
+      set(() => ({ sealClient: c }));
+    },
+
+    setError(err) {
+      set(() => ({ error: err ?? null }));
+    },
+
+    setStakingState(state) {
+      set(() => ({ walrusStakingState: state }));
+    },
+
+    setSystemState(state) {
+      set(() => ({ walrusSystemState: state }));
+    },
+
+    async refreshWalrusState() {
+      const client = get().walrusClient;
+      if (!client) {
+        set(() => ({ error: "WalrusClient not initialized" }));
+        return;
+      }
+
+      try {
+        set(() => ({ isLoading: true, error: null }));
+        const walrusStakingState = await client.stakingState();
+        const walrusSystemState = await client.systemState();
+        set(() => ({ walrusStakingState, walrusSystemState }));
+      } catch (e: any) {
+        set(() => ({ error: e instanceof Error ? e.message : String(e) }));
+      } finally {
+        set(() => ({ isLoading: false }));
+      }
+    },
+
+    async init() {
+      await get().refreshWalrusState();
+    },
+  });
+
+  if (storage) {
+    return createStore<WalrusStore>()(
+      persist(baseStore, {
+        name: storageKey,
+        storage: createJSONStorage(() => storage),
+        partialize: () => ({}),
+      }),
+    );
+  }
+
+  const store = createStore<WalrusStore>()(baseStore);
+
+  if (autoInit) store.getState().init();
+
+  return store;
+}

package/src/stores/zkloginStore.ts

@@ -0,0 +1,53 @@
+import { create } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+
+export interface ZKLoginStorage {
+  jwt: string | null;
+  suiAddress: string | null;
+  maxEpoch: number | null;
+  expiresAt: number | null;
+  ephemeralSecretKey: string | null;
+  zkProof: string | null;
+
+  setSuiAddress: (suiAddress: string) => void;
+  setMaxEpoch: (maxEpoch: number) => void;
+  setExpiresAt: (expiresAt: number) => void;
+  setJWT: (jwt: string) => void;
+  setEphemeralSecretKey: (key: string) => void;
+  setZKProof: (proof: string) => void;
+  reset: () => void;
+}
+
+export const zkloginStorage = create<ZKLoginStorage>()(
+  persist(
+    (set) => ({
+      jwt: null,
+      suiAddress: null,
+      maxEpoch: null,
+      expiresAt: null,
+      ephemeralSecretKey: null,
+      zkProof: null,
+
+      setSuiAddress: (suiAddress: string) => set({ suiAddress }),
+      setMaxEpoch: (maxEpoch: number) => set({ maxEpoch }),
+      setExpiresAt: (expiresAt: number) => set({ expiresAt }),
+      setJWT: (jwt: string) => set({ jwt }),
+      setEphemeralSecretKey: (ephemeralSecretKey: string) =>
+        set({ ephemeralSecretKey }),
+      setZKProof: (zkProof: string) => set({ zkProof }),
+      reset: () =>
+        set({
+          jwt: null,
+          suiAddress: null,
+          maxEpoch: null,
+          expiresAt: null,
+          ephemeralSecretKey: null,
+          zkProof: null,
+        }),
+    }),
+    {
+      name: "zklogin-storage", // localStorage key
+      storage: createJSONStorage(() => localStorage),
+    },
+  ),
+);

package/src/types.ts

@@ -0,0 +1,120 @@
+import type { PlatformType } from "./config/common.js";
+import type { SuiObjectRef, TransactionEffects } from "@mysten/sui/client";
+import type { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import type { decodeJwt, getZkLoginSignature } from "@mysten/sui/zklogin";
+
+export type SuiNetwork = "mainnet" | "testnet";
+// Auth
+export type PartialZkLoginSignature = Omit<
+  Parameters<typeof getZkLoginSignature>["0"]["inputs"],
+  "addressSeed"
+>;
+
+export interface ZKLoginSignerState {
+  ephemeralKeyPair: Ed25519Keypair | null;
+  suiAddress: string | null;
+  decodedJwt: ReturnType<typeof decodeJwt> | null;
+  zkProof: PartialZkLoginSignature | null;
+  maxEpoch: number | null;
+}
+// Sui
+export interface SponsoredGasParams {
+  gaslessTransactionBytes: string;
+  senderAddress: string;
+  gasBudget?: string;
+  gasPrice?: string;
+}
+
+export interface GenerateSaltRequest {
+  sub: string;
+  iss: string;
+  aud: string;
+}
+
+export interface GenerateSaltResponse {
+  salt: string;
+  saltInt: string;
+  deviceId: string | null;
+  timestamp: string;
+}
+
+export type SponsoredGasResponse =
+  | {
+      jsonrpc: string;
+      result: {
+        txBytes: string;
+        txDigest: string;
+        signature: string;
+        expireAtTime: number;
+      };
+      id: number;
+      error?: never; // explicitly forbid error here
+    }
+  | {
+      jsonrpc: string;
+      error: {
+        code: number;
+        message: string;
+        data?: {
+          details?: string;
+        };
+      };
+      id: number;
+      result?: never; // explicitly forbid result here
+    };
+
+export interface ReserveGasRequest {
+  gas_budget: number;
+  reserve_duration_secs: number;
+}
+
+export interface ReserveGasResponse {
+  result: ReserveGasResult | null;
+  error: string | null;
+}
+
+export interface ReserveGasResult {
+  sponsor_address: string;
+  reservation_id: string;
+  gas_coins: SuiObjectRef[];
+}
+
+export interface ExecuteSponsoredTxRequest {
+  reservation_id: string;
+  tx_bytes: string;
+  user_sig: string;
+}
+
+export interface ExecuteSponsoredTxResponse {
+  effects: TransactionEffects | null;
+  error: string | null;
+}
+
+export type PlatformIdentifiers = Record<PlatformType, string>;
+
+export interface ZkLoginProofParams {
+  jwt: string;
+  maxEpoch: string;
+  extendedEphemeralPublicKey: string;
+  jwtRandomness: string;
+}
+
+export interface ZkLoginProofResponse {
+  id: number;
+  result?: {
+    zkProof: PartialZkLoginSignature;
+    suiAddress: string; // Add this line
+  };
+  error?: {
+    code: number;
+    message: string;
+  };
+}
+
+export interface TierPlan {
+  name: string;
+  price: number;
+  duration: number;
+  storage: number;
+  features: string[];
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "@package/tsconfig/module",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "outDir": "dist",
+    "declaration": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "jsx": "react-jsx"
+  },
+  "include": ["src"]
+}