@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/_generated/zing_framework/derived_table.d.ts

@@ -0,0 +1,153 @@
+import { MoveStruct } 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";
+export declare const DerivedTable: MoveStruct<{
+    /** the ID of this table */
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** the number of key-value pairs in the table */
+    size: BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_framework::derived_table::DerivedTable">;
+export interface NewArguments<DerivedObjectKey extends BcsType<any>> {
+    parent: RawTransactionArgument<string>;
+    key: RawTransactionArgument<DerivedObjectKey>;
+}
+export interface NewOptions<DerivedObjectKey extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<DerivedObjectKey> | [
+        parent: RawTransactionArgument<string>,
+        key: RawTransactionArgument<DerivedObjectKey>
+    ];
+    typeArguments: [string, string, string];
+}
+/** Creates a new, empty table */
+export declare function _new<DerivedObjectKey extends BcsType<any>>(options: NewOptions<DerivedObjectKey>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+    v: RawTransactionArgument<V>;
+}
+export interface AddOptions<K extends BcsType<any>, V extends BcsType<any>> {
+    package?: string;
+    arguments: AddArguments<K, V> | [
+        table: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>,
+        v: RawTransactionArgument<V>
+    ];
+    typeArguments: [string, string];
+}
+/**
+ * Adds a key-value pair to the table `table: &mut DerivedTable<K, V>` Aborts with
+ * `sui::dynamic_field::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+export declare function add<K extends BcsType<any>, V extends BcsType<any>>(options: AddOptions<K, V>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowArguments<K> | [table: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Immutable borrows the value associated with the key in the table
+ * `table: &DerivedTable<K, V>`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry
+ * with that key `k: K`.
+ */
+export declare function borrow<K extends BcsType<any>>(options: BorrowOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BorrowMutArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowMutOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowMutArguments<K> | [table: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the value associated with the key in the table
+ * `table: &mut DerivedTable<K, V>`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry
+ * with that key `k: K`.
+ */
+export declare function borrowMut<K extends BcsType<any>>(options: BorrowMutOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface RemoveOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: RemoveArguments<K> | [table: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Removes the key-value pair in the table `table: &mut DerivedTable<K, V>` and
+ * returns the value. Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the
+ * table does not have an entry with that key `k: K`.
+ */
+export declare function remove<K extends BcsType<any>>(options: RemoveOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContainsArguments<K extends BcsType<any>> {
+    table: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface ContainsOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ContainsArguments<K> | [table: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Returns true if there is a value associated with the key `k: K` in table
+ * `table: &DerivedTable<K, V>`
+ */
+export declare function contains<K extends BcsType<any>>(options: ContainsOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LengthArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+    package?: string;
+    arguments: LengthArguments | [table: RawTransactionArgument<string>];
+    typeArguments: [string, string];
+}
+/** Returns the size of the table, the number of key-value pairs */
+export declare function length(options: LengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsEmptyArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+    package?: string;
+    arguments: IsEmptyArguments | [table: RawTransactionArgument<string>];
+    typeArguments: [string, string];
+}
+/** Returns true if the table is empty (if `length` returns `0`) */
+export declare function isEmpty(options: IsEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyEmptyArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface DestroyEmptyOptions {
+    package?: string;
+    arguments: DestroyEmptyArguments | [table: RawTransactionArgument<string>];
+    typeArguments: [string, string];
+}
+/**
+ * Destroys an empty table Aborts with `EDerivedTableNotEmpty` if the table still
+ * contains values
+ */
+export declare function destroyEmpty(options: DestroyEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DropArguments {
+    table: RawTransactionArgument<string>;
+}
+export interface DropOptions {
+    package?: string;
+    arguments: DropArguments | [table: RawTransactionArgument<string>];
+    typeArguments: [string, string];
+}
+/**
+ * Drop a possibly non-empty table. Usable only if the value type `V` has the
+ * `drop` ability
+ */
+export declare function drop(options: DropOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_framework/derived_table.js

@@ -0,0 +1,200 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_framework::derived_table";
+export const DerivedTable = new MoveStruct({
+    name: `${$moduleName}::DerivedTable`,
+    fields: {
+        /** the ID of this table */
+        id: object.UID,
+        /** the number of key-value pairs in the table */
+        size: bcs.u64(),
+    },
+});
+/** Creates a new, empty table */
+export function _new(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        "0x0000000000000000000000000000000000000000000000000000000000000002::object::UID",
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["parent", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "new",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Adds a key-value pair to the table `table: &mut DerivedTable<K, V>` Aborts with
+ * `sui::dynamic_field::EFieldAlreadyExists` if the table already has an entry with
+ * that key `k: K`.
+ */
+export function add(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`,
+    ];
+    const parameterNames = ["table", "k", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "add",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Immutable borrows the value associated with the key in the table
+ * `table: &DerivedTable<K, V>`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry
+ * with that key `k: K`.
+ */
+export function borrow(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "borrow",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Mutably borrows the value associated with the key in the table
+ * `table: &mut DerivedTable<K, V>`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the table does not have an entry
+ * with that key `k: K`.
+ */
+export function borrowMut(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "borrow_mut",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Removes the key-value pair in the table `table: &mut DerivedTable<K, V>` and
+ * returns the value. Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the
+ * table does not have an entry with that key `k: K`.
+ */
+export function remove(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "remove",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Returns true if there is a value associated with the key `k: K` in table
+ * `table: &DerivedTable<K, V>`
+ */
+export function contains(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["table", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "contains",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Returns the size of the table, the number of key-value pairs */
+export function length(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "length",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Returns true if the table is empty (if `length` returns `0`) */
+export function isEmpty(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "is_empty",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Destroys an empty table Aborts with `EDerivedTableNotEmpty` if the table still
+ * contains values
+ */
+export function destroyEmpty(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "destroy_empty",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Drop a possibly non-empty table. Usable only if the value type `V` has the
+ * `drop` ability
+ */
+export function drop(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_table::DerivedTable<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    ];
+    const parameterNames = ["table"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_table",
+        function: "drop",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

package/dist/_generated/zing_governance/admin.d.ts

@@ -0,0 +1,20 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const AdminCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+}, "@local-pkg/zing_governance::admin::AdminCap">;
+export interface NewAdminCapArguments {
+    Cap: RawTransactionArgument<string>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface NewAdminCapOptions {
+    package?: string;
+    arguments: NewAdminCapArguments | [
+        Cap: RawTransactionArgument<string>,
+        recipient: RawTransactionArgument<string>
+    ];
+}
+export declare function newAdminCap(options: NewAdminCapOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_governance/admin.js

@@ -0,0 +1,26 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+const $moduleName = "@local-pkg/zing_governance::admin";
+export const AdminCap = new MoveStruct({
+    name: `${$moduleName}::AdminCap`,
+    fields: {
+        id: object.UID,
+    },
+});
+export function newAdminCap(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_governance";
+    const argumentsTypes = [
+        `${packageAddress}::admin::AdminCap`,
+        "address",
+    ];
+    const parameterNames = ["Cap", "recipient"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "admin",
+        function: "new_admin_cap",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/_generated/zing_governance/deps/sui/object.d.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Sui object identifiers */
+import { MoveStruct } from "../../../utils/index.js";
+export declare const UID: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "0x2::object::UID">;

package/{src/_generated/zing_identity/deps/sui/object.ts → dist/_generated/zing_governance/deps/sui/object.js}

@@ -1,16 +1,13 @@
 /**************************************************************
  * 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,
-  },
+    name: `${$moduleName}::UID`,
+    fields: {
+        id: bcs.Address,
+    },
 });

package/dist/_generated/zing_governance/treasury.d.ts

@@ -0,0 +1,56 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const TreasurySupplyEvent: MoveStruct<{
+    coin_type: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_governance::treasury::TreasurySupplyEvent">;
+export declare const TreasuryClaimEvent: MoveStruct<{
+    coin_type: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_governance::treasury::TreasuryClaimEvent">;
+export declare const BalanceKey: MoveStruct<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/zing_governance::treasury::BalanceKey">;
+export declare const Treasury: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+}, "@local-pkg/zing_governance::treasury::Treasury">;
+export interface BalanceOfArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BalanceOfOptions {
+    package?: string;
+    arguments: BalanceOfArguments | [self: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+export declare function balanceOf(options: BalanceOfOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SupplyTreasuryArguments {
+    self: RawTransactionArgument<string>;
+    balance: RawTransactionArgument<string>;
+}
+export interface SupplyTreasuryOptions {
+    package?: string;
+    arguments: SupplyTreasuryArguments | [
+        self: RawTransactionArgument<string>,
+        balance: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function supplyTreasury(options: SupplyTreasuryOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClaimArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    value: RawTransactionArgument<number | bigint>;
+}
+export interface ClaimOptions {
+    package?: string;
+    arguments: ClaimArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        value: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [string];
+}
+export declare function claim(options: ClaimOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_governance/treasury.js

@@ -0,0 +1,78 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import * as object from "./deps/sui/object.js";
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from "@mysten/sui/bcs";
+const $moduleName = "@local-pkg/zing_governance::treasury";
+export const TreasurySupplyEvent = new MoveStruct({
+    name: `${$moduleName}::TreasurySupplyEvent`,
+    fields: {
+        coin_type: bcs.string(),
+        value: bcs.u64(),
+    },
+});
+export const TreasuryClaimEvent = new MoveStruct({
+    name: `${$moduleName}::TreasuryClaimEvent`,
+    fields: {
+        coin_type: bcs.string(),
+        value: bcs.u64(),
+    },
+});
+export const BalanceKey = new MoveStruct({
+    name: `${$moduleName}::BalanceKey`,
+    fields: {
+        dummy_field: bcs.bool(),
+    },
+});
+export const Treasury = new MoveStruct({
+    name: `${$moduleName}::Treasury`,
+    fields: {
+        id: object.UID,
+    },
+});
+export function balanceOf(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_governance";
+    const argumentsTypes = [
+        `${packageAddress}::treasury::Treasury`,
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "treasury",
+        function: "balance_of",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function supplyTreasury(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_governance";
+    const argumentsTypes = [
+        `${packageAddress}::treasury::Treasury`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["self", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "treasury",
+        function: "supply_treasury",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+export function claim(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_governance";
+    const argumentsTypes = [
+        `${packageAddress}::treasury::Treasury`,
+        `${packageAddress}::admin::AdminCap`,
+        "u64",
+    ];
+    const parameterNames = ["self", "Cap", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "treasury",
+        function: "claim",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

package/dist/_generated/zing_identity/config.d.ts

@@ -0,0 +1,87 @@
+import { MoveStruct } from "../utils/index.js";
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export declare const Config: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    registry: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<{
+            name: string;
+        }[], Iterable<{
+            name: string;
+        }> & {
+            length: number;
+        }, "vector<std::type_name::TypeName>">;
+    }, string>;
+    versions: MoveStruct<{
+        contents: import("@mysten/sui/bcs").BcsType<string[], Iterable<string | number | bigint> & {
+            length: number;
+        }, "vector<u64>">;
+    }, string>;
+    base_read_fee: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_identity::config::Config">;
+export interface PackageVersionOptions {
+    package?: string;
+    arguments?: [];
+}
+export declare function packageVersion(options?: PackageVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface BaseReadFeeArguments {
+    self: RawTransactionArgument<string>;
+}
+export interface BaseReadFeeOptions {
+    package?: string;
+    arguments: BaseReadFeeArguments | [self: RawTransactionArgument<string>];
+}
+export declare function baseReadFee(options: BaseReadFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddVersionArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    version: RawTransactionArgument<number | bigint>;
+}
+export interface AddVersionOptions {
+    package?: string;
+    arguments: AddVersionArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function addVersion(options: AddVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemoveVersionArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    version: RawTransactionArgument<number | bigint>;
+}
+export interface RemoveVersionOptions {
+    package?: string;
+    arguments: RemoveVersionArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        version: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function removeVersion(options: RemoveVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateReadFeeArguments {
+    self: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    fee: RawTransactionArgument<number | bigint>;
+}
+export interface UpdateReadFeeOptions {
+    package?: string;
+    arguments: UpdateReadFeeArguments | [
+        self: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        fee: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function updateReadFee(options: UpdateReadFeeOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DerivedObjectKeyArguments {
+    name: RawTransactionArgument<string>;
+}
+export interface DerivedObjectKeyOptions {
+    package?: string;
+    arguments: DerivedObjectKeyArguments | [name: RawTransactionArgument<string>];
+    typeArguments: [string];
+}
+export declare function derivedObjectKey(options: DerivedObjectKeyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;