@zing-protocol/zing-sdk 0.0.1 → 0.0.2

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

@@ -0,0 +1,327 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const AddStorageEvent: MoveStruct<{
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    added_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    added_size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::AddStorageEvent">;
+export declare const RemoveStorageEvent: MoveStruct<{
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    removed_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    removed_size: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::RemoveStorageEvent">;
+export declare const AllocateStorageEvent: MoveStruct<{
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    start_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    end_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    size_per_epoch: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::AllocateStorageEvent">;
+export declare const DeallocateStorageEvent: MoveStruct<{
+    current_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    start_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    end_epoch: import("@mysten/sui/bcs").BcsType<number, number, "u32">;
+    size_per_epoch: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::DeallocateStorageEvent">;
+export declare const STORAGE: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/zing_studio::storage::STORAGE">;
+export declare const StorageTier: MoveStruct<{
+    price: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    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 StorageTreasury: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    tier_plan: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: {
+                price: string;
+                duration_days: number;
+                storage_limit: string;
+            };
+        }[], Iterable<{
+            key: number;
+            value: {
+                price: string | number | bigint;
+                duration_days: number;
+                storage_limit: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u8, @local-pkg/zing_studio::storage::StorageTier>">;
+    /**
+     * Maps epoch number to storage resources available for that epoch Each epoch can
+     * have multiple storage resources that get fused together
+     */
+    storages_by_epoch: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            key: number;
+            value: {
+                id: {
+                    id: string;
+                };
+                start_epoch: number;
+                end_epoch: number;
+                storage_size: string;
+            };
+        }[], Iterable<{
+            key: number;
+            value: {
+                id: {
+                    id: string | Uint8Array<ArrayBufferLike>;
+                };
+                start_epoch: number;
+                end_epoch: number;
+                storage_size: string | number | bigint;
+            };
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<u32, walrus::storage_resource::Storage>">;
+    wal_treasury: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        balance: MoveStruct<{
+            value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+        }, "0x2::balance::Balance">;
+    }, "0x2::coin::Coin">;
+}, "@local-pkg/zing_studio::storage::StorageTreasury">;
+export declare const StorageSpace: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    owner: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /** Storage tier that determines the storage limit and pricing */
+    tier: import("@mysten/sui/bcs").BcsType<number | null, number | null | undefined, "Option<u8>">;
+    /** Maps epoch number to storage used in that epoch */
+    storage_used: 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>">;
+    credits: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_studio::storage::StorageSpace">;
+export interface TierPlanArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface TierPlanOptions {
+    package?: string;
+    arguments: TierPlanArguments | [self: RawTransactionArgument<string>];
+}
+export declare function tierPlan(options: TierPlanOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StoragesByEpochArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface StoragesByEpochOptions {
+    package?: string;
+    arguments: StoragesByEpochArguments | [self: RawTransactionArgument<string>];
+}
+export declare function storagesByEpoch(options: StoragesByEpochOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface WalTreasuryArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface WalTreasuryOptions {
+    package?: string;
+    arguments: WalTreasuryArguments | [self: RawTransactionArgument<string>];
+}
+export declare function walTreasury(options: WalTreasuryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TierPriceArguments {
+    tier: RawTransactionArgument<string>;
+}
+export interface TierPriceOptions {
+    package?: string;
+    arguments: TierPriceArguments | [tier: RawTransactionArgument<string>];
+}
+export declare function tierPrice(options: TierPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TierDurationDaysArguments {
+    tier: RawTransactionArgument<string>;
+}
+export interface TierDurationDaysOptions {
+    package?: string;
+    arguments: TierDurationDaysArguments | [tier: RawTransactionArgument<string>];
+}
+export declare function tierDurationDays(options: TierDurationDaysOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TierDurationArguments {
+    tier: RawTransactionArgument<string>;
+}
+export interface TierDurationOptions {
+    package?: string;
+    arguments: TierDurationArguments | [tier: RawTransactionArgument<string>];
+}
+export declare function tierDuration(options: TierDurationOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TierStorageLimitArguments {
+    tier: RawTransactionArgument<string>;
+}
+export interface TierStorageLimitOptions {
+    package?: string;
+    arguments: TierStorageLimitArguments | [tier: RawTransactionArgument<string>];
+}
+export declare function tierStorageLimit(options: TierStorageLimitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StorageLimitArguments {
+    self: RawTransactionArgument<string>;
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface StorageLimitOptions {
+    package?: string;
+    arguments: StorageLimitArguments | [
+        self: RawTransactionArgument<string>,
+        storageSpace: RawTransactionArgument<string>
+    ];
+}
+export declare function storageLimit(options: StorageLimitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface OwnerArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface OwnerOptions {
+    package?: string;
+    arguments: OwnerArguments | [storageSpace: RawTransactionArgument<string>];
+}
+export declare function owner(options: OwnerOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface TierArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface TierOptions {
+    package?: string;
+    arguments: TierArguments | [storageSpace: RawTransactionArgument<string>];
+}
+export declare function tier(options: TierOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StorageUsedArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface StorageUsedOptions {
+    package?: string;
+    arguments: StorageUsedArguments | [storageSpace: RawTransactionArgument<string>];
+}
+/** Returns the storage limit for this storage space */
+export declare function storageUsed(options: StorageUsedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface StorageUsedByEpochArguments {
+    storageSpace: RawTransactionArgument<string>;
+    epoch: RawTransactionArgument<number>;
+}
+export interface StorageUsedByEpochOptions {
+    package?: string;
+    arguments: StorageUsedByEpochArguments | [
+        storageSpace: RawTransactionArgument<string>,
+        epoch: RawTransactionArgument<number>
+    ];
+}
+export declare function storageUsedByEpoch(options: StorageUsedByEpochOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreditsArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface CreditsOptions {
+    package?: string;
+    arguments: CreditsArguments | [storageSpace: RawTransactionArgument<string>];
+}
+export declare function credits(options: CreditsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemainingStorageArguments {
+    self: RawTransactionArgument<string>;
+    storageSpace: RawTransactionArgument<string>;
+    epoch: RawTransactionArgument<number>;
+}
+export interface RemainingStorageOptions {
+    package?: string;
+    arguments: RemainingStorageArguments | [
+        self: RawTransactionArgument<string>,
+        storageSpace: RawTransactionArgument<string>,
+        epoch: RawTransactionArgument<number>
+    ];
+}
+/**
+ * Calculates the remaining available storage capacity Returns 0 if already over
+ * limit (defensive programming)
+ */
+export declare function remainingStorage(options: RemainingStorageOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateTierPlanArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    tierIndex: RawTransactionArgument<number>;
+    price: RawTransactionArgument<number | bigint>;
+    durationDays: RawTransactionArgument<number>;
+    storageLimit: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateTierPlanOptions {
+    package?: string;
+    arguments: UpdateTierPlanArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        tierIndex: RawTransactionArgument<number>,
+        price: RawTransactionArgument<number | bigint>,
+        durationDays: RawTransactionArgument<number>,
+        storageLimit: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function updateTierPlan(options: UpdateTierPlanOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveStorageByAdminArguments {
+    self: RawTransactionArgument<string>;
+    walrusSystem: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    epoch: RawTransactionArgument<number>;
+    splitSize: RawTransactionArgument<number | bigint>;
+}
+export interface RemoveStorageByAdminOptions {
+    package?: string;
+    arguments: RemoveStorageByAdminArguments | [
+        self: RawTransactionArgument<string>,
+        walrusSystem: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        epoch: RawTransactionArgument<number>,
+        splitSize: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Admin function to remove storage from treasury for a specific epoch Requires
+ * AdminCap to ensure only authorized users can call this Returns the requested
+ * storage amount, splitting if necessary
+ */
+export declare function removeStorageByAdmin(options: RemoveStorageByAdminOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ShareStorageSpaceArguments {
+    storageSpace: RawTransactionArgument<string>;
+}
+export interface ShareStorageSpaceOptions {
+    package?: string;
+    arguments: ShareStorageSpaceArguments | [storageSpace: RawTransactionArgument<string>];
+}
+export declare function shareStorageSpace(options: ShareStorageSpaceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface FundWalTreasuryArguments {
+    self: RawTransactionArgument<string>;
+    config: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+}
+export interface FundWalTreasuryOptions {
+    package?: string;
+    arguments: FundWalTreasuryArguments | [
+        self: RawTransactionArgument<string>,
+        config: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>
+    ];
+}
+export declare function fundWalTreasury(options: FundWalTreasuryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddStorageToTreasuryArguments {
+    self: RawTransactionArgument<string>;
+    config: RawTransactionArgument<string>;
+    walrusSystem: RawTransactionArgument<string>;
+    storage: RawTransactionArgument<string>;
+}
+export interface AddStorageToTreasuryOptions {
+    package?: string;
+    arguments: AddStorageToTreasuryArguments | [
+        self: RawTransactionArgument<string>,
+        config: RawTransactionArgument<string>,
+        walrusSystem: RawTransactionArgument<string>,
+        storage: RawTransactionArgument<string>
+    ];
+}
+export declare function addStorageToTreasury(options: AddStorageToTreasuryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_studio/storage.js

@@ -0,0 +1,365 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as coin from "./deps/sui/coin.js";
+import * as object from "./deps/sui/object.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as storage_resource from "./deps/walrus/storage_resource.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_studio::storage";
+export const AddStorageEvent = new MoveStruct({
+    name: `${$moduleName}::AddStorageEvent`,
+    fields: {
+        current_epoch: bcs.u32(),
+        added_epoch: bcs.u32(),
+        added_size: bcs.u64(),
+    },
+});
+export const RemoveStorageEvent = new MoveStruct({
+    name: `${$moduleName}::RemoveStorageEvent`,
+    fields: {
+        current_epoch: bcs.u32(),
+        removed_epoch: bcs.u32(),
+        removed_size: bcs.u64(),
+    },
+});
+export const AllocateStorageEvent = new MoveStruct({
+    name: `${$moduleName}::AllocateStorageEvent`,
+    fields: {
+        current_epoch: bcs.u32(),
+        start_epoch: bcs.u32(),
+        end_epoch: bcs.u32(),
+        size_per_epoch: bcs.u64(),
+    },
+});
+export const DeallocateStorageEvent = new MoveStruct({
+    name: `${$moduleName}::DeallocateStorageEvent`,
+    fields: {
+        current_epoch: bcs.u32(),
+        start_epoch: bcs.u32(),
+        end_epoch: bcs.u32(),
+        size_per_epoch: bcs.u64(),
+    },
+});
+export const STORAGE = new MoveStruct({
+    name: `${$moduleName}::STORAGE`,
+    fields: {
+        dummy_field: bcs.bool(),
+    },
+});
+export const StorageTier = new MoveStruct({
+    name: `${$moduleName}::StorageTier`,
+    fields: {
+        price: bcs.u64(),
+        duration_days: bcs.u16(),
+        storage_limit: bcs.u64(),
+    },
+});
+export const StorageTreasury = new MoveStruct({
+    name: `${$moduleName}::StorageTreasury`,
+    fields: {
+        id: object.UID,
+        tier_plan: vec_map.VecMap(bcs.u8(), StorageTier),
+        /**
+         * Maps epoch number to storage resources available for that epoch Each epoch can
+         * have multiple storage resources that get fused together
+         */
+        storages_by_epoch: vec_map.VecMap(bcs.u32(), storage_resource.Storage),
+        wal_treasury: coin.Coin,
+    },
+});
+export const StorageSpace = new MoveStruct({
+    name: `${$moduleName}::StorageSpace`,
+    fields: {
+        id: object.UID,
+        owner: bcs.Address,
+        /** Storage tier that determines the storage limit and pricing */
+        tier: bcs.option(bcs.u8()),
+        /** Maps epoch number to storage used in that epoch */
+        storage_used: vec_map.VecMap(bcs.u32(), bcs.u64()),
+        credits: bcs.u64(),
+    },
+});
+export function tierPlan(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: "tier_plan",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function storagesByEpoch(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: "storages_by_epoch",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function walTreasury(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",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function tierPrice(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTier`,
+    ];
+    const parameterNames = ["tier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "tier_price",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function tierDurationDays(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTier`,
+    ];
+    const parameterNames = ["tier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "tier_duration_days",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function tierDuration(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTier`,
+    ];
+    const parameterNames = ["tier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "tier_duration",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function tierStorageLimit(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTier`,
+    ];
+    const parameterNames = ["tier"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "tier_storage_limit",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function storageLimit(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::storage::StorageSpace`,
+    ];
+    const parameterNames = ["self", "storageSpace"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "storage_limit",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function owner(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: "owner",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function tier(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: "tier",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns the storage limit for this storage space */
+export function storageUsed(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_used",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function storageUsedByEpoch(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageSpace`,
+        "u32",
+    ];
+    const parameterNames = ["storageSpace", "epoch"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "storage_used_by_epoch",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function credits(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: "credits",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Calculates the remaining available storage capacity Returns 0 if already over
+ * limit (defensive programming)
+ */
+export function remainingStorage(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::storage::StorageSpace`,
+        "u32",
+    ];
+    const parameterNames = ["self", "storageSpace", "epoch"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "remaining_storage",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function updateTierPlan(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::admin::AdminCap`,
+        "u8",
+        "u64",
+        "u16",
+        "u64",
+    ];
+    const parameterNames = [
+        "self",
+        "Cap",
+        "tierIndex",
+        "price",
+        "durationDays",
+        "storageLimit",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "update_tier_plan",
+        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
+ * storage amount, splitting if necessary
+ */
+export function removeStorageByAdmin(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::system::System`,
+        `${packageAddress}::admin::AdminCap`,
+        "u32",
+        "u64",
+    ];
+    const parameterNames = ["self", "walrusSystem", "Cap", "epoch", "splitSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "remove_storage_by_admin",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function shareStorageSpace(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: "share_storage_space",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function fundWalTreasury(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::config::Config`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::wal::WAL>`,
+    ];
+    const parameterNames = ["self", "config", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "fund_wal_treasury",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function addStorageToTreasury(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_studio";
+    const argumentsTypes = [
+        `${packageAddress}::storage::StorageTreasury`,
+        `${packageAddress}::config::Config`,
+        `${packageAddress}::system::System`,
+        `${packageAddress}::storage_resource::Storage`,
+    ];
+    const parameterNames = ["self", "config", "walrusSystem", "storage"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "storage",
+        function: "add_storage_to_treasury",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}