@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/src/stores/walletStore.ts

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

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

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

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

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