@zing-protocol/zing-sdk 0.0.6 → 0.0.9

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

@@ -27,6 +27,12 @@ export declare const DeleteArticleEvent: MoveStruct<{
     current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
     timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::app::DeleteArticleEvent">;
+export declare const UpdateArticleSubscriptionLevelEvent: MoveStruct<{
+    article_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    prev_level: import("@mysten/sui/bcs").BcsType<number | null, number | null | undefined, "Option<u8>">;
+    new_level: import("@mysten/sui/bcs").BcsType<number | null, number | null | undefined, "Option<u8>">;
+}, "@local-pkg/zing_studio::app::UpdateArticleSubscriptionLevelEvent">;
 export declare const DonateEvent: MoveStruct<{
     recipient: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
     value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
@@ -169,9 +175,9 @@ export interface StartPublishArticleArguments {
     storageTreasury: RawTransactionArgument<string>;
     storageSpace: RawTransactionArgument<string>;
     subscriptionLevel: RawTransactionArgument<number | null>;
-    blobId: RawTransactionArgument<number | bigint>;
-    rootHash: RawTransactionArgument<number | bigint>;
-    unencodedBlobSize: RawTransactionArgument<number | bigint>;
+    blobIds: RawTransactionArgument<number | bigint[]>;
+    rootHashes: RawTransactionArgument<number | bigint[]>;
+    unencodedBlobSizes: RawTransactionArgument<number | bigint[]>;
     encodingType: RawTransactionArgument<number>;
     identifiers: RawTransactionArgument<string[]>;
     blobIndexes: RawTransactionArgument<number | bigint[]>;
@@ -187,9 +193,9 @@ export interface StartPublishArticleOptions {
         storageTreasury: RawTransactionArgument<string>,
         storageSpace: RawTransactionArgument<string>,
         subscriptionLevel: RawTransactionArgument<number | null>,
-        blobId: RawTransactionArgument<number | bigint>,
-        rootHash: RawTransactionArgument<number | bigint>,
-        unencodedBlobSize: RawTransactionArgument<number | bigint>,
+        blobIds: RawTransactionArgument<number | bigint[]>,
+        rootHashes: RawTransactionArgument<number | bigint[]>,
+        unencodedBlobSizes: RawTransactionArgument<number | bigint[]>,
         encodingType: RawTransactionArgument<number>,
         identifiers: RawTransactionArgument<string[]>,
         blobIndexes: RawTransactionArgument<number | bigint[]>,
@@ -349,3 +355,12 @@ export interface DonateOptions {
     typeArguments: [string];
 }
 export declare function donate(options: DonateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BurnOrKeepPositiveCoinArguments {
+    coin: RawTransactionArgument<string>;
+}
+export interface BurnOrKeepPositiveCoinOptions {
+    package?: string;
+    arguments: BurnOrKeepPositiveCoinArguments | [coin: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+export declare function burnOrKeepPositiveCoin(options: BurnOrKeepPositiveCoinOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/app.js

@@ -40,6 +40,15 @@ export const DeleteArticleEvent = new MoveStruct({
         timestamp_ms: bcs.u64(),
     },
 });
+export const UpdateArticleSubscriptionLevelEvent = new MoveStruct({
+    name: `${$moduleName}::UpdateArticleSubscriptionLevelEvent`,
+    fields: {
+        article_id: bcs.Address,
+        owner: bcs.Address,
+        prev_level: bcs.option(bcs.u8()),
+        new_level: bcs.option(bcs.u8()),
+    },
+});
 export const DonateEvent = new MoveStruct({
     name: `${$moduleName}::DonateEvent`,
     fields: {
@@ -224,9 +233,9 @@ export function startPublishArticle(options) {
         `${packageAddress}::storage::StorageTreasury`,
         `${packageAddress}::storage::StorageSpace`,
         "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u8>",
-        "u256",
-        "u256",
-        "u64",
+        "vector<u256>",
+        "vector<u256>",
+        "vector<u64>",
         "u8",
         "vector<0x0000000000000000000000000000000000000000000000000000000000000001::ascii::String>",
         "vector<u64>",
@@ -241,9 +250,9 @@ export function startPublishArticle(options) {
         "storageTreasury",
         "storageSpace",
         "subscriptionLevel",
-        "blobId",
-        "rootHash",
-        "unencodedBlobSize",
+        "blobIds",
+        "rootHashes",
+        "unencodedBlobSizes",
         "encodingType",
         "identifiers",
         "blobIndexes",
@@ -449,3 +458,17 @@ export function donate(options) {
         typeArguments: options.typeArguments,
     });
 }
+export function burnOrKeepPositiveCoin(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "app",
+        function: "burn_or_keep_positive_coin",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

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

@@ -8,15 +8,16 @@ export declare const ReferralCreatedEvent: MoveStruct<{
     referrer: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
     referee: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
     timestamp_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    expired_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::referral::ReferralCreatedEvent">;
 export declare const ReferralConfig: MoveStruct<{
+    /** 5% from total value (platform fee exclusvie) */
     share_percentage_bps: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
     program_duration: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
     max_cap: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::referral::ReferralConfig">;
 export declare const Referral: MoveStruct<{
-    /** total earning count the value without deducted fee */
-    total_earning: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    referrer_earning: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
     referrer: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
     expired_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::referral::Referral">;
@@ -114,14 +115,6 @@ export interface IsReferralExistsOptions {
     arguments: IsReferralExistsArguments | [studio: RawTransactionArgument<string>];
 }
 export declare function isReferralExists(options: IsReferralExistsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface TotalEarningArguments {
-    self: RawTransactionArgument<string>;
-}
-export interface TotalEarningOptions {
-    package?: string;
-    arguments: TotalEarningArguments | [self: RawTransactionArgument<string>];
-}
-export declare function totalEarning(options: TotalEarningOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface ReferrerArguments {
     self: RawTransactionArgument<string>;
 }
@@ -138,18 +131,14 @@ export interface ExpiredAtOptions {
     arguments: ExpiredAtArguments | [self: RawTransactionArgument<string>];
 }
 export declare function expiredAt(options: ExpiredAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
-export interface AddTotalEarningArguments {
+export interface ReferrerEarningArguments {
     self: RawTransactionArgument<string>;
-    value: RawTransactionArgument<number | bigint>;
 }
-export interface AddTotalEarningOptions {
+export interface ReferrerEarningOptions {
     package?: string;
-    arguments: AddTotalEarningArguments | [
-        self: RawTransactionArgument<string>,
-        value: RawTransactionArgument<number | bigint>
-    ];
+    arguments: ReferrerEarningArguments | [self: RawTransactionArgument<string>];
 }
-export declare function addTotalEarning(options: AddTotalEarningOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export declare function referrerEarning(options: ReferrerEarningOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface AddReferralToStudioArguments {
     studio: RawTransactionArgument<string>;
     config: RawTransactionArgument<string>;

package/dist/_generated/zing_studio/referral.js

@@ -10,11 +10,13 @@ export const ReferralCreatedEvent = new MoveStruct({
         referrer: bcs.Address,
         referee: bcs.Address,
         timestamp_ms: bcs.u64(),
+        expired_at: bcs.u64(),
     },
 });
 export const ReferralConfig = new MoveStruct({
     name: `${$moduleName}::ReferralConfig`,
     fields: {
+        /** 5% from total value (platform fee exclusvie) */
         share_percentage_bps: bcs.u64(),
         program_duration: bcs.u64(),
         max_cap: bcs.u64(),
@@ -23,8 +25,7 @@ export const ReferralConfig = new MoveStruct({
 export const Referral = new MoveStruct({
     name: `${$moduleName}::Referral`,
     fields: {
-        /** total earning count the value without deducted fee */
-        total_earning: bcs.u64(),
+        referrer_earning: bcs.u64(),
         referrer: bcs.Address,
         expired_at: bcs.u64(),
     },
@@ -153,19 +154,6 @@ export function isReferralExists(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export function totalEarning(options) {
-    const packageAddress = options.package ?? "@local-pkg/zing_studio";
-    const argumentsTypes = [
-        `${packageAddress}::referral::Referral`,
-    ];
-    const parameterNames = ["self"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: "referral",
-        function: "total_earning",
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
 export function referrer(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -192,17 +180,16 @@ export function expiredAt(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
-export function addTotalEarning(options) {
+export function referrerEarning(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
         `${packageAddress}::referral::Referral`,
-        "u64",
     ];
-    const parameterNames = ["self", "value"];
+    const parameterNames = ["self"];
     return (tx) => tx.moveCall({
         package: packageAddress,
         module: "referral",
-        function: "add_total_earning",
+        function: "referrer_earning",
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }

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

@@ -31,6 +31,10 @@ export declare const StorageTier: MoveStruct<{
     duration_days: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
     storage_limit: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::storage::StorageTier">;
+export declare const TreasuryUsageBudget: MoveStruct<{
+    duration: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    max_budget: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::TreasuryUsageBudget">;
 export declare const StorageTreasury: MoveStruct<{
     id: MoveStruct<{
         id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
@@ -83,6 +87,18 @@ export declare const StorageTreasury: MoveStruct<{
             length: number;
         }, string>;
     }, "0x2::vec_map::VecMap<u32, walrus::storage_resource::Storage>">;
+    /** allocated storage size is being used */
+    total_used_storage_size_by_epoch: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: string;
+        }[], Iterable<{
+            key: number;
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u32, u64>">;
     wal_treasury: MoveStruct<{
         id: MoveStruct<{
             id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
@@ -91,7 +107,28 @@ export declare const StorageTreasury: MoveStruct<{
             value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
         }, "0x2::balance::Balance">;
     }, "0x2::coin::Coin">;
+    wal_treasury_usage_budget: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: {
+                duration: string;
+                max_budget: string;
+            };
+        }[], Iterable<{
+            key: number;
+            value: {
+                duration: string | number | bigint;
+                max_budget: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u8, @local-pkg/zing_studio::storage::TreasuryUsageBudget>">;
 }, "@local-pkg/zing_studio::storage::StorageTreasury">;
+export declare const TreasuryUsage: MoveStruct<{
+    accumlataed_budget: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    start_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::TreasuryUsage">;
 export declare const StorageSpace: MoveStruct<{
     id: MoveStruct<{
         id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
@@ -112,7 +149,30 @@ export declare const StorageSpace: MoveStruct<{
         }, string>;
     }, "0x2::vec_map::VecMap<u32, u64>">;
     credits: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    treasury_usage: MoveStruct<{
+        accumlataed_budget: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        start_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "@local-pkg/zing_studio::storage::TreasuryUsage">;
 }, "@local-pkg/zing_studio::storage::StorageSpace">;
+export declare const UsageReceipt: MoveStruct<{
+    start_budget: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::UsageReceipt">;
+export interface TreasuryUsageDurationArguments {
+    treasuryUsageBudget: RawTransactionArgument<string>;
+}
+export interface TreasuryUsageDurationOptions {
+    package?: string;
+    arguments: TreasuryUsageDurationArguments | [treasuryUsageBudget: RawTransactionArgument<string>];
+}
+export declare function treasuryUsageDuration(options: TreasuryUsageDurationOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TreasuryUsageMaxBudgetArguments {
+    treasuryUsageBudget: RawTransactionArgument<string>;
+}
+export interface TreasuryUsageMaxBudgetOptions {
+    package?: string;
+    arguments: TreasuryUsageMaxBudgetArguments | [treasuryUsageBudget: RawTransactionArgument<string>];
+}
+export declare function treasuryUsageMaxBudget(options: TreasuryUsageMaxBudgetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface TierPlanArguments {
     self: RawTransactionArgument<string>;
 }
@@ -121,6 +181,14 @@ export interface TierPlanOptions {
     arguments: TierPlanArguments | [self: RawTransactionArgument<string>];
 }
 export declare function tierPlan(options: TierPlanOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TotalUsedStorageSizeByEpochArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TotalUsedStorageSizeByEpochOptions {
+    package?: string;
+    arguments: TotalUsedStorageSizeByEpochArguments | [self: RawTransactionArgument<string>];
+}
+export declare function totalUsedStorageSizeByEpoch(options: TotalUsedStorageSizeByEpochOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface StoragesByEpochArguments {
     self: RawTransactionArgument<string>;
 }
@@ -137,6 +205,14 @@ export interface WalTreasuryOptions {
     arguments: WalTreasuryArguments | [self: RawTransactionArgument<string>];
 }
 export declare function walTreasury(options: WalTreasuryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WalTreasuryUsageBudgetArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface WalTreasuryUsageBudgetOptions {
+    package?: string;
+    arguments: WalTreasuryUsageBudgetArguments | [self: RawTransactionArgument<string>];
+}
+export declare function walTreasuryUsageBudget(options: WalTreasuryUsageBudgetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface TierPriceArguments {
     tier: RawTransactionArgument<string>;
 }
@@ -169,6 +245,22 @@ export interface TierStorageLimitOptions {
     arguments: TierStorageLimitArguments | [tier: RawTransactionArgument<string>];
 }
 export declare function tierStorageLimit(options: TierStorageLimitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TreasuryUsageAccumulatedBudgetArguments {
+    treasuryUsage: RawTransactionArgument<string>;
+}
+export interface TreasuryUsageAccumulatedBudgetOptions {
+    package?: string;
+    arguments: TreasuryUsageAccumulatedBudgetArguments | [treasuryUsage: RawTransactionArgument<string>];
+}
+export declare function treasuryUsageAccumulatedBudget(options: TreasuryUsageAccumulatedBudgetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TreasuryUsageStartAtArguments {
+    treasuryUsage: RawTransactionArgument<string>;
+}
+export interface TreasuryUsageStartAtOptions {
+    package?: string;
+    arguments: TreasuryUsageStartAtArguments | [treasuryUsage: RawTransactionArgument<string>];
+}
+export declare function treasuryUsageStartAt(options: TreasuryUsageStartAtOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface StorageLimitArguments {
     self: RawTransactionArgument<string>;
     storageSpace: RawTransactionArgument<string>;
@@ -226,6 +318,14 @@ export interface CreditsOptions {
     arguments: CreditsArguments | [storageSpace: RawTransactionArgument<string>];
 }
 export declare function credits(options: CreditsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StorageSpaceTreasuryUsageArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface StorageSpaceTreasuryUsageOptions {
+    package?: string;
+    arguments: StorageSpaceTreasuryUsageArguments | [storageSpace: RawTransactionArgument<string>];
+}
+export declare function storageSpaceTreasuryUsage(options: StorageSpaceTreasuryUsageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface RemainingStorageArguments {
     self: RawTransactionArgument<string>;
     storageSpace: RawTransactionArgument<string>;
@@ -264,6 +364,24 @@ export interface UpdateTierPlanOptions {
     ];
 }
 export declare function updateTierPlan(options: UpdateTierPlanOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateWalTreasuryUsageBudgetArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    tierIndex: RawTransactionArgument<number>;
+    duration: RawTransactionArgument<number | bigint>;
+    maxBudget: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateWalTreasuryUsageBudgetOptions {
+    package?: string;
+    arguments: UpdateWalTreasuryUsageBudgetArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        tierIndex: RawTransactionArgument<number>,
+        duration: RawTransactionArgument<number | bigint>,
+        maxBudget: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function updateWalTreasuryUsageBudget(options: UpdateWalTreasuryUsageBudgetOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface RemoveStorageByAdminArguments {
     self: RawTransactionArgument<string>;
     walrusSystem: RawTransactionArgument<string>;

package/dist/_generated/zing_studio/storage.js

@@ -56,6 +56,13 @@ export const StorageTier = new MoveStruct({
         storage_limit: bcs.u64(),
     },
 });
+export const TreasuryUsageBudget = new MoveStruct({
+    name: `${$moduleName}::TreasuryUsageBudget`,
+    fields: {
+        duration: bcs.u64(),
+        max_budget: bcs.u64(),
+    },
+});
 export const StorageTreasury = new MoveStruct({
     name: `${$moduleName}::StorageTreasury`,
     fields: {
@@ -66,7 +73,17 @@ export const StorageTreasury = new MoveStruct({
          * have multiple storage resources that get fused together
          */
         storages_by_epoch: vec_map.VecMap(bcs.u32(), storage_resource.Storage),
+        /** allocated storage size is being used */
+        total_used_storage_size_by_epoch: vec_map.VecMap(bcs.u32(), bcs.u64()),
         wal_treasury: coin.Coin,
+        wal_treasury_usage_budget: vec_map.VecMap(bcs.u8(), TreasuryUsageBudget),
+    },
+});
+export const TreasuryUsage = new MoveStruct({
+    name: `${$moduleName}::TreasuryUsage`,
+    fields: {
+        accumlataed_budget: bcs.u64(),
+        start_at: bcs.u64(),
     },
 });
 export const StorageSpace = new MoveStruct({
@@ -79,8 +96,41 @@ export const StorageSpace = new MoveStruct({
         /** Maps epoch number to storage used in that epoch */
         storage_used: vec_map.VecMap(bcs.u32(), bcs.u64()),
         credits: bcs.u64(),
+        treasury_usage: TreasuryUsage,
     },
 });
+export const UsageReceipt = new MoveStruct({
+    name: `${$moduleName}::UsageReceipt`,
+    fields: {
+        start_budget: bcs.u64(),
+    },
+});
+export function treasuryUsageDuration(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::TreasuryUsageBudget`,
+    ];
+    const parameterNames = ["treasuryUsageBudget"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "treasury_usage_duration",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function treasuryUsageMaxBudget(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::TreasuryUsageBudget`,
+    ];
+    const parameterNames = ["treasuryUsageBudget"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "treasury_usage_max_budget",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function tierPlan(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -94,6 +144,19 @@ export function tierPlan(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function totalUsedStorageSizeByEpoch(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "total_used_storage_size_by_epoch",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function storagesByEpoch(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -120,6 +183,19 @@ export function walTreasury(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function walTreasuryUsageBudget(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "wal_treasury_usage_budget",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function tierPrice(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -172,6 +248,32 @@ export function tierStorageLimit(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function treasuryUsageAccumulatedBudget(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::TreasuryUsage`,
+    ];
+    const parameterNames = ["treasuryUsage"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "treasury_usage_accumulated_budget",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function treasuryUsageStartAt(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::TreasuryUsage`,
+    ];
+    const parameterNames = ["treasuryUsage"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "treasury_usage_start_at",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function storageLimit(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -253,6 +355,19 @@ export function credits(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function storageSpaceTreasuryUsage(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageSpace`,
+    ];
+    const parameterNames = ["storageSpace"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "storage_space_treasury_usage",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 /**
  * Calculates the remaining available storage capacity Returns 0 if already over
  * limit (defensive programming)
@@ -297,6 +412,23 @@ export function updateTierPlan(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function updateWalTreasuryUsageBudget(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::admin::AdminCap`,
+        "u8",
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["self", "Cap", "tierIndex", "duration", "maxBudget"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "update_wal_treasury_usage_budget",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 /**
  * Admin function to remove storage from treasury for a specific epoch Requires
  * AdminCap to ensure only authorized users can call this Returns the requested

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

@@ -48,11 +48,32 @@ export declare const Studio: MoveStruct<{
     encrypted_file_key: import("@mysten/sui/bcs").BcsType<number[] | null, (Iterable<number> & {
         length: number;
     }) | null | undefined, "Option<vector<u8>>">;
+    earnings: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: string;
+            value: string;
+        }[], Iterable<{
+            key: string;
+            value: string | number | bigint;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<string, u64>">;
 }, "@local-pkg/zing_studio::studio::Studio">;
 export declare const Member: MoveStruct<{
     level: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
     expired_at: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
 }, "@local-pkg/zing_studio::studio::Member">;
+export interface DonationEarningKeyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function donationEarningKey(options?: DonationEarningKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface MembershipSubscriptionEarningKeyOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function membershipSubscriptionEarningKey(options?: MembershipSubscriptionEarningKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface OwnerArguments {
     self: RawTransactionArgument<string>;
 }
@@ -110,6 +131,14 @@ export interface MonthlySubscriptionFeeOptions {
     arguments: MonthlySubscriptionFeeArguments | [self: RawTransactionArgument<string>];
 }
 export declare function monthlySubscriptionFee(options: MonthlySubscriptionFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface EarningsArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface EarningsOptions {
+    package?: string;
+    arguments: EarningsArguments | [self: RawTransactionArgument<string>];
+}
+export declare function earnings(options: EarningsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface MembershipArguments {
     self: RawTransactionArgument<string>;
 }
@@ -280,3 +309,11 @@ export interface ShareStudioOptions {
     arguments: ShareStudioArguments | [self: RawTransactionArgument<string>];
 }
 export declare function shareStudio(options: ShareStudioOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TotalEarningArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TotalEarningOptions {
+    package?: string;
+    arguments: TotalEarningArguments | [self: RawTransactionArgument<string>];
+}
+export declare function totalEarning(options: TotalEarningOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/studio.js

@@ -42,6 +42,7 @@ export const Studio = new MoveStruct({
         /** Bag containing the actual asset objects, indexed by their IDs */
         works: derived_object_bag.DerivedObjectBag,
         encrypted_file_key: bcs.option(bcs.vector(bcs.u8())),
+        earnings: vec_map.VecMap(bcs.string(), bcs.u64()),
     },
 });
 export const Member = new MoveStruct({
@@ -51,6 +52,22 @@ export const Member = new MoveStruct({
         expired_at: bcs.u64(),
     },
 });
+export function donationEarningKey(options = {}) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "donation_earning_key",
+    });
+}
+export function membershipSubscriptionEarningKey(options = {}) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "membership_subscription_earning_key",
+    });
+}
 /** Returns the owner address of this studio */
 export function owner(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
@@ -143,6 +160,19 @@ export function monthlySubscriptionFee(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function earnings(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "earnings",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
 export function membership(options) {
     const packageAddress = options.package ?? "@local-pkg/zing_studio";
     const argumentsTypes = [
@@ -358,3 +388,16 @@ export function shareStudio(options) {
         arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
     });
 }
+export function totalEarning(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::studio::Studio`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "studio",
+        function: "total_earning",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/client/index.d.ts

@@ -53,6 +53,12 @@ export declare class ZingClient {
             size: string;
         };
         encrypted_file_key: number[] | null;
+        earnings: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
     } | null>;
     getStorageSpace(owner: string): Promise<{
         id: {
@@ -67,6 +73,10 @@ export declare class ZingClient {
             }[];
         };
         credits: string;
+        treasury_usage: {
+            accumlataed_budget: string;
+            start_at: string;
+        };
     } | null>;
     getStorageTreasury(): Promise<{
         id: {
@@ -95,6 +105,12 @@ export declare class ZingClient {
                 };
             }[];
         };
+        total_used_storage_size_by_epoch: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
         wal_treasury: {
             id: {
                 id: string;
@@ -103,6 +119,15 @@ export declare class ZingClient {
                 value: string;
             };
         };
+        wal_treasury_usage_budget: {
+            contents: {
+                key: number;
+                value: {
+                    duration: string;
+                    max_budget: string;
+                };
+            }[];
+        };
     } | null>;
     getMember(owner: string, member: string): Promise<{
         level: number;

package/dist/config/testnet.js

@@ -1,8 +1,8 @@
 export const testnetZingConfig = {
     ZING_FRAMEWORK_PACKAGE_ADDRESS: "0xd851eb5b907b60aa5fd958dd74044d809c49ee60001cad621726f03ea138f943",
     ZING_IDENTITY_PACKAGE_ADDRESS: "0xaaf27a90890ac1efface4fbb22597e95829cbe6cbb771df02f0d2cc93f067c70",
-    ZING_STUDIO_PACKAGE_ADDRESS: "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa",
-    ZING_STUDIO_V0_PACKAGE_ADDRESS: "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa",
+    ZING_STUDIO_PACKAGE_ADDRESS: "0x3502955f106ee334653443005b37ebc6d1ddf7b9c704d39090263ae136ba599d",
+    ZING_STUDIO_V0_PACKAGE_ADDRESS: "0x3502955f106ee334653443005b37ebc6d1ddf7b9c704d39090263ae136ba599d",
     ZING_TREASURY_SHARED_OBJECT_REF: {
         objectId: "0xca56bc3982525decbd4b025d3d4ae4de07259d6efc187577bfc3ab212e20574f",
         initialSharedVersion: 645292716,
@@ -33,8 +33,8 @@ export const testnetZingConfig = {
         },
     },
     ZING_STUDIO_CONFIG_SHARED_OBJECT_REF: {
-        objectId: "0x4257dc4f3a3fe73e5f8d8c86c2233210876c35dc9b369f72d6aab0521733e57e",
-        initialSharedVersion: 723767900,
+        objectId: "0x0fff74127495094c4f8b0736a0bf4a0c8612e0a8c37342495d8aa00073d25c1e",
+        initialSharedVersion: 745941918,
         mutable: false,
     },
     ZING_STORAGE_TREASURY_SHARED_OBJECT_REF: {
@@ -43,10 +43,10 @@ export const testnetZingConfig = {
         mutable: true,
     },
     ZING_WORKS_TYPE: {
-        article: "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa::article::Article",
+        article: "0x3502955f106ee334653443005b37ebc6d1ddf7b9c704d39090263ae136ba599d::article::Article",
     },
     EVENT_TYPES: {
-        publishArticleEvent: "0x455bd1ba1afe47158c9155001f33b4069c9f008d091eef28f61c47c857bf60aa::article::PublishArticleEvent",
+        publishArticleEvent: "0x3502955f106ee334653443005b37ebc6d1ddf7b9c704d39090263ae136ba599d::article::PublishArticleEvent",
     },
 };
 export const testnetWalrusConfig = {

package/dist/getters.d.ts

@@ -44,6 +44,12 @@ export declare function getStudio(suiGrpcClient: SuiGrpcClient, studioId: string
         size: string;
     };
     encrypted_file_key: number[] | null;
+    earnings: {
+        contents: {
+            key: string;
+            value: string;
+        }[];
+    };
 } | null>;
 export declare function getStorageSpace(suiGrpcClient: SuiGrpcClient, storageSpaceId: string): Promise<{
     id: {
@@ -58,6 +64,10 @@ export declare function getStorageSpace(suiGrpcClient: SuiGrpcClient, storageSpa
         }[];
     };
     credits: string;
+    treasury_usage: {
+        accumlataed_budget: string;
+        start_at: string;
+    };
 } | null>;
 export declare function getStorageTreasury(suiGrpcClient: SuiGrpcClient, storageTreasuryId: string): Promise<{
     id: {
@@ -86,6 +96,12 @@ export declare function getStorageTreasury(suiGrpcClient: SuiGrpcClient, storage
             };
         }[];
     };
+    total_used_storage_size_by_epoch: {
+        contents: {
+            key: number;
+            value: string;
+        }[];
+    };
     wal_treasury: {
         id: {
             id: string;
@@ -94,6 +110,15 @@ export declare function getStorageTreasury(suiGrpcClient: SuiGrpcClient, storage
             value: string;
         };
     };
+    wal_treasury_usage_budget: {
+        contents: {
+            key: number;
+            value: {
+                duration: string;
+                max_budget: string;
+            };
+        }[];
+    };
 } | null>;
 export declare function getMember(suiGrpcClient: SuiGrpcClient, membershipTableId: string, member: string): Promise<{
     level: number;

package/dist/hooks/useGetStudio.d.ts

@@ -23,4 +23,10 @@ export declare function useGetStudio(suiAddress?: string): import("@tanstack/rea
         size: string;
     };
     encrypted_file_key: number[] | null;
+    earnings: {
+        contents: {
+            key: string;
+            value: string;
+        }[];
+    };
 } | null, Error>;

package/dist/hooks/useZingQueries.d.ts

@@ -31,6 +31,12 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             size: string;
         };
         encrypted_file_key: number[] | null;
+        earnings: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
     } | null>;
     getStorageSpace: (owner: string) => Promise<{
         id: {
@@ -45,6 +51,10 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             }[];
         };
         credits: string;
+        treasury_usage: {
+            accumlataed_budget: string;
+            start_at: string;
+        };
     } | null>;
     getStorageTreasury: () => Promise<{
         id: {
@@ -73,6 +83,12 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
                 };
             }[];
         };
+        total_used_storage_size_by_epoch: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
         wal_treasury: {
             id: {
                 id: string;
@@ -81,6 +97,15 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
                 value: string;
             };
         };
+        wal_treasury_usage_budget: {
+            contents: {
+                key: number;
+                value: {
+                    duration: string;
+                    max_budget: string;
+                };
+            }[];
+        };
     } | null>;
     getMember: (owner: string, member: string) => Promise<{
         level: number;

package/dist/hooks/useZingQuery.d.ts

@@ -32,6 +32,12 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             size: string;
         };
         encrypted_file_key: number[] | null;
+        earnings: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
     } | null>;
     getStorageSpace: (owner: string) => Promise<{
         id: {
@@ -46,6 +52,10 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
             }[];
         };
         credits: string;
+        treasury_usage: {
+            accumlataed_budget: string;
+            start_at: string;
+        };
     } | null>;
     getStorageTreasury: () => Promise<{
         id: {
@@ -74,6 +84,12 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
                 };
             }[];
         };
+        total_used_storage_size_by_epoch: {
+            contents: {
+                key: number;
+                value: string;
+            }[];
+        };
         wal_treasury: {
             id: {
                 id: string;
@@ -82,6 +98,15 @@ declare const zingQueryMethodMap: (zingClient: ZingClient) => {
                 value: string;
             };
         };
+        wal_treasury_usage_budget: {
+            contents: {
+                key: number;
+                value: {
+                    duration: string;
+                    max_budget: string;
+                };
+            }[];
+        };
     } | null>;
     getMember: (owner: string, member: string) => Promise<{
         level: number;

package/dist/mutations/signer.js

@@ -2,9 +2,8 @@ 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";
+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();

package/dist/mutations/walrus.js

@@ -42,9 +42,9 @@ export function buildPublishArticleTransaction(config, walrusSystem, walTreasury
                 storageTreasury: tx.sharedObjectRef(zingStorageTreasurySharedObjectRef),
                 storageSpace: tx.object(getDerivedStorageID(zingStudioConfigSharedObjectRef.objectId, owner)),
                 subscriptionLevel: tx.pure.option("u8", subscriptionLevel),
-                blobId: blobIdToInt(blobId),
-                rootHash: BigInt(bcs.u256().parse(rootHash)),
-                unencodedBlobSize: fileSize,
+                blobIds: [blobIdToInt(blobId)],
+                rootHashes: [BigInt(bcs.u256().parse(rootHash))],
+                unencodedBlobSizes: [BigInt(fileSize)],
                 encodingType: REDSTUFF_CODING_TYPE,
                 identifiers: tx.pure.vector("string", articleMetadata.map((m) => m.identifier)),
                 blobIndexes: tx.pure.vector("u64", articleMetadata.map(() => 0)),

package/dist/stores/walletStore.js

@@ -120,12 +120,12 @@ export function createWalletStore(config) {
                     extendedEphemeralPublicKey,
                     jwtRandomness: randomness,
                 });
-                if (!zkProofResponse?.result)
-                    throw new Error(`Failed to get zkProof: ${zkProofResponse.error}`);
-                zkloginStorage
-                    .getState()
-                    .setZKProof(JSON.stringify(zkProofResponse.result.zkProof));
-                const suiAddress = zkProofResponse.result.suiAddress;
+                if (!zkProofResponse || !zkProofResponse.zkProof) {
+                    throw new Error("Invalid response from proof server: Missing zkProof");
+                }
+                // 2. Access keys directly from the response (no .result nesting)
+                const { zkProof, suiAddress } = zkProofResponse;
+                zkloginStorage.getState().setZKProof(JSON.stringify(zkProof));
                 zkloginStorage.getState().setSuiAddress(suiAddress);
                 const account = { jwt: decoded };
                 set({
@@ -133,7 +133,7 @@ export function createWalletStore(config) {
                     decodedJwt: decoded,
                     ephemeralKeyPair,
                     suiAddress,
-                    zkProof: zkProofResponse.result.zkProof,
+                    zkProof,
                     maxEpoch,
                     account,
                     isConnected: true,
@@ -204,8 +204,6 @@ export function createWalletStore(config) {
                 const ephemeralKeyPair = Ed25519Keypair.fromSecretKey(fromBase64(stored.ephemeralSecretKey));
                 const decoded = decodeJwt(stored.jwt);
                 const zkProofParsed = JSON.parse(stored.zkProof);
-                console.log({ decodeJwt: decoded });
-                console.log({ zkProofParsed: zkProofParsed });
                 set({
                     jwtTokenString: stored.jwt,
                     decodedJwt: decoded,

package/dist/types.d.ts

@@ -81,15 +81,19 @@ export interface ZkLoginProofParams {
     jwtRandomness: string;
 }
 export interface ZkLoginProofResponse {
-    id: number;
-    result?: {
-        zkProof: PartialZkLoginSignature;
-        suiAddress: string;
-    };
-    error?: {
-        code: number;
-        message: string;
+    zkProof: {
+        proofPoints: {
+            a: string[];
+            b: string[][];
+            c: string[];
+        };
+        issBase64Details: {
+            value: string;
+            indexMod4: number;
+        };
+        headerBase64: string;
     };
+    suiAddress: string;
 }
 export interface TierPlan {
     name: string;

package/package.json

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