@zing-protocol/zing-sdk 0.0.12 → 0.0.14

package/dist/_generated/zing_studio/app.d.ts

@@ -364,3 +364,18 @@ export interface BurnOrKeepPositiveCoinOptions {
     typeArguments: [string];
 }
 export declare function burnOrKeepPositiveCoin(options: BurnOrKeepPositiveCoinOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PayoutArguments {
+    treasury: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface PayoutOptions {
+    package?: string;
+    arguments: PayoutArguments | [
+        treasury: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function payout(options: PayoutOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/app.js

@@ -472,3 +472,19 @@ export function burnOrKeepPositiveCoin(options) {
         typeArguments: options.typeArguments,
     });
 }
+export function payout(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::treasury::Treasury`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+        "address",
+    ];
+    const parameterNames = ["treasury", "coin", "recipient"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "app",
+        function: "payout",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

package/dist/client/index.d.ts

@@ -267,7 +267,7 @@ export declare class ZingClient {
         };
     }[]>;
     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>;
+    getSessionKey(saltServerUrl: string, signer: ZKLoginSignerState, owner: string): Promise<SessionKey>;
     buildSealApproveTransactionBytes(owner: string): Promise<Uint8Array<ArrayBuffer>>;
     getFileKey(sealClient: SealClient, sessionKey: SessionKey, owner: string, encryptedFileKeyBytes: number[]): Promise<CryptoKey>;
     subscribeToStudioTransaction({ sender, creatorAddress, subscriptionAmount, level, }: SubscribeParams): (tx: Transaction) => void;

package/dist/client/index.js

@@ -98,7 +98,7 @@ export class ZingClient {
         })
             .then((res) => res.response);
     }
-    async getSessionKey(signer, owner) {
+    async getSessionKey(saltServerUrl, signer, owner) {
         const { suiAddress, ephemeralKeyPair, decodedJwt, zkProof, maxEpoch } = signer;
         if (!suiAddress ||
             !ephemeralKeyPair ||
@@ -114,7 +114,7 @@ export class ZingClient {
             suiClient: this.suiJsonRpcClient,
         });
         const message = sessionKey.getPersonalMessage();
-        const { zkLoginSignature } = await signPersonalMessage(signer, message);
+        const { zkLoginSignature } = await signPersonalMessage(saltServerUrl, signer, message);
         sessionKey.setPersonalMessageSignature(zkLoginSignature);
         return sessionKey;
     }

package/dist/components/wallet-provider.d.ts

@@ -1,6 +1,6 @@
 import type { WalletStore, WalletStoreConfig } from "../stores/walletStore.js";
 import type { PropsWithChildren } from "react";
-export declare function WalletProvider({ suiClient, oAuthClientId, network, autoInit, children, }: PropsWithChildren<WalletStoreConfig & {
+export declare function WalletProvider({ suiClient, oAuthClientId, network, saltServerUrl, autoInit, children, }: PropsWithChildren<WalletStoreConfig & {
     network?: string;
     autoInit?: boolean;
 }>): import("react/jsx-runtime").JSX.Element;

package/dist/components/wallet-provider.js

@@ -4,13 +4,14 @@ import { createWalletStore } from "../stores/walletStore.js";
 import { createContext, useContext, useRef, useEffect } from "react";
 import { useStore } from "zustand";
 const WalletContext = createContext(null);
-export function WalletProvider({ suiClient, oAuthClientId, network, autoInit = true, children, }) {
+export function WalletProvider({ suiClient, oAuthClientId, network, saltServerUrl, autoInit = true, children, }) {
     const storeRef = useRef(null);
     if (!storeRef.current) {
         storeRef.current = createWalletStore({
             suiClient,
             oAuthClientId,
             network,
+            saltServerUrl,
             autoInit,
         });
     }

package/dist/components/walrus-provider.d.ts

@@ -22,7 +22,7 @@ export declare function useWalrusUpload(): (zingClient: ZingClient, fileKey: Cry
         "content-type": string;
     };
     size: number;
-}[], signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void) => Promise<typeof PublishArticleEvent.$inferType>;
+}[], saltServerUrl: string, signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void) => Promise<typeof PublishArticleEvent.$inferType>;
 export declare function useWalrusQuiltSize(): (walrusSystem: WalrusSystemState, files: Array<{
     size: number;
     identifier: string;

package/dist/components/walrus-provider.js

@@ -27,7 +27,7 @@ export const WalrusProvider = ({ walrusClient, sealClient, children, autoInit =
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [store]);
-    const uploadFile = useCallback(async (zingClient, fileKey, walrusSystem, walTreasury, storageByEpoch, walrusFiles, subscriptionLevel, metadata, signer, onProgress) => {
+    const uploadFile = useCallback(async (zingClient, fileKey, walrusSystem, walTreasury, storageByEpoch, walrusFiles, subscriptionLevel, metadata, saltServerUrl, signer, onProgress) => {
         const config = zingClient.config;
         return uploadFileToWalrus({
             zingStudioPackageId: config.zing.ZING_STUDIO_PACKAGE_ADDRESS,
@@ -38,7 +38,7 @@ export const WalrusProvider = ({ walrusClient, sealClient, children, autoInit =
             zingStorageTreasurySharedObjectRef: config.zing.ZING_STORAGE_TREASURY_SHARED_OBJECT_REF,
             blobRegisteredEventType: config.walrus.EVENT_TYPES.blobRegistered,
             publishArticleEventType: config.zing.EVENT_TYPES.publishArticleEvent,
-        }, zingClient.suiGrpcClient, zingClient.suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, onProgress);
+        }, zingClient.suiGrpcClient, zingClient.suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, saltServerUrl, signer, onProgress);
     }, [walrusClient]);
     const calculateQuiltSize = useCallback((walrusSystem, files, ivSize = 12) => {
         const numShards = walrusSystem.committee.n_shards;

package/dist/getters.d.ts

@@ -261,6 +261,7 @@ export declare function getPublishedArticleAndBlobId(suiGrpcClient: SuiGrpcClien
     parsedPublishArticleEvent: {
         article_id: string;
         owner: string;
+        subscription_level: number | null;
         blob_ids: string[];
         blob_sizes: string[];
         blob_storage_sizes: string[];

package/dist/getters.js

@@ -1,6 +1,6 @@
 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 { Article, PublishArticleEventV1, } 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";
@@ -280,7 +280,7 @@ export async function getPublishedArticleAndBlobId(suiGrpcClient, suiClient, wal
         throw new Error("fail to get publishArticleEvent");
     }
     const blobObjectId = BlobRegistered.parse(blobRegisteredEvent.contents?.value).object_id;
-    const parsedPublishArticleEvent = PublishArticleEvent.parse(publishArticleEvent.contents.value);
+    const parsedPublishArticleEvent = PublishArticleEventV1.parse(publishArticleEvent.contents.value);
     return { parsedPublishArticleEvent, blobObjectId };
 }
 export function encodeQuiltPatchId(id) {

package/dist/hooks/useSignAndExecuteTransaction.js

@@ -5,6 +5,7 @@ const GAS_POOL_OWNER = "0x3198c7da350bf15c48fc598e5b03a0b6e13356801c71b4d1a18b92
 export const useSignAndExecuteTransaction = () => {
     const getSigner = useWalletStore((s) => s.getSigner);
     const suiClient = useWalletStore((s) => s.suiClient);
+    const saltServerUrl = useWalletStore((s) => s.saltServerUrl);
     return useMutation({
         mutationFn: async ({ transaction }) => {
             const signer = getSigner();
@@ -22,7 +23,7 @@ export const useSignAndExecuteTransaction = () => {
             });
             console.log({ dryRunResponse });
             if (dryRunResponse.effects.status.status === "success") {
-                const effects = await signAndExecuteGasPoolTransaction(signer, suiClient, transaction);
+                const effects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiClient, transaction);
                 // TODO: handle error message by code
                 if (!effects)
                     throw new Error("fail to get Transaction Effects");

package/dist/hooks/useSignPersonalMessage.js

@@ -3,6 +3,7 @@ import { signPersonalMessage } from "../mutations/signer.js";
 import { useMutation } from "@tanstack/react-query";
 export const useSignPersonalMessage = () => {
     const getSigner = useWalletStore((s) => s.getSigner);
+    const saltServerUrl = useWalletStore((s) => s.saltServerUrl);
     return useMutation({
         mutationFn: async ({ message }) => {
             const signer = getSigner();
@@ -12,7 +13,7 @@ export const useSignPersonalMessage = () => {
             if (!signer.suiAddress) {
                 throw new Error("Signer suiAddress not properly initialized");
             }
-            return await signPersonalMessage(signer, message);
+            return await signPersonalMessage(saltServerUrl, signer, message);
         },
         onError: (error) => {
             console.error("Sign Personal Message failed:", error);

package/dist/mutations/signer.d.ts

@@ -2,9 +2,9 @@ import type { ZkLoginProofParams, ZkLoginProofResponse, ZKLoginSignerState } fro
 import type { SuiClient } from "@mysten/sui/client";
 import type { Transaction } from "@mysten/sui/transactions";
 export declare function getSigner(suiClient: SuiClient): Promise<ZKLoginSignerState>;
-export declare function signAndExecuteGasPoolTransaction(signer: ZKLoginSignerState, suiClient: SuiClient, tx: Transaction, gasBudget?: number, reserveDurationSecs?: number): Promise<any>;
-export declare function signPersonalMessage(signer: ZKLoginSignerState, message: Uint8Array): Promise<{
+export declare function signAndExecuteGasPoolTransaction(saltServerUrl: string, signer: ZKLoginSignerState, suiClient: SuiClient, tx: Transaction, gasBudget?: number, reserveDurationSecs?: number): Promise<any>;
+export declare function signPersonalMessage(saltServerUrl: string, signer: ZKLoginSignerState, message: Uint8Array): Promise<{
     zkLoginSignature: any;
     bytes: Uint8Array<ArrayBuffer>;
 }>;
-export declare function createZkLoginProof(params: ZkLoginProofParams): Promise<ZkLoginProofResponse>;
+export declare function createZkLoginProof(saltServerUrl: string, params: ZkLoginProofParams): Promise<ZkLoginProofResponse>;

package/dist/mutations/signer.js

@@ -2,8 +2,6 @@ import { zkloginStorage } from "../stores/zkloginStore.js";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { fromBase64 } from "@mysten/sui/utils";
 import { decodeJwt } from "@mysten/sui/zklogin";
-const SALT_SERVER_BASE_URL = "https://salt-server-production.up.railway.app";
-// "http://localhost:3001";
 export async function getSigner(suiClient) {
     const zkLoginStorage = await zkloginStorage.getState();
     const { epoch: currentEpoch } = await suiClient.getLatestSuiSystemState();
@@ -39,7 +37,7 @@ export async function getSigner(suiClient) {
         maxEpoch: zkLoginStorage.maxEpoch,
     };
 }
-export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, gasBudget = 0.1 * 10 ** 9, reserveDurationSecs = 30) {
+export async function signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiClient, tx, gasBudget = 0.1 * 10 ** 9, reserveDurationSecs = 30) {
     const { ephemeralKeyPair, suiAddress, decodedJwt, zkProof, maxEpoch, jwtTokenString, } = signer;
     if (!ephemeralKeyPair || !suiAddress || !decodedJwt || !zkProof || !maxEpoch)
         return;
@@ -48,7 +46,7 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
             throw new Error("JWT claims (sub, iss, aud) not found");
         }
         // Step 1: Request gas reservation from server
-        const prepareResponse = await fetch(`${SALT_SERVER_BASE_URL}/prepare_tx`, {
+        const prepareResponse = await fetch(`${saltServerUrl}/prepare_tx`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${jwtTokenString}`,
@@ -77,7 +75,7 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
             signer: ephemeralKeyPair,
         });
         // Step 5: Send to server for zkLogin signature generation and execution
-        const executeResponse = await fetch(`${SALT_SERVER_BASE_URL}/execute_tx`, {
+        const executeResponse = await fetch(`${saltServerUrl}/execute_tx`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${jwtTokenString}`,
@@ -105,7 +103,7 @@ export async function signAndExecuteGasPoolTransaction(signer, suiClient, tx, ga
         throw error;
     }
 }
-export async function signPersonalMessage(signer, message) {
+export async function signPersonalMessage(saltServerUrl, signer, message) {
     const { ephemeralKeyPair, decodedJwt, zkProof, maxEpoch, jwtTokenString } = signer;
     if (!ephemeralKeyPair || !decodedJwt || !zkProof || !maxEpoch) {
         throw new Error("Missing required params");
@@ -117,7 +115,7 @@ export async function signPersonalMessage(signer, message) {
         // Sign message with ephemeral key
         const { bytes, signature } = await ephemeralKeyPair.signPersonalMessage(message);
         // Convert bytes to base64 for transmission
-        const response = await fetch(`${SALT_SERVER_BASE_URL}/sign_personal_message`, {
+        const response = await fetch(`${saltServerUrl}/sign_personal_message`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${jwtTokenString}`,
@@ -148,9 +146,9 @@ export async function signPersonalMessage(signer, message) {
         throw error;
     }
 }
-export async function createZkLoginProof(params) {
+export async function createZkLoginProof(saltServerUrl, params) {
     try {
-        const response = await fetch(`${SALT_SERVER_BASE_URL}/zklogin-proof`, {
+        const response = await fetch(`${saltServerUrl}/zklogin-proof`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${params.jwtTokenString}`,

package/dist/mutations/walrus.d.ts

@@ -40,6 +40,7 @@ export declare const zingWriteFlow: (config: ZingWriteFlowConfig, suiGrpcClient:
     upload: (options: WriteFilesFlowUploadOptions) => Promise<{
         article_id: string;
         owner: string;
+        subscription_level: number | null;
         blob_ids: string[];
         blob_sizes: string[];
         blob_storage_sizes: string[];
@@ -69,7 +70,7 @@ export declare function uploadFileToWalrus(zingWriteFlowConfig: ZingWriteFlowCon
         "content-type": string;
     };
     size: number;
-}[], signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void): Promise<typeof PublishArticleEvent.$inferType>;
+}[], saltServerUrl: string, signer: ZKLoginSignerState, onProgress?: (stage: WalrusUploadFlowStage) => void): Promise<typeof PublishArticleEvent.$inferType>;
 export declare function downloadImagesFromMarkdown<T extends "blob" | "uint8array">(markdown: string, as?: T): Promise<{
     url: string;
     data: T extends "blob" ? Blob : Uint8Array;

package/dist/mutations/walrus.js

@@ -295,7 +295,7 @@ export const zingWriteFlow = (config, suiGrpcClient, suiJsonRpcClient, walrusCli
         listFiles: async () => listFiles(getResults("certify", "listFiles")),
     };
 };
-export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, signer, onProgress) {
+export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, suiJsonRpcClient, walrusClient, walrusSystem, walTreasury, storageByEpoch, fileKey, walrusFiles, subscriptionLevel, metadata, saltServerUrl, signer, onProgress) {
     const report = (stage) => {
         if (onProgress)
             onProgress(stage);
@@ -319,7 +319,7 @@ export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, sui
             owner,
             deletable: true,
         });
-        const registerTxEffects = await signAndExecuteGasPoolTransaction(signer, suiJsonRpcClient, registerTx);
+        const registerTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiJsonRpcClient, registerTx);
         if (!registerTxEffects?.transactionDigest)
             throw new Error("fail to execute register Blob transaction");
         const finalizedTransaction = await suiJsonRpcClient.waitForTransaction({
@@ -337,7 +337,7 @@ export async function uploadFileToWalrus(zingWriteFlowConfig, suiGrpcClient, sui
     async function handleCertify() {
         report("certify_blob");
         const certifyTx = flow.certify();
-        const certifyTxEffects = await signAndExecuteGasPoolTransaction(signer, suiJsonRpcClient, certifyTx);
+        const certifyTxEffects = await signAndExecuteGasPoolTransaction(saltServerUrl, signer, suiJsonRpcClient, certifyTx);
         if (!certifyTxEffects?.transactionDigest)
             throw new Error("fail to execute certify Blob transaction");
         await suiJsonRpcClient.waitForTransaction({

package/dist/stores/walletStore.d.ts

@@ -21,6 +21,7 @@ export interface WalletState {
     account: WalletAccount | null;
     error: string | null;
     network: string;
+    saltServerUrl: string;
     jwtTokenString: string | null;
     decodedJwt: ReturnType<typeof decodeJwt> | null;
     authProvider: AuthProvider | null;
@@ -42,6 +43,7 @@ export type WalletStore = WalletState & WalletActions;
 export type WalletStoreConfig = {
     suiClient: SuiClient;
     oAuthClientId: string;
+    saltServerUrl: string;
     network?: string;
     autoInit?: boolean;
 };

package/dist/stores/walletStore.js

@@ -15,6 +15,7 @@ export function createWalletStore(config) {
         account: null,
         error: null,
         network,
+        saltServerUrl: config.saltServerUrl,
         jwtTokenString: null,
         decodedJwt: null,
         authProvider: null,
@@ -114,7 +115,7 @@ export function createWalletStore(config) {
                 zkloginStorage.getState().setJWT(idToken);
                 zkloginStorage.getState().setMaxEpoch(maxEpoch);
                 const extendedEphemeralPublicKey = getExtendedEphemeralPublicKey(ephemeralKeyPair.getPublicKey());
-                const zkProofResponse = await createZkLoginProof({
+                const zkProofResponse = await createZkLoginProof(config.saltServerUrl, {
                     jwtTokenString: idToken,
                     maxEpoch: String(maxEpoch),
                     extendedEphemeralPublicKey,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@zing-protocol/zing-sdk",
   "sideEffects": false,
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {