@zing-protocol/zing-sdk 0.0.1

package/src/config/types.ts

@@ -0,0 +1,69 @@
+import type { CoinSymbol, PlatformType, WorkType } from "./common.js";
+import type { KeyServerConfig } from "@mysten/seal";
+import type { WalrusClient } from "@mysten/walrus";
+
+export interface SharedObjectRef {
+  objectId: string;
+  initialSharedVersion: number;
+  mutable: boolean;
+}
+
+export interface PlatformConfig {
+  PLATFORM_UPDATE_PROOF_TARGET: string;
+  PLATFORM_TYPE: string;
+  // managers
+  RECLAIM_MANAGER_SHARED_OBJECT_REF: SharedObjectRef;
+  IDENTITY_MANAGER_SHARED_OBJECT_REF: SharedObjectRef;
+  // dynamic-field
+  IDENTITY_MANAGER_IDENTIFIER_INFO_DF_ID: string;
+  IDENTITY_MANAGER_ADDRESS_TO_IDENTIFIER_DF_ID: string;
+}
+
+export interface ZingConfig {
+  // Packages
+  ZING_FRAMEWORK_PACKAGE_ADDRESS: string;
+  ZING_IDENTITY_PACKAGE_ADDRESS: string;
+  ZING_STUDIO_PACKAGE_ADDRESS: string;
+  ZING_STUDIO_V0_PACKAGE_ADDRESS: string;
+  // Configs
+  // - zing_governance
+  ZING_TREASURY_SHARED_OBJECT_REF: SharedObjectRef;
+  // - zing_identity
+  ZING_IDENTITY_CONFIG_SHARED_OBJECT_REF: SharedObjectRef;
+  PROOF_COMMITMENT_TYPE: string;
+  IDENTITY_PLATFORMS: Record<PlatformType, PlatformConfig>;
+  // - zing_studio
+  ZING_STUDIO_CONFIG_SHARED_OBJECT_REF: SharedObjectRef;
+  ZING_STORAGE_TREASURY_SHARED_OBJECT_REF: SharedObjectRef;
+  ZING_WORKS_TYPE: Record<WorkType, string>;
+  // events
+  EVENT_TYPES: Record<"publishArticleEvent", string>;
+}
+
+export interface WalrusConfig {
+  WALRUS_PACKAGE: string;
+  WAL_STAKING_INNER_FIELD: string;
+  WALRUS_SYSTEM_SHARED_OBJECT_REF: SharedObjectRef;
+  WALRUS_AGGREGATORS: string[];
+  WALRUS_UPLOAD_RELAY_BASE_URL: string;
+  // events
+  EVENT_TYPES: Record<"blobRegistered", string>;
+}
+
+export interface SealConfig {
+  serverConfigs: KeyServerConfig[];
+}
+
+export interface Config {
+  zing: ZingConfig;
+  walrus: WalrusConfig;
+  seal: SealConfig;
+  coins: Record<CoinSymbol, string>;
+}
+
+export type WalrusStakingState = Awaited<
+  ReturnType<WalrusClient["stakingState"]>
+>;
+export type WalrusSystemState = Awaited<
+  ReturnType<WalrusClient["systemState"]>
+>;

package/src/const.ts

@@ -0,0 +1,32 @@
+import type { SuiNetwork } from "./types.js";
+import type { KeyServerConfig } from "@mysten/seal";
+
+// // Walrus upload relay
+export const WALRUS_UPLOAD_RELAY_BASE_URL: Record<SuiNetwork, string> = {
+  mainnet: "https://walrus-upload-relay-production-73a4.up.railway.app",
+  testnet: "https://walrus-upload-relay-production-73a4.up.railway.app",
+};
+
+// Platform
+// seal
+export const SEAL_SERVERS_CONFIGS: Record<SuiNetwork, KeyServerConfig[]> = {
+  mainnet: [
+    {
+      objectId:
+        "0xe0eb52eba9261b96e895bbb4deca10dcd64fbc626a1133017adcd5131353fd10",
+      weight: 1,
+    },
+  ],
+  testnet: [
+    {
+      objectId:
+        "0x73d05d62c18d9374e3ea529e8e0ed6161da1a141a94d3f76ae3fe4e99356db75",
+      weight: 1,
+    },
+    {
+      objectId:
+        "0xf5d14a81a982144ae441cd7d64b09027f116a468bd36e7eca494f750591623c8",
+      weight: 1,
+    },
+  ],
+};

package/src/getters.ts

@@ -0,0 +1,523 @@
+import { TypeName } from "./_generated/zing_identity/deps/std/type_name.js";
+import { IdentifierInfo } from "./_generated/zing_identity/identity.js";
+import {
+  Article,
+  PublishArticleEvent,
+} from "./_generated/zing_studio/article.js";
+import { Field } from "./_generated/zing_studio/deps/sui/dynamic_field.js";
+import { VecMap } from "./_generated/zing_studio/deps/sui/vec_map.js";
+import { BlobRegistered } from "./_generated/zing_studio/deps/walrus/events.js";
+import {
+  StorageSpace,
+  StorageTreasury,
+} from "./_generated/zing_studio/storage.js";
+import { Member, Studio } from "./_generated/zing_studio/studio.js";
+import { QuiltPatchId, SuiMoveObject } from "./bcs.js";
+import { bcs } from "@mysten/sui/bcs";
+import {
+  deriveDynamicFieldID,
+  deriveObjectID,
+  fromBase64,
+  normalizeStructTag,
+  toBase64,
+} from "@mysten/sui/utils";
+import type { MoveObjectType } from "./bcs.js";
+import type { WalrusSystemState } from "./config/types.js";
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+import type { EncodingType, WalrusClient } from "@mysten/walrus";
+
+// Walrus
+const DIGEST_LEN = 32;
+const BLOB_ID_LEN = 32;
+
+// Zing
+export function getDerivedStudioID(studioConfigId: string, address: string) {
+  return deriveObjectID(
+    studioConfigId,
+    "address",
+    bcs.Address.serialize(address).toBytes(),
+  );
+}
+
+export function getDerivedStorageID(studioConfigId: string, address: string) {
+  const studioId = getDerivedStudioID(studioConfigId, address);
+  const key = new TextEncoder().encode("storage");
+  return deriveObjectID(
+    studioId,
+    "vector<u8>",
+    bcs.vector(bcs.u8()).serialize(key).toBytes(),
+  );
+}
+
+export function getDerivedWorksID(studioConfigId: string, address: string) {
+  const studioId = getDerivedStudioID(studioConfigId, address);
+  const key = new TextEncoder().encode("works");
+  return deriveObjectID(
+    studioId,
+    "vector<u8>",
+    bcs.vector(bcs.u8()).serialize(key).toBytes(),
+  );
+}
+
+export function getDerivedMembershipID(
+  studioConfigId: string,
+  address: string,
+) {
+  const studioId = getDerivedStudioID(studioConfigId, address);
+  const key = new TextEncoder().encode("membership");
+  return deriveObjectID(
+    studioId,
+    "vector<u8>",
+    bcs.vector(bcs.u8()).serialize(key).toBytes(),
+  );
+}
+
+export async function getIdentifierByAddress(
+  suiGrpcClient: SuiGrpcClient,
+  addressToIdentifierDynamicFieldId: string,
+  address: string,
+) {
+  const dfObjectId = deriveDynamicFieldID(
+    addressToIdentifierDynamicFieldId,
+    "address",
+    bcs.Address.serialize(address).toBytes(),
+  );
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: dfObjectId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+  const field = Field(bcs.Address, bcs.String).parse(
+    suiMoveObject.data.MoveObject.contents,
+  );
+
+  return field.value;
+}
+
+export async function getIdentifierInfoByIdentifier(
+  suiGrpcClient: SuiGrpcClient,
+  identifierInfoDynamicFieldId: string,
+  identifier: string,
+) {
+  const dfObjectId = deriveDynamicFieldID(
+    identifierInfoDynamicFieldId,
+    "0x1::ascii::String",
+    bcs.Address.serialize(identifier).toBytes(),
+  );
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: dfObjectId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+  const field = Field(bcs.String, IdentifierInfo).parse(
+    suiMoveObject.data.MoveObject.contents,
+  );
+
+  return field.value;
+}
+
+export async function getDonationByIdentifier(
+  suiGrpcClient: SuiGrpcClient,
+  donationTableId: string,
+  identifier: string,
+) {
+  const dfObjectId = deriveDynamicFieldID(
+    donationTableId,
+    "0x1::ascii::String",
+    bcs.Address.serialize(identifier).toBytes(),
+  );
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: dfObjectId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+  const field = Field(bcs.String, VecMap(TypeName, bcs.U64)).parse(
+    suiMoveObject.data.MoveObject.contents,
+  );
+
+  return field.value;
+}
+
+export async function getStudio(
+  suiGrpcClient: SuiGrpcClient,
+  studioId: string,
+) {
+  try {
+    const res = await suiGrpcClient.ledgerService.getObject({
+      objectId: studioId,
+      readMask: {
+        paths: ["bcs"],
+      },
+    });
+
+    if (!res.response.object?.bcs?.value) {
+      return null;
+    }
+
+    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+
+    return Studio.parse(suiMoveObject.data.MoveObject.contents);
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function getStorageSpace(
+  suiGrpcClient: SuiGrpcClient,
+  storageSpaceId: string,
+) {
+  try {
+    const res = await suiGrpcClient.ledgerService.getObject({
+      objectId: storageSpaceId,
+      readMask: {
+        paths: ["bcs"],
+      },
+    });
+
+    if (!res.response.object?.bcs?.value) {
+      return null;
+    }
+
+    const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+
+    return StorageSpace.parse(suiMoveObject.data.MoveObject.contents);
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+}
+
+export async function getStorageTreasury(
+  suiGrpcClient: SuiGrpcClient,
+  storageTreasuryId: string,
+) {
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: storageTreasuryId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+  return StorageTreasury.parse(suiMoveObject.data.MoveObject.contents);
+}
+
+export async function getMember(
+  suiGrpcClient: SuiGrpcClient,
+  membershipTableId: string,
+  member: string,
+) {
+  const dfObjectId = deriveDynamicFieldID(
+    membershipTableId,
+    "address",
+    bcs.Address.serialize(member).toBytes(),
+  );
+
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: dfObjectId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+  const field = Field(bcs.Address, Member).parse(
+    suiMoveObject.data.MoveObject.contents,
+  );
+
+  return field.value;
+}
+
+export async function getMembers(
+  suiGrpcClient: SuiGrpcClient,
+  membershipTableId: string,
+  cursor?: string,
+  limit = 20,
+) {
+  const res = await suiGrpcClient.stateService.listDynamicFields({
+    parent: membershipTableId,
+    pageToken: cursor ? fromBase64(cursor) : undefined,
+    pageSize: limit,
+    readMask: {
+      paths: ["field_object.bcs"],
+    },
+  });
+
+  const data = res.response.dynamicFields.map((df) => {
+    if (!df.fieldObject?.bcs?.value)
+      throw new Error("Wrong readMask for reading members");
+    const suiMoveObject = SuiMoveObject.parse(df.fieldObject.bcs.value);
+    // Wrapped in dynamicFields
+    const field = Field(bcs.Address, Member).parse(
+      suiMoveObject.data.MoveObject.contents,
+    );
+
+    return {
+      member: field.name,
+      level: field.value.level,
+      expiredAt: field.value.expired_at,
+    };
+  });
+
+  return {
+    data,
+    nextCursor: res.response.nextPageToken
+      ? toBase64(res.response.nextPageToken)
+      : undefined,
+    hasNextPage: res.response.nextPageToken !== undefined,
+  };
+}
+
+export async function getWork(
+  suiGrpcClient: SuiGrpcClient,
+  walrusSystem: WalrusSystemState,
+  workId: string,
+  workType?: string,
+) {
+  const res = await suiGrpcClient.ledgerService.getObject({
+    objectId: workId,
+    readMask: {
+      paths: ["bcs"],
+    },
+  });
+
+  if (!res.response.object?.bcs?.value) {
+    return null;
+  }
+
+  const suiMoveObject = SuiMoveObject.parse(res.response.object.bcs.value);
+
+  const type = suiMoveObject.data.MoveObject
+    .type as typeof MoveObjectType.$inferType;
+
+  if (
+    type.$kind !== "Other" ||
+    normalizeStructTag(type.Other as any) !== workType
+  )
+    return null;
+
+  return Article.parse(suiMoveObject.data.MoveObject.contents);
+}
+
+export async function getWorks(
+  suiGrpcClient: SuiGrpcClient,
+  walrusSystem: WalrusSystemState,
+  workTableId: string,
+  workType?: string,
+  cursor?: string,
+  limit = 20,
+) {
+  const res = await suiGrpcClient.stateService.listDynamicFields({
+    parent: workTableId,
+    pageToken: cursor ? fromBase64(cursor) : undefined,
+    pageSize: limit,
+    readMask: {
+      paths: ["child_object"],
+    },
+  });
+
+  const works = res.response.dynamicFields.map((df) => {
+    if (!df.childObject?.contents?.value)
+      throw new Error("Wrong readMask for reading members");
+    // Wrapped in dynamicObjectFields
+    const objectType = df.childObject.objectType;
+
+    if (objectType !== workType) return null;
+    return Article.parse(df.childObject.contents.value);
+  });
+
+  const data = works
+    .filter((d): d is typeof Article.$inferType => {
+      if (!d || d.blobs.length === 0 || d.deleted) return false;
+      const minEndEpoch = Math.min(...d.blobs.map((b) => b.storage.end_epoch));
+      return minEndEpoch > walrusSystem.committee.epoch;
+    })
+    .sort((a, b) => Number(b.created_at) - Number(a.created_at));
+
+  console.log({ getWorksData: data });
+
+  return {
+    data,
+    nextCursor: res.response.nextPageToken
+      ? toBase64(res.response.nextPageToken)
+      : undefined,
+    hasNextPage: res.response.nextPageToken !== undefined,
+  };
+}
+
+export async function getPublishedArticleAndBlobId(
+  suiGrpcClient: SuiGrpcClient,
+  suiClient: SuiJsonRpcClient,
+  walrusClient: WalrusClient,
+  digest: string,
+  blobRegisteredEventType: string,
+  publishArticleEventType: string,
+) {
+  // suiGrpcClient waitForTransaction calling core.getTransaction which is broken
+  await suiClient.waitForTransaction({
+    digest,
+  });
+
+  if (!digest) throw new Error("fail to get transaction hash");
+
+  const res = await suiGrpcClient.ledgerService.getTransaction({
+    digest,
+    readMask: {
+      paths: ["events"],
+    },
+  });
+
+  const blobRegisteredEvent = res.response.transaction?.events?.events?.find(
+    (e) => e.contents?.name === blobRegisteredEventType,
+  );
+  const publishArticleEvent = res.response.transaction?.events?.events?.find(
+    (e) => e.contents?.name === publishArticleEventType,
+  );
+
+  if (!blobRegisteredEvent || !blobRegisteredEvent.contents?.value) {
+    throw new Error("fail to get blobRegisteredEvent");
+  }
+  if (!publishArticleEvent || !publishArticleEvent.contents?.value) {
+    throw new Error("fail to get publishArticleEvent");
+  }
+
+  const blobObjectId = BlobRegistered.parse(
+    blobRegisteredEvent.contents?.value,
+  ).object_id;
+  const parsedPublishArticleEvent = PublishArticleEvent.parse(
+    publishArticleEvent.contents.value,
+  );
+
+  return { parsedPublishArticleEvent, blobObjectId };
+}
+
+export function encodeQuiltPatchId(id: typeof QuiltPatchId.$inferInput) {
+  return urlSafeBase64(QuiltPatchId.serialize(id).toBytes());
+}
+
+export function urlSafeBase64(bytes: Uint8Array): string {
+  return toBase64(bytes).replace(/=*$/, "").replace("+", "-").replace("/", "_");
+}
+
+export function getMaxFaultyNodes(nShards: number): number {
+  return Math.floor((nShards - 1) / 3);
+}
+
+export function decodingSafetyLimit(
+  nShards: number,
+  encodingType: EncodingType,
+): number {
+  switch (encodingType) {
+    case "RedStuff":
+      return Math.min(5, Math.floor(getMaxFaultyNodes(nShards) / 5));
+    case "RS2":
+      return 0;
+    default:
+      throw new Error(`Encountered unknown encoding type of ${encodingType}`);
+  }
+}
+
+export function signersToBitmap(
+  signers: number[],
+  committeeSize: number,
+): Uint8Array {
+  const bitmapSize = Math.ceil(committeeSize / 8);
+  const bitmap = new Uint8Array(bitmapSize);
+
+  for (const signer of signers) {
+    const byteIndex = Math.floor(signer / 8);
+    const bitIndex = signer % 8;
+    bitmap[byteIndex] |= 1 << bitIndex;
+  }
+
+  return bitmap;
+}
+
+export function getSourceSymbols(
+  nShards: number,
+  encodingType: EncodingType = "RS2",
+) {
+  const safetyLimit = decodingSafetyLimit(nShards, encodingType);
+  const maxFaulty = getMaxFaultyNodes(nShards);
+  const minCorrect = nShards - maxFaulty;
+
+  return {
+    primarySymbols: minCorrect - maxFaulty - safetyLimit,
+    secondarySymbols: minCorrect - safetyLimit,
+  };
+}
+
+/**
+ * Calculate the encoded sliver size.
+ * This matches the Walrus SDK's encodedSliverSize function.
+ */
+export function encodedSliverSize(
+  unencodedLength: number,
+  nShards: number,
+  encodingType: EncodingType = "RS2",
+): number {
+  const { primarySymbols, secondarySymbols } = getSourceSymbols(
+    nShards,
+    encodingType,
+  );
+
+  // Calculate symbol size with proper rounding
+  let symbolSize =
+    Math.floor(
+      (Math.max(unencodedLength, 1) - 1) / (primarySymbols * secondarySymbols),
+    ) + 1;
+
+  // RS2 requires even symbol sizes
+  if (encodingType === "RS2" && symbolSize % 2 === 1) {
+    symbolSize = symbolSize + 1;
+  }
+
+  const singleShardSize = (primarySymbols + secondarySymbols) * symbolSize;
+
+  console.log("encodedSliverSize breakdown:", {
+    unencodedLength,
+    primarySymbols,
+    secondarySymbols,
+    calculatedSymbolSize: symbolSize,
+    singleShardSize,
+    totalSliverSize: singleShardSize * nShards,
+  });
+
+  return singleShardSize * nShards;
+}
+
+export 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;
+}

package/src/hooks/index.ts

@@ -0,0 +1,14 @@
+export * from "./useSignAndExecuteTransaction.js";
+export * from "./useReclaim.js";
+export * from "./useGetStudio.js";
+export * from "./useZingMutation.js";
+export * from "./useZingQuery.js";
+export * from "./useZingQueries.js";
+export * from "./useZingInfiniteQueries.js";
+export * from "./useGetTierPlan.js";
+export * from "./useSignPersonalMessage.js";
+
+export type InfiniteQueryResult<TData> = {
+  pages: TData[];
+  pageParams: number[];
+};

package/src/hooks/useGetStudio.ts

@@ -0,0 +1,22 @@
+import { useZingQuery } from "./useZingQuery.js";
+
+export function useGetStudio(suiAddress?: string) {
+  return useZingQuery(
+    {
+      method: "getStudio",
+      params: [suiAddress || ""],
+    },
+    {
+      enabled: !!suiAddress,
+      retry: (failureCount, error) => {
+        if (error instanceof Error && error.message.includes("notExists")) {
+          return false;
+        }
+        return failureCount < 1;
+      },
+      staleTime: 5 * 60 * 1000, // 5 minutes
+      gcTime: 10 * 60 * 1000, // 10 minutes (formerly cacheTime)
+    },
+    [suiAddress || ""],
+  );
+}