@zing-protocol/zing-sdk 0.0.1

package/src/_generated/zing_studio/deps/sui/dynamic_field.ts

@@ -0,0 +1,272 @@
+import * as object from "./object.js";
+import { MoveStruct, normalizeMoveArguments } from "../../../utils/index.js";
+import type { RawTransactionArgument } from "../../../utils/index.js";
+import type { BcsType } from "@mysten/sui/bcs";
+import type { Transaction } from "@mysten/sui/transactions";
+
+const $moduleName = "@local-pkg/suiii::dynamic_field";
+/** Internal object used for storing the field and value */
+export function Field<Name extends BcsType<any>, Value extends BcsType<any>>(
+  ...typeParameters: [Name, Value]
+) {
+  return new MoveStruct({
+    name: `${$moduleName}::Field<${typeParameters[0].name as Name["name"]}, ${typeParameters[1].name as Value["name"]}>`,
+    fields: {
+      /**
+       * Determined by the hash of the object ID, the field name value and it's type,
+       * i.e. hash(parent.id || name || Name)
+       */
+      id: object.UID,
+      /** The value for the name of this field */
+      name: typeParameters[0],
+      /** The value bound to this field */
+      value: typeParameters[1],
+    },
+  });
+}
+export interface BorrowArguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface BorrowOptions<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | BorrowArguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Immutably borrows the `object`s dynamic field with the name specified by
+ * `name: Name`. Aborts with `EFieldDoesNotExist` if the object does not have a
+ * field with that name. Aborts with `EFieldTypeMismatch` if the field exists, but
+ * the value does not have the specified type.
+ */
+export function borrow<Name extends BcsType<any>>(
+  options: BorrowOptions<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "borrow",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface BorrowMutArguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface BorrowMutOptions<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | BorrowMutArguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the `object`s dynamic field with the name specified by
+ * `name: Name`. Aborts with `EFieldDoesNotExist` if the object does not have a
+ * field with that name. Aborts with `EFieldTypeMismatch` if the field exists, but
+ * the value does not have the specified type.
+ */
+export function borrowMut<Name extends BcsType<any>>(
+  options: BorrowMutOptions<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "borrow_mut",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface RemoveArguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface RemoveOptions<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | RemoveArguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Removes the `object`s dynamic field with the name specified by `name: Name` and
+ * returns the bound value. Aborts with `EFieldDoesNotExist` if the object does not
+ * have a field with that name. Aborts with `EFieldTypeMismatch` if the field
+ * exists, but the value does not have the specified type.
+ */
+export function remove<Name extends BcsType<any>>(
+  options: RemoveOptions<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "remove",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface Exists_Arguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface Exists_Options<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | Exists_Arguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string];
+}
+/**
+ * Returns true if and only if the `object` has a dynamic field with the name
+ * specified by `name: Name` but without specifying the `Value` type
+ */
+export function exists_<Name extends BcsType<any>>(
+  options: Exists_Options<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "exists_",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface RemoveIfExistsArguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface RemoveIfExistsOptions<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | RemoveIfExistsArguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Removes the dynamic field if it exists. Returns the `some(Value)` if it exists
+ * or none otherwise.
+ */
+export function removeIfExists<Name extends BcsType<any>>(
+  options: RemoveIfExistsOptions<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "remove_if_exists",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}
+export interface ExistsWithTypeArguments<Name extends BcsType<any>> {
+  object: RawTransactionArgument<string>;
+  name: RawTransactionArgument<Name>;
+}
+export interface ExistsWithTypeOptions<Name extends BcsType<any>> {
+  package?: string;
+  arguments:
+    | ExistsWithTypeArguments<Name>
+    | [
+        object: RawTransactionArgument<string>,
+        name: RawTransactionArgument<Name>,
+      ];
+  typeArguments: [string, string];
+}
+/**
+ * Returns true if and only if the `object` has a dynamic field with the name
+ * specified by `name: Name` with an assigned value of type `Value`.
+ */
+export function existsWithType<Name extends BcsType<any>>(
+  options: ExistsWithTypeOptions<Name>,
+) {
+  const packageAddress = options.package ?? "@local-pkg/suiii";
+  const argumentsTypes = [
+    "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+    `${options.typeArguments[0]}`,
+  ] satisfies string[];
+  const parameterNames = ["object", "name"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "dynamic_field",
+      function: "exists_with_type",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+      typeArguments: options.typeArguments,
+    });
+}

package/src/_generated/zing_studio/deps/sui/object.ts

@@ -0,0 +1,16 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/** Sui object identifiers */
+
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::object";
+export const UID = new MoveStruct({
+  name: `${$moduleName}::UID`,
+  fields: {
+    id: bcs.Address,
+  },
+});

package/src/_generated/zing_studio/deps/sui/table.ts

@@ -0,0 +1,38 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+
+/**
+ * A table is a map-like collection. But unlike a traditional collection, it's keys
+ * and values are not stored within the `Table` value, but instead are stored using
+ * Sui's object system. The `Table` struct acts only as a handle into the object
+ * system to retrieve those keys and values. Note that this means that `Table`
+ * values with exactly the same key-value mapping will not be equal, with `==`, at
+ * runtime. For example
+ *
+ * ```
+ * let table1 = table::new<u64, bool>();
+ * let table2 = table::new<u64, bool>();
+ * table::add(&mut table1, 0, false);
+ * table::add(&mut table1, 1, true);
+ * table::add(&mut table2, 0, false);
+ * table::add(&mut table2, 1, true);
+ * // table1 does not equal table2, despite having the same entries
+ * assert!(&table1 != &table2);
+ * ```
+ */
+
+import * as object from "./object.js";
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::table";
+export const Table = new MoveStruct({
+  name: `${$moduleName}::Table`,
+  fields: {
+    /** the ID of this table */
+    id: object.UID,
+    /** the number of key-value pairs in the table */
+    size: bcs.u64(),
+  },
+});

package/src/_generated/zing_studio/deps/sui/vec_map.ts

@@ -0,0 +1,39 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { BcsType } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::vec_map";
+/** An entry in the map */
+export function Entry<K extends BcsType<any>, V extends BcsType<any>>(
+  ...typeParameters: [K, V]
+) {
+  return new MoveStruct({
+    name: `${$moduleName}::Entry<${typeParameters[0].name as K["name"]}, ${typeParameters[1].name as V["name"]}>`,
+    fields: {
+      key: typeParameters[0],
+      value: typeParameters[1],
+    },
+  });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap<K extends BcsType<any>, V extends BcsType<any>>(
+  ...typeParameters: [K, V]
+) {
+  return new MoveStruct({
+    name: `${$moduleName}::VecMap<${typeParameters[0].name as K["name"]}, ${typeParameters[1].name as V["name"]}>`,
+    fields: {
+      contents: bcs.vector(Entry(typeParameters[0], typeParameters[1])),
+    },
+  });
+}

package/src/_generated/zing_studio/deps/sui/vec_set.ts

@@ -0,0 +1,28 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+import type { BcsType } from "@mysten/sui/bcs";
+
+const $moduleName = "0x2::vec_set";
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet<K extends BcsType<any>>(
+  ...typeParameters: [K]
+): MoveStruct<{
+  contents: ReturnType<typeof bcs.vector<K>>;
+}> {
+  return new MoveStruct({
+    name: `${$moduleName}::VecSet<${typeParameters[0].name as K["name"]}>`,
+    fields: {
+      contents: bcs.vector(typeParameters[0]),
+    },
+  });
+}

package/src/_generated/zing_studio/deps/walrus/blob.ts

@@ -0,0 +1,22 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as storage_resource from "./storage_resource.js";
+import { MoveStruct } from "../../../utils/index.js";
+import * as object from "../sui/object.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "walrus::blob";
+export const Blob = new MoveStruct({
+  name: `${$moduleName}::Blob`,
+  fields: {
+    id: object.UID,
+    registered_epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+    size: bcs.u64(),
+    encoding_type: bcs.u8(),
+    certified_epoch: bcs.option(bcs.u32()),
+    storage: storage_resource.Storage,
+    deletable: bcs.bool(),
+  },
+});

package/src/_generated/zing_studio/deps/walrus/events.ts

@@ -0,0 +1,124 @@
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "@local-pkg/walrus::events";
+
+export const BlobRegistered = new MoveStruct({
+  name: `${$moduleName}::BlobRegistered`,
+  fields: {
+    epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+    size: bcs.u64(),
+    encoding_type: bcs.u8(),
+    end_epoch: bcs.u32(),
+    deletable: bcs.bool(),
+    object_id: bcs.Address,
+  },
+});
+export const BlobCertified = new MoveStruct({
+  name: `${$moduleName}::BlobCertified`,
+  fields: {
+    epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+    end_epoch: bcs.u32(),
+    deletable: bcs.bool(),
+    object_id: bcs.Address,
+    is_extension: bcs.bool(),
+  },
+});
+export const BlobDeleted = new MoveStruct({
+  name: `${$moduleName}::BlobDeleted`,
+  fields: {
+    epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+    end_epoch: bcs.u32(),
+    object_id: bcs.Address,
+    was_certified: bcs.bool(),
+  },
+});
+export const InvalidBlobID = new MoveStruct({
+  name: `${$moduleName}::InvalidBlobID`,
+  fields: {
+    epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+  },
+});
+export const EpochChangeStart = new MoveStruct({
+  name: `${$moduleName}::EpochChangeStart`,
+  fields: {
+    epoch: bcs.u32(),
+  },
+});
+export const EpochChangeDone = new MoveStruct({
+  name: `${$moduleName}::EpochChangeDone`,
+  fields: {
+    epoch: bcs.u32(),
+  },
+});
+export const ShardsReceived = new MoveStruct({
+  name: `${$moduleName}::ShardsReceived`,
+  fields: {
+    epoch: bcs.u32(),
+    shards: bcs.vector(bcs.u16()),
+  },
+});
+export const EpochParametersSelected = new MoveStruct({
+  name: `${$moduleName}::EpochParametersSelected`,
+  fields: {
+    next_epoch: bcs.u32(),
+  },
+});
+export const ShardRecoveryStart = new MoveStruct({
+  name: `${$moduleName}::ShardRecoveryStart`,
+  fields: {
+    epoch: bcs.u32(),
+    shards: bcs.vector(bcs.u16()),
+  },
+});
+export const ContractUpgraded = new MoveStruct({
+  name: `${$moduleName}::ContractUpgraded`,
+  fields: {
+    epoch: bcs.u32(),
+    package_id: bcs.Address,
+    version: bcs.u64(),
+  },
+});
+export const RegisterDenyListUpdate = new MoveStruct({
+  name: `${$moduleName}::RegisterDenyListUpdate`,
+  fields: {
+    epoch: bcs.u32(),
+    root: bcs.u256(),
+    sequence_number: bcs.u64(),
+    node_id: bcs.Address,
+  },
+});
+export const DenyListUpdate = new MoveStruct({
+  name: `${$moduleName}::DenyListUpdate`,
+  fields: {
+    epoch: bcs.u32(),
+    root: bcs.u256(),
+    sequence_number: bcs.u64(),
+    node_id: bcs.Address,
+  },
+});
+export const DenyListBlobDeleted = new MoveStruct({
+  name: `${$moduleName}::DenyListBlobDeleted`,
+  fields: {
+    epoch: bcs.u32(),
+    blob_id: bcs.u256(),
+  },
+});
+export const ContractUpgradeProposed = new MoveStruct({
+  name: `${$moduleName}::ContractUpgradeProposed`,
+  fields: {
+    epoch: bcs.u32(),
+    package_digest: bcs.vector(bcs.u8()),
+  },
+});
+export const ContractUpgradeQuorumReached = new MoveStruct({
+  name: `${$moduleName}::ContractUpgradeQuorumReached`,
+  fields: {
+    epoch: bcs.u32(),
+    package_digest: bcs.vector(bcs.u8()),
+  },
+});

package/src/_generated/zing_studio/deps/walrus/metadata.ts

@@ -0,0 +1,137 @@
+import { MoveStruct, normalizeMoveArguments } from "../../../utils/index.js";
+import * as vec_map from "../sui/vec_map.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/walrus::metadata";
+export const Metadata = new MoveStruct({
+  name: `${$moduleName}::Metadata`,
+  fields: {
+    metadata: vec_map.VecMap(bcs.string(), bcs.string()),
+  },
+});
+export interface NewOptions {
+  package?: string;
+  arguments?: [];
+}
+/** Creates a new instance of Metadata. */
+export function _new(options: NewOptions = {}) {
+  const packageAddress = options.package ?? "@local-pkg/walrus";
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "metadata",
+      function: "new",
+    });
+}
+export interface InsertOrUpdateArguments {
+  self: RawTransactionArgument<string>;
+  key: RawTransactionArgument<string>;
+  value: RawTransactionArgument<string>;
+}
+export interface InsertOrUpdateOptions {
+  package?: string;
+  arguments:
+    | InsertOrUpdateArguments
+    | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>,
+        value: RawTransactionArgument<string>,
+      ];
+}
+/**
+ * Inserts a key-value pair into the metadata.
+ *
+ * If the key is already present, the value is updated.
+ */
+export function insertOrUpdate(options: InsertOrUpdateOptions) {
+  const packageAddress = options.package ?? "@local-pkg/walrus";
+  const argumentsTypes = [
+    `${packageAddress}::metadata::Metadata`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+    "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+  ] satisfies string[];
+  const parameterNames = ["self", "key", "value"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "metadata",
+      function: "insert_or_update",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface RemoveArguments {
+  self: RawTransactionArgument<string>;
+  key: RawTransactionArgument<string>;
+}
+export interface RemoveOptions {
+  package?: string;
+  arguments:
+    | RemoveArguments
+    | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>,
+      ];
+}
+/** Removes the metadata associated with the given key. */
+export function remove(options: RemoveOptions) {
+  const packageAddress = options.package ?? "@local-pkg/walrus";
+  const argumentsTypes = [
+    `${packageAddress}::metadata::Metadata`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+  ] satisfies string[];
+  const parameterNames = ["self", "key"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "metadata",
+      function: "remove",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}
+export interface RemoveIfExistsArguments {
+  self: RawTransactionArgument<string>;
+  key: RawTransactionArgument<string>;
+}
+export interface RemoveIfExistsOptions {
+  package?: string;
+  arguments:
+    | RemoveIfExistsArguments
+    | [
+        self: RawTransactionArgument<string>,
+        key: RawTransactionArgument<string>,
+      ];
+}
+/**
+ * Removes the metadata associated with the given key, if it exists.
+ *
+ * Optionally returns the previous value associated with the key.
+ */
+export function removeIfExists(options: RemoveIfExistsOptions) {
+  const packageAddress = options.package ?? "@local-pkg/walrus";
+  const argumentsTypes = [
+    `${packageAddress}::metadata::Metadata`,
+    "0x0000000000000000000000000000000000000000000000000000000000000001::string::String",
+  ] satisfies string[];
+  const parameterNames = ["self", "key"];
+  return (tx: Transaction) =>
+    tx.moveCall({
+      package: packageAddress,
+      module: "metadata",
+      function: "remove_if_exists",
+      arguments: normalizeMoveArguments(
+        options.arguments,
+        argumentsTypes,
+        parameterNames,
+      ),
+    });
+}

package/src/_generated/zing_studio/deps/walrus/storage_resource.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct } from "../../../utils/index.js";
+import * as object from "../sui/object.js";
+import { bcs } from "@mysten/sui/bcs";
+
+const $moduleName = "walrus::storage_resource";
+export const Storage = new MoveStruct({
+  name: `${$moduleName}::Storage`,
+  fields: {
+    id: object.UID,
+    start_epoch: bcs.u32(),
+    end_epoch: bcs.u32(),
+    storage_size: bcs.u64(),
+  },
+});