@suilend/sdk 12.7.0 → 13.0.0-next.g16373c6

package/_generated/_dependencies/{source/0x1 → std}/option/structs.d.ts

@@ -1,44 +1,52 @@
-import * as reified from "../../../../_framework/reified";
-import { PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { Vector } from "../../../../_framework/vector";
-import { PKG_V13 } from "../index";
-import { BcsType } from "@mysten/sui/bcs";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
+/** This module defines the Option type and its methods to represent and handle an optional value. */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToJSON, ToTypeArgument, ToTypeStr, TypeArgument } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { Vector } from '../../../_framework/vector';
 export declare function isOption(type: string): boolean;
 export interface OptionFields<Element extends TypeArgument> {
     vec: ToField<Vector<Element>>;
 }
 export type OptionReified<Element extends TypeArgument> = Reified<Option<Element>, OptionFields<Element>>;
+export type OptionJSONField<Element extends TypeArgument> = {
+    vec: ToJSON<Element>[];
+};
+export type OptionJSON<Element extends TypeArgument> = {
+    $typeName: typeof Option.$typeName;
+    $typeArgs: [ToTypeStr<Element>];
+} & OptionJSONField<Element>;
+/**
+ * Abstraction of a value that may or may not be present. Implemented with a vector of size
+ * zero or one because Move bytecode does not have ADTs.
+ */
 export declare class Option<Element extends TypeArgument> implements StructClass {
     __StructClass: true;
-    static readonly $typeName = "0x1::option::Option";
+    static readonly $typeName: `0x1::option::Option`;
     static readonly $numTypeParams = 1;
     static readonly $isPhantom: readonly [false];
     __inner: Element;
-    readonly $typeName = "0x1::option::Option";
-    readonly $fullTypeName: `${typeof PKG_V13}::option::Option<${ToTypeStr<Element>}>`;
+    readonly $typeName: typeof Option.$typeName;
+    readonly $fullTypeName: `0x1::option::Option<${ToTypeStr<Element>}>`;
     readonly $typeArgs: [ToTypeStr<Element>];
-    readonly $isPhantom: readonly [false];
+    readonly $isPhantom: typeof Option.$isPhantom;
     readonly vec: ToField<Vector<Element>>;
     private constructor();
     static reified<Element extends Reified<TypeArgument, any>>(Element: Element): OptionReified<ToTypeArgument<Element>>;
     static get r(): typeof Option.reified;
     static phantom<Element extends Reified<TypeArgument, any>>(Element: Element): PhantomReified<ToTypeStr<Option<ToTypeArgument<Element>>>>;
     static get p(): typeof Option.phantom;
-    static get bcs(): <Element extends BcsType<any>>(Element: Element) => BcsType<any>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Option.instantiateBcs>;
     static fromFields<Element extends Reified<TypeArgument, any>>(typeArg: Element, fields: Record<string, any>): Option<ToTypeArgument<Element>>;
     static fromFieldsWithTypes<Element extends Reified<TypeArgument, any>>(typeArg: Element, item: FieldsWithTypes): Option<ToTypeArgument<Element>>;
     static fromBcs<Element extends Reified<TypeArgument, any>>(typeArg: Element, data: Uint8Array): Option<ToTypeArgument<Element>>;
-    toJSONField(): {
-        vec: reified.ToJSON<Element>[];
-    };
-    toJSON(): {
-        vec: reified.ToJSON<Element>[];
-        $typeName: string;
-        $typeArgs: [reified.ToTypeStr<Element>];
-    };
+    toJSONField(): OptionJSONField<Element>;
+    toJSON(): OptionJSON<Element>;
     static fromJSONField<Element extends Reified<TypeArgument, any>>(typeArg: Element, field: any): Option<ToTypeArgument<Element>>;
     static fromJSON<Element extends Reified<TypeArgument, any>>(typeArg: Element, json: Record<string, any>): Option<ToTypeArgument<Element>>;
-    static fetch<Element extends Reified<TypeArgument, any>>(client: SuiGrpcClient, typeArg: Element, id: string): Promise<Option<ToTypeArgument<Element>>>;
+    static fromCoreObject<Element extends Reified<TypeArgument, any>>(typeArg: Element, obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Option<ToTypeArgument<Element>>;
+    static fetch<Element extends Reified<TypeArgument, any>>(client: ClientWithCoreApi, typeArg: Element, id: string): Promise<Option<ToTypeArgument<Element>>>;
 }

package/_generated/_dependencies/std/option/structs.js

@@ -0,0 +1,155 @@
+/** This module defines the Option type and its methods to represent and handle an optional value. */
+import { bcs } from '@mysten/sui/bcs';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs, vector, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../../_framework/util.js';
+/* ============================== Option =============================== */
+export function isOption(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`0x1::option::Option` + '<');
+}
+/**
+ * Abstraction of a value that may or may not be present. Implemented with a vector of size
+ * zero or one because Move bytecode does not have ADTs.
+ */
+export class Option {
+    __StructClass = true;
+    static $typeName = `0x1::option::Option`;
+    static $numTypeParams = 1;
+    static $isPhantom = [false];
+    __inner = null; // for type checking in reified.ts
+    $typeName = Option.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Option.$isPhantom;
+    vec;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(Option.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.vec = fields.vec;
+    }
+    static reified(Element) {
+        const reifiedBcs = Option.bcs(toBcs(Element));
+        return {
+            get typeName() {
+                return Option.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Option.$typeName, ...[extractType(Element)]);
+            },
+            get typeArgs() {
+                return [extractType(Element)];
+            },
+            isPhantom: Option.$isPhantom,
+            reifiedTypeArgs: [Element],
+            fromFields: (fields) => Option.fromFields(Element, fields),
+            fromFieldsWithTypes: (item) => Option.fromFieldsWithTypes(Element, item),
+            fromBcs: (data) => Option.fromFields(Element, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Option.fromJSONField(Element, field),
+            fromJSON: (json) => Option.fromJSON(Element, json),
+            fromCoreObject: (obj) => Option.fromCoreObject(Element, obj),
+            fetch: async (client, id) => Option.fetch(client, Element, id),
+            new: (fields) => {
+                return new Option([extractType(Element)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return Option.reified;
+    }
+    static phantom(Element) {
+        return phantom(Option.reified(Element));
+    }
+    static get p() {
+        return Option.phantom;
+    }
+    static instantiateBcs() {
+        return (Element) => bcs.struct(`Option<${Element.name}>`, {
+            vec: bcs.vector(Element),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Option.cachedBcs) {
+            Option.cachedBcs = Option.instantiateBcs();
+        }
+        return Option.cachedBcs;
+    }
+    static fromFields(typeArg, fields) {
+        return Option.reified(typeArg).new({
+            vec: decodeFromFields(vector(typeArg), fields.vec),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isOption(item.type)) {
+            throw new Error('not a Option type');
+        }
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
+        return Option.reified(typeArg).new({
+            vec: decodeFromFieldsWithTypes(vector(typeArg), item.fields.vec),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        const typeArgs = [typeArg];
+        return Option.fromFields(typeArg, Option.bcs(toBcs(typeArg)).parse(data));
+    }
+    toJSONField() {
+        return {
+            vec: fieldToJSON(`vector<${this.$typeArgs[0]}>`, this.vec),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArg, field) {
+        return Option.reified(typeArg).new({
+            vec: decodeFromJSONField(vector(typeArg), field.vec),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Option.$typeName) {
+            throw new Error(`not a Option json object: expected '${Option.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(Option.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
+        return Option.fromJSONField(typeArg, json);
+    }
+    static fromCoreObject(typeArg, obj) {
+        if (!isOption(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Option object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Option.fromBcs(typeArg, obj.content);
+    }
+    static async fetch(client, typeArg, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isOption(object.type)) {
+            throw new Error(`object at id ${id} is not a Option object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 1) {
+            throw new Error(`type argument mismatch: expected 1 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 1; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType([typeArg][i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return Option.fromBcs(typeArg, object.content);
+    }
+}

package/_generated/_dependencies/std/type-name/structs.d.ts

@@ -0,0 +1,65 @@
+/** Functionality for converting Move types into values. Use with care! */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { String } from '../ascii/structs';
+export declare function isTypeName(type: string): boolean;
+export interface TypeNameFields {
+    /**
+     * 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: ToField<String>;
+}
+export type TypeNameReified = Reified<TypeName, TypeNameFields>;
+export type TypeNameJSONField = {
+    name: string;
+};
+export type TypeNameJSON = {
+    $typeName: typeof TypeName.$typeName;
+    $typeArgs: [];
+} & TypeNameJSONField;
+export declare class TypeName implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x1::type_name::TypeName`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof TypeName.$typeName;
+    readonly $fullTypeName: `0x1::type_name::TypeName`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof TypeName.$isPhantom;
+    /**
+     * 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)
+     */
+    readonly name: ToField<String>;
+    private constructor();
+    static reified(): TypeNameReified;
+    static get r(): TypeNameReified;
+    static phantom(): PhantomReified<ToTypeStr<TypeName>>;
+    static get p(): PhantomReified<ToTypeStr<TypeName>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof TypeName.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): TypeName;
+    static fromFieldsWithTypes(item: FieldsWithTypes): TypeName;
+    static fromBcs(data: Uint8Array): TypeName;
+    toJSONField(): TypeNameJSONField;
+    toJSON(): TypeNameJSON;
+    static fromJSONField(field: any): TypeName;
+    static fromJSON(json: Record<string, any>): TypeName;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): TypeName;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<TypeName>;
+}

package/_generated/_dependencies/{source/0x1 → std}/type-name/structs.js

@@ -1,22 +1,31 @@
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { String } from "../ascii/structs.js";
-import { PKG_V13 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
+/** Functionality for converting Move types into values. Use with care! */
+import { bcs } from '@mysten/sui/bcs';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../../_framework/util.js';
+import { String } from '../ascii/structs.js';
 /* ============================== TypeName =============================== */
 export function isTypeName(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V13}::type_name::TypeName`;
+    return type === `0x1::type_name::TypeName`;
 }
 export class TypeName {
     __StructClass = true;
-    static $typeName = `${PKG_V13}::type_name::TypeName`;
+    static $typeName = `0x1::type_name::TypeName`;
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = TypeName.$typeName;
     $fullTypeName;
     $typeArgs;
     $isPhantom = TypeName.$isPhantom;
+    /**
+     * 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;
     constructor(typeArgs, fields) {
         this.$fullTypeName = composeSuiType(TypeName.$typeName, ...typeArgs);
@@ -24,23 +33,29 @@ export class TypeName {
         this.name = fields.name;
     }
     static reified() {
+        const reifiedBcs = TypeName.bcs;
         return {
-            typeName: TypeName.$typeName,
-            fullTypeName: composeSuiType(TypeName.$typeName, ...[]),
+            get typeName() {
+                return TypeName.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(TypeName.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: TypeName.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => TypeName.fromFields(fields),
             fromFieldsWithTypes: (item) => TypeName.fromFieldsWithTypes(item),
-            fromBcs: (data) => TypeName.fromBcs(data),
-            bcs: TypeName.bcs,
+            fromBcs: (data) => TypeName.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => TypeName.fromJSONField(field),
             fromJSON: (json) => TypeName.fromJSON(json),
+            fromCoreObject: (obj) => TypeName.fromCoreObject(obj),
             fetch: async (client, id) => TypeName.fetch(client, id),
             new: (fields) => {
                 return new TypeName([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -52,11 +67,18 @@ export class TypeName {
     static get p() {
         return TypeName.phantom();
     }
-    static get bcs() {
-        return bcs.struct("TypeName", {
+    static instantiateBcs() {
+        return bcs.struct('TypeName', {
             name: String.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!TypeName.cachedBcs) {
+            TypeName.cachedBcs = TypeName.instantiateBcs();
+        }
+        return TypeName.cachedBcs;
+    }
     static fromFields(fields) {
         return TypeName.reified().new({
             name: decodeFromFields(String.reified(), fields.name),
@@ -64,7 +86,7 @@ export class TypeName {
     }
     static fromFieldsWithTypes(item) {
         if (!isTypeName(item.type)) {
-            throw new Error("not a TypeName type");
+            throw new Error('not a TypeName type');
         }
         return TypeName.reified().new({
             name: decodeFromFieldsWithTypes(String.reified(), item.fields.name),
@@ -79,11 +101,7 @@ export class TypeName {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return TypeName.reified().new({
@@ -92,12 +110,21 @@ export class TypeName {
     }
     static fromJSON(json) {
         if (json.$typeName !== TypeName.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a TypeName json object: expected '${TypeName.$typeName}' but got '${json.$typeName}'`);
         }
         return TypeName.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isTypeName(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a TypeName object`);
+        }
+        return TypeName.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isTypeName(object.type)) {
             throw new Error(`object at id ${id} is not a TypeName object`);
         }

package/_generated/_dependencies/sui/bag/structs.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A bag is a heterogeneous map-like collection. The collection is similar to `sui::table` in that
+ * its keys and values are not stored within the `Bag` value, but instead are stored using Sui's
+ * object system. The `Bag` struct acts only as a handle into the object system to retrieve those
+ * keys and values.
+ * Note that this means that `Bag` values with exactly the same key-value mapping will not be
+ * equal, with `==`, at runtime. For example
+ * ```
+ * let bag1 = bag::new();
+ * let bag2 = bag::new();
+ * bag::add(&mut bag1, 0, false);
+ * bag::add(&mut bag1, 1, true);
+ * bag::add(&mut bag2, 0, false);
+ * bag::add(&mut bag2, 1, true);
+ * // bag1 does not equal bag2, despite having the same entries
+ * assert!(&bag1 != &bag2);
+ * ```
+ * At it's core, `sui::bag` is a wrapper around `UID` that allows for access to
+ * `sui::dynamic_field` while preventing accidentally stranding field values. A `UID` can be
+ * deleted, even if it has dynamic fields associated with it, but a bag, on the other hand, must be
+ * empty to be destroyed.
+ */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { UID } from '../object/structs';
+export declare function isBag(type: string): boolean;
+export interface BagFields {
+    /** the ID of this bag */
+    id: ToField<UID>;
+    /** the number of key-value pairs in the bag */
+    size: ToField<'u64'>;
+}
+export type BagReified = Reified<Bag, BagFields>;
+export type BagJSONField = {
+    id: string;
+    size: string;
+};
+export type BagJSON = {
+    $typeName: typeof Bag.$typeName;
+    $typeArgs: [];
+} & BagJSONField;
+export declare class Bag implements StructClass {
+    __StructClass: true;
+    static readonly $typeName: `0x2::bag::Bag`;
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName: typeof Bag.$typeName;
+    readonly $fullTypeName: `0x2::bag::Bag`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: typeof Bag.$isPhantom;
+    /** the ID of this bag */
+    readonly id: ToField<UID>;
+    /** the number of key-value pairs in the bag */
+    readonly size: ToField<'u64'>;
+    private constructor();
+    static reified(): BagReified;
+    static get r(): BagReified;
+    static phantom(): PhantomReified<ToTypeStr<Bag>>;
+    static get p(): PhantomReified<ToTypeStr<Bag>>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Bag.instantiateBcs>;
+    static fromFields(fields: Record<string, any>): Bag;
+    static fromFieldsWithTypes(item: FieldsWithTypes): Bag;
+    static fromBcs(data: Uint8Array): Bag;
+    toJSONField(): BagJSONField;
+    toJSON(): BagJSON;
+    static fromJSONField(field: any): Bag;
+    static fromJSON(json: Record<string, any>): Bag;
+    static fromCoreObject(obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Bag;
+    static fetch(client: ClientWithCoreApi, id: string): Promise<Bag>;
+}

package/_generated/_dependencies/sui/bag/structs.js

@@ -0,0 +1,154 @@
+/**
+ * A bag is a heterogeneous map-like collection. The collection is similar to `sui::table` in that
+ * its keys and values are not stored within the `Bag` value, but instead are stored using Sui's
+ * object system. The `Bag` struct acts only as a handle into the object system to retrieve those
+ * keys and values.
+ * Note that this means that `Bag` values with exactly the same key-value mapping will not be
+ * equal, with `==`, at runtime. For example
+ * ```
+ * let bag1 = bag::new();
+ * let bag2 = bag::new();
+ * bag::add(&mut bag1, 0, false);
+ * bag::add(&mut bag1, 1, true);
+ * bag::add(&mut bag2, 0, false);
+ * bag::add(&mut bag2, 1, true);
+ * // bag1 does not equal bag2, despite having the same entries
+ * assert!(&bag1 != &bag2);
+ * ```
+ * At it's core, `sui::bag` is a wrapper around `UID` that allows for access to
+ * `sui::dynamic_field` while preventing accidentally stranding field values. A `UID` can be
+ * deleted, even if it has dynamic fields associated with it, but a bag, on the other hand, must be
+ * empty to be destroyed.
+ */
+import { bcs } from '@mysten/sui/bcs';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../../_framework/util.js';
+import { UID } from '../object/structs.js';
+/* ============================== Bag =============================== */
+export function isBag(type) {
+    type = compressSuiType(type);
+    return type === `0x2::bag::Bag`;
+}
+export class Bag {
+    __StructClass = true;
+    static $typeName = `0x2::bag::Bag`;
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = Bag.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = Bag.$isPhantom;
+    /** the ID of this bag */
+    id;
+    /** the number of key-value pairs in the bag */
+    size;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(Bag.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.size = fields.size;
+    }
+    static reified() {
+        const reifiedBcs = Bag.bcs;
+        return {
+            get typeName() {
+                return Bag.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Bag.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: Bag.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => Bag.fromFields(fields),
+            fromFieldsWithTypes: (item) => Bag.fromFieldsWithTypes(item),
+            fromBcs: (data) => Bag.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => Bag.fromJSONField(field),
+            fromJSON: (json) => Bag.fromJSON(json),
+            fromCoreObject: (obj) => Bag.fromCoreObject(obj),
+            fetch: async (client, id) => Bag.fetch(client, id),
+            new: (fields) => {
+                return new Bag([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return Bag.reified();
+    }
+    static phantom() {
+        return phantom(Bag.reified());
+    }
+    static get p() {
+        return Bag.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('Bag', {
+            id: UID.bcs,
+            size: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Bag.cachedBcs) {
+            Bag.cachedBcs = Bag.instantiateBcs();
+        }
+        return Bag.cachedBcs;
+    }
+    static fromFields(fields) {
+        return Bag.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            size: decodeFromFields('u64', fields.size),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isBag(item.type)) {
+            throw new Error('not a Bag type');
+        }
+        return Bag.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            size: decodeFromFieldsWithTypes('u64', item.fields.size),
+        });
+    }
+    static fromBcs(data) {
+        return Bag.fromFields(Bag.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            size: this.size.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return Bag.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            size: decodeFromJSONField('u64', field.size),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== Bag.$typeName) {
+            throw new Error(`not a Bag json object: expected '${Bag.$typeName}' but got '${json.$typeName}'`);
+        }
+        return Bag.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isBag(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Bag object`);
+        }
+        return Bag.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isBag(object.type)) {
+            throw new Error(`object at id ${id} is not a Bag object`);
+        }
+        return Bag.fromBcs(object.content);
+    }
+}