@suilend/springsui-cli 1.0.0

package/sdk/src/_generated/_framework/util.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitGenericParameters = splitGenericParameters;
+exports.parseTypeName = parseTypeName;
+exports.isTransactionArgument = isTransactionArgument;
+exports.obj = obj;
+exports.pure = pure;
+exports.option = option;
+exports.generic = generic;
+exports.vector = vector;
+exports.typeArgIsPure = typeArgIsPure;
+exports.compressSuiAddress = compressSuiAddress;
+exports.compressSuiType = compressSuiType;
+exports.composeSuiType = composeSuiType;
+const bcs_1 = require("@mysten/sui/bcs");
+function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
+    const [left, right] = genericSeparators;
+    const tok = [];
+    let word = "";
+    let nestedAngleBrackets = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === left) {
+            nestedAngleBrackets++;
+        }
+        if (char === right) {
+            nestedAngleBrackets--;
+        }
+        if (nestedAngleBrackets === 0 && char === ",") {
+            tok.push(word.trim());
+            word = "";
+            continue;
+        }
+        word += char;
+    }
+    tok.push(word.trim());
+    return tok;
+}
+function parseTypeName(name) {
+    if (typeof name !== "string") {
+        throw new Error(`Illegal type passed as a name of the type: ${name}`);
+    }
+    const [left, right] = ["<", ">"];
+    const l_bound = name.indexOf(left);
+    const r_bound = Array.from(name).reverse().indexOf(right);
+    // if there are no generics - exit gracefully.
+    if (l_bound === -1 && r_bound === -1) {
+        return { typeName: name, typeArgs: [] };
+    }
+    // if one of the bounds is not defined - throw an Error.
+    if (l_bound === -1 || r_bound === -1) {
+        throw new Error(`Unclosed generic in name '${name}'`);
+    }
+    const typeName = name.slice(0, l_bound);
+    const typeArgs = splitGenericParameters(name.slice(l_bound + 1, name.length - r_bound - 1), [left, right]);
+    return { typeName, typeArgs };
+}
+function isTransactionArgument(arg) {
+    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
+        return false;
+    }
+    return ("GasCoin" in arg ||
+        "Input" in arg ||
+        "Result" in arg ||
+        "NestedResult" in arg);
+}
+function obj(tx, arg) {
+    return isTransactionArgument(arg) ? arg : tx.object(arg);
+}
+function pure(tx, arg, type) {
+    if (isTransactionArgument(arg)) {
+        return obj(tx, arg);
+    }
+    function getBcsForType(type) {
+        const { typeName, typeArgs } = parseTypeName(type);
+        switch (typeName) {
+            case "bool":
+                return bcs_1.bcs.Bool;
+            case "u8":
+                return bcs_1.bcs.U8;
+            case "u16":
+                return bcs_1.bcs.U16;
+            case "u32":
+                return bcs_1.bcs.U32;
+            case "u64":
+                return bcs_1.bcs.U64;
+            case "u128":
+                return bcs_1.bcs.U128;
+            case "u256":
+                return bcs_1.bcs.U256;
+            case "address":
+                return bcs_1.bcs.Address;
+            case "0x1::string::String":
+            case "0x1::ascii::String":
+                return bcs_1.bcs.String;
+            case "0x2::object::ID":
+                return bcs_1.bcs.Address;
+            case "0x1::option::Option":
+                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
+            case "vector":
+                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
+            default:
+                throw new Error(`invalid primitive type ${type}`);
+        }
+    }
+    function hasUndefinedOrNull(items) {
+        for (const item of items) {
+            if (typeof item === "undefined" || item === null) {
+                return true;
+            }
+            if (Array.isArray(item)) {
+                return hasUndefinedOrNull(item);
+            }
+        }
+        return false;
+    }
+    function consistsOnlyOfPrimitiveValues(items) {
+        for (const item of items) {
+            if (!Array.isArray(item)) {
+                if (item === null) {
+                    continue;
+                }
+                switch (typeof item) {
+                    case "string":
+                    case "number":
+                    case "bigint":
+                    case "boolean":
+                        continue;
+                    default:
+                        return false;
+                }
+            }
+            return consistsOnlyOfPrimitiveValues(item);
+        }
+        return true;
+    }
+    function hasPrimitiveValues(items) {
+        for (const item of items) {
+            if (!Array.isArray(item)) {
+                switch (typeof item) {
+                    case "string":
+                    case "number":
+                    case "bigint":
+                    case "boolean":
+                        return true;
+                    default:
+                        continue;
+                }
+            }
+            return hasPrimitiveValues(item);
+        }
+        return false;
+    }
+    // handle some cases when TransactionArgument is nested within a vector or option
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "0x1::option::Option":
+            if (arg === null) {
+                return tx.pure.option("bool", null); // 'bool' is arbitrary
+            }
+            if (consistsOnlyOfPrimitiveValues([arg])) {
+                return tx.pure(getBcsForType(type).serialize(arg));
+            }
+            if (hasPrimitiveValues([arg])) {
+                throw new Error("mixing primitive and TransactionArgument values is not supported");
+            }
+            // wrap it with some
+            return tx.moveCall({
+                target: `0x1::option::some`,
+                typeArguments: [typeArgs[0]],
+                arguments: [pure(tx, arg, typeArgs[0])],
+            });
+        case "vector":
+            if (!Array.isArray(arg)) {
+                throw new Error("expected an array for vector type");
+            }
+            if (arg.length === 0) {
+                return tx.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
+            }
+            if (hasUndefinedOrNull(arg)) {
+                throw new Error("the provided array contains undefined or null values");
+            }
+            if (consistsOnlyOfPrimitiveValues(arg)) {
+                return tx.pure(getBcsForType(type).serialize(arg));
+            }
+            if (hasPrimitiveValues(arg)) {
+                throw new Error("mixing primitive and TransactionArgument values is not supported");
+            }
+            return tx.makeMoveVec({
+                type: typeArgs[0],
+                elements: arg,
+            });
+        default:
+            return tx.pure(getBcsForType(type).serialize(arg));
+    }
+}
+function option(tx, type, arg) {
+    if (isTransactionArgument(arg)) {
+        return arg;
+    }
+    if (typeArgIsPure(type)) {
+        return pure(tx, arg, `0x1::option::Option<${type}>`);
+    }
+    if (arg === null) {
+        return tx.moveCall({
+            target: `0x1::option::none`,
+            typeArguments: [type],
+            arguments: [],
+        });
+    }
+    // wrap it with some
+    const val = generic(tx, type, arg);
+    return tx.moveCall({
+        target: `0x1::option::some`,
+        typeArguments: [type],
+        arguments: [val],
+    });
+}
+function generic(tx, type, arg) {
+    if (typeArgIsPure(type)) {
+        return pure(tx, arg, type);
+    }
+    else {
+        const { typeName, typeArgs } = parseTypeName(type);
+        if (typeName === "vector" && Array.isArray(arg)) {
+            const itemType = typeArgs[0];
+            return tx.makeMoveVec({
+                type: itemType,
+                elements: arg.map((item) => obj(tx, item)),
+            });
+        }
+        else {
+            return obj(tx, arg);
+        }
+    }
+}
+function vector(tx, itemType, items) {
+    if (typeof items === "function") {
+        throw new Error("Transaction plugins are not supported");
+    }
+    if (typeArgIsPure(itemType)) {
+        return pure(tx, items, `vector<${itemType}>`);
+    }
+    else if (isTransactionArgument(items)) {
+        return items;
+    }
+    else {
+        const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType);
+        if (itemTypeName === "0x1::option::Option") {
+            const elements = items.map((item) => option(tx, itemTypeArgs[0], item));
+            return tx.makeMoveVec({
+                type: itemType,
+                elements,
+            });
+        }
+        return tx.makeMoveVec({
+            type: itemType,
+            elements: items,
+        });
+    }
+}
+function typeArgIsPure(type) {
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return true;
+        case "vector":
+            return typeArgIsPure(typeArgs[0]);
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::object::ID":
+            return true;
+        case "0x1::option::Option":
+            return typeArgIsPure(typeArgs[0]);
+        default:
+            return false;
+    }
+}
+function compressSuiAddress(addr) {
+    // remove leading zeros
+    const stripped = addr.split("0x").join("");
+    for (let i = 0; i < stripped.length; i++) {
+        if (stripped[i] !== "0") {
+            return `0x${stripped.substring(i)}`;
+        }
+    }
+    return "0x0";
+}
+// Recursively removes leading zeros from a type.
+// e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
+function compressSuiType(type) {
+    const { typeName, typeArgs } = parseTypeName(type);
+    switch (typeName) {
+        case "bool":
+        case "u8":
+        case "u16":
+        case "u32":
+        case "u64":
+        case "u128":
+        case "u256":
+        case "address":
+        case "signer":
+            return typeName;
+        case "vector":
+            return `vector<${compressSuiType(typeArgs[0])}>`;
+        default: {
+            const tok = typeName.split("::");
+            tok[0] = compressSuiAddress(tok[0]);
+            const compressedName = tok.join("::");
+            if (typeArgs.length > 0) {
+                return `${compressedName}<${typeArgs.map((typeArg) => compressSuiType(typeArg)).join(",")}>`;
+            }
+            else {
+                return compressedName;
+            }
+        }
+    }
+}
+function composeSuiType(typeName, ...typeArgs) {
+    if (typeArgs.length > 0) {
+        return `${typeName}<${typeArgs.join(", ")}>`;
+    }
+    else {
+        return typeName;
+    }
+}

package/sdk/src/_generated/_framework/vector.d.ts

@@ -0,0 +1,35 @@
+import { Reified, ToField, ToTypeArgument, ToTypeStr, TypeArgument, VectorClass, VectorClassReified } from "./reified";
+import { FieldsWithTypes } from "./util";
+export type VectorElements<T extends TypeArgument> = Array<ToField<T>>;
+export type VectorReified<T extends TypeArgument> = VectorClassReified<Vector<T>, VectorElements<T>>;
+export declare class Vector<T extends TypeArgument> implements VectorClass {
+    __VectorClass: true;
+    static readonly $typeName = "vector";
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [false];
+    readonly $typeName = "vector";
+    readonly $fullTypeName: `vector<${ToTypeStr<T>}>`;
+    readonly $typeArgs: [ToTypeStr<T>];
+    readonly $isPhantom: readonly [false];
+    readonly elements: Array<ToField<T>>;
+    constructor(typeArgs: [ToTypeStr<T>], elements: VectorElements<T>);
+    static reified<T extends Reified<TypeArgument, any>>(T: T): VectorReified<ToTypeArgument<T>>;
+    static get r(): typeof Vector.reified;
+    static get bcs(): <T, Input>(type: import("@mysten/sui/bcs").BcsType<T, Input>, options?: import("@mysten/sui/bcs").BcsTypeOptions<T[], Iterable<Input> & {
+        length: number;
+    }>) => import("@mysten/sui/bcs").BcsType<T[], Iterable<Input> & {
+        length: number;
+    }>;
+    static fromFields<T extends Reified<TypeArgument, any>>(typeArg: T, elements: any[]): Vector<ToTypeArgument<T>>;
+    static fromFieldsWithTypes<T extends Reified<TypeArgument, any>>(typeArg: T, item: FieldsWithTypes): Vector<ToTypeArgument<T>>;
+    static fromBcs<T extends Reified<TypeArgument, any>>(typeArg: T, data: Uint8Array): Vector<ToTypeArgument<T>>;
+    toJSONField(): import("./reified").ToJSON<T>[];
+    toJSON(): {
+        $typeName: string;
+        $typeArgs: [ToTypeStr<T>];
+        elements: import("./reified").ToJSON<T>[];
+    };
+    static fromJSONField<T extends Reified<TypeArgument, any>>(typeArg: T, field: any[]): Vector<ToTypeArgument<T>>;
+    static fromJSON<T extends Reified<TypeArgument, any>>(typeArg: T, json: any): Vector<ToTypeArgument<T>>;
+}
+export declare function vector<T extends Reified<TypeArgument, any>>(T: T): VectorClassReified<Vector<ToTypeArgument<T>>, VectorElements<ToTypeArgument<T>>>;

package/sdk/src/_generated/_framework/vector.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = void 0;
+exports.vector = vector;
+const bcs_1 = require("@mysten/sui/bcs");
+const reified_1 = require("./reified");
+const util_1 = require("./util");
+class Vector {
+    constructor(typeArgs, elements) {
+        this.__VectorClass = true;
+        this.$typeName = "vector";
+        this.$isPhantom = [false];
+        this.$fullTypeName = (0, util_1.composeSuiType)(this.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.elements = elements;
+    }
+    static reified(T) {
+        return {
+            typeName: Vector.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Vector.$typeName, ...[(0, reified_1.extractType)(T)]),
+            typeArgs: [(0, reified_1.extractType)(T)],
+            isPhantom: Vector.$isPhantom,
+            reifiedTypeArgs: [T],
+            fromFields: (elements) => Vector.fromFields(T, elements),
+            fromFieldsWithTypes: (item) => Vector.fromFieldsWithTypes(T, item),
+            fromBcs: (data) => Vector.fromBcs(T, data),
+            bcs: Vector.bcs((0, reified_1.toBcs)(T)),
+            fromJSONField: (field) => Vector.fromJSONField(T, field),
+            fromJSON: (json) => Vector.fromJSON(T, json),
+            new: (elements) => {
+                return new Vector([(0, reified_1.extractType)(T)], elements);
+            },
+            kind: "VectorClassReified",
+        };
+    }
+    static get r() {
+        return Vector.reified;
+    }
+    static get bcs() {
+        return bcs_1.bcs.vector;
+    }
+    static fromFields(typeArg, elements) {
+        return Vector.reified(typeArg).new(elements.map((element) => (0, reified_1.decodeFromFields)(typeArg, element)));
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        return Vector.reified(typeArg).new(item.map((field) => (0, reified_1.decodeFromFieldsWithTypes)(typeArg, field)));
+    }
+    static fromBcs(typeArg, data) {
+        return Vector.fromFields(typeArg, Vector.bcs((0, reified_1.toBcs)(typeArg)).parse(data));
+    }
+    toJSONField() {
+        return this.elements.map((element) => (0, reified_1.fieldToJSON)(this.$typeArgs[0], element));
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            elements: this.toJSONField(),
+        };
+    }
+    static fromJSONField(typeArg, field) {
+        return Vector.reified(typeArg).new(field.map((field) => (0, reified_1.decodeFromJSONField)(typeArg, field)));
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Vector.$typeName) {
+            throw new Error("not a vector json object");
+        }
+        return Vector.fromJSONField(typeArg, json.elements);
+    }
+}
+exports.Vector = Vector;
+Vector.$typeName = "vector";
+Vector.$numTypeParams = 1;
+Vector.$isPhantom = [false];
+function vector(T) {
+    return Vector.r(T);
+}

package/sdk/src/_generated/liquid_staking/cell/structs.d.ts

@@ -0,0 +1,54 @@
+import { Option } from "../../_dependencies/source/0x1/option/structs";
+import { PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeStr, TypeArgument } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { PKG_V1 } from "../index";
+import { BcsType } from "@mysten/sui/bcs";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isCell(type: string): boolean;
+export interface CellFields<Element extends TypeArgument> {
+    element: ToField<Option<Element>>;
+}
+export type CellReified<Element extends TypeArgument> = Reified<Cell<Element>, CellFields<Element>>;
+export declare class Cell<Element extends TypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::cell::Cell";
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [false];
+    readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::cell::Cell";
+    readonly $fullTypeName: `${typeof PKG_V1}::cell::Cell<${ToTypeStr<Element>}>`;
+    readonly $typeArgs: [ToTypeStr<Element>];
+    readonly $isPhantom: readonly [false];
+    readonly element: ToField<Option<Element>>;
+    private constructor();
+    static reified<Element extends Reified<TypeArgument, any>>(Element: Element): CellReified<ToTypeArgument<Element>>;
+    static get r(): typeof Cell.reified;
+    static phantom<Element extends Reified<TypeArgument, any>>(Element: Element): PhantomReified<ToTypeStr<Cell<ToTypeArgument<Element>>>>;
+    static get p(): typeof Cell.phantom;
+    static get bcs(): <Element extends BcsType<any>>(Element: Element) => BcsType<{
+        element: {
+            vec: any[];
+        };
+    }, {
+        element: {
+            vec: Iterable<any> & {
+                length: number;
+            };
+        };
+    }>;
+    static fromFields<Element extends Reified<TypeArgument, any>>(typeArg: Element, fields: Record<string, any>): Cell<ToTypeArgument<Element>>;
+    static fromFieldsWithTypes<Element extends Reified<TypeArgument, any>>(typeArg: Element, item: FieldsWithTypes): Cell<ToTypeArgument<Element>>;
+    static fromBcs<Element extends Reified<TypeArgument, any>>(typeArg: Element, data: Uint8Array): Cell<ToTypeArgument<Element>>;
+    toJSONField(): {
+        element: import("../../_framework/reified").ToJSON<Element> | null;
+    };
+    toJSON(): {
+        element: import("../../_framework/reified").ToJSON<Element> | null;
+        $typeName: string;
+        $typeArgs: [ToTypeStr<Element>];
+    };
+    static fromJSONField<Element extends Reified<TypeArgument, any>>(typeArg: Element, field: any): Cell<ToTypeArgument<Element>>;
+    static fromJSON<Element extends Reified<TypeArgument, any>>(typeArg: Element, json: Record<string, any>): Cell<ToTypeArgument<Element>>;
+    static fromSuiParsedData<Element extends Reified<TypeArgument, any>>(typeArg: Element, content: SuiParsedData): Cell<ToTypeArgument<Element>>;
+    static fromSuiObjectData<Element extends Reified<TypeArgument, any>>(typeArg: Element, data: SuiObjectData): Cell<ToTypeArgument<Element>>;
+    static fetch<Element extends Reified<TypeArgument, any>>(client: SuiClient, typeArg: Element, id: string): Promise<Cell<ToTypeArgument<Element>>>;
+}

package/sdk/src/_generated/liquid_staking/cell/structs.js

@@ -0,0 +1,156 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cell = void 0;
+exports.isCell = isCell;
+const structs_1 = require("../../_dependencies/source/0x1/option/structs");
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const index_1 = require("../index");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== Cell =============================== */
+function isCell(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::cell::Cell` + "<");
+}
+class Cell {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = Cell.$typeName;
+        this.$isPhantom = Cell.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(Cell.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.element = fields.element;
+    }
+    static reified(Element) {
+        return {
+            typeName: Cell.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Cell.$typeName, ...[(0, reified_1.extractType)(Element)]),
+            typeArgs: [(0, reified_1.extractType)(Element)],
+            isPhantom: Cell.$isPhantom,
+            reifiedTypeArgs: [Element],
+            fromFields: (fields) => Cell.fromFields(Element, fields),
+            fromFieldsWithTypes: (item) => Cell.fromFieldsWithTypes(Element, item),
+            fromBcs: (data) => Cell.fromBcs(Element, data),
+            bcs: Cell.bcs((0, reified_1.toBcs)(Element)),
+            fromJSONField: (field) => Cell.fromJSONField(Element, field),
+            fromJSON: (json) => Cell.fromJSON(Element, json),
+            fromSuiParsedData: (content) => Cell.fromSuiParsedData(Element, content),
+            fromSuiObjectData: (content) => Cell.fromSuiObjectData(Element, content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Cell.fetch(client, Element, id); }),
+            new: (fields) => {
+                return new Cell([(0, reified_1.extractType)(Element)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return Cell.reified;
+    }
+    static phantom(Element) {
+        return (0, reified_1.phantom)(Cell.reified(Element));
+    }
+    static get p() {
+        return Cell.phantom;
+    }
+    static get bcs() {
+        return (Element) => bcs_1.bcs.struct(`Cell<${Element.name}>`, {
+            element: structs_1.Option.bcs(Element),
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return Cell.reified(typeArg).new({
+            element: (0, reified_1.decodeFromFields)(structs_1.Option.reified(typeArg), fields.element),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isCell(item.type)) {
+            throw new Error("not a Cell type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return Cell.reified(typeArg).new({
+            element: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Option.reified(typeArg), item.fields.element),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        const typeArgs = [typeArg];
+        return Cell.fromFields(typeArg, Cell.bcs((0, reified_1.toBcs)(typeArgs[0])).parse(data));
+    }
+    toJSONField() {
+        return {
+            element: (0, reified_1.fieldToJSON)(`${structs_1.Option.$typeName}<${this.$typeArgs[0]}>`, this.element),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(typeArg, field) {
+        return Cell.reified(typeArg).new({
+            element: (0, reified_1.decodeFromJSONField)(structs_1.Option.reified(typeArg), field.element),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== Cell.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(Cell.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return Cell.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isCell(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a Cell object`);
+        }
+        return Cell.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isCell(data.bcs.type)) {
+                throw new Error(`object at is not a Cell object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return Cell.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return Cell.fromSuiParsedData(typeArg, data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static fetch(client, typeArg, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const res = yield client.getObject({ id, options: { showBcs: true } });
+            if (res.error) {
+                throw new Error(`error fetching Cell object at id ${id}: ${res.error.code}`);
+            }
+            if (((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject" ||
+                !isCell(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a Cell object`);
+            }
+            return Cell.fromSuiObjectData(typeArg, res.data);
+        });
+    }
+}
+exports.Cell = Cell;
+Cell.$typeName = `${index_1.PKG_V1}::cell::Cell`;
+Cell.$numTypeParams = 1;
+Cell.$isPhantom = [false];