@suilend/springsui-cli 1.0.13 → 2.0.0

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

@@ -1,6 +1,6 @@
 import { BcsType } from "@mysten/sui/bcs";
 import { FieldsWithTypes } from "./util";
-import { SuiClient, SuiParsedData, SuiObjectData } from "@mysten/sui/client";
+import { SuiJsonRpcClient, SuiParsedData, SuiObjectData } from "@mysten/sui/jsonRpc";
 export { vector } from "./vector";
 export interface StructClass {
     readonly $typeName: string;
@@ -37,7 +37,7 @@ export interface StructClassReified<T extends StructClass, Fields> {
     fromJSON: (json: Record<string, any>) => T;
     fromSuiParsedData: (content: SuiParsedData) => T;
     fromSuiObjectData: (data: SuiObjectData) => T;
-    fetch: (client: SuiClient, id: string) => Promise<T>;
+    fetch: (client: SuiJsonRpcClient, id: string) => Promise<T>;
     new: (fields: Fields) => T;
     kind: "StructClassReified";
 }

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

@@ -1,22 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.vector = void 0;
-exports.phantom = phantom;
-exports.toBcs = toBcs;
-exports.extractType = extractType;
-exports.decodeFromFields = decodeFromFields;
-exports.decodeFromFieldsWithTypes = decodeFromFieldsWithTypes;
-exports.assertReifiedTypeArgsMatch = assertReifiedTypeArgsMatch;
-exports.assertFieldsWithTypesArgsMatch = assertFieldsWithTypesArgsMatch;
-exports.fieldToJSON = fieldToJSON;
-exports.decodeFromJSONField = decodeFromJSONField;
-const bcs_1 = require("@mysten/sui/bcs");
-const utils_1 = require("@mysten/sui/utils");
-const util_1 = require("./util");
+import { bcs } from "@mysten/sui/bcs";
+import { fromHex, toHex } from "@mysten/sui/utils";
+import { compressSuiType, parseTypeName } from "./util";
 // for backwards compatibility
-var vector_1 = require("./vector");
-Object.defineProperty(exports, "vector", { enumerable: true, get: function () { return vector_1.vector; } });
-function phantom(type) {
+export { vector } from "./vector";
+export function phantom(type) {
     if (typeof type === "string") {
         return {
             phantomType: type,
@@ -30,33 +17,33 @@ function phantom(type) {
         };
     }
 }
-const Address = bcs_1.bcs.bytes(32).transform({
-    input: (val) => (0, utils_1.fromHEX)(val),
-    output: (val) => (0, utils_1.toHEX)(val),
+const Address = bcs.bytes(32).transform({
+    input: (val) => fromHex(val),
+    output: (val) => toHex(val),
 });
-function toBcs(arg) {
+export function toBcs(arg) {
     switch (arg) {
         case "bool":
-            return bcs_1.bcs.bool();
+            return bcs.bool();
         case "u8":
-            return bcs_1.bcs.u8();
+            return bcs.u8();
         case "u16":
-            return bcs_1.bcs.u16();
+            return bcs.u16();
         case "u32":
-            return bcs_1.bcs.u32();
+            return bcs.u32();
         case "u64":
-            return bcs_1.bcs.u64();
+            return bcs.u64();
         case "u128":
-            return bcs_1.bcs.u128();
+            return bcs.u128();
         case "u256":
-            return bcs_1.bcs.u256();
+            return bcs.u256();
         case "address":
             return Address;
         default:
             return arg.bcs;
     }
 }
-function extractType(reified) {
+export function extractType(reified) {
     switch (reified) {
         case "u8":
         case "u16":
@@ -78,7 +65,7 @@ function extractType(reified) {
     }
     throw new Error("unreachable");
 }
-function decodeFromFields(reified, field) {
+export function decodeFromFields(reified, field) {
     switch (reified) {
         case "bool":
         case "u8":
@@ -117,7 +104,7 @@ function decodeFromFields(reified, field) {
             return reified.fromFields(field);
     }
 }
-function decodeFromFieldsWithTypes(reified, item) {
+export function decodeFromFieldsWithTypes(reified, item) {
     switch (reified) {
         case "bool":
         case "u8":
@@ -154,23 +141,23 @@ function decodeFromFieldsWithTypes(reified, item) {
             return reified.fromFieldsWithTypes(item);
     }
 }
-function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
+export function assertReifiedTypeArgsMatch(fullType, typeArgs, reifiedTypeArgs) {
     if (reifiedTypeArgs.length !== typeArgs.length) {
         throw new Error(`provided item has mismatching number of type argments ${fullType} (expected ${reifiedTypeArgs.length}, got ${typeArgs.length}))`);
     }
     for (let i = 0; i < typeArgs.length; i++) {
-        if ((0, util_1.compressSuiType)(typeArgs[i]) !==
-            (0, util_1.compressSuiType)(extractType(reifiedTypeArgs[i]))) {
+        if (compressSuiType(typeArgs[i]) !==
+            compressSuiType(extractType(reifiedTypeArgs[i]))) {
             throw new Error(`provided item has mismatching type argments ${fullType} (expected ${extractType(reifiedTypeArgs[i])}, got ${typeArgs[i]}))`);
         }
     }
 }
-function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
-    const { typeArgs: itemTypeArgs } = (0, util_1.parseTypeName)(item.type);
+export function assertFieldsWithTypesArgsMatch(item, reifiedTypeArgs) {
+    const { typeArgs: itemTypeArgs } = parseTypeName(item.type);
     assertReifiedTypeArgsMatch(item.type, itemTypeArgs, reifiedTypeArgs);
 }
-function fieldToJSON(type, field) {
-    const { typeName, typeArgs } = (0, util_1.parseTypeName)(type);
+export function fieldToJSON(type, field) {
+    const { typeName, typeArgs } = parseTypeName(type);
     switch (typeName) {
         case "bool":
             return field;
@@ -204,7 +191,7 @@ function fieldToJSON(type, field) {
             return field.toJSONField();
     }
 }
-function decodeFromJSONField(typeArg, field) {
+export function decodeFromJSONField(typeArg, field) {
     switch (typeArg) {
         case "bool":
         case "u8":

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

@@ -1,4 +1,4 @@
-import { Transaction, TransactionArgument, TransactionObjectInput } from "@mysten/sui/transactions";
+import { Transaction, TransactionArgument, TransactionObjectArgument, TransactionObjectInput } from "@mysten/sui/transactions";
 export interface FieldsWithTypes {
     fields: Record<string, any>;
     type: string;
@@ -12,19 +12,7 @@ export declare function parseTypeName(name: string): {
     typeArgs: string[];
 };
 export declare function isTransactionArgument(arg: GenericArg): arg is TransactionArgument;
-export declare function obj(tx: Transaction, arg: TransactionObjectInput): {
-    GasCoin: true;
-} | {
-    Input: number;
-    type?: "pure" | "object";
-} | {
-    Result: number;
-} | {
-    NestedResult: [number, number];
-} | ((tx: Transaction) => Exclude<import("valibot").InferInput<typeof import("@mysten/sui/dist/cjs/transactions/data/internal").ArgumentSchema>, {
-    Input: unknown;
-    type?: "pure";
-}>) | import("@mysten/sui/dist/cjs/transactions/Transaction").AsyncTransactionThunk<import("@mysten/sui/dist/cjs/transactions/Transaction").TransactionResultArgument>;
+export declare function obj(tx: Transaction, arg: TransactionObjectInput): TransactionObjectArgument;
 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;

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

@@ -1,19 +1,5 @@
-"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 = ["<", ">"]) {
+import { bcs } from "@mysten/sui/bcs";
+export function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
     const [left, right] = genericSeparators;
     const tok = [];
     let word = "";
@@ -36,7 +22,7 @@ function splitGenericParameters(str, genericSeparators = ["<", ">"]) {
     tok.push(word.trim());
     return tok;
 }
-function parseTypeName(name) {
+export function parseTypeName(name) {
     if (typeof name !== "string") {
         throw new Error(`Illegal type passed as a name of the type: ${name}`);
     }
@@ -55,7 +41,7 @@ function parseTypeName(name) {
     const typeArgs = splitGenericParameters(name.slice(l_bound + 1, name.length - r_bound - 1), [left, right]);
     return { typeName, typeArgs };
 }
-function isTransactionArgument(arg) {
+export function isTransactionArgument(arg) {
     if (!arg || typeof arg !== "object" || Array.isArray(arg)) {
         return false;
     }
@@ -64,10 +50,10 @@ function isTransactionArgument(arg) {
         "Result" in arg ||
         "NestedResult" in arg);
 }
-function obj(tx, arg) {
+export function obj(tx, arg) {
     return isTransactionArgument(arg) ? arg : tx.object(arg);
 }
-function pure(tx, arg, type) {
+export function pure(tx, arg, type) {
     if (isTransactionArgument(arg)) {
         return obj(tx, arg);
     }
@@ -75,30 +61,30 @@ function pure(tx, arg, type) {
         const { typeName, typeArgs } = parseTypeName(type);
         switch (typeName) {
             case "bool":
-                return bcs_1.bcs.Bool;
+                return bcs.Bool;
             case "u8":
-                return bcs_1.bcs.U8;
+                return bcs.U8;
             case "u16":
-                return bcs_1.bcs.U16;
+                return bcs.U16;
             case "u32":
-                return bcs_1.bcs.U32;
+                return bcs.U32;
             case "u64":
-                return bcs_1.bcs.U64;
+                return bcs.U64;
             case "u128":
-                return bcs_1.bcs.U128;
+                return bcs.U128;
             case "u256":
-                return bcs_1.bcs.U256;
+                return bcs.U256;
             case "address":
-                return bcs_1.bcs.Address;
+                return bcs.Address;
             case "0x1::string::String":
             case "0x1::ascii::String":
-                return bcs_1.bcs.String;
+                return bcs.String;
             case "0x2::object::ID":
-                return bcs_1.bcs.Address;
+                return bcs.Address;
             case "0x1::option::Option":
-                return bcs_1.bcs.option(getBcsForType(typeArgs[0]));
+                return bcs.option(getBcsForType(typeArgs[0]));
             case "vector":
-                return bcs_1.bcs.vector(getBcsForType(typeArgs[0]));
+                return bcs.vector(getBcsForType(typeArgs[0]));
             default:
                 throw new Error(`invalid primitive type ${type}`);
         }
@@ -175,7 +161,7 @@ function pure(tx, arg, type) {
                 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
+                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");
@@ -194,7 +180,7 @@ function pure(tx, arg, type) {
             return tx.pure(getBcsForType(type).serialize(arg));
     }
 }
-function option(tx, type, arg) {
+export function option(tx, type, arg) {
     if (isTransactionArgument(arg)) {
         return arg;
     }
@@ -216,7 +202,7 @@ function option(tx, type, arg) {
         arguments: [val],
     });
 }
-function generic(tx, type, arg) {
+export function generic(tx, type, arg) {
     if (typeArgIsPure(type)) {
         return pure(tx, arg, type);
     }
@@ -234,7 +220,7 @@ function generic(tx, type, arg) {
         }
     }
 }
-function vector(tx, itemType, items) {
+export function vector(tx, itemType, items) {
     if (typeof items === "function") {
         throw new Error("Transaction plugins are not supported");
     }
@@ -259,7 +245,7 @@ function vector(tx, itemType, items) {
         });
     }
 }
-function typeArgIsPure(type) {
+export function typeArgIsPure(type) {
     const { typeName, typeArgs } = parseTypeName(type);
     switch (typeName) {
         case "bool":
@@ -284,7 +270,7 @@ function typeArgIsPure(type) {
             return false;
     }
 }
-function compressSuiAddress(addr) {
+export function compressSuiAddress(addr) {
     // remove leading zeros
     const stripped = addr.split("0x").join("");
     for (let i = 0; i < stripped.length; i++) {
@@ -296,7 +282,7 @@ function compressSuiAddress(addr) {
 }
 // Recursively removes leading zeros from a type.
 // e.g. `0x00000002::module::Name<0x00001::a::C>` -> `0x2::module::Name<0x1::a::C>`
-function compressSuiType(type) {
+export function compressSuiType(type) {
     const { typeName, typeArgs } = parseTypeName(type);
     switch (typeName) {
         case "bool":
@@ -324,7 +310,7 @@ function compressSuiType(type) {
         }
     }
 }
-function composeSuiType(typeName, ...typeArgs) {
+export function composeSuiType(typeName, ...typeArgs) {
     if (typeArgs.length > 0) {
         return `${typeName}<${typeArgs.join(", ")}>`;
     }

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

@@ -16,14 +16,14 @@ export declare class Vector<T extends TypeArgument> implements VectorClass {
     static reified<T extends Reified<TypeArgument, any>>(T: T): VectorReified<ToTypeArgument<T>>;
     static get r(): typeof Vector.reified;
     static get bcs(): {
-        <T extends import("@mysten/sui/bcs").BcsType<any>, Name extends string = `vector<${T["name"]}>`>(type: T, options?: import("@mysten/sui/bcs").BcsTypeOptions<import("@mysten/bcs").InferBcsType<T>[], Iterable<import("@mysten/bcs").InferBcsInput<T>> & {
+        <T extends import("@mysten/bcs").BcsType<any>, Name extends string = `vector<${T["name"]}>`>(type: T, options?: import("@mysten/bcs").BcsTypeOptions<import("@mysten/bcs").InferBcsType<T>[], Iterable<import("@mysten/bcs").InferBcsInput<T>> & {
             length: number;
-        }, Name>): import("@mysten/sui/bcs").BcsType<import("@mysten/bcs").InferBcsType<T>[], Iterable<import("@mysten/bcs").InferBcsInput<T>> & {
+        }, Name>): import("@mysten/bcs").BcsType<import("@mysten/bcs").InferBcsType<T>[], Iterable<import("@mysten/bcs").InferBcsInput<T>> & {
             length: number;
         }, Name>;
-        <T, Input, Name extends string = string>(type: import("@mysten/sui/bcs").BcsType<T, Input, Name>, options?: import("@mysten/sui/bcs").BcsTypeOptions<T[], Iterable<Input> & {
+        <T, Input, Name extends string = string>(type: import("@mysten/bcs").BcsType<T, Input, Name>, options?: import("@mysten/bcs").BcsTypeOptions<T[], Iterable<Input> & {
             length: number;
-        }, `vector<${Name}>`>): import("@mysten/sui/bcs").BcsType<T[], Iterable<Input> & {
+        }, `vector<${Name}>`>): import("@mysten/bcs").BcsType<T[], Iterable<Input> & {
             length: number;
         }, `vector<${Name}>`>;
     };

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

@@ -1,34 +1,30 @@
-"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 {
+import { bcs } from "@mysten/sui/bcs";
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, toBcs, fieldToJSON, } from "./reified";
+import { composeSuiType } from "./util";
+export class Vector {
     constructor(typeArgs, elements) {
         this.__VectorClass = true;
         this.$typeName = "vector";
         this.$isPhantom = [false];
-        this.$fullTypeName = (0, util_1.composeSuiType)(this.$typeName, ...typeArgs);
+        this.$fullTypeName = 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)],
+            fullTypeName: composeSuiType(Vector.$typeName, ...[extractType(T)]),
+            typeArgs: [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)),
+            bcs: Vector.bcs(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);
+                return new Vector([extractType(T)], elements);
             },
             kind: "VectorClassReified",
         };
@@ -37,19 +33,19 @@ class Vector {
         return Vector.reified;
     }
     static get bcs() {
-        return bcs_1.bcs.vector;
+        return bcs.vector;
     }
     static fromFields(typeArg, elements) {
-        return Vector.reified(typeArg).new(elements.map((element) => (0, reified_1.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) => (0, reified_1.decodeFromFieldsWithTypes)(typeArg, field)));
+        return Vector.reified(typeArg).new(item.map((field) => decodeFromFieldsWithTypes(typeArg, field)));
     }
     static fromBcs(typeArg, data) {
-        return Vector.fromFields(typeArg, Vector.bcs((0, reified_1.toBcs)(typeArg)).parse(data));
+        return Vector.fromFields(typeArg, Vector.bcs(toBcs(typeArg)).parse(data));
     }
     toJSONField() {
-        return this.elements.map((element) => (0, reified_1.fieldToJSON)(this.$typeArgs[0], element));
+        return this.elements.map((element) => fieldToJSON(this.$typeArgs[0], element));
     }
     toJSON() {
         return {
@@ -59,7 +55,7 @@ class Vector {
         };
     }
     static fromJSONField(typeArg, field) {
-        return Vector.reified(typeArg).new(field.map((field) => (0, reified_1.decodeFromJSONField)(typeArg, field)));
+        return Vector.reified(typeArg).new(field.map((field) => decodeFromJSONField(typeArg, field)));
     }
     static fromJSON(typeArg, json) {
         if (json.$typeName !== Vector.$typeName) {
@@ -68,10 +64,9 @@ class Vector {
         return Vector.fromJSONField(typeArg, json.elements);
     }
 }
-exports.Vector = Vector;
 Vector.$typeName = "vector";
 Vector.$numTypeParams = 1;
 Vector.$isPhantom = [false];
-function vector(T) {
+export function vector(T) {
     return Vector.r(T);
 }

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

@@ -3,7 +3,7 @@ import { PhantomReified, Reified, StructClass, ToField, ToTypeArgument, ToTypeSt
 import { FieldsWithTypes } from "../../_framework/util";
 import { PKG_V1 } from "../index";
 import { BcsType } from "@mysten/sui/bcs";
-import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+import { SuiJsonRpcClient, SuiObjectData, SuiParsedData } from "@mysten/sui/jsonRpc";
 export declare function isCell(type: string): boolean;
 export interface CellFields<Element extends TypeArgument> {
     element: ToField<Option<Element>>;
@@ -24,8 +24,8 @@ export declare class Cell<Element extends TypeArgument> implements StructClass {
     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/sui/bcs").BcsStruct<{
-        element: import("@mysten/sui/bcs").BcsStruct<{
+    static get bcs(): <Element extends BcsType<any>>(Element: Element) => import("@mysten/bcs").BcsStruct<{
+        element: import("@mysten/bcs").BcsStruct<{
             vec: BcsType<import("@mysten/bcs").InferBcsType<Element>[], Iterable<import("@mysten/bcs").InferBcsInput<Element>> & {
                 length: number;
             }, string>;
@@ -46,5 +46,5 @@ export declare class Cell<Element extends TypeArgument> implements StructClass {
     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>>>;
+    static fetch<Element extends Reified<TypeArgument, any>>(client: SuiJsonRpcClient, typeArg: Element, id: string): Promise<Cell<ToTypeArgument<Element>>>;
 }

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

@@ -1,4 +1,3 @@
-"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) {
@@ -8,47 +7,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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");
+import { Option } from "../../_dependencies/source/0x1/option/structs";
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, toBcs, } from "../../_framework/reified";
+import { composeSuiType, compressSuiType, parseTypeName, } from "../../_framework/util";
+import { PKG_V1 } from "../index";
+import { bcs } from "@mysten/sui/bcs";
+import { fromBase64 } from "@mysten/sui/utils";
 /* ============================== Cell =============================== */
-function isCell(type) {
-    type = (0, util_1.compressSuiType)(type);
-    return type.startsWith(`${index_1.PKG_V1}::cell::Cell` + "<");
+export function isCell(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`${PKG_V1}::cell::Cell` + "<");
 }
-class Cell {
+export 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.$fullTypeName = 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)],
+            fullTypeName: composeSuiType(Cell.$typeName, ...[extractType(Element)]),
+            typeArgs: [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)),
+            bcs: Cell.bcs(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);
+                return new Cell([extractType(Element)], fields);
             },
             kind: "StructClassReified",
         };
@@ -57,37 +53,37 @@ class Cell {
         return Cell.reified;
     }
     static phantom(Element) {
-        return (0, reified_1.phantom)(Cell.reified(Element));
+        return 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),
+        return (Element) => bcs.struct(`Cell<${Element.name}>`, {
+            element: Option.bcs(Element),
         });
     }
     static fromFields(typeArg, fields) {
         return Cell.reified(typeArg).new({
-            element: (0, reified_1.decodeFromFields)(structs_1.Option.reified(typeArg), fields.element),
+            element: decodeFromFields(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]);
+        assertFieldsWithTypesArgsMatch(item, [typeArg]);
         return Cell.reified(typeArg).new({
-            element: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Option.reified(typeArg), item.fields.element),
+            element: decodeFromFieldsWithTypes(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));
+        return Cell.fromFields(typeArg, Cell.bcs(toBcs(typeArgs[0])).parse(data));
     }
     toJSONField() {
         return {
-            element: (0, reified_1.fieldToJSON)(`${structs_1.Option.$typeName}<${this.$typeArgs[0]}>`, this.element),
+            element: fieldToJSON(`${Option.$typeName}<${this.$typeArgs[0]}>`, this.element),
         };
     }
     toJSON() {
@@ -95,14 +91,14 @@ class Cell {
     }
     static fromJSONField(typeArg, field) {
         return Cell.reified(typeArg).new({
-            element: (0, reified_1.decodeFromJSONField)(structs_1.Option.reified(typeArg), field.element),
+            element: decodeFromJSONField(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]);
+        assertReifiedTypeArgsMatch(composeSuiType(Cell.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
         return Cell.fromJSONField(typeArg, json);
     }
     static fromSuiParsedData(typeArg, content) {
@@ -119,16 +115,16 @@ class Cell {
             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;
+            const gotTypeArgs = 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))) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[0]);
+            const expectedTypeArg = compressSuiType(extractType(typeArg));
+            if (gotTypeArg !== compressSuiType(extractType(typeArg))) {
                 throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
             }
-            return Cell.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+            return Cell.fromBcs(typeArg, fromBase64(data.bcs.bcsBytes));
         }
         if (data.content) {
             return Cell.fromSuiParsedData(typeArg, data.content);
@@ -150,7 +146,6 @@ class Cell {
         });
     }
 }
-exports.Cell = Cell;
-Cell.$typeName = `${index_1.PKG_V1}::cell::Cell`;
+Cell.$typeName = `${PKG_V1}::cell::Cell`;
 Cell.$numTypeParams = 1;
 Cell.$isPhantom = [false];