@suilend/sdk 1.0.9 → 1.1.1

package/mainnet/_generated/_framework/util.d.ts

@@ -1,52 +1,40 @@
-import { TransactionArgument, TransactionBlock, TransactionObjectArgument } from "@mysten/sui.js/transactions";
-import { ObjectArg as SuiObjectArg } from "@mysten/sui.js/bcs";
+import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
 export interface FieldsWithTypes {
     fields: Record<string, any>;
     type: string;
 }
 export type ObjectId = string;
-export type ObjectCallArg = {
-    Object: SuiObjectArg;
-};
-export type ObjectArg = string | ObjectCallArg | TransactionArgument;
 export type PureArg = bigint | string | number | boolean | null | TransactionArgument | Array<PureArg>;
-export type GenericArg = ObjectArg | PureArg | Array<ObjectArg> | Array<PureArg> | Array<GenericArg>;
+export type GenericArg = TransactionObjectInput | PureArg | Array<TransactionObjectInput> | Array<PureArg> | Array<GenericArg>;
+export declare function splitGenericParameters(str: string, genericSeparators?: [string, string]): string[];
 export declare function parseTypeName(name: string): {
     typeName: string;
     typeArgs: string[];
 };
 export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
-export declare function isTransactionObjectArgument(arg: GenericArg): arg is TransactionObjectArgument;
-export declare function obj(txb: TransactionBlock, arg: ObjectArg): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function pure(txb: TransactionBlock, arg: PureArg, type: string): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function option(txb: TransactionBlock, type: string, arg: GenericArg | null): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function generic(txb: TransactionBlock, type: string, arg: GenericArg): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
-export declare function vector(txb: TransactionBlock, itemType: string, items: Array<GenericArg> | TransactionArgument): {
-    index: number;
-    kind: "Input";
-    type: "pure";
-    value?: any;
-} | TransactionObjectArgument;
+export declare function obj(tx: Transaction, arg: TransactionObjectInput): {
+    GasCoin: true;
+} | {
+    Input: number;
+    type?: "object" | "pure" | undefined;
+} | {
+    Result: number;
+} | {
+    NestedResult: [number, number];
+} | ((tx: Transaction) => {
+    GasCoin: true;
+} | {
+    Input: number;
+    type?: "object" | "pure" | undefined;
+} | {
+    Result: number;
+} | {
+    NestedResult: [number, number];
+});
+export declare function pure(tx: Transaction, arg: PureArg, type: string): TransactionArgument;
+export declare function option(tx: Transaction, type: string, arg: GenericArg | null): TransactionArgument;
+export declare function generic(tx: Transaction, type: string, arg: GenericArg): TransactionArgument;
+export declare function vector(tx: Transaction, itemType: string, items: Array<GenericArg> | TransactionArgument): TransactionArgument;
 export declare function typeArgIsPure(type: string): boolean;
 export declare function compressSuiAddress(addr: string): string;
 export declare function compressSuiType(type: string): string;

package/mainnet/_generated/_framework/util.js

@@ -1,36 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.composeSuiType = exports.compressSuiType = exports.compressSuiAddress = exports.typeArgIsPure = exports.vector = exports.generic = exports.option = exports.pure = exports.obj = exports.isTransactionObjectArgument = exports.isTransactionArgument = exports.parseTypeName = void 0;
-const bcs_1 = require("@mysten/sui.js/bcs");
+exports.composeSuiType = exports.compressSuiType = exports.compressSuiAddress = exports.typeArgIsPure = exports.vector = exports.generic = exports.option = exports.pure = exports.obj = exports.isTransactionArgument = exports.parseTypeName = exports.splitGenericParameters = void 0;
+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;
+}
+exports.splitGenericParameters = splitGenericParameters;
 function parseTypeName(name) {
-    const parsed = bcs_1.bcs.parseTypeName(name);
-    return { typeName: parsed.name, typeArgs: parsed.params };
+    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 };
 }
 exports.parseTypeName = parseTypeName;
 function isTransactionArgument(arg) {
     if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
         return false;
     }
-    return "kind" in arg;
+    return ("GasCoin" in arg ||
+        "Input" in arg ||
+        "Result" in arg ||
+        "NestedResult" in arg);
 }
 exports.isTransactionArgument = isTransactionArgument;
-function isTransactionObjectArgument(arg) {
-    if (!isTransactionArgument(arg)) {
-        return false;
-    }
-    if (arg.kind === "Input" && arg.type === "pure") {
-        return false;
-    }
-    return true;
-}
-exports.isTransactionObjectArgument = isTransactionObjectArgument;
-function obj(txb, arg) {
-    return isTransactionArgument(arg) ? arg : txb.object(arg);
+function obj(tx, arg) {
+    return isTransactionArgument(arg) ? arg : tx.object(arg);
 }
 exports.obj = obj;
-function pure(txb, arg, type) {
+function pure(tx, arg, type) {
     if (isTransactionArgument(arg)) {
-        return obj(txb, arg);
+        return obj(tx, arg);
     }
     function getBcsForType(type) {
         const { typeName, typeArgs } = parseTypeName(type);
@@ -64,92 +96,146 @@ function pure(txb, arg, type) {
                 throw new Error(`invalid primitive type ${type}`);
         }
     }
-    function isOrHasNestedTransactionArgument(arg) {
-        if (Array.isArray(arg)) {
-            return arg.some((item) => isOrHasNestedTransactionArgument(item));
+    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 isTransactionArgument(arg);
+        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 txb.pure(bcs_1.bcs.option(bcs_1.bcs.Bool).serialize(null)); // bcs.Bool is arbitrary
+                return tx.pure.option("bool", null); // 'bool' is arbitrary
             }
-            if (isOrHasNestedTransactionArgument(arg)) {
-                throw new Error("nesting TransactionArgument is not supported");
+            if (consistsOnlyOfPrimitiveValues([arg])) {
+                return tx.pure(getBcsForType(type).serialize(arg));
             }
-            break;
+            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 txb.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
+                return tx.pure(bcs_1.bcs.vector(bcs_1.bcs.Bool).serialize([])); // bcs.Bool is arbitrary
             }
-            if (arg.some((arg) => Array.isArray(arg) && isOrHasNestedTransactionArgument(arg))) {
-                throw new Error("nesting TransactionArgument is not supported");
+            if (hasUndefinedOrNull(arg)) {
+                throw new Error("the provided array contains undefined or null values");
             }
-            if (isTransactionArgument(arg[0]) &&
-                arg.filter((arg) => !isTransactionArgument(arg)).length > 0) {
-                throw new Error("mixing TransactionArgument with other types is not supported");
+            if (consistsOnlyOfPrimitiveValues(arg)) {
+                return tx.pure(getBcsForType(type).serialize(arg));
             }
-            if (isTransactionObjectArgument(arg[0])) {
-                return txb.makeMoveVec({
-                    objects: arg,
-                    type: typeArgs[0],
-                });
+            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));
     }
-    return txb.pure(getBcsForType(type).serialize(arg));
 }
 exports.pure = pure;
-function option(txb, type, arg) {
+function option(tx, type, arg) {
     if (isTransactionArgument(arg)) {
         return arg;
     }
     if (typeArgIsPure(type)) {
-        return pure(txb, arg, `0x1::option::Option<${type}>`);
+        return pure(tx, arg, `0x1::option::Option<${type}>`);
     }
     if (arg === null) {
-        return txb.moveCall({
+        return tx.moveCall({
             target: `0x1::option::none`,
             typeArguments: [type],
             arguments: [],
         });
     }
     // wrap it with some
-    const val = generic(txb, type, arg);
-    return txb.moveCall({
+    const val = generic(tx, type, arg);
+    return tx.moveCall({
         target: `0x1::option::some`,
         typeArguments: [type],
         arguments: [val],
     });
 }
 exports.option = option;
-function generic(txb, type, arg) {
+function generic(tx, type, arg) {
     if (typeArgIsPure(type)) {
-        return pure(txb, arg, type);
+        return pure(tx, arg, type);
     }
     else {
         const { typeName, typeArgs } = parseTypeName(type);
         if (typeName === "vector" && Array.isArray(arg)) {
             const itemType = typeArgs[0];
-            return txb.makeMoveVec({
-                objects: arg.map((item) => obj(txb, item)),
+            return tx.makeMoveVec({
                 type: itemType,
+                elements: arg.map((item) => obj(tx, item)),
             });
         }
         else {
-            return obj(txb, arg);
+            return obj(tx, arg);
         }
     }
 }
 exports.generic = generic;
-function vector(txb, itemType, items) {
+function vector(tx, itemType, items) {
+    if (typeof items === "function") {
+        throw new Error("Transaction plugins are not supported");
+    }
     if (typeArgIsPure(itemType)) {
-        return pure(txb, items, `vector<${itemType}>`);
+        return pure(tx, items, `vector<${itemType}>`);
     }
     else if (isTransactionArgument(items)) {
         return items;
@@ -157,15 +243,15 @@ function vector(txb, itemType, items) {
     else {
         const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType);
         if (itemTypeName === "0x1::option::Option") {
-            const objects = items.map((item) => option(txb, itemTypeArgs[0], item));
-            return txb.makeMoveVec({
-                objects,
+            const elements = items.map((item) => option(tx, itemTypeArgs[0], item));
+            return tx.makeMoveVec({
                 type: itemType,
+                elements,
             });
         }
-        return txb.makeMoveVec({
-            objects: items,
+        return tx.makeMoveVec({
             type: itemType,
+            elements: items,
         });
     }
 }

package/mainnet/_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;
+    }> | undefined) => 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/mainnet/_generated/_framework/vector.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vector = exports.Vector = void 0;
+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);
+}
+exports.vector = vector;

package/mainnet/_generated/suilend/cell/structs.d.ts

@@ -1,19 +1,23 @@
 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 { BcsType } from "@mysten/bcs";
-import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+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 = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell";
     static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [false];
     readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell";
-    readonly $fullTypeName: `0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell<${ToTypeStr<Element>}>`;
+    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>>;
@@ -45,5 +49,6 @@ export declare class Cell<Element extends TypeArgument> implements StructClass {
     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/mainnet/_generated/suilend/cell/structs.js

@@ -13,16 +13,20 @@ exports.Cell = exports.isCell = void 0;
 const structs_1 = require("../../_dependencies/source/0x1/option/structs");
 const reified_1 = require("../../_framework/reified");
 const util_1 = require("../../_framework/util");
-const bcs_1 = require("@mysten/bcs");
+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("0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell<");
+    return type.startsWith(`${index_1.PKG_V1}::cell::Cell` + "<");
 }
 exports.isCell = isCell;
 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;
@@ -32,6 +36,7 @@ class Cell {
             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),
@@ -40,6 +45,7 @@ class Cell {
             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);
@@ -81,7 +87,7 @@ class Cell {
     }
     toJSONField() {
         return {
-            element: (0, reified_1.fieldToJSON)(`0x1::option::Option<${this.$typeArgs[0]}>`, this.element),
+            element: (0, reified_1.fieldToJSON)(`${structs_1.Option.$typeName}<${this.$typeArgs[0]}>`, this.element),
         };
     }
     toJSON() {
@@ -108,6 +114,27 @@ class Cell {
         }
         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;
@@ -119,10 +146,11 @@ class Cell {
                 !isCell(res.data.bcs.type)) {
                 throw new Error(`object at id ${id} is not a Cell object`);
             }
-            return Cell.fromBcs(typeArg, (0, bcs_1.fromB64)(res.data.bcs.bcsBytes));
+            return Cell.fromSuiObjectData(typeArg, res.data);
         });
     }
 }
 exports.Cell = Cell;
-Cell.$typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::cell::Cell";
+Cell.$typeName = `${index_1.PKG_V1}::cell::Cell`;
 Cell.$numTypeParams = 1;
+Cell.$isPhantom = [false];

package/mainnet/_generated/suilend/decimal/structs.d.ts

@@ -1,24 +1,28 @@
 import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../_framework/reified";
 import { FieldsWithTypes } from "../../_framework/util";
-import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+import { PKG_V1 } from "../index";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
 export declare function isDecimal(type: string): boolean;
 export interface DecimalFields {
     value: ToField<"u256">;
 }
 export type DecimalReified = Reified<Decimal, DecimalFields>;
 export declare class Decimal implements StructClass {
+    __StructClass: true;
     static readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::decimal::Decimal";
     static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
     readonly $typeName = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::decimal::Decimal";
-    readonly $fullTypeName: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::decimal::Decimal";
+    readonly $fullTypeName: `${typeof PKG_V1}::decimal::Decimal`;
     readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
     readonly value: ToField<"u256">;
     private constructor();
     static reified(): DecimalReified;
     static get r(): import("../../_framework/reified").StructClassReified<Decimal, DecimalFields>;
     static phantom(): PhantomReified<ToTypeStr<Decimal>>;
     static get p(): PhantomReified<"0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::decimal::Decimal">;
-    static get bcs(): import("@mysten/bcs").BcsType<{
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
         value: string;
     }, {
         value: string | number | bigint;
@@ -37,5 +41,6 @@ export declare class Decimal implements StructClass {
     static fromJSONField(field: any): Decimal;
     static fromJSON(json: Record<string, any>): Decimal;
     static fromSuiParsedData(content: SuiParsedData): Decimal;
+    static fromSuiObjectData(data: SuiObjectData): Decimal;
     static fetch(client: SuiClient, id: string): Promise<Decimal>;
 }