@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/src/lib/utils/reclaim.ts

@@ -1,148 +0,0 @@
-import {
-  ClaimInfo,
-  SignedClaim,
-} from "../../_generated/zing_identity/reclaim.js";
-import { bcs } from "@mysten/sui/bcs";
-import { ReclaimProofRequest } from "@reclaimprotocol/js-sdk";
-import sha3 from "js-sha3";
-
-export function hexToBytes(hex: string): Uint8Array {
-  return new Uint8Array(
-    hex.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16)),
-  );
-}
-
-export function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes)
-    .map((byte) => byte.toString(16).padStart(2, "0"))
-    .join("");
-}
-
-export function textToBytes(text: string): Uint8Array {
-  return new TextEncoder().encode(text);
-}
-
-// Uint8Array ? String
-export function bytesToText(bytes: Uint8Array): string {
-  return new TextDecoder().decode(bytes);
-}
-
-export async function startVerification({
-  reclaimAppId,
-  reclaimAppSecret,
-  reclaimProviderId,
-}: {
-  reclaimAppId: string;
-  reclaimAppSecret: string;
-  reclaimProviderId: string;
-}) {
-  try {
-    // Initialize the Reclaim SDK with your credentials
-    const reclaimProofRequest = await ReclaimProofRequest.init(
-      reclaimAppId,
-      reclaimAppSecret,
-      reclaimProviderId,
-    );
-
-    reclaimProofRequest.setModalOptions({ modalPopupTimer: 3 }); // 3min
-
-    // Trigger the verification session
-    await reclaimProofRequest.triggerReclaimFlow();
-
-    // Start listening for proof submissions and return a promise
-    const proofs = await new Promise((resolve, reject) => {
-      reclaimProofRequest.startSession({
-        onSuccess: (proofs) => {
-          console.log("Verification successful:", proofs);
-          resolve(proofs);
-        },
-        onError: (error) => {
-          console.error("Verification failed", error);
-          reject(error);
-        },
-      });
-    });
-
-    return proofs;
-  } catch (error) {
-    console.error("Error starting verification:", error);
-    throw error;
-  }
-}
-
-export function generateCommitNonce(
-  userAddress: string,
-  claimIdentifier: string,
-) {
-  // Use the same random data as in Move function
-  const randomBytes = crypto.getRandomValues(new Uint8Array(32));
-  // Encode user address as BCS (32 bytes for address type)
-  const addressBytes = bcs.Address.serialize(userAddress).toBytes();
-
-  // Encode claim identifier as BCS address (32 bytes for address type)
-  const identifierBytes = bcs.Address.serialize(claimIdentifier).toBytes();
-
-  // Combine: random + userAddress + identifier (no timestamp to match Move logic)
-  const combined = new Uint8Array(
-    randomBytes.length + addressBytes.length + identifierBytes.length,
-  );
-
-  let offset = 0;
-  combined.set(randomBytes, offset);
-  offset += randomBytes.length;
-  combined.set(addressBytes, offset);
-  offset += addressBytes.length;
-  combined.set(identifierBytes, offset);
-
-  return Array.from(combined);
-}
-
-export function generateCommitmentHash(proof: ReclaimProof, nonce: number[]) {
-  const claimInfoBytes = ClaimInfo.serialize({
-    provider: proof.claimData.provider,
-    parameters: proof.claimData.parameters,
-    context: proof.claimData.context,
-  }).toBytes(); // checked
-  const signedClaimBytes = SignedClaim.serialize({
-    claim: {
-      identifier: proof.claimData.identifier,
-      owner: proof.claimData.owner,
-      epoch: proof.claimData.epoch.toString(),
-      timestamp_s: proof.claimData.timestampS.toString(),
-    },
-    signatures: proof.signatures.map((sig) => hexToBytes(sig.substring(2))),
-  }).toBytes();
-
-  const combined = new Uint8Array(
-    claimInfoBytes.length + signedClaimBytes.length + nonce.length,
-  );
-
-  let offset = 0;
-  combined.set(claimInfoBytes, offset);
-  offset += claimInfoBytes.length;
-  combined.set(signedClaimBytes, offset);
-  offset += signedClaimBytes.length;
-  combined.set(nonce, offset);
-
-  // Convert Uint8Array -> Buffer before hashing
-  return hexToBytes(sha3.keccak256(combined));
-}
-
-export type ReclaimProof = {
-  identifier: string;
-  claimData: {
-    provider: string;
-    parameters: string;
-    owner: string;
-    timestampS: number;
-    context: string;
-    identifier: string;
-    epoch: number;
-  };
-  signatures: string[];
-  witnesses: {
-    id: string;
-    url: string;
-  }[];
-  publicData: string | null;
-};

package/src/lib/utils/types.ts

@@ -1,14 +0,0 @@
-import type { COLORS } from "./const.js";
-import type { TupleToUnion } from "type-fest";
-
-export type * from "type-fest";
-export type ColorType =
-  | "success"
-  | "info"
-  | "error"
-  | "warning"
-  | keyof typeof COLORS;
-export type ExcludeValuesFromBaseArrayType<
-  B extends string[],
-  E extends (string | number)[],
-> = Exclude<TupleToUnion<B>, TupleToUnion<E>>[];

package/src/mutations/seal.ts

@@ -1,78 +0,0 @@
-export async function createFileKey(): Promise<Uint8Array> {
-  // Generate AES-GCM key
-  const key = await crypto.subtle.generateKey(
-    { name: "AES-GCM", length: 256 },
-    true, // extractable (so we can export)
-    ["encrypt", "decrypt"],
-  );
-
-  // Export as raw bytes
-  const rawKey = await crypto.subtle.exportKey("raw", key);
-  return new Uint8Array(rawKey); // 32 bytes (256 bits)
-}
-
-export async function importFileKey(
-  raw: Uint8Array | ArrayBuffer,
-): Promise<CryptoKey> {
-  // Convert to Uint8Array and create a clean copy
-  const keyBytes = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
-  const cleanBytes = new Uint8Array(keyBytes);
-
-  return crypto.subtle.importKey(
-    "raw",
-    cleanBytes,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt", "decrypt"],
-  );
-}
-
-/**
- * Encrypt data using AES-256-GCM.
- * @returns {Uint8Array} Concatenated [IV | ciphertext]
- */
-export async function encryptData(
-  key: CryptoKey,
-  data: ArrayBuffer | Uint8Array,
-  iv: Uint8Array, // Accept IV as parameter
-): Promise<Uint8Array> {
-  const encoded = data instanceof Uint8Array ? data : new Uint8Array(data);
-  const cleanEncoded = new Uint8Array(encoded);
-  const cleanivBytes = new Uint8Array(iv);
-  const ciphertext = new Uint8Array(
-    await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv: cleanivBytes },
-      key,
-      cleanEncoded,
-    ),
-  );
-
-  // Combine IV + ciphertext for easy storage
-  const combined = new Uint8Array(iv.length + ciphertext.length);
-  combined.set(iv);
-  combined.set(ciphertext, iv.length);
-  return combined;
-}
-
-/**
- * Decrypt data using AES-256-GCM.
- * Input must be the combined [IV | ciphertext] format.
- */
-export async function decryptData(
-  key: CryptoKey,
-  encrypted: ArrayBuffer | Uint8Array,
-): Promise<Uint8Array> {
-  const bytes =
-    encrypted instanceof Uint8Array ? encrypted : new Uint8Array(encrypted);
-  const iv = bytes.slice(0, 12);
-  const ciphertext = bytes.slice(12);
-
-  console.log({ iv, ciphertext });
-
-  const plaintext = await crypto.subtle.decrypt(
-    { name: "AES-GCM", iv },
-    key,
-    ciphertext,
-  );
-  return new Uint8Array(plaintext);
-}

package/src/mutations/signer.ts

@@ -1,241 +0,0 @@
-import { zkloginStorage } from "../stores/zkloginStore.js";
-import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
-import { fromBase64 } from "@mysten/sui/utils";
-import { decodeJwt } from "@mysten/sui/zklogin";
-import type {
-  ZkLoginProofParams,
-  ZkLoginProofResponse,
-  ZKLoginSignerState,
-} from "../types.js";
-import type { SuiClient } from "@mysten/sui/client";
-import type { Transaction } from "@mysten/sui/transactions";
-
-const SALT_SERVER_BASE_URL = "https://salt-server-production.up.railway.app";
-
-export async function getSigner(
-  suiClient: SuiClient,
-): Promise<ZKLoginSignerState> {
-  const zkLoginStorage = await zkloginStorage.getState();
-
-  const { epoch: currentEpoch } = await suiClient.getLatestSuiSystemState();
-
-  if (
-    !zkLoginStorage?.jwt ||
-    !zkLoginStorage?.maxEpoch ||
-    !zkLoginStorage.ephemeralSecretKey ||
-    !zkLoginStorage.zkProof ||
-    !zkLoginStorage.suiAddress
-  )
-    return {
-      ephemeralKeyPair: null,
-      suiAddress: null,
-      decodedJwt: null,
-      zkProof: null,
-      maxEpoch: null,
-    };
-
-  if (Number(currentEpoch) > zkLoginStorage.maxEpoch)
-    return {
-      ephemeralKeyPair: null,
-      suiAddress: null,
-      decodedJwt: null,
-      zkProof: null,
-      maxEpoch: null,
-    };
-
-  const ephemeralKeyPair = Ed25519Keypair.fromSecretKey(
-    fromBase64(zkLoginStorage.ephemeralSecretKey),
-  );
-
-  return {
-    suiAddress: zkLoginStorage.suiAddress,
-    ephemeralKeyPair,
-    decodedJwt: decodeJwt(zkLoginStorage.jwt),
-    zkProof: JSON.parse(zkLoginStorage.zkProof),
-    maxEpoch: zkLoginStorage.maxEpoch,
-  };
-}
-
-export async function signAndExecuteGasPoolTransaction(
-  signer: ZKLoginSignerState,
-  suiClient: SuiClient,
-  tx: Transaction,
-  gasBudget = 0.1 * 10 ** 9,
-  reserveDurationSecs = 30,
-) {
-  const { ephemeralKeyPair, suiAddress, decodedJwt, zkProof, maxEpoch } =
-    signer;
-  if (!ephemeralKeyPair || !suiAddress || !decodedJwt || !zkProof || !maxEpoch)
-    return;
-
-  try {
-    if (!decodedJwt.sub || !decodedJwt.iss || !decodedJwt.aud) {
-      throw new Error("JWT claims (sub, iss, aud) not found");
-    }
-
-    // Step 1: Request gas reservation from server
-    const prepareResponse = await fetch(`${SALT_SERVER_BASE_URL}/prepare_tx`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        sub: decodedJwt.sub,
-        iss: decodedJwt.iss,
-        aud: Array.isArray(decodedJwt.aud) ? decodedJwt.aud[0] : decodedJwt.aud,
-        gasBudget,
-        reserveDurationSecs,
-      }),
-    });
-
-    if (!prepareResponse.ok) {
-      const errorData = await prepareResponse.json().catch(() => ({}));
-      throw new Error(
-        errorData.error || `Server error: ${prepareResponse.statusText}`,
-      );
-    }
-
-    const prepareData = await prepareResponse.json();
-
-    if (!prepareData.result) {
-      throw new Error(`Failed to reserve gas: ${prepareData.error}`);
-    }
-
-    // Step 2: Set gas payment and sender
-    tx.setSender(suiAddress);
-    tx.setGasOwner(prepareData.result.sponsor_address);
-    tx.setGasPayment(prepareData.result.gas_coins);
-
-    // Step 4: Sign only the transaction bytes with ephemeral key
-    const { bytes, signature: ephemeralSignature } = await tx.sign({
-      client: suiClient,
-      signer: ephemeralKeyPair,
-    });
-
-    // Step 5: Send to server for zkLogin signature generation and execution
-    const executeResponse = await fetch(`${SALT_SERVER_BASE_URL}/execute_tx`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        sub: decodedJwt.sub,
-        iss: decodedJwt.iss,
-        aud: Array.isArray(decodedJwt.aud) ? decodedJwt.aud[0] : decodedJwt.aud,
-        reservationId: prepareData.result.reservation_id,
-        txBytes: bytes,
-        ephemeralSignature,
-        maxEpoch,
-        zkProof,
-      }),
-    });
-
-    const executeData = await executeResponse.json().catch(() => ({}));
-
-    if (!executeResponse.ok) {
-      throw new Error(
-        executeData.error || `Server error: ${executeResponse.statusText}`,
-      );
-    }
-
-    if (!executeData.effects) {
-      throw new Error(
-        `Transaction execution failed: ${executeData.error || "Unknown error"}`,
-      );
-    }
-
-    return executeData.effects;
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
-}
-
-export async function signPersonalMessage(
-  signer: ZKLoginSignerState,
-  message: Uint8Array,
-) {
-  const { ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } = signer;
-  if (!ephemeralKeyPair || !decodedJwt || !zkProof || !maxEpoch) {
-    throw new Error("Missing required params");
-  }
-
-  try {
-    if (!decodedJwt.sub || !decodedJwt.iss || !decodedJwt.aud) {
-      throw new Error("JWT claims (sub, iss, aud) not found");
-    }
-
-    // Sign message with ephemeral key
-    const { bytes, signature } =
-      await ephemeralKeyPair.signPersonalMessage(message);
-
-    // Convert bytes to base64 for transmission
-    const response = await fetch(
-      `${SALT_SERVER_BASE_URL}/sign_personal_message`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          sub: decodedJwt.sub,
-          iss: decodedJwt.iss,
-          aud: Array.isArray(decodedJwt.aud)
-            ? decodedJwt.aud[0]
-            : decodedJwt.aud,
-          messageBytes: bytes,
-          ephemeralSignature: signature,
-          maxEpoch,
-          zkProof,
-        }),
-      },
-    );
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(
-        errorData.error || `Server error: ${response.statusText}`,
-      );
-    }
-
-    const data = await response.json();
-
-    if (!data.zkLoginSignature) {
-      throw new Error("Failed to generate zkLogin signature");
-    }
-
-    return {
-      zkLoginSignature: data.zkLoginSignature,
-      bytes: fromBase64(data.bytes),
-    };
-  } catch (error) {
-    console.error(error);
-    throw error;
-  }
-}
-
-export async function createZkLoginProof(
-  params: ZkLoginProofParams,
-): Promise<ZkLoginProofResponse> {
-  try {
-    const response = await fetch(`${SALT_SERVER_BASE_URL}/zklogin-proof`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(params),
-    });
-
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || `HTTP ${response.status}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw error;
-    }
-    throw new Error("Unknown error occurred");
-  }
-}