@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/stores/walletStore.js

@@ -0,0 +1,232 @@
+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";
+export function createWalletStore(config) {
+    const { suiClient, oAuthClientId, network = "testnet", autoInit = true, } = config;
+    const baseCreator = (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((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"));
+                        }
+                    };
+                    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 = { jwt: decoded };
+                set({
+                    jwt: idToken,
+                    decodedJwt: decoded,
+                    ephemeralKeyPair,
+                    suiAddress,
+                    zkProof: zkProofResponse.result.zkProof,
+                    maxEpoch,
+                    account,
+                    isConnected: true,
+                    isLoading: false,
+                    error: null,
+                });
+            }
+            catch (err) {
+                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,
+            };
+        },
+        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 },
+                    isConnected: true,
+                    error: null,
+                });
+            }
+            catch (err) {
+                set({ error: err?.message ?? String(err) });
+            }
+            set({ isLoading: false });
+        },
+    });
+    const store = createStore()(baseCreator);
+    if (autoInit) {
+        store
+            .getState()
+            .initFromStorage()
+            .catch(() => { });
+    }
+    return store;
+}

package/dist/stores/walrusStore.d.ts

@@ -0,0 +1,28 @@
+import type { WalrusStakingState, WalrusSystemState } from "../config/types.js";
+import type { SealClient } from "@mysten/seal";
+import type { WalrusClient } from "@mysten/walrus";
+import type { 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;
+    init: () => Promise<void>;
+    refreshWalrusState: () => Promise<void>;
+    setError: (err?: string | null) => void;
+    setStakingState: (state?: WalrusStakingState) => void;
+    setSystemState: (state?: WalrusSystemState) => void;
+    setWalrusClient: (c: WalrusClient) => void;
+    setSealClient: (c: SealClient) => void;
+};
+export type WalrusStoreConfig = {
+    walrusClient: WalrusClient;
+    sealClient: SealClient;
+    storage?: StateStorage;
+    storageKey?: string;
+    autoInit?: boolean;
+};
+export declare function createWalrusStore(config: WalrusStoreConfig): StoreApi<WalrusStore>;

package/dist/stores/walrusStore.js

@@ -0,0 +1,61 @@
+import { createStore } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+export function createWalrusStore(config) {
+    const { walrusClient, sealClient, storage, storageKey = "walrus-store", autoInit = true, } = config;
+    const baseStore = (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) {
+                set(() => ({ error: e instanceof Error ? e.message : String(e) }));
+            }
+            finally {
+                set(() => ({ isLoading: false }));
+            }
+        },
+        async init() {
+            await get().refreshWalrusState();
+        },
+    });
+    if (storage) {
+        return createStore()(persist(baseStore, {
+            name: storageKey,
+            storage: createJSONStorage(() => storage),
+            partialize: () => ({}),
+        }));
+    }
+    const store = createStore()(baseStore);
+    if (autoInit)
+        store.getState().init();
+    return store;
+}

package/dist/stores/zkloginStore.d.ts

@@ -0,0 +1,28 @@
+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 declare const zkloginStorage: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ZKLoginStorage>, "setState" | "persist"> & {
+    setState(partial: ZKLoginStorage | Partial<ZKLoginStorage> | ((state: ZKLoginStorage) => ZKLoginStorage | Partial<ZKLoginStorage>), replace?: false | undefined): unknown;
+    setState(state: ZKLoginStorage | ((state: ZKLoginStorage) => ZKLoginStorage), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ZKLoginStorage, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ZKLoginStorage) => void) => () => void;
+        onFinishHydration: (fn: (state: ZKLoginStorage) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ZKLoginStorage, unknown, unknown>>;
+    };
+}>;

package/dist/stores/zkloginStore.js

@@ -0,0 +1,27 @@
+import { create } from "zustand";
+import { persist, createJSONStorage } from "zustand/middleware";
+export const zkloginStorage = create()(persist((set) => ({
+    jwt: null,
+    suiAddress: null,
+    maxEpoch: null,
+    expiresAt: null,
+    ephemeralSecretKey: null,
+    zkProof: null,
+    setSuiAddress: (suiAddress) => set({ suiAddress }),
+    setMaxEpoch: (maxEpoch) => set({ maxEpoch }),
+    setExpiresAt: (expiresAt) => set({ expiresAt }),
+    setJWT: (jwt) => set({ jwt }),
+    setEphemeralSecretKey: (ephemeralSecretKey) => set({ ephemeralSecretKey }),
+    setZKProof: (zkProof) => 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/dist/types.d.ts

@@ -0,0 +1,99 @@
+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";
+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;
+}
+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;
+} | {
+    jsonrpc: string;
+    error: {
+        code: number;
+        message: string;
+        data?: {
+            details?: string;
+        };
+    };
+    id: number;
+    result?: never;
+};
+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;
+    };
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface TierPlan {
+    name: string;
+    price: number;
+    duration: number;
+    storage: number;
+    features: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -2,12 +2,14 @@
   "name": "@zing-protocol/zing-sdk",
   "sideEffects": false,
   "type": "module",
-  "version": "0.0.1",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "version": "0.0.2",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./src/*": "./src/*"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "build": "tsc",
@@ -33,5 +35,11 @@
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
     "@types/node": "catalog:"
-  }
+  },
+  "private": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/_generated/utils/index.ts

@@ -1,181 +0,0 @@
-import {
-  bcs,
-  TypeTagSerializer,
-  BcsStruct,
-  BcsEnum,
-  BcsTuple,
-} from "@mysten/sui/bcs";
-import { isArgument } from "@mysten/sui/transactions";
-import { normalizeSuiAddress } from "@mysten/sui/utils";
-import type { BcsType, TypeTag } from "@mysten/sui/bcs";
-import type { TransactionArgument } from "@mysten/sui/transactions";
-
-const MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
-const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
-const SUI_SYSTEM_ADDRESS = normalizeSuiAddress("0x3");
-
-function stringify(val: unknown) {
-  if (typeof val === "object") {
-    return JSON.stringify(val, (val: unknown) => val);
-  }
-  if (typeof val === "bigint") {
-    return val.toString();
-  }
-
-  return val;
-}
-
-export type RawTransactionArgument<T> = T | TransactionArgument;
-
-export function getPureBcsSchema(
-  typeTag: string | TypeTag,
-): BcsType<any> | null {
-  const parsedTag =
-    typeof typeTag === "string"
-      ? TypeTagSerializer.parseFromStr(typeTag)
-      : typeTag;
-
-  if ("u8" in parsedTag) {
-    return bcs.U8;
-  } else if ("u16" in parsedTag) {
-    return bcs.U16;
-  } else if ("u32" in parsedTag) {
-    return bcs.U32;
-  } else if ("u64" in parsedTag) {
-    return bcs.U64;
-  } else if ("u128" in parsedTag) {
-    return bcs.U128;
-  } else if ("u256" in parsedTag) {
-    return bcs.U256;
-  } else if ("address" in parsedTag) {
-    return bcs.Address;
-  } else if ("bool" in parsedTag) {
-    return bcs.Bool;
-  } else if ("vector" in parsedTag) {
-    const type = getPureBcsSchema(parsedTag.vector);
-    return type ? bcs.vector(type) : null;
-  } else if ("struct" in parsedTag) {
-    const structTag = parsedTag.struct;
-    const pkg = normalizeSuiAddress(parsedTag.struct.address);
-
-    if (pkg === MOVE_STDLIB_ADDRESS) {
-      if (
-        (structTag.module === "ascii" || structTag.module === "string") &&
-        structTag.name === "String"
-      ) {
-        return bcs.String;
-      }
-
-      if (structTag.module === "option" && structTag.name === "Option") {
-        const type = getPureBcsSchema(structTag.typeParams[0]!);
-        return type ? bcs.option(type) : null;
-      }
-    }
-
-    if (
-      pkg === SUI_FRAMEWORK_ADDRESS &&
-      structTag.module === "Object" &&
-      structTag.name === "ID"
-    ) {
-      return bcs.Address;
-    }
-  }
-
-  return null;
-}
-
-export function normalizeMoveArguments(
-  args: unknown[] | object,
-  argTypes: string[],
-  parameterNames?: string[],
-) {
-  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
-  if (parameterNames && argLen !== parameterNames.length) {
-    throw new Error(
-      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`,
-    );
-  }
-
-  const normalizedArgs: TransactionArgument[] = [];
-
-  let index = 0;
-  for (const [i, argType] of argTypes.entries()) {
-    if (argType === `${SUI_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
-      normalizedArgs.push((tx) => tx.object.denyList());
-      continue;
-    }
-
-    if (argType === `${SUI_FRAMEWORK_ADDRESS}::random::Random`) {
-      normalizedArgs.push((tx) => tx.object.random());
-      continue;
-    }
-
-    if (argType === `${SUI_FRAMEWORK_ADDRESS}::clock::Clock`) {
-      normalizedArgs.push((tx) => tx.object.clock());
-      continue;
-    }
-
-    if (argType === `${SUI_SYSTEM_ADDRESS}::sui_system::SuiSystemState`) {
-      normalizedArgs.push((tx) => tx.object.system());
-      continue;
-    }
-
-    let arg;
-    if (Array.isArray(args)) {
-      if (index >= args.length) {
-        throw new Error(
-          `Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`,
-        );
-      }
-      arg = args[index];
-    } else {
-      if (!parameterNames) {
-        throw new Error(`Expected arguments to be passed as an array`);
-      }
-      const name = parameterNames[index];
-      arg = args[name as keyof typeof args];
-
-      if (arg === undefined) {
-        throw new Error(`Parameter ${name} is required`);
-      }
-    }
-
-    index += 1;
-
-    if (typeof arg === "function" || isArgument(arg)) {
-      normalizedArgs.push(arg as TransactionArgument);
-      continue;
-    }
-
-    const type = argTypes[i]!;
-    const bcsType = getPureBcsSchema(type);
-
-    if (bcsType) {
-      const bytes = bcsType.serialize(arg as never);
-      normalizedArgs.push((tx) => tx.pure(bytes));
-      continue;
-    } else if (typeof arg === "string") {
-      normalizedArgs.push((tx) => tx.object(arg));
-      continue;
-    }
-
-    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
-  }
-
-  return normalizedArgs;
-}
-
-export class MoveStruct<
-  T extends Record<string, BcsType<any>>,
-  const Name extends string = string,
-> extends BcsStruct<T, Name> {}
-
-export class MoveEnum<
-  T extends Record<string, BcsType<any> | null>,
-  const Name extends string,
-> extends BcsEnum<T, Name> {}
-
-export class MoveTuple<
-  T extends readonly BcsType<any>[],
-  const Name extends string,
-> extends BcsTuple<T, Name> {}