@suilend/sdk 1.1.99 → 2.0.1

package/_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/_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/_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/_generated/suilend/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/_generated/suilend/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];

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

@@ -1,7 +1,7 @@
 import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../_framework/reified";
 import { FieldsWithTypes } from "../../_framework/util";
 import { PKG_V1 } from "../index";
-import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+import { SuiJsonRpcClient, SuiObjectData, SuiParsedData } from "@mysten/sui/jsonRpc";
 export declare function isDecimal(type: string): boolean;
 export interface DecimalFields {
     value: ToField<"u256">;
@@ -22,8 +22,8 @@ export declare class Decimal implements StructClass {
     static get r(): import("../../_framework/reified").StructClassReified<Decimal, DecimalFields>;
     static phantom(): PhantomReified<ToTypeStr<Decimal>>;
     static get p(): PhantomReified<"0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21::decimal::Decimal" | "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::decimal::Decimal">;
-    static get bcs(): import("@mysten/sui/bcs").BcsStruct<{
-        value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u256">;
+    static get bcs(): import("@mysten/bcs").BcsStruct<{
+        value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u256">;
     }, string>;
     static fromFields(fields: Record<string, any>): Decimal;
     static fromFieldsWithTypes(item: FieldsWithTypes): Decimal;
@@ -40,5 +40,5 @@ export declare class Decimal implements StructClass {
     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>;
+    static fetch(client: SuiJsonRpcClient, id: string): Promise<Decimal>;
 }

package/_generated/suilend/decimal/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,32 +7,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decimal = void 0;
-exports.isDecimal = isDecimal;
-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 { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from "../../_framework/reified";
+import { composeSuiType, compressSuiType, } from "../../_framework/util";
+import { PKG_V1 } from "../index";
+import { bcs } from "@mysten/sui/bcs";
+import { fromBase64 } from "@mysten/sui/utils";
 /* ============================== Decimal =============================== */
-function isDecimal(type) {
-    type = (0, util_1.compressSuiType)(type);
-    return type === `${index_1.PKG_V1}::decimal::Decimal`;
+export function isDecimal(type) {
+    type = compressSuiType(type);
+    return type === `${PKG_V1}::decimal::Decimal`;
 }
-class Decimal {
+export class Decimal {
     constructor(typeArgs, fields) {
         this.__StructClass = true;
         this.$typeName = Decimal.$typeName;
         this.$isPhantom = Decimal.$isPhantom;
-        this.$fullTypeName = (0, util_1.composeSuiType)(Decimal.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(Decimal.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
         this.value = fields.value;
     }
     static reified() {
         return {
             typeName: Decimal.$typeName,
-            fullTypeName: (0, util_1.composeSuiType)(Decimal.$typeName, ...[]),
+            fullTypeName: composeSuiType(Decimal.$typeName, ...[]),
             typeArgs: [],
             isPhantom: Decimal.$isPhantom,
             reifiedTypeArgs: [],
@@ -56,19 +52,19 @@ class Decimal {
         return Decimal.reified();
     }
     static phantom() {
-        return (0, reified_1.phantom)(Decimal.reified());
+        return phantom(Decimal.reified());
     }
     static get p() {
         return Decimal.phantom();
     }
     static get bcs() {
-        return bcs_1.bcs.struct("Decimal", {
-            value: bcs_1.bcs.u256(),
+        return bcs.struct("Decimal", {
+            value: bcs.u256(),
         });
     }
     static fromFields(fields) {
         return Decimal.reified().new({
-            value: (0, reified_1.decodeFromFields)("u256", fields.value),
+            value: decodeFromFields("u256", fields.value),
         });
     }
     static fromFieldsWithTypes(item) {
@@ -76,7 +72,7 @@ class Decimal {
             throw new Error("not a Decimal type");
         }
         return Decimal.reified().new({
-            value: (0, reified_1.decodeFromFieldsWithTypes)("u256", item.fields.value),
+            value: decodeFromFieldsWithTypes("u256", item.fields.value),
         });
     }
     static fromBcs(data) {
@@ -92,7 +88,7 @@ class Decimal {
     }
     static fromJSONField(field) {
         return Decimal.reified().new({
-            value: (0, reified_1.decodeFromJSONField)("u256", field.value),
+            value: decodeFromJSONField("u256", field.value),
         });
     }
     static fromJSON(json) {
@@ -115,7 +111,7 @@ class Decimal {
             if (data.bcs.dataType !== "moveObject" || !isDecimal(data.bcs.type)) {
                 throw new Error(`object at is not a Decimal object`);
             }
-            return Decimal.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+            return Decimal.fromBcs(fromBase64(data.bcs.bcsBytes));
         }
         if (data.content) {
             return Decimal.fromSuiParsedData(data.content);
@@ -137,7 +133,6 @@ class Decimal {
         });
     }
 }
-exports.Decimal = Decimal;
-Decimal.$typeName = `${index_1.PKG_V1}::decimal::Decimal`;
+Decimal.$typeName = `${PKG_V1}::decimal::Decimal`;
 Decimal.$numTypeParams = 0;
 Decimal.$isPhantom = [];

package/_generated/suilend/index.js

@@ -1,25 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PKG_V11 = exports.PKG_V10 = exports.PKG_V8 = exports.PKG_V1 = exports.PUBLISHED_AT = exports.PACKAGE_ID = void 0;
-exports.setPublishedAt = setPublishedAt;
-exports.PACKAGE_ID = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export const PACKAGE_ID = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21"
     : "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
-exports.PUBLISHED_AT = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export let PUBLISHED_AT = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0x5bb8cb3894945f523736f4f5059b1621056e8093b165ea56b20805d0ef2461a9"
     : "0xe37cc7bb50fd9b6dbd3873df66fa2c554e973697f50ef97707311dc78bd08444";
-exports.PKG_V1 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export const PKG_V1 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0x1f54a9a2d71799553197e9ea24557797c6398d6a65f2d4d3818c9304b75d5e21"
     : "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
-exports.PKG_V8 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export const PKG_V8 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0xe5ed361add4433f4d23e56fc0e3bacab39b93592d5e65d508e33fd19ff696669"
     : "0x5b54b47971238403d6ade3c8c2cc75814cb55145a5184af916bb5b12aaf184cb";
-exports.PKG_V10 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export const PKG_V10 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0xe5ed361add4433f4d23e56fc0e3bacab39b93592d5e65d508e33fd19ff696669"
     : "0xe37cc7bb50fd9b6dbd3873df66fa2c554e973697f50ef97707311dc78bd08444";
-exports.PKG_V11 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
+export const PKG_V11 = process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === "true"
     ? "0xe5ed361add4433f4d23e56fc0e3bacab39b93592d5e65d508e33fd19ff696669"
     : "0xd2a67633ccb8de063163e25bcfca242929caf5cf1a26c2929dab519ee0b8f331";
-function setPublishedAt(publishedAt) {
-    exports.PUBLISHED_AT = publishedAt;
+export function setPublishedAt(publishedAt) {
+    PUBLISHED_AT = publishedAt;
 }

package/_generated/suilend/lending-market/functions.d.ts

@@ -170,6 +170,7 @@ export interface AddReserveArgs {
     clock: TransactionObjectInput;
 }
 export declare function addReserve(tx: Transaction, typeArgs: [string, string], args: AddReserveArgs): import("@mysten/sui/transactions").TransactionResult;
+export declare function addReserveV2(tx: Transaction, typeArgs: [string, string], args: AddReserveArgs): import("@mysten/sui/transactions").TransactionResult;
 export interface BorrowRequestArgs {
     lendingMarket: TransactionObjectInput;
     reserveArrayIndex: bigint | TransactionArgument;