@zing-protocol/zing-sdk 0.0.1

package/src/bcs.ts

@@ -0,0 +1,139 @@
+import { bcs, TypeTagSerializer } from "@mysten/sui/bcs";
+import {
+  fromBase64,
+  normalizeStructTag,
+  parseStructTag,
+  SUI_FRAMEWORK_ADDRESS,
+  SUI_SYSTEM_ADDRESS,
+} from "@mysten/sui/utils";
+import { blobIdFromInt, blobIdToInt } from "@mysten/walrus";
+import type { ObjectOwner } from "@mysten/sui/client";
+
+function compareBcsBytes(a: Uint8Array, b: Uint8Array) {
+  // sort by length first, because bcs bytes prefix length
+  if (a.length !== b.length) {
+    return a.length - b.length;
+  }
+
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return a[i] - b[i];
+    }
+  }
+
+  return 0;
+}
+
+export const BlobId = bcs.u256().transform({
+  input: (blobId: string | bigint) =>
+    typeof blobId === "string" ? blobIdToInt(blobId) : blobId,
+  output: (id: string) => blobIdFromInt(id),
+});
+
+export const QuiltPatchId = bcs.struct("QuiltPatchId", {
+  quiltId: BlobId,
+  patchId: bcs.struct("InternalQuiltPatchId", {
+    version: bcs.u8(),
+    startIndex: bcs.u16(),
+    endIndex: bcs.u16(),
+  }),
+});
+export const QuiltPatchTags = bcs.map(bcs.string(), bcs.string()).transform({
+  // tags is a BTreeMap, so we need to sort entries before serializing
+  input: (tags: Record<string, string> | Map<string, string>) =>
+    new Map(
+      [...(tags instanceof Map ? tags : Object.entries(tags))].sort(
+        ([a], [b]) =>
+          compareBcsBytes(
+            bcs.string().serialize(a).toBytes(),
+            bcs.string().serialize(b).toBytes(),
+          ),
+      ),
+    ),
+  output: (tags: Map<string, string>) => Object.fromEntries(tags),
+});
+export const QuiltPatchV1 = bcs.struct("QuiltPatchV1", {
+  endIndex: bcs.u16(),
+  identifier: bcs.string(),
+  tags: QuiltPatchTags,
+});
+export const QuiltIndexV1 = bcs.struct("QuiltIndexV1", {
+  patches: bcs.vector(QuiltPatchV1),
+});
+
+export const MoveObjectType = bcs.enum("MoveObjectType", {
+  Other: bcs.StructTag,
+  GasCoin: null,
+  StakedSui: null,
+  Coin: bcs.TypeTag,
+});
+
+export const SuiMoveObject = bcs.struct("SuiMoveObject", {
+  data: bcs.enum("Data", {
+    MoveObject: bcs.struct("MoveObject", {
+      type: MoveObjectType.transform({
+        input: (objectType: string): typeof MoveObjectType.$inferType => {
+          const structTag = parseStructTag(objectType);
+
+          if (
+            structTag.address === SUI_FRAMEWORK_ADDRESS &&
+            structTag.module === "coin" &&
+            structTag.name === "Coin" &&
+            typeof structTag.typeParams[0] === "object"
+          ) {
+            const innerStructTag = structTag.typeParams[0];
+            if (
+              innerStructTag.address === SUI_FRAMEWORK_ADDRESS &&
+              innerStructTag.module === "sui" &&
+              innerStructTag.name === "SUI"
+            ) {
+              return { GasCoin: true, $kind: "GasCoin" };
+            }
+            return { Coin: normalizeStructTag(innerStructTag), $kind: "Coin" };
+          } else if (
+            structTag.address === SUI_SYSTEM_ADDRESS &&
+            structTag.module === "staking_pool" &&
+            structTag.name === "StakedSui"
+          ) {
+            return { StakedSui: true, $kind: "StakedSui" };
+          }
+          return {
+            Other: {
+              ...structTag,
+              typeParams: structTag.typeParams.map((typeParam) =>
+                TypeTagSerializer.parseFromStr(normalizeStructTag(typeParam)),
+              ),
+            },
+            $kind: "Other",
+          };
+        },
+      }),
+      hasPublicTransfer: bcs.bool(),
+      version: bcs.u64(),
+      contents: bcs.byteVector().transform({ input: fromBase64 }),
+    }),
+  }),
+  owner: bcs.Owner.transform({
+    input: (objectOwner: ObjectOwner) => {
+      if (objectOwner === "Immutable") {
+        return { Immutable: null };
+      } else if ("Shared" in objectOwner) {
+        return {
+          Shared: {
+            initialSharedVersion: objectOwner.Shared.initial_shared_version,
+          },
+        };
+      } else if ("ConsensusAddressOwner" in objectOwner) {
+        return {
+          ConsensusAddressOwner: {
+            owner: objectOwner.ConsensusAddressOwner.owner,
+            startVersion: objectOwner.ConsensusAddressOwner.start_version,
+          },
+        };
+      }
+      return objectOwner;
+    },
+  }),
+  previousTransaction: bcs.ObjectDigest,
+  storageRebate: bcs.u64(),
+});

package/src/client/index.ts

@@ -0,0 +1,557 @@
+import { burnOrSendPositiveCoin } from "../_generated/zing_framework/coin_utils.js";
+import {
+  deleteArticle,
+  donate,
+  purchaseStorageTier,
+  setMonthlySubscriptionFee,
+  subscribeToStudio,
+  updateArticleSubscriptionLevel,
+} from "../_generated/zing_studio/app.js";
+import { addReferralToStudio } from "../_generated/zing_studio/referral.js";
+import { shareStorageSpace } from "../_generated/zing_studio/storage.js";
+import {
+  _new as newStudio,
+  sealApproveStudioOwner,
+  shareStudio,
+} from "../_generated/zing_studio/studio.js";
+import { getConfig } from "../config/index.js";
+import {
+  getDerivedMembershipID,
+  getDerivedStorageID,
+  getDerivedStudioID,
+  getDerivedWorksID,
+  getIdentifierByAddress,
+  getIdentifierInfoByIdentifier,
+  getMember,
+  getMembers,
+  getStorageSpace,
+  getStorageTreasury,
+  getStudio,
+  getWork,
+  getWorks,
+} from "../getters.js";
+import { importFileKey } from "../mutations/seal.js";
+import { signPersonalMessage } from "../mutations/signer.js";
+import { SessionKey } from "@mysten/seal";
+import { Transaction, coinWithBalance } from "@mysten/sui/transactions";
+import { fromHex } from "@mysten/sui/utils";
+import type {
+  PurchaseStorageTierParams,
+  SetMonthlySubscriptionFeeParams,
+  SubscribeParams,
+} from "./types.js";
+import type { CoinSymbol, PlatformType, WorkType } from "../config/index.js";
+import type { Config, WalrusSystemState } from "../config/types.js";
+import type { SuiNetwork, ZKLoginSignerState } from "../types.js";
+import type { SealClient } from "@mysten/seal";
+import type { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+
+interface Params {
+  network: SuiNetwork;
+  suiGrpcClient: SuiGrpcClient;
+  suiJsonRpcClient: SuiJsonRpcClient;
+  gasPoolBearerToken: string;
+}
+
+export class ZingClient {
+  suiGrpcClient: SuiGrpcClient;
+  suiJsonRpcClient: SuiJsonRpcClient;
+  network: SuiNetwork;
+  config: Config;
+  gasPoolBearerToken: string;
+
+  constructor({
+    network,
+    suiGrpcClient,
+    suiJsonRpcClient,
+    gasPoolBearerToken,
+  }: Params) {
+    this.suiGrpcClient = suiGrpcClient;
+    this.suiJsonRpcClient = suiJsonRpcClient;
+    this.network = network || "testnet";
+    this.config = getConfig(network);
+    this.gasPoolBearerToken = gasPoolBearerToken;
+  }
+
+  public getConfig() {
+    return this.config;
+  }
+
+  // Getters
+  getDerivedStudioID(address: string): string {
+    return getDerivedStudioID(
+      this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF.objectId,
+      address,
+    );
+  }
+
+  getDerivedStorageID(address: string) {
+    return getDerivedStorageID(
+      this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF.objectId,
+      address,
+    );
+  }
+
+  getDerivedWorksID(address: string) {
+    return getDerivedWorksID(
+      this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF.objectId,
+      address,
+    );
+  }
+
+  getDerivedMembershipID(address: string) {
+    return getDerivedMembershipID(
+      this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF.objectId,
+      address,
+    );
+  }
+
+  async getIdentifierByAddress(platform: PlatformType, address: string) {
+    return getIdentifierByAddress(
+      this.suiGrpcClient,
+      this.config.zing.IDENTITY_PLATFORMS[platform]
+        .IDENTITY_MANAGER_ADDRESS_TO_IDENTIFIER_DF_ID,
+      address,
+    );
+  }
+
+  async getIdentifierInfoByIdentifier(
+    platform: PlatformType,
+    identifier: string,
+  ) {
+    return getIdentifierInfoByIdentifier(
+      this.suiGrpcClient,
+      this.config.zing.IDENTITY_PLATFORMS[platform]
+        .IDENTITY_MANAGER_IDENTIFIER_INFO_DF_ID,
+      identifier,
+    );
+  }
+
+  // async getDonationByIdentifier(identifier: string) {
+  //   const donations = await getDonationByIdentifier(
+  //     this.suiGrpcClient,
+  //     this.config.zing.DONATIONS_TABLE_DF_ID,
+  //     identifier,
+  //   );
+  //
+  //   return Object.keys(this.config.coins).reduce(
+  //     (acc, coinSymbol) => {
+  //       const symbol = coinSymbol as CoinSymbol;
+  //       const donation = donations?.contents.find(
+  //         (c) => c.key.name === this.config.coins[symbol],
+  //       );
+  //       if (donation) acc[symbol] = donation.value;
+  //       return acc;
+  //     },
+  //     {} as Record<CoinSymbol, string>,
+  //   );
+  // }
+
+  async getStudio(owner: string) {
+    return getStudio(this.suiGrpcClient, this.getDerivedStudioID(owner));
+  }
+
+  async getStorageSpace(owner: string) {
+    return getStorageSpace(this.suiGrpcClient, this.getDerivedStorageID(owner));
+  }
+
+  async getStorageTreasury() {
+    return getStorageTreasury(
+      this.suiGrpcClient,
+      this.config.zing.ZING_STORAGE_TREASURY_SHARED_OBJECT_REF.objectId,
+    );
+  }
+
+  async getMember(owner: string, member: string) {
+    return getMember(
+      this.suiGrpcClient,
+      this.getDerivedMembershipID(owner),
+      member,
+    );
+  }
+
+  async getMembers(owner: string, cursor?: string, limit = 20) {
+    return getMembers(
+      this.suiGrpcClient,
+      this.getDerivedMembershipID(owner),
+      cursor,
+      limit,
+    );
+  }
+
+  async getWork(
+    walrusSystem: WalrusSystemState,
+    workId: string,
+    workType?: WorkType,
+  ) {
+    return getWork(
+      this.suiGrpcClient,
+      walrusSystem,
+      workId,
+      workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined,
+    );
+  }
+
+  async getWorks(
+    walrusSystem: WalrusSystemState,
+    owner: string,
+    workType?: WorkType,
+    cursor?: string,
+    limit = 20,
+  ) {
+    return getWorks(
+      this.suiGrpcClient,
+      walrusSystem,
+      this.getDerivedWorksID(owner),
+      workType ? this.config.zing.ZING_WORKS_TYPE[workType] : undefined,
+      cursor,
+      limit,
+    );
+  }
+
+  async getBalance(owner: string, coinSymbol: CoinSymbol) {
+    return this.suiGrpcClient.stateService
+      .getBalance({
+        owner,
+        coinType: this.config.coins[coinSymbol],
+      })
+      .then((res) => res.response);
+  }
+
+  async getSessionKey(signer: ZKLoginSignerState, owner: string) {
+    const { suiAddress, ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } =
+      signer;
+    if (
+      !suiAddress ||
+      !ephemeralKeyPair ||
+      !decodedJwt ||
+      !zkProof ||
+      !maxEpoch
+    ) {
+      throw new Error("Missing required wallet data for session key creation");
+    }
+
+    const sessionKey = await SessionKey.create({
+      address: owner,
+      packageId: this.config.zing.ZING_STUDIO_V0_PACKAGE_ADDRESS,
+      ttlMin: 10,
+      suiClient: this.suiJsonRpcClient,
+    });
+    const message = sessionKey.getPersonalMessage();
+    const { zkLoginSignature } = await signPersonalMessage(signer, message);
+
+    sessionKey.setPersonalMessageSignature(zkLoginSignature);
+
+    return sessionKey;
+  }
+
+  async buildSealApproveTransactionBytes(owner: string) {
+    const tx = new Transaction();
+    // codegen didn't generate interface for entry fun
+    const studioId = this.getDerivedStudioID(owner);
+
+    tx.add(
+      sealApproveStudioOwner({
+        package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+        arguments: {
+          id: tx.pure.vector("u8", fromHex(studioId)),
+          config: tx.sharedObjectRef(
+            this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+          ),
+          self: tx.object(studioId),
+        },
+      }),
+    );
+
+    return tx.build({
+      client: this.suiJsonRpcClient,
+      onlyTransactionKind: true,
+    });
+  }
+
+  async getFileKey(
+    sealClient: SealClient,
+    sessionKey: SessionKey,
+    owner: string,
+    encryptedFileKeyBytes: number[],
+  ) {
+    const txBytes = await this.buildSealApproveTransactionBytes(owner);
+    const decryptedKey = await sealClient.decrypt({
+      data: new Uint8Array(encryptedFileKeyBytes),
+      sessionKey,
+      txBytes,
+    });
+    return await importFileKey(decryptedKey);
+  }
+
+  // --- Transaction Builders ---
+
+  /**
+   * Constructs the transaction for subscribing to a studio.
+   * Does not execute; returns the Transaction object to be signed.
+   */
+  public subscribeToStudioTransaction({
+    sender,
+    creatorAddress,
+    subscriptionAmount,
+    level,
+  }: SubscribeParams) {
+    return (tx: Transaction) => {
+      const usdcCoin = tx.add(
+        coinWithBalance({
+          type: this.config.coins.USDC,
+          balance: subscriptionAmount,
+          useGasCoin: false,
+        }),
+      );
+
+      const studioId = this.getDerivedStudioID(creatorAddress);
+
+      tx.add(
+        subscribeToStudio({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          typeArguments: [this.config.coins.USDC],
+          arguments: {
+            studio: tx.object(studioId),
+            treasury: tx.sharedObjectRef(
+              this.config.zing.ZING_TREASURY_SHARED_OBJECT_REF,
+            ),
+            subscriptionLevel: tx.pure.u8(level),
+            payment: usdcCoin,
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+          },
+        }),
+      );
+
+      tx.add(
+        burnOrSendPositiveCoin({
+          package: this.config.zing.ZING_FRAMEWORK_PACKAGE_ADDRESS,
+          typeArguments: [this.config.coins.USDC],
+          arguments: {
+            coin: usdcCoin,
+            recipient: tx.pure.address(sender),
+          },
+        }),
+      );
+    };
+  }
+
+  public purchaseStorageTierTransaction({
+    sender,
+    objs,
+    newTierIdx,
+    balance,
+    referrer,
+  }: PurchaseStorageTierParams) {
+    return (tx: Transaction) => {
+      const [studio, storageSpace] =
+        objs === null
+          ? tx.add(
+              newStudio({
+                package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+                arguments: [
+                  tx.sharedObjectRef({
+                    ...this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+                    mutable: true,
+                  }), // mutable for new derived Object
+                ],
+              }),
+            )
+          : [tx.object(objs.studioId), tx.object(objs.storageSpaceId)];
+
+      if (objs == null && referrer !== null && sender !== referrer) {
+        tx.add(
+          addReferralToStudio({
+            package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+            arguments: {
+              studio,
+              config: tx.sharedObjectRef(
+                this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+              ),
+              referrer,
+            },
+          }),
+        );
+      }
+
+      const usdcCoin = tx.add(
+        coinWithBalance({
+          type: this.config.coins.USDC,
+          balance,
+          useGasCoin: false,
+        }),
+      );
+
+      tx.add(
+        purchaseStorageTier({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          typeArguments: [this.config.coins.USDC],
+          arguments: {
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+            studio,
+            treasury: tx.sharedObjectRef(
+              this.config.zing.ZING_TREASURY_SHARED_OBJECT_REF,
+            ),
+            walrusSystem: tx.sharedObjectRef(
+              this.config.walrus.WALRUS_SYSTEM_SHARED_OBJECT_REF,
+            ),
+            storageTreasury: tx.sharedObjectRef(
+              this.config.zing.ZING_STORAGE_TREASURY_SHARED_OBJECT_REF,
+            ),
+            storageSpace,
+            newTierIdx: tx.pure.u8(newTierIdx),
+            payment: usdcCoin,
+          },
+        }),
+      );
+
+      if (objs === null) {
+        tx.add(
+          shareStudio({
+            package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+            arguments: [studio],
+          }),
+        );
+
+        tx.add(
+          shareStorageSpace({
+            package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+            arguments: [storageSpace],
+          }),
+        );
+      }
+
+      tx.add(
+        burnOrSendPositiveCoin({
+          package: this.config.zing.ZING_FRAMEWORK_PACKAGE_ADDRESS,
+          typeArguments: [this.config.coins.USDC],
+          arguments: {
+            coin: usdcCoin,
+            recipient: tx.pure.address(sender),
+          },
+        }),
+      );
+    };
+  }
+
+  public setMonthlySubscriptionFeeTransaction({
+    sender,
+    monthlyFee,
+    level,
+  }: SetMonthlySubscriptionFeeParams) {
+    return (tx: Transaction) => {
+      tx.add(
+        setMonthlySubscriptionFee({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          arguments: {
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+            studio: tx.object(this.getDerivedStudioID(sender)),
+            level: tx.pure.u8(level),
+            monthlySubscriptionFee: tx.pure.u64(monthlyFee),
+          },
+        }),
+      );
+    };
+  }
+
+  public updateArticleSubscriptionLevelTransaction({
+    sender,
+    articleId,
+    subscriptionLevel,
+  }: {
+    sender: string;
+    articleId: string;
+    subscriptionLevel: null | number;
+  }) {
+    return (tx: Transaction) => {
+      tx.add(
+        updateArticleSubscriptionLevel({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          arguments: {
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+            studio: tx.object(this.getDerivedStudioID(sender)),
+            walrusSystem: tx.sharedObjectRef(
+              this.config.walrus.WALRUS_SYSTEM_SHARED_OBJECT_REF,
+            ),
+            articleId: tx.pure.id(articleId),
+            subscriptionLevel: tx.pure.option("u8", subscriptionLevel),
+          },
+        }),
+      );
+    };
+  }
+
+  public deleteArticleTransaction({
+    sender,
+    articleId,
+  }: {
+    sender: string;
+    articleId: string;
+  }) {
+    return (tx: Transaction) => {
+      tx.add(
+        deleteArticle({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          arguments: {
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+            studio: tx.object(this.getDerivedStudioID(sender)),
+            storageSpace: tx.object(this.getDerivedStorageID(sender)),
+            walrusSystem: tx.sharedObjectRef(
+              this.config.walrus.WALRUS_SYSTEM_SHARED_OBJECT_REF,
+            ),
+            articleId: tx.pure.id(articleId),
+          },
+        }),
+      );
+    };
+  }
+
+  public donateTransaction({
+    recipient,
+    message,
+    value,
+  }: {
+    recipient: string;
+    message: string;
+    value: number;
+  }) {
+    return (tx: Transaction) => {
+      const usdcCoin = tx.add(
+        coinWithBalance({
+          type: this.config.coins.USDC,
+          balance: value,
+          useGasCoin: false,
+        }),
+      );
+
+      tx.add(
+        donate({
+          package: this.config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
+          typeArguments: [this.config.coins.USDC],
+          arguments: {
+            config: tx.sharedObjectRef(
+              this.config.zing.ZING_STUDIO_CONFIG_SHARED_OBJECT_REF,
+            ),
+            studio: tx.object(this.getDerivedStudioID(recipient)),
+            treasury: tx.sharedObjectRef(
+              this.config.zing.ZING_TREASURY_SHARED_OBJECT_REF,
+            ),
+            message: tx.pure.string(message),
+            donation: usdcCoin,
+          },
+        }),
+      );
+    };
+  }
+}

package/src/client/types.ts

@@ -0,0 +1,28 @@
+import type { Transaction } from "@mysten/sui/transactions";
+
+export type TransactionBuilderFn<TParams> = (
+  tx: Transaction,
+  params: TParams,
+) => void;
+export interface SubscribeParams {
+  sender: string;
+  creatorAddress: string;
+  subscriptionAmount: number;
+  level: number;
+}
+export interface PurchaseStorageTierParams {
+  sender: string;
+  objs: null | {
+    studioId: string;
+    storageSpaceId: string;
+  };
+  newTierIdx: number;
+  referrer: string | null;
+  balance: number;
+}
+
+export interface SetMonthlySubscriptionFeeParams {
+  sender: string;
+  monthlyFee: number;
+  level: number;
+}