@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/_framework/util.js

@@ -1,8 +1,8 @@
-import { bcs } from "@mysten/sui/bcs";
-export function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
+import { bcs } from '@mysten/sui/bcs';
+export function splitGenericParameters(str, genericSeparators = ['<', '>']) {
     const [left, right] = genericSeparators;
     const tok = [];
-    let word = "";
+    let word = '';
     let nestedAngleBrackets = 0;
     for (let i = 0; i < str.length; i++) {
         const char = str[i];
@@ -12,9 +12,9 @@ export function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
         if (char === right) {
             nestedAngleBrackets--;
         }
-        if (nestedAngleBrackets === 0 && char === ",") {
+        if (nestedAngleBrackets === 0 && char === ',') {
             tok.push(word.trim());
-            word = "";
+            word = '';
             continue;
         }
         word += char;
@@ -23,10 +23,10 @@ export function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
     return tok;
 }
 export function parseTypeName(name) {
-    if (typeof name !== "string") {
+    if (typeof name !== 'string') {
         throw new Error(`Illegal type passed as a name of the type: ${name}`);
     }
-    const [left, right] = ["<", ">"];
+    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.
@@ -38,52 +38,55 @@ export function parseTypeName(name) {
         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]);
+    const typeArgs = splitGenericParameters(name.slice(l_bound + 1, name.length - r_bound - 1), [
+        left,
+        right,
+    ]);
     return { typeName, typeArgs };
 }
 export function isTransactionArgument(arg) {
-    if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
+    if (!arg || typeof arg !== 'object' || Array.isArray(arg)) {
         return false;
     }
-    return ("GasCoin" in arg ||
-        "Input" in arg ||
-        "Result" in arg ||
-        "NestedResult" in arg);
+    return 'GasCoin' in arg || 'Input' in arg || 'Result' in arg || 'NestedResult' in arg;
 }
 export function obj(tx, arg) {
     return isTransactionArgument(arg) ? arg : tx.object(arg);
 }
 export function pure(tx, arg, type) {
     if (isTransactionArgument(arg)) {
+        if (typeof arg === 'function') {
+            throw new Error('Transaction plugins are not supported');
+        }
         return obj(tx, arg);
     }
     function getBcsForType(type) {
         const { typeName, typeArgs } = parseTypeName(type);
         switch (typeName) {
-            case "bool":
+            case 'bool':
                 return bcs.Bool;
-            case "u8":
+            case 'u8':
                 return bcs.U8;
-            case "u16":
+            case 'u16':
                 return bcs.U16;
-            case "u32":
+            case 'u32':
                 return bcs.U32;
-            case "u64":
+            case 'u64':
                 return bcs.U64;
-            case "u128":
+            case 'u128':
                 return bcs.U128;
-            case "u256":
+            case 'u256':
                 return bcs.U256;
-            case "address":
+            case 'address':
                 return bcs.Address;
-            case "0x1::string::String":
-            case "0x1::ascii::String":
+            case '0x1::string::String':
+            case '0x1::ascii::String':
                 return bcs.String;
-            case "0x2::object::ID":
+            case '0x2::object::ID':
                 return bcs.Address;
-            case "0x1::option::Option":
+            case '0x1::option::Option':
                 return bcs.option(getBcsForType(typeArgs[0]));
-            case "vector":
+            case 'vector':
                 return bcs.vector(getBcsForType(typeArgs[0]));
             default:
                 throw new Error(`invalid primitive type ${type}`);
@@ -91,7 +94,7 @@ export function pure(tx, arg, type) {
     }
     function hasUndefinedOrNull(items) {
         for (const item of items) {
-            if (typeof item === "undefined" || item === null) {
+            if (typeof item === 'undefined' || item === null) {
                 return true;
             }
             if (Array.isArray(item)) {
@@ -107,10 +110,10 @@ export function pure(tx, arg, type) {
                     continue;
                 }
                 switch (typeof item) {
-                    case "string":
-                    case "number":
-                    case "bigint":
-                    case "boolean":
+                    case 'string':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
                         continue;
                     default:
                         return false;
@@ -124,10 +127,10 @@ export function pure(tx, arg, type) {
         for (const item of items) {
             if (!Array.isArray(item)) {
                 switch (typeof item) {
-                    case "string":
-                    case "number":
-                    case "bigint":
-                    case "boolean":
+                    case 'string':
+                    case 'number':
+                    case 'bigint':
+                    case 'boolean':
                         return true;
                     default:
                         continue;
@@ -140,15 +143,15 @@ export function pure(tx, arg, type) {
     // handle some cases when TransactionArgument is nested within a vector or option
     const { typeName, typeArgs } = parseTypeName(type);
     switch (typeName) {
-        case "0x1::option::Option":
+        case '0x1::option::Option':
             if (arg === null) {
-                return tx.pure.option("bool", null); // 'bool' is arbitrary
+                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");
+                throw new Error('mixing primitive and TransactionArgument values is not supported');
             }
             // wrap it with some
             return tx.moveCall({
@@ -156,21 +159,21 @@ export function pure(tx, arg, type) {
                 typeArguments: [typeArgs[0]],
                 arguments: [pure(tx, arg, typeArgs[0])],
             });
-        case "vector":
+        case 'vector':
             if (!Array.isArray(arg)) {
-                throw new Error("expected an array for vector type");
+                throw new Error('expected an array for vector type');
             }
             if (arg.length === 0) {
                 return tx.pure(bcs.vector(bcs.Bool).serialize([])); // bcs.Bool is arbitrary
             }
             if (hasUndefinedOrNull(arg)) {
-                throw new Error("the provided array contains undefined or null values");
+                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");
+                throw new Error('mixing primitive and TransactionArgument values is not supported');
             }
             return tx.makeMoveVec({
                 type: typeArgs[0],
@@ -208,11 +211,11 @@ export function generic(tx, type, arg) {
     }
     else {
         const { typeName, typeArgs } = parseTypeName(type);
-        if (typeName === "vector" && Array.isArray(arg)) {
+        if (typeName === 'vector' && Array.isArray(arg)) {
             const itemType = typeArgs[0];
             return tx.makeMoveVec({
                 type: itemType,
-                elements: arg.map((item) => obj(tx, item)),
+                elements: arg.map(item => obj(tx, item)),
             });
         }
         else {
@@ -221,8 +224,8 @@ export function generic(tx, type, arg) {
     }
 }
 export function vector(tx, itemType, items) {
-    if (typeof items === "function") {
-        throw new Error("Transaction plugins are not supported");
+    if (typeof items === 'function') {
+        throw new Error('Transaction plugins are not supported');
     }
     if (typeArgIsPure(itemType)) {
         return pure(tx, items, `vector<${itemType}>`);
@@ -232,8 +235,8 @@ export function vector(tx, itemType, items) {
     }
     else {
         const { typeName: itemTypeName, typeArgs: itemTypeArgs } = parseTypeName(itemType);
-        if (itemTypeName === "0x1::option::Option") {
-            const elements = items.map((item) => option(tx, itemTypeArgs[0], item));
+        if (itemTypeName === '0x1::option::Option') {
+            const elements = items.map(item => option(tx, itemTypeArgs[0], item));
             return tx.makeMoveVec({
                 type: itemType,
                 elements,
@@ -248,23 +251,23 @@ export function vector(tx, itemType, items) {
 export 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":
+        case 'bool':
+        case 'u8':
+        case 'u16':
+        case 'u32':
+        case 'u64':
+        case 'u128':
+        case 'u256':
+        case 'address':
+        case 'signer':
             return true;
-        case "vector":
+        case 'vector':
             return typeArgIsPure(typeArgs[0]);
-        case "0x1::string::String":
-        case "0x1::ascii::String":
-        case "0x2::object::ID":
+        case '0x1::string::String':
+        case '0x1::ascii::String':
+        case '0x2::object::ID':
             return true;
-        case "0x1::option::Option":
+        case '0x1::option::Option':
             return typeArgIsPure(typeArgs[0]);
         default:
             return false;
@@ -272,37 +275,37 @@ export function typeArgIsPure(type) {
 }
 export function compressSuiAddress(addr) {
     // remove leading zeros
-    const stripped = addr.split("0x").join("");
+    const stripped = addr.split('0x').join('');
     for (let i = 0; i < stripped.length; i++) {
-        if (stripped[i] !== "0") {
+        if (stripped[i] !== '0') {
             return `0x${stripped.substring(i)}`;
         }
     }
-    return "0x0";
+    return '0x0';
 }
 // Recursively removes leading zeros from a type.
 // e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
 export 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":
+        case 'bool':
+        case 'u8':
+        case 'u16':
+        case 'u32':
+        case 'u64':
+        case 'u128':
+        case 'u256':
+        case 'address':
+        case 'signer':
             return typeName;
-        case "vector":
+        case 'vector':
             return `vector<${compressSuiType(typeArgs[0])}>`;
         default: {
-            const tok = typeName.split("::");
+            const tok = typeName.split('::');
             tok[0] = compressSuiAddress(tok[0]);
-            const compressedName = tok.join("::");
+            const compressedName = tok.join('::');
             if (typeArgs.length > 0) {
-                return `${compressedName}<${typeArgs.map((typeArg) => compressSuiType(typeArg)).join(",")}>`;
+                return `${compressedName}<${typeArgs.map(typeArg => compressSuiType(typeArg)).join(',')}>`;
             }
             else {
                 return compressedName;
@@ -312,7 +315,7 @@ export function compressSuiType(type) {
 }
 export function composeSuiType(typeName, ...typeArgs) {
     if (typeArgs.length > 0) {
-        return `${typeName}<${typeArgs.join(", ")}>`;
+        return `${typeName}<${typeArgs.join(', ')}>`;
     }
     else {
         return typeName;

package/_generated/_framework/vector.d.ts

@@ -1,8 +1,14 @@
-import { bcs } from "@mysten/sui/bcs";
-import { Reified, ToField, ToTypeArgument, ToTypeStr, TypeArgument, VectorClass, VectorClassReified } from "./reified";
-import { FieldsWithTypes } from "./util";
+import { bcs } from '@mysten/sui/bcs';
+import { Reified, ToField, ToJSON, 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 type VectorJSONField<T extends TypeArgument> = ToJSON<T>[];
+export type VectorJSON<T extends TypeArgument> = {
+    $typeName: 'vector';
+    $typeArgs: [ToTypeStr<T>];
+    elements: VectorJSONField<T>;
+};
 export declare class Vector<T extends TypeArgument> implements VectorClass {
     __VectorClass: true;
     static readonly $typeName = "vector";
@@ -20,12 +26,8 @@ export declare class Vector<T extends TypeArgument> implements VectorClass {
     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>[];
-    };
+    toJSONField(): VectorJSONField<T>;
+    toJSON(): VectorJSON<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>>;
 }

package/_generated/_framework/vector.js

@@ -1,12 +1,12 @@
-import { bcs } from "@mysten/sui/bcs";
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, toBcs, fieldToJSON, } from "./reified.js";
-import { composeSuiType } from "./util.js";
+import { bcs } from '@mysten/sui/bcs';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, toBcs, } from './reified.js';
+import { composeSuiType } from './util.js';
 export class Vector {
     __VectorClass = true;
-    static $typeName = "vector";
+    static $typeName = 'vector';
     static $numTypeParams = 1;
     static $isPhantom = [false];
-    $typeName = "vector";
+    $typeName = 'vector';
     $fullTypeName;
     $typeArgs;
     $isPhantom = [false];
@@ -32,7 +32,7 @@ export class Vector {
             new: (elements) => {
                 return new Vector([extractType(T)], elements);
             },
-            kind: "VectorClassReified",
+            kind: 'VectorClassReified',
         };
     }
     static get r() {
@@ -42,7 +42,7 @@ export class Vector {
         return bcs.vector;
     }
     static fromFields(typeArg, elements) {
-        return Vector.reified(typeArg).new(elements.map((element) => decodeFromFields(typeArg, element)));
+        return Vector.reified(typeArg).new(elements.map(element => decodeFromFields(typeArg, element)));
     }
     static fromFieldsWithTypes(typeArg, item) {
         return Vector.reified(typeArg).new(item.map((field) => decodeFromFieldsWithTypes(typeArg, field)));
@@ -51,7 +51,7 @@ export class Vector {
         return Vector.fromFields(typeArg, Vector.bcs(toBcs(typeArg)).parse(data));
     }
     toJSONField() {
-        return this.elements.map((element) => fieldToJSON(this.$typeArgs[0], element));
+        return this.elements.map(element => fieldToJSON(this.$typeArgs[0], element));
     }
     toJSON() {
         return {
@@ -61,11 +61,11 @@ export class Vector {
         };
     }
     static fromJSONField(typeArg, field) {
-        return Vector.reified(typeArg).new(field.map((field) => decodeFromJSONField(typeArg, field)));
+        return Vector.reified(typeArg).new(field.map(field => decodeFromJSONField(typeArg, field)));
     }
     static fromJSON(typeArg, json) {
         if (json.$typeName !== Vector.$typeName) {
-            throw new Error("not a vector json object");
+            throw new Error('not a vector json object');
         }
         return Vector.fromJSONField(typeArg, json.elements);
     }

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

@@ -1,44 +1,46 @@
-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 { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { Option } from '../../_dependencies/std/option/structs';
+import { PhantomReified, Reified, StructClass, ToField, ToJSON, ToTypeArgument, ToTypeStr, TypeArgument } from '../../_framework/reified';
+import { FieldsWithTypes } from '../../_framework/util';
 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 type CellJSONField<Element extends TypeArgument> = {
+    element: ToJSON<Element> | null;
+};
+export type CellJSON<Element extends TypeArgument> = {
+    $typeName: typeof Cell.$typeName;
+    $typeArgs: [ToTypeStr<Element>];
+} & CellJSONField<Element>;
 export declare class Cell<Element extends TypeArgument> implements StructClass {
     __StructClass: true;
-    static readonly $typeName: string;
+    static get $typeName(): `${string}::cell::Cell`;
     static readonly $numTypeParams = 1;
     static readonly $isPhantom: readonly [false];
-    readonly $typeName: string;
-    readonly $fullTypeName: `${typeof PKG_V1}::cell::Cell<${ToTypeStr<Element>}>`;
+    readonly $typeName: typeof Cell.$typeName;
+    readonly $fullTypeName: `${string}::cell::Cell<${ToTypeStr<Element>}>`;
     readonly $typeArgs: [ToTypeStr<Element>];
-    readonly $isPhantom: readonly [false];
+    readonly $isPhantom: typeof Cell.$isPhantom;
     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) => import("@mysten/bcs").BcsStruct<{
-        element: BcsType<any, any, string>;
-    }, string>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof Cell.instantiateBcs>;
     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>];
-    };
+    toJSONField(): CellJSONField<Element>;
+    toJSON(): CellJSON<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 fetch<Element extends Reified<TypeArgument, any>>(client: SuiGrpcClient, typeArg: Element, id: string): Promise<Cell<ToTypeArgument<Element>>>;
+    static fromCoreObject<Element extends Reified<TypeArgument, any>>(typeArg: Element, obj: SuiClientTypes.Object<{
+        content: true;
+    }>): Cell<ToTypeArgument<Element>>;
+    static fetch<Element extends Reified<TypeArgument, any>>(client: ClientWithCoreApi, typeArg: Element, id: string): Promise<Cell<ToTypeArgument<Element>>>;
 }

package/_generated/suilend/cell/structs.js

@@ -1,16 +1,18 @@
-import { Option } from "../../_dependencies/source/0x1/option/structs.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { PKG_V1 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
+import { bcs } from '@mysten/sui/bcs';
+import { Option } from '../../_dependencies/std/option/structs.js';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../_framework/util.js';
 /* ============================== Cell =============================== */
 export function isCell(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::cell::Cell` + "<");
+    return type.startsWith(`${getTypeOrigin('suilend', 'cell::Cell')}::cell::Cell` + '<');
 }
 export class Cell {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::cell::Cell`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'cell::Cell')}::cell::Cell`;
+    }
     static $numTypeParams = 1;
     static $isPhantom = [false];
     $typeName = Cell.$typeName;
@@ -24,23 +26,31 @@ export class Cell {
         this.element = fields.element;
     }
     static reified(Element) {
+        const reifiedBcs = Cell.bcs(toBcs(Element));
         return {
-            typeName: Cell.$typeName,
-            fullTypeName: composeSuiType(Cell.$typeName, ...[extractType(Element)]),
-            typeArgs: [extractType(Element)],
+            get typeName() {
+                return Cell.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(Cell.$typeName, ...[extractType(Element)]);
+            },
+            get typeArgs() {
+                return [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(toBcs(Element)),
+            fromBcs: (data) => Cell.fromFields(Element, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => Cell.fromJSONField(Element, field),
             fromJSON: (json) => Cell.fromJSON(Element, json),
+            fromCoreObject: (obj) => Cell.fromCoreObject(Element, obj),
             fetch: async (client, id) => Cell.fetch(client, Element, id),
             new: (fields) => {
                 return new Cell([extractType(Element)], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -52,11 +62,18 @@ export class Cell {
     static get p() {
         return Cell.phantom;
     }
-    static get bcs() {
+    static instantiateBcs() {
         return (Element) => bcs.struct(`Cell<${Element.name}>`, {
             element: Option.bcs(Element),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!Cell.cachedBcs) {
+            Cell.cachedBcs = Cell.instantiateBcs();
+        }
+        return Cell.cachedBcs;
+    }
     static fromFields(typeArg, fields) {
         return Cell.reified(typeArg).new({
             element: decodeFromFields(Option.reified(typeArg), fields.element),
@@ -64,7 +81,7 @@ export class Cell {
     }
     static fromFieldsWithTypes(typeArg, item) {
         if (!isCell(item.type)) {
-            throw new Error("not a Cell type");
+            throw new Error('not a Cell type');
         }
         assertFieldsWithTypesArgsMatch(item, [typeArg]);
         return Cell.reified(typeArg).new({
@@ -73,7 +90,7 @@ export class Cell {
     }
     static fromBcs(typeArg, data) {
         const typeArgs = [typeArg];
-        return Cell.fromFields(typeArg, Cell.bcs(toBcs(typeArgs[0])).parse(data));
+        return Cell.fromFields(typeArg, Cell.bcs(toBcs(typeArg)).parse(data));
     }
     toJSONField() {
         return {
@@ -81,11 +98,7 @@ export class Cell {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(typeArg, field) {
         return Cell.reified(typeArg).new({
@@ -94,16 +107,47 @@ export class Cell {
     }
     static fromJSON(typeArg, json) {
         if (json.$typeName !== Cell.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a Cell json object: expected '${Cell.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(Cell.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
+        assertReifiedTypeArgsMatch(composeSuiType(Cell.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
         return Cell.fromJSONField(typeArg, json);
     }
+    static fromCoreObject(typeArg, obj) {
+        if (!isCell(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a Cell 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 Cell.fromBcs(typeArg, obj.content);
+    }
     static async fetch(client, typeArg, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isCell(object.type)) {
             throw new Error(`object at id ${id} is not a Cell 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 Cell.fromBcs(typeArg, object.content);
     }
 }