@zing-protocol/zing-sdk 0.0.1 → 0.0.2

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

@@ -1,272 +0,0 @@
-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/walrus/events.ts

@@ -1,124 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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,
-      ),
-    });
-}