@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/lib/utils/helpers.js

@@ -0,0 +1,49 @@
+export const excludeValuesFromBaseArray = (baseArray, excludeArray) => baseArray.filter((value) => !excludeArray.includes(value));
+export const sleep = async (time) => new Promise((r) => setTimeout(r, time));
+export const formatDate = (date) => date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+});
+export const formatBalance = (balance, decimal, digits = 4) => {
+    const normalizedBalance = Number(balance) / Math.pow(10, decimal);
+    const fixed = normalizedBalance.toFixed(digits);
+    return fixed.replace(/\.?0+$/, "");
+};
+export const formatTimeAgo = (date) => {
+    const now = new Date();
+    const diffInHours = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60));
+    if (diffInHours < 1)
+        return "Just now";
+    if (diffInHours < 24)
+        return `${diffInHours}h ago`;
+    if (diffInHours < 168)
+        return `${Math.floor(diffInHours / 24)}d ago`;
+    return formatDate(date);
+};
+export function formatDaysAuto(days) {
+    if (days < 30)
+        return `${days} day${days === 1 ? "" : "s"}`;
+    const months = days / 30;
+    if (months < 12) {
+        const rounded = Math.floor(months);
+        return `${rounded} month${rounded === 1 ? "" : "s"}`;
+    }
+    const years = Math.floor(days / 365);
+    return `${years} year${years === 1 ? "" : "s"}`;
+}
+export const formatBytes = (bytes) => {
+    if (bytes === 0)
+        return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB", "TB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+};
+export const getDaysRemaining = (comp) => {
+    const now = new Date();
+    const diffTime = comp - now.getTime();
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+    return diffDays;
+};
+export const bytesToGB = (bytes) => bytes / (1024 * 1024 * 1024);

package/dist/lib/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./helpers.js";
+export * from "./reclaim.js";
+export * from "./colorful-logger.js";
+export * from "./init-app-with-shadow.js";

package/dist/lib/utils/init-app-with-shadow.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+export declare const initAppWithShadow: ({ id, app, inlineCss, }: {
+    id: string;
+    inlineCss: string;
+    app: ReactElement;
+}) => void;

package/dist/lib/utils/init-app-with-shadow.js

@@ -0,0 +1,28 @@
+import { createRoot } from "react-dom/client";
+export const initAppWithShadow = ({ id, app, inlineCss, }) => {
+    const root = document.createElement("div");
+    root.id = id;
+    document.body.append(root);
+    const rootIntoShadow = document.createElement("div");
+    rootIntoShadow.id = `shadow-root-${id}`;
+    const shadowRoot = root.attachShadow({ mode: "open" });
+    if (navigator.userAgent.includes("Firefox")) {
+        /**
+         * In the firefox environment, adoptedStyleSheets cannot be used due to the bug
+         * @url https://bugzilla.mozilla.org/show_bug.cgi?id=1770592
+         *
+         * Injecting styles into the document, this may cause style conflicts with the host page
+         */
+        const styleElement = document.createElement("style");
+        styleElement.innerHTML = inlineCss;
+        shadowRoot.appendChild(styleElement);
+    }
+    else {
+        /** Inject styles into shadow dom */
+        const globalStyleSheet = new CSSStyleSheet();
+        globalStyleSheet.replaceSync(inlineCss);
+        shadowRoot.adoptedStyleSheets = [globalStyleSheet];
+    }
+    shadowRoot.appendChild(rootIntoShadow);
+    createRoot(rootIntoShadow).render(app);
+};

package/dist/lib/utils/quilt.d.ts

@@ -0,0 +1,61 @@
+import type { EncodingType } from "@mysten/walrus";
+export interface QuiltSizeInput {
+    blobs: {
+        size: number;
+        identifier: string;
+        tags?: Record<string, string>;
+    }[];
+    numShards: number;
+    encodingType?: EncodingType;
+}
+export interface QuiltSizeResult {
+    quiltSize: number;
+    symbolSize: number;
+    numRows: number;
+    numColumns: number;
+    indexSize: number;
+    blobSizes: number[];
+}
+/**
+ * Finds the minimum symbol size needed to store blobs in a fixed number of columns.
+ * Each blob must be stored in consecutive columns exclusively.
+ *
+ * A binary search is used to find the minimum symbol size:
+ * 1. Compute the upper and lower bounds for the symbol size.
+ * 2. Check if the all the blobs can be fit into the quilt with the current symbol size.
+ * 3. Adjust the bounds based on the result and repeat until the symbol size is found.
+ *
+ * @param blobsSizes - Slice of blob lengths, including the index size as the first element.
+ *   Note that the len of the blob_size should be between 1 and n_columns.
+ * @param nColumns - Number of columns available.
+ * @param nRows - Number of rows available.
+ * @param maxNumColumnsForQuiltIndex - The maximum number of columns that can be used to
+ *   store the quilt index.
+ * @param encodingType - The encoding type to use.
+ *
+ * @returns The minimum symbol size needed.
+ **/
+export declare function computeSymbolSize(blobsSizes: number[], nColumns: number, nRows: number, maxNumColumnsForQuiltIndex: number, encodingType?: EncodingType): number;
+/**
+ * Calculate the quilt size without actually encoding the data.
+ * This is useful for estimating costs before uploading.
+ *
+ * @param input - Configuration with blob sizes, identifiers, tags, and encoding params
+ * @returns Information about the resulting quilt size and structure
+ */
+export declare function calculateQuiltSize(input: QuiltSizeInput): QuiltSizeResult;
+/**
+ * Calculate quilt size accounting for encryption overhead.
+ * AES-GCM adds 16 bytes of authentication tag.
+ *
+ * @param files - Array of files with original sizes
+ * @param numShards - Number of shards
+ * @param ivSize - Size of IV (typically 12 bytes for GCM)
+ * @param encodingType - Encoding type
+ * @returns Quilt size information
+ */
+export declare function calculateEncryptedQuiltSize(files: Array<{
+    size: number;
+    identifier: string;
+    tags?: Record<string, string>;
+}>, numShards: number, ivSize?: number, encodingType?: EncodingType): QuiltSizeResult;

package/dist/lib/utils/quilt.js

@@ -0,0 +1,194 @@
+import { QuiltIndexV1, QuiltPatchTags } from "../../bcs.js";
+import { getSourceSymbols } from "../../getters.js";
+import { bcs } from "@mysten/sui/bcs";
+const MAX_NUM_SLIVERS_FOR_QUILT_INDEX = 10;
+const QUILT_INDEX_SIZE_BYTES_LENGTH = 4;
+const QUILT_VERSION_BYTES_LENGTH = 1;
+const QUILT_INDEX_PREFIX_SIZE = QUILT_VERSION_BYTES_LENGTH + QUILT_INDEX_SIZE_BYTES_LENGTH;
+const QUILT_PATCH_BLOB_HEADER_SIZE = 1 + 4 + 1; // bcs length of QuiltPatchBlobHeader
+const BLOB_IDENTIFIER_SIZE_BYTES_LENGTH = 2;
+const TAGS_SIZE_BYTES_LENGTH = 2;
+const MAX_BLOB_IDENTIFIER_BYTES_LENGTH = (1 << (8 * BLOB_IDENTIFIER_SIZE_BYTES_LENGTH)) - 1;
+const REQUIRED_ALIGNMENT_BY_ENCODING_TYPE = {
+    RS2: 2,
+    RedStuff: 2,
+};
+const MAX_SYMBOL_SIZE_BY_ENCODING_TYPE = {
+    RS2: 2 ** 16 - 1,
+    RedStuff: 2 ** 16 - 1,
+};
+function canBlobsFitIntoMatrix(blobsSizes, nColumns, columnSize) {
+    return (blobsSizes.reduce((acc, size) => acc + Math.ceil(size / columnSize), 0) <=
+        nColumns);
+}
+// Add these constants at the top of your quilt-size.ts file
+const DIGEST_LEN = 32;
+const BLOB_ID_LEN = 32;
+/**
+ * Calculate the encoded blob length including all overhead.
+ * This matches the Walrus SDK's encodedBlobLength function.
+ */
+function encodedBlobLength(unencodedLength, nShards, encodingType = "RS2") {
+    const sliverSize = encodedSliverSize(unencodedLength, nShards, encodingType);
+    const metadata = nShards * DIGEST_LEN * 2 + BLOB_ID_LEN;
+    return nShards * metadata + sliverSize;
+}
+/**
+ * Calculate the encoded sliver size.
+ * This matches the Walrus SDK's encodedSliverSize function.
+ */
+function encodedSliverSize(unencodedLength, nShards, encodingType = "RS2") {
+    const { primarySymbols, secondarySymbols } = getSourceSymbols(nShards, encodingType);
+    let symbolSize = Math.floor((Math.max(unencodedLength, 1) - 1) / (primarySymbols * secondarySymbols)) + 1;
+    if (encodingType === "RS2" && symbolSize % 2 === 1) {
+        symbolSize = symbolSize + 1;
+    }
+    const singleShardSize = (primarySymbols + secondarySymbols) * symbolSize;
+    return singleShardSize * nShards;
+}
+/**
+ * Finds the minimum symbol size needed to store blobs in a fixed number of columns.
+ * Each blob must be stored in consecutive columns exclusively.
+ *
+ * A binary search is used to find the minimum symbol size:
+ * 1. Compute the upper and lower bounds for the symbol size.
+ * 2. Check if the all the blobs can be fit into the quilt with the current symbol size.
+ * 3. Adjust the bounds based on the result and repeat until the symbol size is found.
+ *
+ * @param blobsSizes - Slice of blob lengths, including the index size as the first element.
+ *   Note that the len of the blob_size should be between 1 and n_columns.
+ * @param nColumns - Number of columns available.
+ * @param nRows - Number of rows available.
+ * @param maxNumColumnsForQuiltIndex - The maximum number of columns that can be used to
+ *   store the quilt index.
+ * @param encodingType - The encoding type to use.
+ *
+ * @returns The minimum symbol size needed.
+ **/
+export function computeSymbolSize(blobsSizes, nColumns, nRows, maxNumColumnsForQuiltIndex, encodingType = "RS2") {
+    if (blobsSizes.length > nColumns) {
+        throw new Error("Too many blobs, the number of blobs must be less than the number of columns");
+    }
+    if (blobsSizes.length === 0) {
+        throw new Error("No blobs provided");
+    }
+    let minVal = Math.max(blobsSizes.reduce((acc, size) => acc + size, 0) / (nColumns * nRows), blobsSizes[0] / (nRows * maxNumColumnsForQuiltIndex), Math.ceil(QUILT_INDEX_PREFIX_SIZE / nRows));
+    let maxVal = Math.ceil((Math.max(...blobsSizes) / (nColumns / blobsSizes.length)) * nRows);
+    while (minVal < maxVal) {
+        const mid = (minVal + maxVal) / 2;
+        if (canBlobsFitIntoMatrix(blobsSizes, nColumns, mid * nRows)) {
+            maxVal = mid;
+        }
+        else {
+            minVal = mid + 1;
+        }
+    }
+    const symbolSize = Math.ceil(minVal / REQUIRED_ALIGNMENT_BY_ENCODING_TYPE[encodingType]) *
+        REQUIRED_ALIGNMENT_BY_ENCODING_TYPE[encodingType];
+    if (!canBlobsFitIntoMatrix(blobsSizes, nColumns, symbolSize * nRows)) {
+        throw new Error("Quilt oversize");
+    }
+    if (symbolSize > MAX_SYMBOL_SIZE_BY_ENCODING_TYPE[encodingType]) {
+        throw new Error(`Quilt oversize: the resulting symbol size ${symbolSize} is larger than the maximum symbol size ${MAX_SYMBOL_SIZE_BY_ENCODING_TYPE[encodingType]}; remove some blobs`);
+    }
+    return symbolSize;
+}
+/**
+ * Calculate the quilt size without actually encoding the data.
+ * This is useful for estimating costs before uploading.
+ *
+ * @param input - Configuration with blob sizes, identifiers, tags, and encoding params
+ * @returns Information about the resulting quilt size and structure
+ */
+export function calculateQuiltSize(input) {
+    const { blobs, numShards, encodingType = "RS2" } = input;
+    const { primarySymbols: nRows, secondarySymbols: nCols } = getSourceSymbols(numShards, encodingType);
+    // Sort blobs by identifier (same as encoding logic)
+    const sortedBlobs = [...blobs].sort((a, b) => a.identifier < b.identifier ? -1 : 1);
+    // Validate identifiers
+    const identifiers = new Set();
+    for (const blob of sortedBlobs) {
+        if (identifiers.has(blob.identifier)) {
+            throw new Error(`Duplicate blob identifier: ${blob.identifier}`);
+        }
+        if (blob.identifier.length > MAX_BLOB_IDENTIFIER_BYTES_LENGTH) {
+            throw new Error(`Blob identifier too long: ${blob.identifier}`);
+        }
+        identifiers.add(blob.identifier);
+    }
+    // Build index structure (same as encoding)
+    const index = {
+        patches: sortedBlobs.map((blob) => ({
+            startIndex: 0,
+            endIndex: 0,
+            identifier: blob.identifier,
+            tags: blob.tags ?? {},
+        })),
+    };
+    // Calculate index size
+    const indexSize = QUILT_INDEX_PREFIX_SIZE + QuiltIndexV1.serialize(index).toBytes().length;
+    // Calculate metadata sizes
+    const blobMetadataSizes = sortedBlobs.map((blob) => {
+        const identifierBytes = bcs.string().serialize(blob.identifier).toBytes();
+        let metadataSize = QUILT_PATCH_BLOB_HEADER_SIZE +
+            BLOB_IDENTIFIER_SIZE_BYTES_LENGTH +
+            identifierBytes.length;
+        if (blob.tags && Object.keys(blob.tags).length > 0) {
+            const tagsBytes = QuiltPatchTags.serialize(blob.tags).toBytes();
+            metadataSize += TAGS_SIZE_BYTES_LENGTH + tagsBytes.length;
+        }
+        return metadataSize;
+    });
+    // Calculate total blob sizes (metadata + content)
+    const blobSizes = [
+        indexSize,
+        ...sortedBlobs.map((blob, i) => blobMetadataSizes[i] + blob.size),
+    ];
+    // Compute symbol size
+    const symbolSize = computeSymbolSize(blobSizes, nCols, nRows, MAX_NUM_SLIVERS_FOR_QUILT_INDEX, encodingType);
+    const columnSize = symbolSize * nRows;
+    // Calculate how many columns are actually used
+    const indexColumnsNeeded = Math.ceil(indexSize / columnSize);
+    let currentColumn = indexColumnsNeeded;
+    for (const blobSize of blobSizes.slice(1)) {
+        // Skip index (it's first in blobSizes)
+        const columnsNeeded = Math.ceil(blobSize / columnSize);
+        currentColumn += columnsNeeded;
+    }
+    // The actual unencoded size is based on COLUMNS USED, not all columns
+    // Each column is columnSize bytes tall
+    const actualUnencodedQuiltSize = currentColumn * columnSize;
+    // Now use the ACTUAL size for encoding calculation
+    const encodedQuiltSize = encodedBlobLength(actualUnencodedQuiltSize, numShards, encodingType);
+    return {
+        quiltSize: encodedQuiltSize,
+        symbolSize,
+        numRows: nRows,
+        numColumns: nCols,
+        indexSize,
+        blobSizes,
+    };
+}
+/**
+ * Calculate quilt size accounting for encryption overhead.
+ * AES-GCM adds 16 bytes of authentication tag.
+ *
+ * @param files - Array of files with original sizes
+ * @param numShards - Number of shards
+ * @param ivSize - Size of IV (typically 12 bytes for GCM)
+ * @param encodingType - Encoding type
+ * @returns Quilt size information
+ */
+export function calculateEncryptedQuiltSize(files, numShards, ivSize = 12, encodingType) {
+    const GCM_TAG_SIZE = 16; // AES-GCM authentication tag
+    return calculateQuiltSize({
+        blobs: files.map((file) => ({
+            // Account for IV + encrypted data + GCM tag
+            size: ivSize + file.size + GCM_TAG_SIZE,
+            identifier: file.identifier,
+            tags: file.tags,
+        })),
+        numShards,
+        encodingType,
+    });
+}

package/dist/lib/utils/reclaim.d.ts

@@ -0,0 +1,29 @@
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function textToBytes(text: string): Uint8Array;
+export declare function bytesToText(bytes: Uint8Array): string;
+export declare function startVerification({ reclaimAppId, reclaimAppSecret, reclaimProviderId, }: {
+    reclaimAppId: string;
+    reclaimAppSecret: string;
+    reclaimProviderId: string;
+}): Promise<unknown>;
+export declare function generateCommitNonce(userAddress: string, claimIdentifier: string): number[];
+export declare function generateCommitmentHash(proof: ReclaimProof, nonce: number[]): Uint8Array<ArrayBufferLike>;
+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/dist/lib/utils/reclaim.js

@@ -0,0 +1,88 @@
+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) {
+    return new Uint8Array(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+}
+export function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function textToBytes(text) {
+    return new TextEncoder().encode(text);
+}
+// Uint8Array ? String
+export function bytesToText(bytes) {
+    return new TextDecoder().decode(bytes);
+}
+export async function startVerification({ reclaimAppId, reclaimAppSecret, reclaimProviderId, }) {
+    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, claimIdentifier) {
+    // 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, nonce) {
+    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));
+}

package/dist/lib/utils/types.d.ts

@@ -0,0 +1,5 @@
+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/dist/lib/utils/types.js

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

package/dist/mutations/index.js

@@ -0,0 +1,3 @@
+export * from "./walrus.js";
+export * from "./signer.js";
+export * from "./seal.js";

package/dist/mutations/seal.d.ts

@@ -0,0 +1,12 @@
+export declare function createFileKey(): Promise<Uint8Array>;
+export declare function importFileKey(raw: Uint8Array | ArrayBuffer): Promise<CryptoKey>;
+/**
+ * Encrypt data using AES-256-GCM.
+ * @returns {Uint8Array} Concatenated [IV | ciphertext]
+ */
+export declare function encryptData(key: CryptoKey, data: ArrayBuffer | Uint8Array, iv: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt data using AES-256-GCM.
+ * Input must be the combined [IV | ciphertext] format.
+ */
+export declare function decryptData(key: CryptoKey, encrypted: ArrayBuffer | Uint8Array): Promise<Uint8Array>;

package/dist/mutations/seal.js

@@ -0,0 +1,41 @@
+export async function createFileKey() {
+    // 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) {
+    // 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, data, iv) {
+    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, encrypted) {
+    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/dist/mutations/signer.d.ts

@@ -0,0 +1,10 @@
+import type { ZkLoginProofParams, ZkLoginProofResponse, ZKLoginSignerState } from "../types.js";
+import type { SuiClient } from "@mysten/sui/client";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare function getSigner(suiClient: SuiClient): Promise<ZKLoginSignerState>;
+export declare function signAndExecuteGasPoolTransaction(signer: ZKLoginSignerState, suiClient: SuiClient, tx: Transaction, gasBudget?: number, reserveDurationSecs?: number): Promise<any>;
+export declare function signPersonalMessage(signer: ZKLoginSignerState, message: Uint8Array): Promise<{
+    zkLoginSignature: any;
+    bytes: Uint8Array<ArrayBuffer>;
+}>;
+export declare function createZkLoginProof(params: ZkLoginProofParams): Promise<ZkLoginProofResponse>;