@zing-protocol/zing-sdk 0.0.1 → 0.0.3

package/src/_generated/zing_studio/storage.ts

@@ -1,664 +0,0 @@
-/**************************************************************
- * 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";
-import type { RawTransactionArgument } from "../utils/index.js";
-import type { Transaction } from "@mysten/sui/transactions";
-
-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 interface TierPlanArguments {
-  self: RawTransactionArgument<string>;
-}
-export interface TierPlanOptions {
-  package?: string;
-  arguments: TierPlanArguments | [self: RawTransactionArgument<string>];
-}
-export function tierPlan(options: TierPlanOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-  ] satisfies string[];
-  const parameterNames = ["self"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier_plan",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface StoragesByEpochArguments {
-  self: RawTransactionArgument<string>;
-}
-export interface StoragesByEpochOptions {
-  package?: string;
-  arguments: StoragesByEpochArguments | [self: RawTransactionArgument<string>];
-}
-export function storagesByEpoch(options: StoragesByEpochOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-  ] satisfies string[];
-  const parameterNames = ["self"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "storages_by_epoch",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface WalTreasuryArguments {
-  self: RawTransactionArgument<string>;
-}
-export interface WalTreasuryOptions {
-  package?: string;
-  arguments: WalTreasuryArguments | [self: RawTransactionArgument<string>];
-}
-export function walTreasury(options: WalTreasuryOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-  ] satisfies string[];
-  const parameterNames = ["self"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "wal_treasury",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface TierPriceArguments {
-  tier: RawTransactionArgument<string>;
-}
-export interface TierPriceOptions {
-  package?: string;
-  arguments: TierPriceArguments | [tier: RawTransactionArgument<string>];
-}
-export function tierPrice(options: TierPriceOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTier`,
-  ] satisfies string[];
-  const parameterNames = ["tier"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier_price",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface TierDurationDaysArguments {
-  tier: RawTransactionArgument<string>;
-}
-export interface TierDurationDaysOptions {
-  package?: string;
-  arguments: TierDurationDaysArguments | [tier: RawTransactionArgument<string>];
-}
-export function tierDurationDays(options: TierDurationDaysOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTier`,
-  ] satisfies string[];
-  const parameterNames = ["tier"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier_duration_days",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface TierDurationArguments {
-  tier: RawTransactionArgument<string>;
-}
-export interface TierDurationOptions {
-  package?: string;
-  arguments: TierDurationArguments | [tier: RawTransactionArgument<string>];
-}
-export function tierDuration(options: TierDurationOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTier`,
-  ] satisfies string[];
-  const parameterNames = ["tier"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier_duration",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface TierStorageLimitArguments {
-  tier: RawTransactionArgument<string>;
-}
-export interface TierStorageLimitOptions {
-  package?: string;
-  arguments: TierStorageLimitArguments | [tier: RawTransactionArgument<string>];
-}
-export function tierStorageLimit(options: TierStorageLimitOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTier`,
-  ] satisfies string[];
-  const parameterNames = ["tier"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier_storage_limit",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface StorageLimitArguments {
-  self: RawTransactionArgument<string>;
-  storageSpace: RawTransactionArgument<string>;
-}
-export interface StorageLimitOptions {
-  package?: string;
-  arguments:
-    | StorageLimitArguments
-    | [
-        self: RawTransactionArgument<string>,
-        storageSpace: RawTransactionArgument<string>,
-      ];
-}
-export function storageLimit(options: StorageLimitOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["self", "storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "storage_limit",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface OwnerArguments {
-  storageSpace: RawTransactionArgument<string>;
-}
-export interface OwnerOptions {
-  package?: string;
-  arguments: OwnerArguments | [storageSpace: RawTransactionArgument<string>];
-}
-export function owner(options: OwnerOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "owner",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface TierArguments {
-  storageSpace: RawTransactionArgument<string>;
-}
-export interface TierOptions {
-  package?: string;
-  arguments: TierArguments | [storageSpace: RawTransactionArgument<string>];
-}
-export function tier(options: TierOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "tier",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function storageUsed(options: StorageUsedOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "storage_used",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface StorageUsedByEpochArguments {
-  storageSpace: RawTransactionArgument<string>;
-  epoch: RawTransactionArgument<number>;
-}
-export interface StorageUsedByEpochOptions {
-  package?: string;
-  arguments:
-    | StorageUsedByEpochArguments
-    | [
-        storageSpace: RawTransactionArgument<string>,
-        epoch: RawTransactionArgument<number>,
-      ];
-}
-export function storageUsedByEpoch(options: StorageUsedByEpochOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-    "u32",
-  ] satisfies string[];
-  const parameterNames = ["storageSpace", "epoch"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "storage_used_by_epoch",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface CreditsArguments {
-  storageSpace: RawTransactionArgument<string>;
-}
-export interface CreditsOptions {
-  package?: string;
-  arguments: CreditsArguments | [storageSpace: RawTransactionArgument<string>];
-}
-export function credits(options: CreditsOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "credits",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function remainingStorage(options: RemainingStorageOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::storage::StorageSpace`,
-    "u32",
-  ] satisfies string[];
-  const parameterNames = ["self", "storageSpace", "epoch"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "remaining_storage",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function updateTierPlan(options: UpdateTierPlanOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::admin::AdminCap`,
-    "u8",
-    "u64",
-    "u16",
-    "u64",
-  ] satisfies string[];
-  const parameterNames = [
-    "self",
-    "Cap",
-    "tierIndex",
-    "price",
-    "durationDays",
-    "storageLimit",
-  ];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "update_tier_plan",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function removeStorageByAdmin(options: RemoveStorageByAdminOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::system::System`,
-    `${packageAddress}::admin::AdminCap`,
-    "u32",
-    "u64",
-  ] satisfies string[];
-  const parameterNames = ["self", "walrusSystem", "Cap", "epoch", "splitSize"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "remove_storage_by_admin",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-export interface ShareStorageSpaceArguments {
-  storageSpace: RawTransactionArgument<string>;
-}
-export interface ShareStorageSpaceOptions {
-  package?: string;
-  arguments:
-    | ShareStorageSpaceArguments
-    | [storageSpace: RawTransactionArgument<string>];
-}
-export function shareStorageSpace(options: ShareStorageSpaceOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageSpace`,
-  ] satisfies string[];
-  const parameterNames = ["storageSpace"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "share_storage_space",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function fundWalTreasury(options: FundWalTreasuryOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::config::Config`,
-    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${packageAddress}::wal::WAL>`,
-  ] satisfies string[];
-  const parameterNames = ["self", "config", "coin"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "fund_wal_treasury",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}
-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 function addStorageToTreasury(options: AddStorageToTreasuryOptions) {
-  const packageAddress = options.package ?? "@local-pkg/zing_studio";
-  const argumentsTypes = [
-    `${packageAddress}::storage::StorageTreasury`,
-    `${packageAddress}::config::Config`,
-    `${packageAddress}::system::System`,
-    `${packageAddress}::storage_resource::Storage`,
-  ] satisfies string[];
-  const parameterNames = ["self", "config", "walrusSystem", "storage"];
-  return (tx: Transaction) =>
-    tx.moveCall({
-      package: packageAddress,
-      module: "storage",
-      function: "add_storage_to_treasury",
-      arguments: normalizeMoveArguments(
-        options.arguments,
-        argumentsTypes,
-        parameterNames,
-      ),
-    });
-}