@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/bcs.d.ts

@@ -0,0 +1,61 @@
+import type { ObjectOwner } from "@mysten/sui/client";
+export declare const BlobId: import("@mysten/sui/bcs").BcsType<string, string | bigint, "u256">;
+export declare const QuiltPatchId: import("@mysten/sui/bcs").BcsStruct<{
+    quiltId: import("@mysten/sui/bcs").BcsType<string, string | bigint, "u256">;
+    patchId: import("@mysten/sui/bcs").BcsStruct<{
+        version: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+        startIndex: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+        endIndex: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    }, string>;
+}, string>;
+export declare const QuiltPatchTags: import("@mysten/sui/bcs").BcsType<{
+    [k: string]: string;
+}, Map<string, string> | Record<string, string>, "Map<string, string>">;
+export declare const QuiltPatchV1: import("@mysten/sui/bcs").BcsStruct<{
+    endIndex: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+    identifier: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    tags: import("@mysten/sui/bcs").BcsType<{
+        [k: string]: string;
+    }, Map<string, string> | Record<string, string>, "Map<string, string>">;
+}, string>;
+export declare const QuiltIndexV1: import("@mysten/sui/bcs").BcsStruct<{
+    patches: import("@mysten/sui/bcs").BcsType<{
+        endIndex: number;
+        identifier: string;
+        tags: {
+            [k: string]: string;
+        };
+    }[], Iterable<{
+        endIndex: number;
+        identifier: string;
+        tags: Map<string, string> | Record<string, string>;
+    }> & {
+        length: number;
+    }, string>;
+}, string>;
+export declare const MoveObjectType: import("@mysten/sui/bcs").BcsEnum<{
+    Other: import("@mysten/sui/bcs").BcsStruct<{
+        address: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        module: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+        typeParams: import("@mysten/sui/bcs").BcsType<import("@mysten/sui/bcs").TypeTag[], Iterable<import("@mysten/sui/bcs").TypeTag> & {
+            length: number;
+        }, string>;
+    }, string>;
+    GasCoin: null;
+    StakedSui: null;
+    Coin: import("@mysten/sui/bcs").BcsType<string, string | import("@mysten/sui/bcs").TypeTag, string>;
+}, "MoveObjectType">;
+export declare const SuiMoveObject: import("@mysten/sui/bcs").BcsStruct<{
+    data: import("@mysten/sui/bcs").BcsEnum<{
+        MoveObject: import("@mysten/sui/bcs").BcsStruct<{
+            type: import("@mysten/sui/bcs").BcsType<any, string, string>;
+            hasPublicTransfer: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+            version: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+            contents: import("@mysten/sui/bcs").BcsType<any, string, string>;
+        }, string>;
+    }, "Data">;
+    owner: import("@mysten/sui/bcs").BcsType<any, ObjectOwner, string>;
+    previousTransaction: import("@mysten/sui/bcs").BcsType<string, string, "ObjectDigest">;
+    storageRebate: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, string>;

package/dist/bcs.js

@@ -0,0 +1,109 @@
+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";
+function compareBcsBytes(a, b) {
+    // 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) => typeof blobId === "string" ? blobIdToInt(blobId) : blobId,
+    output: (id) => 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) => 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) => 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) => {
+                    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) => {
+            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/dist/client/index.d.ts

@@ -0,0 +1,228 @@
+import { SessionKey } from "@mysten/seal";
+import { Transaction } from "@mysten/sui/transactions";
+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 declare class ZingClient {
+    suiGrpcClient: SuiGrpcClient;
+    suiJsonRpcClient: SuiJsonRpcClient;
+    network: SuiNetwork;
+    config: Config;
+    gasPoolBearerToken: string;
+    constructor({ network, suiGrpcClient, suiJsonRpcClient, gasPoolBearerToken, }: Params);
+    getConfig(): Config;
+    getDerivedStudioID(address: string): string;
+    getDerivedStorageID(address: string): string;
+    getDerivedWorksID(address: string): string;
+    getDerivedMembershipID(address: string): string;
+    getIdentifierByAddress(platform: PlatformType, address: string): Promise<string | null>;
+    getIdentifierInfoByIdentifier(platform: PlatformType, identifier: string): Promise<{
+        owner: string;
+        updated_at: string;
+    } | null>;
+    getStudio(owner: string): Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        period: string[];
+        monthly_subscription_fee: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        membership: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        works: {
+            id: {
+                id: string;
+            };
+            size: string;
+        };
+        encrypted_file_key: number[] | null;
+    } | null>;
+    getStorageSpace(owner: string): Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        tier: number | null;
+        storage_used: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
+        credits: string;
+    } | null>;
+    getStorageTreasury(): Promise<{
+        id: {
+            id: string;
+        };
+        tier_plan: {
+            contents: {
+                key: number;
+                value: {
+                    price: string;
+                    duration_days: number;
+                    storage_limit: string;
+                };
+            }[];
+        };
+        storages_by_epoch: {
+            contents: {
+                key: number;
+                value: {
+                    id: {
+                        id: string;
+                    };
+                    start_epoch: number;
+                    end_epoch: number;
+                    storage_size: string;
+                };
+            }[];
+        };
+        wal_treasury: {
+            id: {
+                id: string;
+            };
+            balance: {
+                value: string;
+            };
+        };
+    } | null>;
+    getMember(owner: string, member: string): Promise<{
+        level: number;
+        expired_at: string;
+    } | null>;
+    getMembers(owner: string, cursor?: string, limit?: number): Promise<{
+        data: {
+            member: string;
+            level: number;
+            expiredAt: string;
+        }[];
+        nextCursor: string | undefined;
+        hasNextPage: boolean;
+    }>;
+    getWork(walrusSystem: WalrusSystemState, workId: string, workType?: WorkType): Promise<{
+        id: {
+            id: string;
+        };
+        owner: string;
+        deleted: boolean;
+        created_at: string;
+        subscription_level: number | null;
+        blobs: {
+            id: {
+                id: string;
+            };
+            registered_epoch: number;
+            blob_id: string;
+            size: string;
+            encoding_type: number;
+            certified_epoch: number | null;
+            storage: {
+                id: {
+                    id: string;
+                };
+                start_epoch: number;
+                end_epoch: number;
+                storage_size: string;
+            };
+            deletable: boolean;
+        }[];
+        files: {
+            contents: {
+                key: string;
+                value: {
+                    blob_index: string;
+                    mime_type: string;
+                    size: string;
+                };
+            }[];
+        };
+    } | null>;
+    getWorks(walrusSystem: WalrusSystemState, owner: string, workType?: WorkType, cursor?: string, limit?: number): Promise<{
+        data: {
+            id: {
+                id: string;
+            };
+            owner: string;
+            deleted: boolean;
+            created_at: string;
+            subscription_level: number | null;
+            blobs: {
+                id: {
+                    id: string;
+                };
+                registered_epoch: number;
+                blob_id: string;
+                size: string;
+                encoding_type: number;
+                certified_epoch: number | null;
+                storage: {
+                    id: {
+                        id: string;
+                    };
+                    start_epoch: number;
+                    end_epoch: number;
+                    storage_size: string;
+                };
+                deletable: boolean;
+            }[];
+            files: {
+                contents: {
+                    key: string;
+                    value: {
+                        blob_index: string;
+                        mime_type: string;
+                        size: string;
+                    };
+                }[];
+            };
+        }[];
+        nextCursor: string | undefined;
+        hasNextPage: boolean;
+    }>;
+    getBalance(owner: string, coinSymbol: CoinSymbol): Promise<import("node_modules/@mysten/sui/dist/esm/grpc/proto/sui/rpc/v2/state_service.js").GetBalanceResponse>;
+    getSessionKey(signer: ZKLoginSignerState, owner: string): Promise<SessionKey>;
+    buildSealApproveTransactionBytes(owner: string): Promise<Uint8Array<ArrayBuffer>>;
+    getFileKey(sealClient: SealClient, sessionKey: SessionKey, owner: string, encryptedFileKeyBytes: number[]): Promise<CryptoKey>;
+    /**
+     * Constructs the transaction for subscribing to a studio.
+     * Does not execute; returns the Transaction object to be signed.
+     */
+    subscribeToStudioTransaction({ sender, creatorAddress, subscriptionAmount, level, }: SubscribeParams): (tx: Transaction) => void;
+    purchaseStorageTierTransaction({ sender, objs, newTierIdx, balance, referrer, }: PurchaseStorageTierParams): (tx: Transaction) => void;
+    setMonthlySubscriptionFeeTransaction({ sender, monthlyFee, level, }: SetMonthlySubscriptionFeeParams): (tx: Transaction) => void;
+    updateArticleSubscriptionLevelTransaction({ sender, articleId, subscriptionLevel, }: {
+        sender: string;
+        articleId: string;
+        subscriptionLevel: null | number;
+    }): (tx: Transaction) => void;
+    deleteArticleTransaction({ sender, articleId, }: {
+        sender: string;
+        articleId: string;
+    }): (tx: Transaction) => void;
+    donateTransaction({ recipient, message, value, }: {
+        recipient: string;
+        message: string;
+        value: number;
+    }): (tx: Transaction) => void;
+}
+export {};