@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/src/bcs.ts

@@ -1,139 +0,0 @@
-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

@@ -1,557 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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;
-}