@waterx/sdk 2.1.0

package/dist/src/generated/waterx_credit/credit_registry.js

@@ -0,0 +1,658 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveTuple, MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as vec_set from "./deps/sui/vec_set.js";
+import * as limited_supply from "./limited_supply.js";
+import * as table from "./deps/sui/table.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as type_name from "./deps/std/type_name.js";
+import * as vec_set_1 from "./deps/sui/vec_set.js";
+const $moduleName = '@waterx/credit::credit_registry';
+export const CapKey = new MoveTuple({ name: `${$moduleName}::CapKey`, fields: [bcs.bool()] });
+export const Mint = new MoveStruct({ name: `${$moduleName}::Mint<phantom CREDIT, phantom M>`, fields: {
+        amount: bcs.u64(),
+        module_supply: bcs.u64(),
+        total_supply: bcs.u64()
+    } });
+export const Burn = new MoveStruct({ name: `${$moduleName}::Burn<phantom CREDIT, phantom M>`, fields: {
+        amount: bcs.u64(),
+        module_supply: bcs.u64(),
+        total_supply: bcs.u64()
+    } });
+export const ProtocolCapBasisRefreshed = new MoveStruct({ name: `${$moduleName}::ProtocolCapBasisRefreshed<phantom CREDIT>`, fields: {
+        cap_basis_supply: bcs.u64(),
+        last_refresh_ms: bcs.u64()
+    } });
+export const CollectFee = new MoveStruct({ name: `${$moduleName}::CollectFee<phantom CREDIT, phantom M>`, fields: {
+        memo: bcs.string(),
+        coin_type: bcs.string(),
+        amount: bcs.u64()
+    } });
+export const ClaimFee = new MoveStruct({ name: `${$moduleName}::ClaimFee<phantom CREDIT, phantom M>`, fields: {
+        coin_type: bcs.string(),
+        amount: bcs.u64()
+    } });
+export const ModuleConfig = new MoveStruct({ name: `${$moduleName}::ModuleConfig`, fields: {
+        valid_versions: vec_set.VecSet(bcs.u16()),
+        limited_supply: limited_supply.LimitedSupply
+    } });
+export const BurnWindow = new MoveStruct({ name: `${$moduleName}::BurnWindow`, fields: {
+        burned: bcs.u64(),
+        window_start_ms: bcs.u64()
+    } });
+export const PersonalBurnCap = new MoveStruct({ name: `${$moduleName}::PersonalBurnCap`, fields: {
+        cap_amount: bcs.u64(),
+        window_ms: bcs.u64(),
+        user_burns: table.Table
+    } });
+export const ProtocolBurnCap = new MoveStruct({ name: `${$moduleName}::ProtocolBurnCap`, fields: {
+        cap_basis_supply: bcs.u64(),
+        cap_bps: bcs.u64(),
+        refresh_interval_ms: bcs.u64(),
+        last_refresh_ms: bcs.u64(),
+        burned_in_window: bcs.u64()
+    } });
+export const CreditRegistry = new MoveStruct({ name: `${$moduleName}::CreditRegistry<phantom CREDIT>`, fields: {
+        id: bcs.Address,
+        module_config_map: vec_map.VecMap(type_name.TypeName, ModuleConfig),
+        beneficiary_address: bcs.Address,
+        offset_supply: bcs.u64(),
+        personal_burn_cap: PersonalBurnCap,
+        protocol_burn_cap: ProtocolBurnCap,
+        /**
+         * Admin-managed package-version allowlist for the registry's own upgrade
+         * lifecycle. Distinct from `ModuleConfig.valid_versions` which tracks per-module
+         * witness versions. Every mutating public entry asserts
+         * `PACKAGE_VERSION ∈ allowed_versions`; admin uses `add_package_version` /
+         * `remove_package_version` to kill-switch a deprecated package after upgrade.
+         */
+        allowed_versions: vec_set_1.VecSet(bcs.u16())
+    } });
+export function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'package_version',
+    });
+}
+/**
+ * Wrap an existing `TreasuryCap<CREDIT>` into a shared `CreditRegistry<CREDIT>`.
+ * Caps default to disabled (cap_amount = 0, cap_bps = 0); admin opts in via
+ * `set_personal_burn_cap` / `set_protocol_burn_cap`.
+ */
+export function createCreditRegistry(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["_", "treasuryCap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'create_credit_registry',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === Admin === */
+export function setBeneficiaryAddress(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "_", "addr"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'set_beneficiary_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: whitelist a package version on this registry. Skips the version check
+ * itself so admin can recover from a stuck state.
+ */
+export function addPackageVersion(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'add_package_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: remove a package version from this registry's allowlist. Skips the
+ * version check itself.
+ */
+export function removePackageVersion(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'remove_package_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Personal cap = max amount of `CREDIT` a single sender can burn within
+ * `window_ms`. `cap_amount = 0` disables (default). `window_ms` must be > 0 even
+ * when disabled — `window_ms = 0` would reset the accumulator every burn and
+ * silently degrade the cap to per-tx only.
+ */
+export function setPersonalBurnCap(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["registry", "_", "capAmount", "windowMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'set_personal_burn_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Protocol cap = `cap_basis_supply * cap_bps / 10_000`. `cap_basis_supply` is
+ * refreshed lazily on burn after `refresh_interval_ms` has elapsed, so a sudden
+ * supply spike does not immediately raise the gate. `cap_bps = 0` disables
+ * (default).
+ *
+ * `cap_bps` must be ≤ `BPS_DENOMINATOR` (≤100%); larger values would make the gate
+ * computation wrap silently on the final `as u64` cast. `refresh_interval_ms` must
+ * be > 0; otherwise the burned-in-window accumulator resets on every burn and the
+ * rolling cap collapses to a per-tx ceiling.
+ */
+export function setProtocolBurnCap(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "_", "capBps", "refreshIntervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'set_protocol_burn_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Force-reset the protocol cap basis to current supply. Use sparingly (e.g. after
+ * legitimate large mint / burn events).
+ */
+export function refreshProtocolCapBasis(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'refresh_protocol_cap_basis',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Clear a single user's burn window (e.g. after manual review approves extra
+ * withdrawal).
+ */
+export function resetPersonalBurnWindow(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "_", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'reset_personal_burn_window',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function setSupplyLimit(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["registry", "_", "supplyLimit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'set_supply_limit',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addVersion(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'add_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeVersion(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'remove_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function removeModule(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'remove_module',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * === Mint / Burn === Mint `amount` of `CREDIT` on behalf of module `M`. `M` must
+ * be a registered owned module of this registry (via `add_version`) and `version`
+ * must be a whitelisted version of `M`. The `M: drop` witness proves the call site
+ * is inside `M`.
+ */
+export function mint(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[1]}`,
+        'u16',
+        'u64'
+    ];
+    const parameterNames = ["registry", "Witness", "version", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'mint',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Burn `coin` against module `M`'s supply limit. The personal burn cap is keyed by
+ * `account_id.to_address()` — the wxa Account whose stored `Balance<CREDIT>`
+ * produced this coin via the withdraw-policy flow. The deposit-before-withdraw
+ * property of the wxa custody layer means an attacker can't sidestep the
+ * per-account cap by minting fresh bucket-framework accounts at burn time (audit
+ * finding #2): to spread CREDIT across N accounts they'd need to deposit into
+ * each, and CREDIT can only enter an account through a mint that targets a
+ * specific `account_id` or a (capped) account-to-account withdraw + deposit round
+ * trip.
+ */
+export function burn(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        `${options.typeArguments[1]}`,
+        'u16',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["registry", "accountId", "witness", "version", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'burn',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === Fee collect / claim === */
+export function collect(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[2]}`,
+        'u16',
+        '0x1::string::String',
+        null
+    ];
+    const parameterNames = ["registry", "Witness", "version", "memo", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'collect',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drain the per-module `M` fee bucket for `T`. Gated by an `AccountRequest` whose
+ * address matches `registry.beneficiary_address` — so the beneficiary can claim
+ * their own fees without holding an `AdminCap`. Admin rotates the beneficiary via
+ * `set_beneficiary_address`.
+ */
+export function claim(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["registry", "request"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'claim',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** === Views === */
+export function totalSupply(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'total_supply',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function moduleConfigMap(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'module_config_map',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function limitedSupply(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'limited_supply',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function validVersions(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["config"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'valid_versions',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function beneficiaryAddress(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'beneficiary_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function offsetSupply(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'offset_supply',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function personalBurnCapAmount(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'personal_burn_cap_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function personalBurnCapWindowMs(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'personal_burn_cap_window_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function personalBurned(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["registry", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'personal_burned',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function personalBurnWindowCount(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'personal_burn_window_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolCapBasisSupply(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'protocol_cap_basis_supply',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolCapBps(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'protocol_cap_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolCapRefreshIntervalMs(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'protocol_cap_refresh_interval_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolCapLastRefreshMs(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'protocol_cap_last_refresh_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function protocolCapBurnedInWindow(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'protocol_cap_burned_in_window',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function isClaimableMapExistsType(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'is_claimable_map_exists_type',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function claimableMap(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'claimable_map',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function assertValidModuleVersion(options) {
+    const packageAddress = options.package ?? '@waterx/credit';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "version"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'credit_registry',
+        function: 'assert_valid_module_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/dist/src/generated/waterx_credit/deps/std/type_name.d.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const TypeName: MoveStruct<{
+    /**
+       * String representation of the type. All types are represented using their source
+       * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+       * Struct types are represented as fully qualified type names; e.g.
+       * `00000000000000000000000000000001::string::String` or
+       * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+       * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+       * 32 depending on the Move platform)
+       */
+    name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+}, "std::type_name::TypeName">;

package/dist/src/generated/waterx_credit/deps/std/type_name.js

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+        /**
+           * String representation of the type. All types are represented using their source
+           * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+           * Struct types are represented as fully qualified type names; e.g.
+           * `00000000000000000000000000000001::string::String` or
+           * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+           * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+           * 32 depending on the Move platform)
+           */
+        name: bcs.string()
+    } });