@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/suilend/liquidity-mining/structs.js

@@ -1,21 +1,168 @@
-import * as reified from "../../_framework/reified.js";
-import { Option } from "../../_dependencies/source/0x1/option/structs.js";
-import { TypeName } from "../../_dependencies/source/0x1/type-name/structs.js";
-import { Bag } from "../../_dependencies/source/0x2/bag/structs.js";
-import { ID, UID } from "../../_dependencies/source/0x2/object/structs.js";
-import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, } from "../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../_framework/util.js";
-import { Decimal } from "../decimal/structs.js";
-import { PKG_V1 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
+/** A user_reward_manager farms pool_rewards to receive rewards proportional to their stake in the pool. */
+import { bcs } from '@mysten/sui/bcs';
+import { Option } from '../../_dependencies/std/option/structs.js';
+import { TypeName } from '../../_dependencies/std/type-name/structs.js';
+import { Bag } from '../../_dependencies/sui/bag/structs.js';
+import { ID, UID } from '../../_dependencies/sui/object/structs.js';
+import { getTypeOrigin } from '../../_envs/index.js';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, fieldToJSON, phantom, vector, } from '../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../_framework/util.js';
+import { Decimal } from '../decimal/structs.js';
+/* ============================== PoolRewardManager =============================== */
+export function isPoolRewardManager(type) {
+    type = compressSuiType(type);
+    return type
+        === `${getTypeOrigin('suilend', 'liquidity_mining::PoolRewardManager')}::liquidity_mining::PoolRewardManager`;
+}
+/** This struct manages all pool_rewards for a given stake pool. */
+export class PoolRewardManager {
+    __StructClass = true;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'liquidity_mining::PoolRewardManager')}::liquidity_mining::PoolRewardManager`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = PoolRewardManager.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = PoolRewardManager.$isPhantom;
+    id;
+    totalShares;
+    poolRewards;
+    lastUpdateTimeMs;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(PoolRewardManager.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.totalShares = fields.totalShares;
+        this.poolRewards = fields.poolRewards;
+        this.lastUpdateTimeMs = fields.lastUpdateTimeMs;
+    }
+    static reified() {
+        const reifiedBcs = PoolRewardManager.bcs;
+        return {
+            get typeName() {
+                return PoolRewardManager.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PoolRewardManager.$typeName, ...[]);
+            },
+            typeArgs: [],
+            isPhantom: PoolRewardManager.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => PoolRewardManager.fromFields(fields),
+            fromFieldsWithTypes: (item) => PoolRewardManager.fromFieldsWithTypes(item),
+            fromBcs: (data) => PoolRewardManager.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => PoolRewardManager.fromJSONField(field),
+            fromJSON: (json) => PoolRewardManager.fromJSON(json),
+            fromCoreObject: (obj) => PoolRewardManager.fromCoreObject(obj),
+            fetch: async (client, id) => PoolRewardManager.fetch(client, id),
+            new: (fields) => {
+                return new PoolRewardManager([], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return PoolRewardManager.reified();
+    }
+    static phantom() {
+        return phantom(PoolRewardManager.reified());
+    }
+    static get p() {
+        return PoolRewardManager.phantom();
+    }
+    static instantiateBcs() {
+        return bcs.struct('PoolRewardManager', {
+            id: UID.bcs,
+            total_shares: bcs.u64(),
+            pool_rewards: bcs.vector(Option.bcs(PoolReward.bcs)),
+            last_update_time_ms: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PoolRewardManager.cachedBcs) {
+            PoolRewardManager.cachedBcs = PoolRewardManager.instantiateBcs();
+        }
+        return PoolRewardManager.cachedBcs;
+    }
+    static fromFields(fields) {
+        return PoolRewardManager.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            totalShares: decodeFromFields('u64', fields.total_shares),
+            poolRewards: decodeFromFields(vector(Option.reified(PoolReward.reified())), fields.pool_rewards),
+            lastUpdateTimeMs: decodeFromFields('u64', fields.last_update_time_ms),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isPoolRewardManager(item.type)) {
+            throw new Error('not a PoolRewardManager type');
+        }
+        return PoolRewardManager.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            totalShares: decodeFromFieldsWithTypes('u64', item.fields.total_shares),
+            poolRewards: decodeFromFieldsWithTypes(vector(Option.reified(PoolReward.reified())), item.fields.pool_rewards),
+            lastUpdateTimeMs: decodeFromFieldsWithTypes('u64', item.fields.last_update_time_ms),
+        });
+    }
+    static fromBcs(data) {
+        return PoolRewardManager.fromFields(PoolRewardManager.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            totalShares: this.totalShares.toString(),
+            poolRewards: fieldToJSON(`vector<${Option.$typeName}<${PoolReward.$typeName}>>`, this.poolRewards),
+            lastUpdateTimeMs: this.lastUpdateTimeMs.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(field) {
+        return PoolRewardManager.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            totalShares: decodeFromJSONField('u64', field.totalShares),
+            poolRewards: decodeFromJSONField(vector(Option.reified(PoolReward.reified())), field.poolRewards),
+            lastUpdateTimeMs: decodeFromJSONField('u64', field.lastUpdateTimeMs),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== PoolRewardManager.$typeName) {
+            throw new Error(`not a PoolRewardManager json object: expected '${PoolRewardManager.$typeName}' but got '${json.$typeName}'`);
+        }
+        return PoolRewardManager.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isPoolRewardManager(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PoolRewardManager object`);
+        }
+        return PoolRewardManager.fromBcs(obj.content);
+    }
+    static async fetch(client, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isPoolRewardManager(object.type)) {
+            throw new Error(`object at id ${id} is not a PoolRewardManager object`);
+        }
+        return PoolRewardManager.fromBcs(object.content);
+    }
+}
 /* ============================== PoolReward =============================== */
 export function isPoolReward(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::liquidity_mining::PoolReward`;
+    return type
+        === `${getTypeOrigin('suilend', 'liquidity_mining::PoolReward')}::liquidity_mining::PoolReward`;
 }
 export class PoolReward {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::liquidity_mining::PoolReward`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'liquidity_mining::PoolReward')}::liquidity_mining::PoolReward`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = PoolReward.$typeName;
@@ -28,6 +175,7 @@ export class PoolReward {
     startTimeMs;
     endTimeMs;
     totalRewards;
+    /** amount of rewards that have been earned by users */
     allocatedRewards;
     cumulativeRewardsPerShare;
     numUserRewardManagers;
@@ -47,23 +195,29 @@ export class PoolReward {
         this.additionalFields = fields.additionalFields;
     }
     static reified() {
+        const reifiedBcs = PoolReward.bcs;
         return {
-            typeName: PoolReward.$typeName,
-            fullTypeName: composeSuiType(PoolReward.$typeName, ...[]),
+            get typeName() {
+                return PoolReward.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(PoolReward.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: PoolReward.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => PoolReward.fromFields(fields),
             fromFieldsWithTypes: (item) => PoolReward.fromFieldsWithTypes(item),
-            fromBcs: (data) => PoolReward.fromBcs(data),
-            bcs: PoolReward.bcs,
+            fromBcs: (data) => PoolReward.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => PoolReward.fromJSONField(field),
             fromJSON: (json) => PoolReward.fromJSON(json),
+            fromCoreObject: (obj) => PoolReward.fromCoreObject(obj),
             fetch: async (client, id) => PoolReward.fetch(client, id),
             new: (fields) => {
                 return new PoolReward([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -75,8 +229,8 @@ export class PoolReward {
     static get p() {
         return PoolReward.phantom();
     }
-    static get bcs() {
-        return bcs.struct("PoolReward", {
+    static instantiateBcs() {
+        return bcs.struct('PoolReward', {
             id: UID.bcs,
             pool_reward_manager_id: ID.bcs,
             coin_type: TypeName.bcs,
@@ -89,34 +243,41 @@ export class PoolReward {
             additional_fields: Bag.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!PoolReward.cachedBcs) {
+            PoolReward.cachedBcs = PoolReward.instantiateBcs();
+        }
+        return PoolReward.cachedBcs;
+    }
     static fromFields(fields) {
         return PoolReward.reified().new({
             id: decodeFromFields(UID.reified(), fields.id),
             poolRewardManagerId: decodeFromFields(ID.reified(), fields.pool_reward_manager_id),
             coinType: decodeFromFields(TypeName.reified(), fields.coin_type),
-            startTimeMs: decodeFromFields("u64", fields.start_time_ms),
-            endTimeMs: decodeFromFields("u64", fields.end_time_ms),
-            totalRewards: decodeFromFields("u64", fields.total_rewards),
+            startTimeMs: decodeFromFields('u64', fields.start_time_ms),
+            endTimeMs: decodeFromFields('u64', fields.end_time_ms),
+            totalRewards: decodeFromFields('u64', fields.total_rewards),
             allocatedRewards: decodeFromFields(Decimal.reified(), fields.allocated_rewards),
             cumulativeRewardsPerShare: decodeFromFields(Decimal.reified(), fields.cumulative_rewards_per_share),
-            numUserRewardManagers: decodeFromFields("u64", fields.num_user_reward_managers),
+            numUserRewardManagers: decodeFromFields('u64', fields.num_user_reward_managers),
             additionalFields: decodeFromFields(Bag.reified(), fields.additional_fields),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isPoolReward(item.type)) {
-            throw new Error("not a PoolReward type");
+            throw new Error('not a PoolReward type');
         }
         return PoolReward.reified().new({
             id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
             poolRewardManagerId: decodeFromFieldsWithTypes(ID.reified(), item.fields.pool_reward_manager_id),
             coinType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.coin_type),
-            startTimeMs: decodeFromFieldsWithTypes("u64", item.fields.start_time_ms),
-            endTimeMs: decodeFromFieldsWithTypes("u64", item.fields.end_time_ms),
-            totalRewards: decodeFromFieldsWithTypes("u64", item.fields.total_rewards),
+            startTimeMs: decodeFromFieldsWithTypes('u64', item.fields.start_time_ms),
+            endTimeMs: decodeFromFieldsWithTypes('u64', item.fields.end_time_ms),
+            totalRewards: decodeFromFieldsWithTypes('u64', item.fields.total_rewards),
             allocatedRewards: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.allocated_rewards),
             cumulativeRewardsPerShare: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_rewards_per_share),
-            numUserRewardManagers: decodeFromFieldsWithTypes("u64", item.fields.num_user_reward_managers),
+            numUserRewardManagers: decodeFromFieldsWithTypes('u64', item.fields.num_user_reward_managers),
             additionalFields: decodeFromFieldsWithTypes(Bag.reified(), item.fields.additional_fields),
         });
     }
@@ -127,7 +288,7 @@ export class PoolReward {
         return {
             id: this.id,
             poolRewardManagerId: this.poolRewardManagerId,
-            coinType: this.coinType.toJSONField(),
+            coinType: this.coinType,
             startTimeMs: this.startTimeMs.toString(),
             endTimeMs: this.endTimeMs.toString(),
             totalRewards: this.totalRewards.toString(),
@@ -138,170 +299,55 @@ export class PoolReward {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return PoolReward.reified().new({
             id: decodeFromJSONField(UID.reified(), field.id),
             poolRewardManagerId: decodeFromJSONField(ID.reified(), field.poolRewardManagerId),
             coinType: decodeFromJSONField(TypeName.reified(), field.coinType),
-            startTimeMs: decodeFromJSONField("u64", field.startTimeMs),
-            endTimeMs: decodeFromJSONField("u64", field.endTimeMs),
-            totalRewards: decodeFromJSONField("u64", field.totalRewards),
+            startTimeMs: decodeFromJSONField('u64', field.startTimeMs),
+            endTimeMs: decodeFromJSONField('u64', field.endTimeMs),
+            totalRewards: decodeFromJSONField('u64', field.totalRewards),
             allocatedRewards: decodeFromJSONField(Decimal.reified(), field.allocatedRewards),
             cumulativeRewardsPerShare: decodeFromJSONField(Decimal.reified(), field.cumulativeRewardsPerShare),
-            numUserRewardManagers: decodeFromJSONField("u64", field.numUserRewardManagers),
+            numUserRewardManagers: decodeFromJSONField('u64', field.numUserRewardManagers),
             additionalFields: decodeFromJSONField(Bag.reified(), field.additionalFields),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== PoolReward.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a PoolReward json object: expected '${PoolReward.$typeName}' but got '${json.$typeName}'`);
         }
         return PoolReward.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isPoolReward(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a PoolReward object`);
+        }
+        return PoolReward.fromBcs(obj.content);
+    }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
         if (!isPoolReward(object.type)) {
             throw new Error(`object at id ${id} is not a PoolReward object`);
         }
         return PoolReward.fromBcs(object.content);
     }
 }
-/* ============================== PoolRewardManager =============================== */
-export function isPoolRewardManager(type) {
-    type = compressSuiType(type);
-    return type === `${PKG_V1}::liquidity_mining::PoolRewardManager`;
-}
-export class PoolRewardManager {
-    __StructClass = true;
-    static $typeName = `${PKG_V1}::liquidity_mining::PoolRewardManager`;
-    static $numTypeParams = 0;
-    static $isPhantom = [];
-    $typeName = PoolRewardManager.$typeName;
-    $fullTypeName;
-    $typeArgs;
-    $isPhantom = PoolRewardManager.$isPhantom;
-    id;
-    totalShares;
-    poolRewards;
-    lastUpdateTimeMs;
-    constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(PoolRewardManager.$typeName, ...typeArgs);
-        this.$typeArgs = typeArgs;
-        this.id = fields.id;
-        this.totalShares = fields.totalShares;
-        this.poolRewards = fields.poolRewards;
-        this.lastUpdateTimeMs = fields.lastUpdateTimeMs;
-    }
-    static reified() {
-        return {
-            typeName: PoolRewardManager.$typeName,
-            fullTypeName: composeSuiType(PoolRewardManager.$typeName, ...[]),
-            typeArgs: [],
-            isPhantom: PoolRewardManager.$isPhantom,
-            reifiedTypeArgs: [],
-            fromFields: (fields) => PoolRewardManager.fromFields(fields),
-            fromFieldsWithTypes: (item) => PoolRewardManager.fromFieldsWithTypes(item),
-            fromBcs: (data) => PoolRewardManager.fromBcs(data),
-            bcs: PoolRewardManager.bcs,
-            fromJSONField: (field) => PoolRewardManager.fromJSONField(field),
-            fromJSON: (json) => PoolRewardManager.fromJSON(json),
-            fetch: async (client, id) => PoolRewardManager.fetch(client, id),
-            new: (fields) => {
-                return new PoolRewardManager([], fields);
-            },
-            kind: "StructClassReified",
-        };
-    }
-    static get r() {
-        return PoolRewardManager.reified();
-    }
-    static phantom() {
-        return phantom(PoolRewardManager.reified());
-    }
-    static get p() {
-        return PoolRewardManager.phantom();
-    }
-    static get bcs() {
-        return bcs.struct("PoolRewardManager", {
-            id: UID.bcs,
-            total_shares: bcs.u64(),
-            pool_rewards: bcs.vector(Option.bcs(PoolReward.bcs)),
-            last_update_time_ms: bcs.u64(),
-        });
-    }
-    static fromFields(fields) {
-        return PoolRewardManager.reified().new({
-            id: decodeFromFields(UID.reified(), fields.id),
-            totalShares: decodeFromFields("u64", fields.total_shares),
-            poolRewards: decodeFromFields(reified.vector(Option.reified(PoolReward.reified())), fields.pool_rewards),
-            lastUpdateTimeMs: decodeFromFields("u64", fields.last_update_time_ms),
-        });
-    }
-    static fromFieldsWithTypes(item) {
-        if (!isPoolRewardManager(item.type)) {
-            throw new Error("not a PoolRewardManager type");
-        }
-        return PoolRewardManager.reified().new({
-            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
-            totalShares: decodeFromFieldsWithTypes("u64", item.fields.total_shares),
-            poolRewards: decodeFromFieldsWithTypes(reified.vector(Option.reified(PoolReward.reified())), item.fields.pool_rewards),
-            lastUpdateTimeMs: decodeFromFieldsWithTypes("u64", item.fields.last_update_time_ms),
-        });
-    }
-    static fromBcs(data) {
-        return PoolRewardManager.fromFields(PoolRewardManager.bcs.parse(data));
-    }
-    toJSONField() {
-        return {
-            id: this.id,
-            totalShares: this.totalShares.toString(),
-            poolRewards: fieldToJSON(`vector<${Option.$typeName}<${PoolReward.$typeName}>>`, this.poolRewards),
-            lastUpdateTimeMs: this.lastUpdateTimeMs.toString(),
-        };
-    }
-    toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
-    }
-    static fromJSONField(field) {
-        return PoolRewardManager.reified().new({
-            id: decodeFromJSONField(UID.reified(), field.id),
-            totalShares: decodeFromJSONField("u64", field.totalShares),
-            poolRewards: decodeFromJSONField(reified.vector(Option.reified(PoolReward.reified())), field.poolRewards),
-            lastUpdateTimeMs: decodeFromJSONField("u64", field.lastUpdateTimeMs),
-        });
-    }
-    static fromJSON(json) {
-        if (json.$typeName !== PoolRewardManager.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
-        }
-        return PoolRewardManager.fromJSONField(json);
-    }
-    static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isPoolRewardManager(object.type)) {
-            throw new Error(`object at id ${id} is not a PoolRewardManager object`);
-        }
-        return PoolRewardManager.fromBcs(object.content);
-    }
-}
 /* ============================== RewardBalance =============================== */
 export function isRewardBalance(type) {
     type = compressSuiType(type);
-    return type.startsWith(`${PKG_V1}::liquidity_mining::RewardBalance` + "<");
+    return type.startsWith(`${getTypeOrigin('suilend', 'liquidity_mining::RewardBalance')}::liquidity_mining::RewardBalance` + '<');
 }
 export class RewardBalance {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::liquidity_mining::RewardBalance`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'liquidity_mining::RewardBalance')}::liquidity_mining::RewardBalance`;
+    }
     static $numTypeParams = 1;
     static $isPhantom = [true];
     $typeName = RewardBalance.$typeName;
@@ -315,23 +361,31 @@ export class RewardBalance {
         this.dummyField = fields.dummyField;
     }
     static reified(T) {
+        const reifiedBcs = RewardBalance.bcs;
         return {
-            typeName: RewardBalance.$typeName,
-            fullTypeName: composeSuiType(RewardBalance.$typeName, ...[extractType(T)]),
-            typeArgs: [extractType(T)],
+            get typeName() {
+                return RewardBalance.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(RewardBalance.$typeName, ...[extractType(T)]);
+            },
+            get typeArgs() {
+                return [extractType(T)];
+            },
             isPhantom: RewardBalance.$isPhantom,
             reifiedTypeArgs: [T],
             fromFields: (fields) => RewardBalance.fromFields(T, fields),
             fromFieldsWithTypes: (item) => RewardBalance.fromFieldsWithTypes(T, item),
-            fromBcs: (data) => RewardBalance.fromBcs(T, data),
-            bcs: RewardBalance.bcs,
+            fromBcs: (data) => RewardBalance.fromFields(T, reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => RewardBalance.fromJSONField(T, field),
             fromJSON: (json) => RewardBalance.fromJSON(T, json),
+            fromCoreObject: (obj) => RewardBalance.fromCoreObject(T, obj),
             fetch: async (client, id) => RewardBalance.fetch(client, T, id),
             new: (fields) => {
                 return new RewardBalance([extractType(T)], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -343,23 +397,30 @@ export class RewardBalance {
     static get p() {
         return RewardBalance.phantom;
     }
-    static get bcs() {
-        return bcs.struct("RewardBalance", {
+    static instantiateBcs() {
+        return bcs.struct('RewardBalance', {
             dummy_field: bcs.bool(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!RewardBalance.cachedBcs) {
+            RewardBalance.cachedBcs = RewardBalance.instantiateBcs();
+        }
+        return RewardBalance.cachedBcs;
+    }
     static fromFields(typeArg, fields) {
         return RewardBalance.reified(typeArg).new({
-            dummyField: decodeFromFields("bool", fields.dummy_field),
+            dummyField: decodeFromFields('bool', fields.dummy_field),
         });
     }
     static fromFieldsWithTypes(typeArg, item) {
         if (!isRewardBalance(item.type)) {
-            throw new Error("not a RewardBalance type");
+            throw new Error('not a RewardBalance type');
         }
         assertFieldsWithTypesArgsMatch(item, [typeArg]);
         return RewardBalance.reified(typeArg).new({
-            dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field),
+            dummyField: decodeFromFieldsWithTypes('bool', item.fields.dummy_field),
         });
     }
     static fromBcs(typeArg, data) {
@@ -371,266 +432,335 @@ export class RewardBalance {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(typeArg, field) {
         return RewardBalance.reified(typeArg).new({
-            dummyField: decodeFromJSONField("bool", field.dummyField),
+            dummyField: decodeFromJSONField('bool', field.dummyField),
         });
     }
     static fromJSON(typeArg, json) {
         if (json.$typeName !== RewardBalance.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a RewardBalance json object: expected '${RewardBalance.$typeName}' but got '${json.$typeName}'`);
         }
-        assertReifiedTypeArgsMatch(composeSuiType(RewardBalance.$typeName, extractType(typeArg)), json.$typeArgs, [typeArg]);
+        assertReifiedTypeArgsMatch(composeSuiType(RewardBalance.$typeName, ...[extractType(typeArg)]), json.$typeArgs, [typeArg]);
         return RewardBalance.fromJSONField(typeArg, json);
     }
+    static fromCoreObject(typeArg, obj) {
+        if (!isRewardBalance(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a RewardBalance 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 RewardBalance.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 (!isRewardBalance(object.type)) {
             throw new Error(`object at id ${id} is not a RewardBalance 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 RewardBalance.fromBcs(typeArg, object.content);
     }
 }
-/* ============================== UserReward =============================== */
-export function isUserReward(type) {
+/* ============================== UserRewardManager =============================== */
+export function isUserRewardManager(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::liquidity_mining::UserReward`;
+    return type
+        === `${getTypeOrigin('suilend', 'liquidity_mining::UserRewardManager')}::liquidity_mining::UserRewardManager`;
 }
-export class UserReward {
+export class UserRewardManager {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::liquidity_mining::UserReward`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'liquidity_mining::UserRewardManager')}::liquidity_mining::UserRewardManager`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = UserReward.$typeName;
+    $typeName = UserRewardManager.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = UserReward.$isPhantom;
-    poolRewardId;
-    earnedRewards;
-    cumulativeRewardsPerShare;
+    $isPhantom = UserRewardManager.$isPhantom;
+    poolRewardManagerId;
+    share;
+    rewards;
+    lastUpdateTimeMs;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(UserReward.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(UserRewardManager.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.poolRewardId = fields.poolRewardId;
-        this.earnedRewards = fields.earnedRewards;
-        this.cumulativeRewardsPerShare = fields.cumulativeRewardsPerShare;
+        this.poolRewardManagerId = fields.poolRewardManagerId;
+        this.share = fields.share;
+        this.rewards = fields.rewards;
+        this.lastUpdateTimeMs = fields.lastUpdateTimeMs;
     }
     static reified() {
+        const reifiedBcs = UserRewardManager.bcs;
         return {
-            typeName: UserReward.$typeName,
-            fullTypeName: composeSuiType(UserReward.$typeName, ...[]),
+            get typeName() {
+                return UserRewardManager.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(UserRewardManager.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: UserReward.$isPhantom,
+            isPhantom: UserRewardManager.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => UserReward.fromFields(fields),
-            fromFieldsWithTypes: (item) => UserReward.fromFieldsWithTypes(item),
-            fromBcs: (data) => UserReward.fromBcs(data),
-            bcs: UserReward.bcs,
-            fromJSONField: (field) => UserReward.fromJSONField(field),
-            fromJSON: (json) => UserReward.fromJSON(json),
-            fetch: async (client, id) => UserReward.fetch(client, id),
+            fromFields: (fields) => UserRewardManager.fromFields(fields),
+            fromFieldsWithTypes: (item) => UserRewardManager.fromFieldsWithTypes(item),
+            fromBcs: (data) => UserRewardManager.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => UserRewardManager.fromJSONField(field),
+            fromJSON: (json) => UserRewardManager.fromJSON(json),
+            fromCoreObject: (obj) => UserRewardManager.fromCoreObject(obj),
+            fetch: async (client, id) => UserRewardManager.fetch(client, id),
             new: (fields) => {
-                return new UserReward([], fields);
+                return new UserRewardManager([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return UserReward.reified();
+        return UserRewardManager.reified();
     }
     static phantom() {
-        return phantom(UserReward.reified());
+        return phantom(UserRewardManager.reified());
     }
     static get p() {
-        return UserReward.phantom();
+        return UserRewardManager.phantom();
     }
-    static get bcs() {
-        return bcs.struct("UserReward", {
-            pool_reward_id: ID.bcs,
-            earned_rewards: Decimal.bcs,
-            cumulative_rewards_per_share: Decimal.bcs,
+    static instantiateBcs() {
+        return bcs.struct('UserRewardManager', {
+            pool_reward_manager_id: ID.bcs,
+            share: bcs.u64(),
+            rewards: bcs.vector(Option.bcs(UserReward.bcs)),
+            last_update_time_ms: bcs.u64(),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!UserRewardManager.cachedBcs) {
+            UserRewardManager.cachedBcs = UserRewardManager.instantiateBcs();
+        }
+        return UserRewardManager.cachedBcs;
+    }
     static fromFields(fields) {
-        return UserReward.reified().new({
-            poolRewardId: decodeFromFields(ID.reified(), fields.pool_reward_id),
-            earnedRewards: decodeFromFields(Decimal.reified(), fields.earned_rewards),
-            cumulativeRewardsPerShare: decodeFromFields(Decimal.reified(), fields.cumulative_rewards_per_share),
+        return UserRewardManager.reified().new({
+            poolRewardManagerId: decodeFromFields(ID.reified(), fields.pool_reward_manager_id),
+            share: decodeFromFields('u64', fields.share),
+            rewards: decodeFromFields(vector(Option.reified(UserReward.reified())), fields.rewards),
+            lastUpdateTimeMs: decodeFromFields('u64', fields.last_update_time_ms),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isUserReward(item.type)) {
-            throw new Error("not a UserReward type");
+        if (!isUserRewardManager(item.type)) {
+            throw new Error('not a UserRewardManager type');
         }
-        return UserReward.reified().new({
-            poolRewardId: decodeFromFieldsWithTypes(ID.reified(), item.fields.pool_reward_id),
-            earnedRewards: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.earned_rewards),
-            cumulativeRewardsPerShare: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_rewards_per_share),
+        return UserRewardManager.reified().new({
+            poolRewardManagerId: decodeFromFieldsWithTypes(ID.reified(), item.fields.pool_reward_manager_id),
+            share: decodeFromFieldsWithTypes('u64', item.fields.share),
+            rewards: decodeFromFieldsWithTypes(vector(Option.reified(UserReward.reified())), item.fields.rewards),
+            lastUpdateTimeMs: decodeFromFieldsWithTypes('u64', item.fields.last_update_time_ms),
         });
     }
     static fromBcs(data) {
-        return UserReward.fromFields(UserReward.bcs.parse(data));
+        return UserRewardManager.fromFields(UserRewardManager.bcs.parse(data));
     }
     toJSONField() {
         return {
-            poolRewardId: this.poolRewardId,
-            earnedRewards: this.earnedRewards.toJSONField(),
-            cumulativeRewardsPerShare: this.cumulativeRewardsPerShare.toJSONField(),
+            poolRewardManagerId: this.poolRewardManagerId,
+            share: this.share.toString(),
+            rewards: fieldToJSON(`vector<${Option.$typeName}<${UserReward.$typeName}>>`, this.rewards),
+            lastUpdateTimeMs: this.lastUpdateTimeMs.toString(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return UserReward.reified().new({
-            poolRewardId: decodeFromJSONField(ID.reified(), field.poolRewardId),
-            earnedRewards: decodeFromJSONField(Decimal.reified(), field.earnedRewards),
-            cumulativeRewardsPerShare: decodeFromJSONField(Decimal.reified(), field.cumulativeRewardsPerShare),
+        return UserRewardManager.reified().new({
+            poolRewardManagerId: decodeFromJSONField(ID.reified(), field.poolRewardManagerId),
+            share: decodeFromJSONField('u64', field.share),
+            rewards: decodeFromJSONField(vector(Option.reified(UserReward.reified())), field.rewards),
+            lastUpdateTimeMs: decodeFromJSONField('u64', field.lastUpdateTimeMs),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== UserReward.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== UserRewardManager.$typeName) {
+            throw new Error(`not a UserRewardManager json object: expected '${UserRewardManager.$typeName}' but got '${json.$typeName}'`);
         }
-        return UserReward.fromJSONField(json);
+        return UserRewardManager.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isUserRewardManager(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a UserRewardManager object`);
+        }
+        return UserRewardManager.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isUserReward(object.type)) {
-            throw new Error(`object at id ${id} is not a UserReward object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isUserRewardManager(object.type)) {
+            throw new Error(`object at id ${id} is not a UserRewardManager object`);
         }
-        return UserReward.fromBcs(object.content);
+        return UserRewardManager.fromBcs(object.content);
     }
 }
-/* ============================== UserRewardManager =============================== */
-export function isUserRewardManager(type) {
+/* ============================== UserReward =============================== */
+export function isUserReward(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V1}::liquidity_mining::UserRewardManager`;
+    return type
+        === `${getTypeOrigin('suilend', 'liquidity_mining::UserReward')}::liquidity_mining::UserReward`;
 }
-export class UserRewardManager {
+export class UserReward {
     __StructClass = true;
-    static $typeName = `${PKG_V1}::liquidity_mining::UserRewardManager`;
+    static get $typeName() {
+        return `${getTypeOrigin('suilend', 'liquidity_mining::UserReward')}::liquidity_mining::UserReward`;
+    }
     static $numTypeParams = 0;
     static $isPhantom = [];
-    $typeName = UserRewardManager.$typeName;
+    $typeName = UserReward.$typeName;
     $fullTypeName;
     $typeArgs;
-    $isPhantom = UserRewardManager.$isPhantom;
-    poolRewardManagerId;
-    share;
-    rewards;
-    lastUpdateTimeMs;
+    $isPhantom = UserReward.$isPhantom;
+    poolRewardId;
+    earnedRewards;
+    cumulativeRewardsPerShare;
     constructor(typeArgs, fields) {
-        this.$fullTypeName = composeSuiType(UserRewardManager.$typeName, ...typeArgs);
+        this.$fullTypeName = composeSuiType(UserReward.$typeName, ...typeArgs);
         this.$typeArgs = typeArgs;
-        this.poolRewardManagerId = fields.poolRewardManagerId;
-        this.share = fields.share;
-        this.rewards = fields.rewards;
-        this.lastUpdateTimeMs = fields.lastUpdateTimeMs;
+        this.poolRewardId = fields.poolRewardId;
+        this.earnedRewards = fields.earnedRewards;
+        this.cumulativeRewardsPerShare = fields.cumulativeRewardsPerShare;
     }
     static reified() {
+        const reifiedBcs = UserReward.bcs;
         return {
-            typeName: UserRewardManager.$typeName,
-            fullTypeName: composeSuiType(UserRewardManager.$typeName, ...[]),
+            get typeName() {
+                return UserReward.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(UserReward.$typeName, ...[]);
+            },
             typeArgs: [],
-            isPhantom: UserRewardManager.$isPhantom,
+            isPhantom: UserReward.$isPhantom,
             reifiedTypeArgs: [],
-            fromFields: (fields) => UserRewardManager.fromFields(fields),
-            fromFieldsWithTypes: (item) => UserRewardManager.fromFieldsWithTypes(item),
-            fromBcs: (data) => UserRewardManager.fromBcs(data),
-            bcs: UserRewardManager.bcs,
-            fromJSONField: (field) => UserRewardManager.fromJSONField(field),
-            fromJSON: (json) => UserRewardManager.fromJSON(json),
-            fetch: async (client, id) => UserRewardManager.fetch(client, id),
+            fromFields: (fields) => UserReward.fromFields(fields),
+            fromFieldsWithTypes: (item) => UserReward.fromFieldsWithTypes(item),
+            fromBcs: (data) => UserReward.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => UserReward.fromJSONField(field),
+            fromJSON: (json) => UserReward.fromJSON(json),
+            fromCoreObject: (obj) => UserReward.fromCoreObject(obj),
+            fetch: async (client, id) => UserReward.fetch(client, id),
             new: (fields) => {
-                return new UserRewardManager([], fields);
+                return new UserReward([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
-        return UserRewardManager.reified();
+        return UserReward.reified();
     }
     static phantom() {
-        return phantom(UserRewardManager.reified());
+        return phantom(UserReward.reified());
     }
     static get p() {
-        return UserRewardManager.phantom();
+        return UserReward.phantom();
     }
-    static get bcs() {
-        return bcs.struct("UserRewardManager", {
-            pool_reward_manager_id: ID.bcs,
-            share: bcs.u64(),
-            rewards: bcs.vector(Option.bcs(UserReward.bcs)),
-            last_update_time_ms: bcs.u64(),
+    static instantiateBcs() {
+        return bcs.struct('UserReward', {
+            pool_reward_id: ID.bcs,
+            earned_rewards: Decimal.bcs,
+            cumulative_rewards_per_share: Decimal.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!UserReward.cachedBcs) {
+            UserReward.cachedBcs = UserReward.instantiateBcs();
+        }
+        return UserReward.cachedBcs;
+    }
     static fromFields(fields) {
-        return UserRewardManager.reified().new({
-            poolRewardManagerId: decodeFromFields(ID.reified(), fields.pool_reward_manager_id),
-            share: decodeFromFields("u64", fields.share),
-            rewards: decodeFromFields(reified.vector(Option.reified(UserReward.reified())), fields.rewards),
-            lastUpdateTimeMs: decodeFromFields("u64", fields.last_update_time_ms),
+        return UserReward.reified().new({
+            poolRewardId: decodeFromFields(ID.reified(), fields.pool_reward_id),
+            earnedRewards: decodeFromFields(Decimal.reified(), fields.earned_rewards),
+            cumulativeRewardsPerShare: decodeFromFields(Decimal.reified(), fields.cumulative_rewards_per_share),
         });
     }
     static fromFieldsWithTypes(item) {
-        if (!isUserRewardManager(item.type)) {
-            throw new Error("not a UserRewardManager type");
+        if (!isUserReward(item.type)) {
+            throw new Error('not a UserReward type');
         }
-        return UserRewardManager.reified().new({
-            poolRewardManagerId: decodeFromFieldsWithTypes(ID.reified(), item.fields.pool_reward_manager_id),
-            share: decodeFromFieldsWithTypes("u64", item.fields.share),
-            rewards: decodeFromFieldsWithTypes(reified.vector(Option.reified(UserReward.reified())), item.fields.rewards),
-            lastUpdateTimeMs: decodeFromFieldsWithTypes("u64", item.fields.last_update_time_ms),
+        return UserReward.reified().new({
+            poolRewardId: decodeFromFieldsWithTypes(ID.reified(), item.fields.pool_reward_id),
+            earnedRewards: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.earned_rewards),
+            cumulativeRewardsPerShare: decodeFromFieldsWithTypes(Decimal.reified(), item.fields.cumulative_rewards_per_share),
         });
     }
     static fromBcs(data) {
-        return UserRewardManager.fromFields(UserRewardManager.bcs.parse(data));
+        return UserReward.fromFields(UserReward.bcs.parse(data));
     }
     toJSONField() {
         return {
-            poolRewardManagerId: this.poolRewardManagerId,
-            share: this.share.toString(),
-            rewards: fieldToJSON(`vector<${Option.$typeName}<${UserReward.$typeName}>>`, this.rewards),
-            lastUpdateTimeMs: this.lastUpdateTimeMs.toString(),
+            poolRewardId: this.poolRewardId,
+            earnedRewards: this.earnedRewards.toJSONField(),
+            cumulativeRewardsPerShare: this.cumulativeRewardsPerShare.toJSONField(),
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
-        return UserRewardManager.reified().new({
-            poolRewardManagerId: decodeFromJSONField(ID.reified(), field.poolRewardManagerId),
-            share: decodeFromJSONField("u64", field.share),
-            rewards: decodeFromJSONField(reified.vector(Option.reified(UserReward.reified())), field.rewards),
-            lastUpdateTimeMs: decodeFromJSONField("u64", field.lastUpdateTimeMs),
+        return UserReward.reified().new({
+            poolRewardId: decodeFromJSONField(ID.reified(), field.poolRewardId),
+            earnedRewards: decodeFromJSONField(Decimal.reified(), field.earnedRewards),
+            cumulativeRewardsPerShare: decodeFromJSONField(Decimal.reified(), field.cumulativeRewardsPerShare),
         });
     }
     static fromJSON(json) {
-        if (json.$typeName !== UserRewardManager.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+        if (json.$typeName !== UserReward.$typeName) {
+            throw new Error(`not a UserReward json object: expected '${UserReward.$typeName}' but got '${json.$typeName}'`);
         }
-        return UserRewardManager.fromJSONField(json);
+        return UserReward.fromJSONField(json);
+    }
+    static fromCoreObject(obj) {
+        if (!isUserReward(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a UserReward object`);
+        }
+        return UserReward.fromBcs(obj.content);
     }
     static async fetch(client, id) {
-        const { object } = await client.getObject({ objectId: id, include: { content: true } });
-        if (!isUserRewardManager(object.type)) {
-            throw new Error(`object at id ${id} is not a UserRewardManager object`);
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isUserReward(object.type)) {
+            throw new Error(`object at id ${id} is not a UserReward object`);
         }
-        return UserRewardManager.fromBcs(object.content);
+        return UserReward.fromBcs(object.content);
     }
 }