@zing-protocol/zing-sdk 0.0.1 → 0.0.2

package/dist/_generated/index.js

@@ -0,0 +1,6 @@
+export * as Reclaim from "./zing_identity/reclaim.js";
+export * as Identity from "./zing_identity/identity.js";
+export * as StudioApp from "./zing_studio/app.js";
+export * as Studio from "./zing_studio/studio.js";
+export * as Article from "./zing_studio/article.js";
+export * as Storage from "./zing_studio/storage.js";

package/dist/_generated/utils/index.d.ts

@@ -0,0 +1,12 @@
+import { BcsStruct, BcsEnum, BcsTuple } from "@mysten/sui/bcs";
+import type { BcsType, TypeTag } from "@mysten/sui/bcs";
+import type { TransactionArgument } from "@mysten/sui/transactions";
+export type RawTransactionArgument<T> = T | TransactionArgument;
+export declare function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null;
+export declare function normalizeMoveArguments(args: unknown[] | object, argTypes: string[], parameterNames?: string[]): TransactionArgument[];
+export declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+}
+export declare class MoveEnum<T extends Record<string, BcsType<any> | null>, const Name extends string> extends BcsEnum<T, Name> {
+}
+export declare class MoveTuple<T extends readonly BcsType<any>[], const Name extends string> extends BcsTuple<T, Name> {
+}

package/dist/_generated/utils/index.js

@@ -0,0 +1,135 @@
+import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple, } from "@mysten/sui/bcs";
+import { isArgument } from "@mysten/sui/transactions";
+import { normalizeSuiAddress } from "@mysten/sui/utils";
+const MOVE_STDLIB_ADDRESS = normalizeSuiAddress("0x1");
+const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress("0x2");
+const SUI_SYSTEM_ADDRESS = normalizeSuiAddress("0x3");
+function stringify(val) {
+    if (typeof val === "object") {
+        return JSON.stringify(val, (val) => val);
+    }
+    if (typeof val === "bigint") {
+        return val.toString();
+    }
+    return val;
+}
+export function getPureBcsSchema(typeTag) {
+    const parsedTag = typeof typeTag === "string"
+        ? TypeTagSerializer.parseFromStr(typeTag)
+        : typeTag;
+    if ("u8" in parsedTag) {
+        return bcs.U8;
+    }
+    else if ("u16" in parsedTag) {
+        return bcs.U16;
+    }
+    else if ("u32" in parsedTag) {
+        return bcs.U32;
+    }
+    else if ("u64" in parsedTag) {
+        return bcs.U64;
+    }
+    else if ("u128" in parsedTag) {
+        return bcs.U128;
+    }
+    else if ("u256" in parsedTag) {
+        return bcs.U256;
+    }
+    else if ("address" in parsedTag) {
+        return bcs.Address;
+    }
+    else if ("bool" in parsedTag) {
+        return bcs.Bool;
+    }
+    else if ("vector" in parsedTag) {
+        const type = getPureBcsSchema(parsedTag.vector);
+        return type ? bcs.vector(type) : null;
+    }
+    else if ("struct" in parsedTag) {
+        const structTag = parsedTag.struct;
+        const pkg = normalizeSuiAddress(parsedTag.struct.address);
+        if (pkg === MOVE_STDLIB_ADDRESS) {
+            if ((structTag.module === "ascii" || structTag.module === "string") &&
+                structTag.name === "String") {
+                return bcs.String;
+            }
+            if (structTag.module === "option" && structTag.name === "Option") {
+                const type = getPureBcsSchema(structTag.typeParams[0]);
+                return type ? bcs.option(type) : null;
+            }
+        }
+        if (pkg === SUI_FRAMEWORK_ADDRESS &&
+            structTag.module === "Object" &&
+            structTag.name === "ID") {
+            return bcs.Address;
+        }
+    }
+    return null;
+}
+export function normalizeMoveArguments(args, argTypes, parameterNames) {
+    const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+    if (parameterNames && argLen !== parameterNames.length) {
+        throw new Error(`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`);
+    }
+    const normalizedArgs = [];
+    let index = 0;
+    for (const [i, argType] of argTypes.entries()) {
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+            normalizedArgs.push((tx) => tx.object.denyList());
+            continue;
+        }
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::random::Random`) {
+            normalizedArgs.push((tx) => tx.object.random());
+            continue;
+        }
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::clock::Clock`) {
+            normalizedArgs.push((tx) => tx.object.clock());
+            continue;
+        }
+        if (argType === `${SUI_SYSTEM_ADDRESS}::sui_system::SuiSystemState`) {
+            normalizedArgs.push((tx) => tx.object.system());
+            continue;
+        }
+        let arg;
+        if (Array.isArray(args)) {
+            if (index >= args.length) {
+                throw new Error(`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`);
+            }
+            arg = args[index];
+        }
+        else {
+            if (!parameterNames) {
+                throw new Error(`Expected arguments to be passed as an array`);
+            }
+            const name = parameterNames[index];
+            arg = args[name];
+            if (arg === undefined) {
+                throw new Error(`Parameter ${name} is required`);
+            }
+        }
+        index += 1;
+        if (typeof arg === "function" || isArgument(arg)) {
+            normalizedArgs.push(arg);
+            continue;
+        }
+        const type = argTypes[i];
+        const bcsType = getPureBcsSchema(type);
+        if (bcsType) {
+            const bytes = bcsType.serialize(arg);
+            normalizedArgs.push((tx) => tx.pure(bytes));
+            continue;
+        }
+        else if (typeof arg === "string") {
+            normalizedArgs.push((tx) => tx.object(arg));
+            continue;
+        }
+        throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+    }
+    return normalizedArgs;
+}
+export class MoveStruct extends BcsStruct {
+}
+export class MoveEnum extends BcsEnum {
+}
+export class MoveTuple extends BcsTuple {
+}

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

@@ -0,0 +1,15 @@
+import type { RawTransactionArgument } from "../utils/index.js";
+import type { Transaction } from "@mysten/sui/transactions";
+export interface BurnOrSendPositiveCoinArguments {
+    coin: RawTransactionArgument<string>;
+    recipient: RawTransactionArgument<string>;
+}
+export interface BurnOrSendPositiveCoinOptions {
+    package?: string;
+    arguments: BurnOrSendPositiveCoinArguments | [
+        coin: RawTransactionArgument<string>,
+        recipient: RawTransactionArgument<string>
+    ];
+    typeArguments: [string];
+}
+export declare function burnOrSendPositiveCoin(options: BurnOrSendPositiveCoinOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_framework/coin_utils.js

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { normalizeMoveArguments } from "../utils/index.js";
+export function burnOrSendPositiveCoin(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+        "address",
+    ];
+    const parameterNames = ["coin", "recipient"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "coin_utils",
+        function: "burn_or_send_positive_coin",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}

package/dist/_generated/zing_framework/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_governance/deps/sui/object.ts → dist/_generated/zing_framework/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_framework/derived_object_bag.d.ts

@@ -0,0 +1,166 @@
+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 DerivedObjectBag: MoveStruct<{
+    /** the ID of this bag */
+    id: MoveStruct<{
+        id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    /** the number of key-value pairs in the bag */
+    size: BcsType<string, string | number | bigint, "u64">;
+}, "@local-pkg/zing_framework::derived_object_bag::DerivedObjectBag">;
+export interface NewArguments<K extends BcsType<any>> {
+    parent: RawTransactionArgument<string>;
+    key: RawTransactionArgument<K>;
+}
+export interface NewOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: NewArguments<K> | [parent: RawTransactionArgument<string>, key: RawTransactionArgument<K>];
+    typeArguments: [string];
+}
+/** Creates a new, empty bag */
+export declare function _new<K extends BcsType<any>>(options: NewOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddArguments<K extends BcsType<any>, V extends BcsType<any>> {
+    bag: 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> | [
+        bag: RawTransactionArgument<string>,
+        k: RawTransactionArgument<K>,
+        v: RawTransactionArgument<V>
+    ];
+    typeArguments: [string, string];
+}
+/**
+ * Adds a key-value pair to the bag `bag: &mut DerivedObjectBag` Aborts with
+ * `sui::dynamic_field::EFieldAlreadyExists` if the bag 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>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Immutably borrows the value associated with the key in the bag
+ * `bag: &DerivedObjectBag`. Aborts with `sui::dynamic_field::EFieldDoesNotExist`
+ * if the bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+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>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface BorrowMutOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: BorrowMutArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the value associated with the key in the bag
+ * `bag: &mut DerivedObjectBag`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the bag does not have an entry with
+ * that key `k: K`. Aborts with `sui::dynamic_field::EFieldTypeMismatch` if the bag
+ * has an entry for the key, but the value does not have the specified type.
+ */
+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>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface RemoveOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: RemoveArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Mutably borrows the key-value pair in the bag `bag: &mut DerivedObjectBag` and
+ * returns the value. Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the
+ * bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+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>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface ContainsOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ContainsArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string];
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag`
+ */
+export declare function contains<K extends BcsType<any>>(options: ContainsOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContainsWithTypeArguments<K extends BcsType<any>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface ContainsWithTypeOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ContainsWithTypeArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string, string];
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag` with an assigned value of type `V`
+ */
+export declare function containsWithType<K extends BcsType<any>>(options: ContainsWithTypeOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface LengthArguments {
+    bag: RawTransactionArgument<string>;
+}
+export interface LengthOptions {
+    package?: string;
+    arguments: LengthArguments | [bag: RawTransactionArgument<string>];
+}
+/** Returns the size of the bag, the number of key-value pairs */
+export declare function length(options: LengthOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsEmptyArguments {
+    bag: RawTransactionArgument<string>;
+}
+export interface IsEmptyOptions {
+    package?: string;
+    arguments: IsEmptyArguments | [bag: RawTransactionArgument<string>];
+}
+/** Returns true iff the bag is empty (if `length` returns `0`) */
+export declare function isEmpty(options: IsEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DestroyEmptyArguments {
+    bag: RawTransactionArgument<string>;
+}
+export interface DestroyEmptyOptions {
+    package?: string;
+    arguments: DestroyEmptyArguments | [bag: RawTransactionArgument<string>];
+}
+/**
+ * Destroys an empty bag Aborts with `EBagNotEmpty` if the bag still contains
+ * values
+ */
+export declare function destroyEmpty(options: DestroyEmptyOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ValueIdArguments<K extends BcsType<any>> {
+    bag: RawTransactionArgument<string>;
+    k: RawTransactionArgument<K>;
+}
+export interface ValueIdOptions<K extends BcsType<any>> {
+    package?: string;
+    arguments: ValueIdArguments<K> | [bag: RawTransactionArgument<string>, k: RawTransactionArgument<K>];
+    typeArguments: [string];
+}
+/**
+ * Returns the ID of the object associated with the key if the bag has an entry
+ * with key `k: K` Returns none otherwise
+ */
+export declare function valueId<K extends BcsType<any>>(options: ValueIdOptions<K>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/_generated/zing_framework/derived_object_bag.js

@@ -0,0 +1,221 @@
+/**************************************************************
+ * 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_object_bag";
+export const DerivedObjectBag = new MoveStruct({
+    name: `${$moduleName}::DerivedObjectBag`,
+    fields: {
+        /** the ID of this bag */
+        id: object.UID,
+        /** the number of key-value pairs in the bag */
+        size: bcs.u64(),
+    },
+});
+/** Creates a new, empty bag */
+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_object_bag",
+        function: "new",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Adds a key-value pair to the bag `bag: &mut DerivedObjectBag` Aborts with
+ * `sui::dynamic_field::EFieldAlreadyExists` if the bag 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_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`,
+    ];
+    const parameterNames = ["bag", "k", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "add",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Immutably borrows the value associated with the key in the bag
+ * `bag: &DerivedObjectBag`. Aborts with `sui::dynamic_field::EFieldDoesNotExist`
+ * if the bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+export function borrow(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "borrow",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Mutably borrows the value associated with the key in the bag
+ * `bag: &mut DerivedObjectBag`. Aborts with
+ * `sui::dynamic_field::EFieldDoesNotExist` if the bag does not have an entry with
+ * that key `k: K`. Aborts with `sui::dynamic_field::EFieldTypeMismatch` if the bag
+ * has an entry for the key, but the value does not have the specified type.
+ */
+export function borrowMut(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "borrow_mut",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Mutably borrows the key-value pair in the bag `bag: &mut DerivedObjectBag` and
+ * returns the value. Aborts with `sui::dynamic_field::EFieldDoesNotExist` if the
+ * bag does not have an entry with that key `k: K`. Aborts with
+ * `sui::dynamic_field::EFieldTypeMismatch` if the bag has an entry for the key,
+ * but the value does not have the specified type.
+ */
+export function remove(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "remove",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag`
+ */
+export function contains(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "contains",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Returns true iff there is an value associated with the key `k: K` in the bag
+ * `bag: &DerivedObjectBag` with an assigned value of type `V`
+ */
+export function containsWithType(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "contains_with_type",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** Returns the size of the bag, the number of key-value pairs */
+export function length(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    ];
+    const parameterNames = ["bag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "length",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns true iff the bag is empty (if `length` returns `0`) */
+export function isEmpty(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    ];
+    const parameterNames = ["bag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "is_empty",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Destroys an empty bag Aborts with `EBagNotEmpty` if the bag still contains
+ * values
+ */
+export function destroyEmpty(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+    ];
+    const parameterNames = ["bag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "destroy_empty",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns the ID of the object associated with the key if the bag has an entry
+ * with key `k: K` Returns none otherwise
+ */
+export function valueId(options) {
+    const packageAddress = options.package ?? "@local-pkg/zing_framework";
+    const argumentsTypes = [
+        `${packageAddress}::derived_object_bag::DerivedObjectBag`,
+        `${options.typeArguments[0]}`,
+    ];
+    const parameterNames = ["bag", "k"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "derived_object_bag",
+        function: "value_id",
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}