@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/dist/mutations/signer.js

@@ -0,0 +1,176 @@
+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";
+const SALT_SERVER_BASE_URL = "https://salt-server-production.up.railway.app";
+export async function getSigner(suiClient) {
+    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, suiClient, tx, 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, message) {
+    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) {
+    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");
+    }
+}

package/dist/mutations/walrus.d.ts

@@ -0,0 +1,98 @@
+import { Transaction } from "@mysten/sui/transactions";
+import type { PublishArticleEvent } from "../_generated/zing_studio/article.js";
+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;
+    zingStudioV0PackageId: string;
+    walrusPackageId: string;
+    zingStudioConfigSharedObjectRef: SharedObjectRef;
+    walrusSystemSharedObjectRef: SharedObjectRef;
+    zingStorageTreasurySharedObjectRef: SharedObjectRef;
+    blobRegisteredEventType: string;
+    publishArticleEventType: string;
+};
+export declare function buildPublishArticleTransaction(config: ZingWriteFlowConfig, walrusSystem: WalrusSystemState, walTreasury: string, storageByEpoch: Record<number, number>, fileSize: number, owner: string, subscriptionLevel: null | number, blobId: string, rootHash: Uint8Array, articleMetadata: {
+    identifier: string;
+    tags: {
+        "content-type": string;
+    };
+    size: number;
+}[], attributes: Record<string, string | null>, existingAttributes: Record<string, string> | null): (tx: Transaction) => void;
+export declare function buildCertifyArticleBlobTransaction(config: {
+    zingStudioPackageId: string;
+    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: {
+    identifier: string;
+    tags: {
+        "content-type": string;
+    };
+    size: number;
+}[], options: WriteFilesFlowOptions, withUploadRelayClient: boolean, blobRegisteredEventType: string, publishArticleEventType: string) => {
+    encode: () => Promise<void>;
+    register: (options: WriteFilesFlowRegisterOptions) => Transaction;
+    upload: (options: WriteFilesFlowUploadOptions) => Promise<{
+        article_id: string;
+        owner: string;
+        blob_ids: string[];
+        blob_sizes: string[];
+        blob_storage_sizes: string[];
+        blob_end_epochs: number[];
+        files: {
+            contents: {
+                key: string;
+                value: {
+                    blob_index: string;
+                    mime_type: string;
+                    size: string;
+                };
+            }[];
+        };
+        timestamp_ms: string;
+    }>;
+    certify: () => Transaction;
+    listFiles: () => Promise<{
+        id: string;
+        blobId: string;
+        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: {
+    identifier: string;
+    tags: {
+        "content-type": string;
+    };
+    size: number;
+}[], signer: ZKLoginSignerState, gasPoolBearerToken: string, onProgress?: (stage: WalrusUploadFlowStage) => void): Promise<typeof PublishArticleEvent.$inferType>;
+export declare function downloadImagesFromMarkdown<T extends "blob" | "uint8array">(markdown: string, as?: T): Promise<{
+    url: string;
+    data: T extends "blob" ? Blob : Uint8Array;
+}[]>;
+/**
+ * Calculate the cost of storing a blob for a given a size and number of epochs.
+ */
+export declare function storageCost(systemState: WalrusSystemState, size: number, epochs: number): {
+    encodedSize: number;
+    storageCost: bigint;
+    writeCost: bigint;
+    totalCost: bigint;
+};
+export declare function storageUnitsFromSize(size: number): number;
+/**
+ * Replace all base64 image URLs in markdown with asset identifiers (e.g. assets-0.png).
+ *
+ * @param markdown - the original markdown string containing data URLs
+ * @param assets - the array returned from downloadImagesFromMarkdown()
+ * @returns a new markdown string with data URLs replaced by identifiers
+ */
+export declare function replaceBase64ImagesWithIdentifiers(markdown: string, assets: {
+    url: string;
+    data: Blob | Uint8Array;
+}[]): string;
+export {};