@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/src/hooks/useZingQuery.ts

@@ -1,88 +0,0 @@
-import { useZingClient } from "../components/zing-provider.js";
-import { useQuery } from "@tanstack/react-query";
-import type { ZingClient } from "../client/index.js";
-import type { SuiNetwork } from "../types.js";
-import type { UseQueryOptions } from "@tanstack/react-query";
-
-// ---------------------------------------------
-// Method map
-// ---------------------------------------------
-const zingQueryMethodMap = (zingClient: ZingClient) => ({
-  getIdentifierByAddress: zingClient.getIdentifierByAddress.bind(zingClient),
-  getIdentifierInfoByIdentifier:
-    zingClient.getIdentifierInfoByIdentifier.bind(zingClient),
-  getStudio: zingClient.getStudio.bind(zingClient),
-  getStorageSpace: zingClient.getStorageSpace.bind(zingClient),
-  getStorageTreasury: zingClient.getStorageTreasury.bind(zingClient),
-  getMember: zingClient.getMember.bind(zingClient),
-  getBalance: zingClient.getBalance.bind(zingClient),
-  getWork: zingClient.getWork.bind(zingClient),
-});
-
-type ZingQueryMethods = ReturnType<typeof zingQueryMethodMap>;
-
-type ExtractParams<T> = T extends (...args: infer P) => any ? P : never;
-
-type MethodParamsMap = {
-  [K in keyof ZingQueryMethods]: ExtractParams<ZingQueryMethods[K]>;
-};
-
-type ExtractReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-
-type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-
-type MethodReturnMap = {
-  [K in keyof ZingQueryMethods]: UnwrapPromise<
-    ExtractReturnType<ZingQueryMethods[K]>
-  >;
-};
-
-type UseZingQueryParams<
-  K extends keyof ZingQueryMethods = keyof ZingQueryMethods,
-> = {
-  method: K;
-  params: MethodParamsMap[K];
-};
-
-// ---------------------------------------------
-// Hook
-// ---------------------------------------------
-
-type ExtraQueryOptions<TData> = Omit<
-  UseQueryOptions<TData, Error, TData, readonly unknown[]>,
-  "queryKey" | "queryFn"
->;
-
-export function getZingQueryKey<K extends keyof ZingQueryMethods>(
-  network: SuiNetwork,
-  method: K,
-  memo: string[],
-): readonly [string, K, string[]] {
-  return [network, method, memo] as const;
-}
-
-export function useZingQuery<K extends keyof ZingQueryMethods>(
-  input: UseZingQueryParams<K>,
-  options: ExtraQueryOptions<MethodReturnMap[K]> = {},
-  memo: string[] = [],
-) {
-  const zingClient = useZingClient();
-  const methodMap = zingQueryMethodMap(zingClient);
-
-  const { method, params } = input;
-
-  return useQuery<MethodReturnMap[K]>({
-    queryKey: [zingClient.network, method, memo],
-    gcTime: options.gcTime,
-    staleTime: options.staleTime,
-    enabled: options.enabled,
-    retry: options.retry,
-
-    queryFn: async () => {
-      const fn = methodMap[method];
-      return (fn as (...args: MethodParamsMap[K]) => MethodReturnMap[K])(
-        ...params,
-      );
-    },
-  });
-}

package/src/lib/utils/colorful-logger.ts

@@ -1,27 +0,0 @@
-import { COLORS } from "./const.js";
-import type { ColorType, ValueOf } from "./types.js";
-
-export const colorfulLog = (message: string, type: ColorType) => {
-  let color: ValueOf<typeof COLORS>;
-
-  switch (type) {
-    case "success":
-      color = COLORS.FgGreen;
-      break;
-    case "info":
-      color = COLORS.FgBlue;
-      break;
-    case "error":
-      color = COLORS.FgRed;
-      break;
-    case "warning":
-      color = COLORS.FgYellow;
-      break;
-    default:
-      color = COLORS[type];
-      break;
-  }
-
-  console.info(color, message);
-  console.info(COLORS["Reset"]);
-};

package/src/lib/utils/const.ts

@@ -1,25 +0,0 @@
-export const COLORS = {
-  Reset: "\x1b[0m",
-  Bright: "\x1b[1m",
-  Dim: "\x1b[2m",
-  Underscore: "\x1b[4m",
-  Blink: "\x1b[5m",
-  Reverse: "\x1b[7m",
-  Hidden: "\x1b[8m",
-  FgBlack: "\x1b[30m",
-  FgRed: "\x1b[31m",
-  FgGreen: "\x1b[32m",
-  FgYellow: "\x1b[33m",
-  FgBlue: "\x1b[34m",
-  FgMagenta: "\x1b[35m",
-  FgCyan: "\x1b[36m",
-  FgWhite: "\x1b[37m",
-  BgBlack: "\x1b[40m",
-  BgRed: "\x1b[41m",
-  BgGreen: "\x1b[42m",
-  BgYellow: "\x1b[43m",
-  BgBlue: "\x1b[44m",
-  BgMagenta: "\x1b[45m",
-  BgCyan: "\x1b[46m",
-  BgWhite: "\x1b[47m",
-} as const;

package/src/lib/utils/helpers.ts

@@ -1,78 +0,0 @@
-import type { ExcludeValuesFromBaseArrayType } from "./types.js";
-
-export const excludeValuesFromBaseArray = <
-  B extends string[],
-  E extends (string | number)[],
->(
-  baseArray: B,
-  excludeArray: E,
-) =>
-  baseArray.filter(
-    (value) => !excludeArray.includes(value),
-  ) as ExcludeValuesFromBaseArrayType<B, E>;
-
-export const sleep = async (time: number) =>
-  new Promise((r) => setTimeout(r, time));
-
-export const formatDate = (date: Date) =>
-  date.toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "short",
-    day: "numeric",
-  });
-
-export const formatBalance = (
-  balance: string | number | bigint,
-  decimal: number,
-  digits: number = 4,
-): string => {
-  const normalizedBalance = Number(balance) / Math.pow(10, decimal);
-
-  const fixed = normalizedBalance.toFixed(digits);
-
-  return fixed.replace(/\.?0+$/, "");
-};
-
-export const formatTimeAgo = (date: 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: number): string {
-  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: number): string => {
-  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: number) => {
-  const now = new Date();
-  const diffTime = comp - now.getTime();
-  const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-  return diffDays;
-};
-
-export const bytesToGB = (bytes: number) => bytes / (1024 * 1024 * 1024);

package/src/lib/utils/init-app-with-shadow.ts

@@ -1,42 +0,0 @@
-import { createRoot } from "react-dom/client";
-import type { ReactElement } from "react";
-
-export const initAppWithShadow = ({
-  id,
-  app,
-  inlineCss,
-}: {
-  id: string;
-  inlineCss: string;
-  app: ReactElement;
-}) => {
-  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/src/lib/utils/quilt.ts

@@ -1,317 +0,0 @@
-import { QuiltIndexV1, QuiltPatchTags } from "../../bcs.js";
-import { getSourceSymbols } from "../../getters.js";
-import { bcs } from "@mysten/sui/bcs";
-import type { EncodingType } from "@mysten/walrus";
-
-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: number[],
-  nColumns: number,
-  columnSize: number,
-): boolean {
-  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: number,
-  nShards: number,
-  encodingType: EncodingType = "RS2",
-): number {
-  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: number,
-  nShards: number,
-  encodingType: EncodingType = "RS2",
-): number {
-  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;
-}
-
-export interface QuiltSizeInput {
-  blobs: {
-    size: number; // Size of the blob content in bytes
-    identifier: string;
-    tags?: Record<string, string>;
-  }[];
-  numShards: number;
-  encodingType?: EncodingType;
-}
-
-export interface QuiltSizeResult {
-  quiltSize: number; // Total size of the quilt in bytes
-  symbolSize: number; // Size of each symbol
-  numRows: number;
-  numColumns: number;
-  indexSize: number;
-  blobSizes: number[]; // Size of each blob including metadata
-}
-
-/**
- * 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: number[],
-  nColumns: number,
-  nRows: number,
-  maxNumColumnsForQuiltIndex: number,
-  encodingType: EncodingType = "RS2",
-): number {
-  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: QuiltSizeInput): QuiltSizeResult {
-  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<string>();
-  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: Array<{
-    size: number;
-    identifier: string;
-    tags?: Record<string, string>;
-  }>,
-  numShards: number,
-  ivSize: number = 12,
-  encodingType?: EncodingType,
-): QuiltSizeResult {
-  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,
-  });
-}