@suilend/sdk 12.7.0 → 13.0.0-next.g803bba0

package/_generated/_dependencies/{source/0x2 → sui}/object/structs.js

@@ -1,16 +1,24 @@
-import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from "../../../../_framework/reified.js";
-import { composeSuiType, compressSuiType, } from "../../../../_framework/util.js";
-import { PKG_V30 } from "../index.js";
-import { bcs } from "@mysten/sui/bcs";
-import { fromHex, toHex } from "@mysten/sui/utils";
+/** Sui object identifiers */
+import { bcs } from '@mysten/sui/bcs';
+import { fromHex, toHex } from '@mysten/sui/utils';
+import { decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, phantom, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType } from '../../../_framework/util.js';
 /* ============================== ID =============================== */
 export function isID(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V30}::object::ID`;
+    return type === `0x2::object::ID`;
 }
+/**
+ * An object ID. This is used to reference Sui Objects.
+ * This is *not* guaranteed to be globally unique--anyone can create an `ID` from a `UID` or
+ * from an object, and ID's can be freely copied and dropped.
+ * Here, the values are not globally unique because there can be multiple values of type `ID`
+ * with the same underlying bytes. For example, `object::id(&obj)` can be called as many times
+ * as you want for a given `obj`, and each `ID` value will be identical.
+ */
 export class ID {
     __StructClass = true;
-    static $typeName = `${PKG_V30}::object::ID`;
+    static $typeName = `0x2::object::ID`;
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = ID.$typeName;
@@ -24,23 +32,29 @@ export class ID {
         this.bytes = fields.bytes;
     }
     static reified() {
+        const reifiedBcs = ID.bcs;
         return {
-            typeName: ID.$typeName,
-            fullTypeName: composeSuiType(ID.$typeName, ...[]),
+            get typeName() {
+                return ID.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ID.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: ID.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => ID.fromFields(fields),
             fromFieldsWithTypes: (item) => ID.fromFieldsWithTypes(item),
-            fromBcs: (data) => ID.fromBcs(data),
-            bcs: ID.bcs,
+            fromBcs: (data) => ID.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => ID.fromJSONField(field),
             fromJSON: (json) => ID.fromJSON(json),
+            fromCoreObject: (obj) => ID.fromCoreObject(obj),
             fetch: async (client, id) => ID.fetch(client, id),
             new: (fields) => {
                 return new ID([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -52,27 +66,32 @@ export class ID {
     static get p() {
         return ID.phantom();
     }
-    static get bcs() {
-        return bcs.struct("ID", {
-            bytes: bcs
-                .bytes(32)
-                .transform({
+    static instantiateBcs() {
+        return bcs.struct('ID', {
+            bytes: bcs.bytes(32).transform({
                 input: (val) => fromHex(val),
                 output: (val) => toHex(val),
             }),
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ID.cachedBcs) {
+            ID.cachedBcs = ID.instantiateBcs();
+        }
+        return ID.cachedBcs;
+    }
     static fromFields(fields) {
         return ID.reified().new({
-            bytes: decodeFromFields("address", fields.bytes),
+            bytes: decodeFromFields('address', fields.bytes),
         });
     }
     static fromFieldsWithTypes(item) {
         if (!isID(item.type)) {
-            throw new Error("not a ID type");
+            throw new Error('not a ID type');
         }
         return ID.reified().new({
-            bytes: decodeFromFieldsWithTypes("address", item.fields.bytes),
+            bytes: decodeFromFieldsWithTypes('address', item.fields.bytes),
         });
     }
     static fromBcs(data) {
@@ -84,25 +103,30 @@ export class ID {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return ID.reified().new({
-            bytes: decodeFromJSONField("address", field.bytes),
+            bytes: decodeFromJSONField('address', field.bytes),
         });
     }
     static fromJSON(json) {
         if (json.$typeName !== ID.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a ID json object: expected '${ID.$typeName}' but got '${json.$typeName}'`);
         }
         return ID.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isID(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ID object`);
+        }
+        return ID.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 (!isID(object.type)) {
             throw new Error(`object at id ${id} is not a ID object`);
         }
@@ -112,11 +136,19 @@ export class ID {
 /* ============================== UID =============================== */
 export function isUID(type) {
     type = compressSuiType(type);
-    return type === `${PKG_V30}::object::UID`;
+    return type === `0x2::object::UID`;
 }
+/**
+ * Globally unique IDs that define an object's ID in storage. Any Sui Object, that is a struct
+ * with the `key` ability, must have `id: UID` as its first field.
+ * These are globally unique in the sense that no two values of type `UID` are ever equal, in
+ * other words for any two values `id1: UID` and `id2: UID`, `id1` != `id2`.
+ * This is a privileged type that can only be derived from a `TxContext`.
+ * `UID` doesn't have the `drop` ability, so deleting a `UID` requires a call to `delete`.
+ */
 export class UID {
     __StructClass = true;
-    static $typeName = `${PKG_V30}::object::UID`;
+    static $typeName = `0x2::object::UID`;
     static $numTypeParams = 0;
     static $isPhantom = [];
     $typeName = UID.$typeName;
@@ -130,23 +162,29 @@ export class UID {
         this.id = fields.id;
     }
     static reified() {
+        const reifiedBcs = UID.bcs;
         return {
-            typeName: UID.$typeName,
-            fullTypeName: composeSuiType(UID.$typeName, ...[]),
+            get typeName() {
+                return UID.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(UID.$typeName, ...[]);
+            },
             typeArgs: [],
             isPhantom: UID.$isPhantom,
             reifiedTypeArgs: [],
             fromFields: (fields) => UID.fromFields(fields),
             fromFieldsWithTypes: (item) => UID.fromFieldsWithTypes(item),
-            fromBcs: (data) => UID.fromBcs(data),
-            bcs: UID.bcs,
+            fromBcs: (data) => UID.fromFields(reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
             fromJSONField: (field) => UID.fromJSONField(field),
             fromJSON: (json) => UID.fromJSON(json),
+            fromCoreObject: (obj) => UID.fromCoreObject(obj),
             fetch: async (client, id) => UID.fetch(client, id),
             new: (fields) => {
                 return new UID([], fields);
             },
-            kind: "StructClassReified",
+            kind: 'StructClassReified',
         };
     }
     static get r() {
@@ -158,17 +196,26 @@ export class UID {
     static get p() {
         return UID.phantom();
     }
-    static get bcs() {
-        return bcs.struct("UID", {
+    static instantiateBcs() {
+        return bcs.struct('UID', {
             id: ID.bcs,
         });
     }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!UID.cachedBcs) {
+            UID.cachedBcs = UID.instantiateBcs();
+        }
+        return UID.cachedBcs;
+    }
     static fromFields(fields) {
-        return UID.reified().new({ id: decodeFromFields(ID.reified(), fields.id) });
+        return UID.reified().new({
+            id: decodeFromFields(ID.reified(), fields.id),
+        });
     }
     static fromFieldsWithTypes(item) {
         if (!isUID(item.type)) {
-            throw new Error("not a UID type");
+            throw new Error('not a UID type');
         }
         return UID.reified().new({
             id: decodeFromFieldsWithTypes(ID.reified(), item.fields.id),
@@ -183,11 +230,7 @@ export class UID {
         };
     }
     toJSON() {
-        return {
-            $typeName: this.$typeName,
-            $typeArgs: this.$typeArgs,
-            ...this.toJSONField(),
-        };
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
     }
     static fromJSONField(field) {
         return UID.reified().new({
@@ -196,12 +239,21 @@ export class UID {
     }
     static fromJSON(json) {
         if (json.$typeName !== UID.$typeName) {
-            throw new Error("not a WithTwoGenerics json object");
+            throw new Error(`not a UID json object: expected '${UID.$typeName}' but got '${json.$typeName}'`);
         }
         return UID.fromJSONField(json);
     }
+    static fromCoreObject(obj) {
+        if (!isUID(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a UID object`);
+        }
+        return UID.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 (!isUID(object.type)) {
             throw new Error(`object at id ${id} is not a UID object`);
         }

package/_generated/_dependencies/{source/0x2 → sui}/object-table/structs.d.ts

@@ -1,52 +1,59 @@
-import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr } from "../../../../_framework/reified";
-import { FieldsWithTypes } from "../../../../_framework/util";
-import { PKG_V30 } from "../index";
-import { UID } from "../object/structs";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
+/**
+ * Similar to `sui::table`, an `ObjectTable<K, V>` is a map-like collection. But unlike
+ * `sui::table`, the values bound to these dynamic fields _must_ be objects themselves. This allows
+ * for the objects to still exist within in storage, which may be important for external tools.
+ * The difference is otherwise not observable from within Move.
+ */
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr } from '../../../_framework/reified';
+import { FieldsWithTypes } from '../../../_framework/util';
+import { UID } from '../object/structs';
 export declare function isObjectTable(type: string): boolean;
 export interface ObjectTableFields<K extends PhantomTypeArgument, V extends PhantomTypeArgument> {
+    /** the ID of this table */
     id: ToField<UID>;
-    size: ToField<"u64">;
+    /** the number of key-value pairs in the table */
+    size: ToField<'u64'>;
 }
 export type ObjectTableReified<K extends PhantomTypeArgument, V extends PhantomTypeArgument> = Reified<ObjectTable<K, V>, ObjectTableFields<K, V>>;
+export type ObjectTableJSONField<K extends PhantomTypeArgument, V extends PhantomTypeArgument> = {
+    id: string;
+    size: string;
+};
+export type ObjectTableJSON<K extends PhantomTypeArgument, V extends PhantomTypeArgument> = {
+    $typeName: typeof ObjectTable.$typeName;
+    $typeArgs: [PhantomToTypeStr<K>, PhantomToTypeStr<V>];
+} & ObjectTableJSONField<K, V>;
 export declare class ObjectTable<K extends PhantomTypeArgument, V extends PhantomTypeArgument> implements StructClass {
     __StructClass: true;
-    static readonly $typeName = "0x2::object_table::ObjectTable";
+    static readonly $typeName: `0x2::object_table::ObjectTable`;
     static readonly $numTypeParams = 2;
     static readonly $isPhantom: readonly [true, true];
-    readonly $typeName = "0x2::object_table::ObjectTable";
-    readonly $fullTypeName: `${typeof PKG_V30}::object_table::ObjectTable<${PhantomToTypeStr<K>}, ${PhantomToTypeStr<V>}>`;
+    readonly $typeName: typeof ObjectTable.$typeName;
+    readonly $fullTypeName: `0x2::object_table::ObjectTable<${PhantomToTypeStr<K>}, ${PhantomToTypeStr<V>}>`;
     readonly $typeArgs: [PhantomToTypeStr<K>, PhantomToTypeStr<V>];
-    readonly $isPhantom: readonly [true, true];
+    readonly $isPhantom: typeof ObjectTable.$isPhantom;
+    /** the ID of this table */
     readonly id: ToField<UID>;
-    readonly size: ToField<"u64">;
+    /** the number of key-value pairs in the table */
+    readonly size: ToField<'u64'>;
     private constructor();
     static reified<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(K: K, V: V): ObjectTableReified<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
     static get r(): typeof ObjectTable.reified;
     static phantom<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(K: K, V: V): PhantomReified<ToTypeStr<ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>>>;
     static get p(): typeof ObjectTable.phantom;
-    static get bcs(): import("@mysten/bcs").BcsStruct<{
-        id: import("@mysten/bcs").BcsStruct<{
-            id: import("@mysten/bcs").BcsStruct<{
-                bytes: import("@mysten/bcs").BcsType<string, string, string>;
-            }, string>;
-        }, string>;
-        size: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
-    }, string>;
+    private static instantiateBcs;
+    private static cachedBcs;
+    static get bcs(): ReturnType<typeof ObjectTable.instantiateBcs>;
     static fromFields<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], fields: Record<string, any>): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
     static fromFieldsWithTypes<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], item: FieldsWithTypes): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
     static fromBcs<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], data: Uint8Array): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
-    toJSONField(): {
-        id: string;
-        size: string;
-    };
-    toJSON(): {
-        id: string;
-        size: string;
-        $typeName: string;
-        $typeArgs: [PhantomToTypeStr<K>, PhantomToTypeStr<V>];
-    };
+    toJSONField(): ObjectTableJSONField<K, V>;
+    toJSON(): ObjectTableJSON<K, V>;
     static fromJSONField<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], field: any): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
     static fromJSON<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], json: Record<string, any>): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
-    static fetch<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(client: SuiGrpcClient, typeArgs: [K, V], id: string): Promise<ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>>;
+    static fromCoreObject<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(typeArgs: [K, V], obj: SuiClientTypes.Object<{
+        content: true;
+    }>): ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>;
+    static fetch<K extends PhantomReified<PhantomTypeArgument>, V extends PhantomReified<PhantomTypeArgument>>(client: ClientWithCoreApi, typeArgs: [K, V], id: string): Promise<ObjectTable<ToPhantomTypeArgument<K>, ToPhantomTypeArgument<V>>>;
 }

package/_generated/_dependencies/sui/object-table/structs.js

@@ -0,0 +1,164 @@
+/**
+ * Similar to `sui::table`, an `ObjectTable<K, V>` is a map-like collection. But unlike
+ * `sui::table`, the values bound to these dynamic fields _must_ be objects themselves. This allows
+ * for the objects to still exist within in storage, which may be important for external tools.
+ * The difference is otherwise not observable from within Move.
+ */
+import { bcs } from '@mysten/sui/bcs';
+import { assertFieldsWithTypesArgsMatch, assertReifiedTypeArgsMatch, decodeFromFields, decodeFromFieldsWithTypes, decodeFromJSONField, extractType, phantom, } from '../../../_framework/reified.js';
+import { composeSuiType, compressSuiType, parseTypeName, } from '../../../_framework/util.js';
+import { UID } from '../object/structs.js';
+/* ============================== ObjectTable =============================== */
+export function isObjectTable(type) {
+    type = compressSuiType(type);
+    return type.startsWith(`0x2::object_table::ObjectTable` + '<');
+}
+export class ObjectTable {
+    __StructClass = true;
+    static $typeName = `0x2::object_table::ObjectTable`;
+    static $numTypeParams = 2;
+    static $isPhantom = [true, true];
+    $typeName = ObjectTable.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ObjectTable.$isPhantom;
+    /** the ID of this table */
+    id;
+    /** the number of key-value pairs in the table */
+    size;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = composeSuiType(ObjectTable.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.size = fields.size;
+    }
+    static reified(K, V) {
+        const reifiedBcs = ObjectTable.bcs;
+        return {
+            get typeName() {
+                return ObjectTable.$typeName;
+            },
+            get fullTypeName() {
+                return composeSuiType(ObjectTable.$typeName, ...[extractType(K), extractType(V)]);
+            },
+            get typeArgs() {
+                return [extractType(K), extractType(V)];
+            },
+            isPhantom: ObjectTable.$isPhantom,
+            reifiedTypeArgs: [K, V],
+            fromFields: (fields) => ObjectTable.fromFields([K, V], fields),
+            fromFieldsWithTypes: (item) => ObjectTable.fromFieldsWithTypes([K, V], item),
+            fromBcs: (data) => ObjectTable.fromFields([K, V], reifiedBcs.parse(data)),
+            bcs: reifiedBcs,
+            fromJSONField: (field) => ObjectTable.fromJSONField([K, V], field),
+            fromJSON: (json) => ObjectTable.fromJSON([K, V], json),
+            fromCoreObject: (obj) => ObjectTable.fromCoreObject([K, V], obj),
+            fetch: async (client, id) => ObjectTable.fetch(client, [K, V], id),
+            new: (fields) => {
+                return new ObjectTable([extractType(K), extractType(V)], fields);
+            },
+            kind: 'StructClassReified',
+        };
+    }
+    static get r() {
+        return ObjectTable.reified;
+    }
+    static phantom(K, V) {
+        return phantom(ObjectTable.reified(K, V));
+    }
+    static get p() {
+        return ObjectTable.phantom;
+    }
+    static instantiateBcs() {
+        return bcs.struct('ObjectTable', {
+            id: UID.bcs,
+            size: bcs.u64(),
+        });
+    }
+    static cachedBcs = null;
+    static get bcs() {
+        if (!ObjectTable.cachedBcs) {
+            ObjectTable.cachedBcs = ObjectTable.instantiateBcs();
+        }
+        return ObjectTable.cachedBcs;
+    }
+    static fromFields(typeArgs, fields) {
+        return ObjectTable.reified(typeArgs[0], typeArgs[1]).new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            size: decodeFromFields('u64', fields.size),
+        });
+    }
+    static fromFieldsWithTypes(typeArgs, item) {
+        if (!isObjectTable(item.type)) {
+            throw new Error('not a ObjectTable type');
+        }
+        assertFieldsWithTypesArgsMatch(item, typeArgs);
+        return ObjectTable.reified(typeArgs[0], typeArgs[1]).new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            size: decodeFromFieldsWithTypes('u64', item.fields.size),
+        });
+    }
+    static fromBcs(typeArgs, data) {
+        return ObjectTable.fromFields(typeArgs, ObjectTable.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            size: this.size.toString(),
+        };
+    }
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+    static fromJSONField(typeArgs, field) {
+        return ObjectTable.reified(typeArgs[0], typeArgs[1]).new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            size: decodeFromJSONField('u64', field.size),
+        });
+    }
+    static fromJSON(typeArgs, json) {
+        if (json.$typeName !== ObjectTable.$typeName) {
+            throw new Error(`not a ObjectTable json object: expected '${ObjectTable.$typeName}' but got '${json.$typeName}'`);
+        }
+        assertReifiedTypeArgsMatch(composeSuiType(ObjectTable.$typeName, ...typeArgs.map(extractType)), json.$typeArgs, typeArgs);
+        return ObjectTable.fromJSONField(typeArgs, json);
+    }
+    static fromCoreObject(typeArgs, obj) {
+        if (!isObjectTable(obj.type)) {
+            throw new Error(`object at ${obj.objectId} is not a ObjectTable object`);
+        }
+        const gotTypeArgs = parseTypeName(obj.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return ObjectTable.fromBcs(typeArgs, obj.content);
+    }
+    static async fetch(client, typeArgs, id) {
+        const { object } = await client.core.getObject({
+            objectId: id,
+            include: { content: true },
+        });
+        if (!isObjectTable(object.type)) {
+            throw new Error(`object at id ${id} is not a ObjectTable object`);
+        }
+        const gotTypeArgs = parseTypeName(object.type).typeArgs;
+        if (gotTypeArgs.length !== 2) {
+            throw new Error(`type argument mismatch: expected 2 type arguments but got '${gotTypeArgs.length}'`);
+        }
+        for (let i = 0; i < 2; i++) {
+            const gotTypeArg = compressSuiType(gotTypeArgs[i]);
+            const expectedTypeArg = compressSuiType(extractType(typeArgs[i]));
+            if (gotTypeArg !== expectedTypeArg) {
+                throw new Error(`type argument mismatch at position ${i}: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+        }
+        return ObjectTable.fromBcs(typeArgs, object.content);
+    }
+}

package/_generated/_envs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mainnet';
+export { cloneEnv, getActiveEnv, getActiveEnvName, getDependencyConfig, getEnv, getOriginalId, getPackageConfig, getPublishedAt, getRegisteredEnvs, getTypeOrigin, getTypeOriginAddresses, getTypeOriginAddressesFor, setActiveEnv, setActiveEnvWithConfig, } from '../_framework/env';
+export type { EnvConfig, PackageConfig } from '../_framework/env';

package/_generated/_envs/index.js

@@ -0,0 +1,18 @@
+// Re-export environment configs
+export * from './mainnet.js';
+// Import internal functions and env configs
+import { registerEnv, setActiveEnv } from '../_framework/env.js';
+import { mainnetEnv } from './mainnet.js';
+// Applied by apply-env-guard.js after codegen; regeneration drops it.
+if (process.env.NEXT_PUBLIC_SUILEND_USE_BETA_MARKET === 'true') {
+    throw new Error('NEXT_PUBLIC_SUILEND_USE_BETA_MARKET is set, but @suilend/sdk only targets mainnet. Unset it rather than send beta transactions to mainnet.');
+}
+// Initialize environments (runs once on first import)
+let initialized = false;
+if (!initialized) {
+    registerEnv('mainnet', mainnetEnv);
+    setActiveEnv('mainnet');
+    initialized = true;
+}
+// Re-export public API from _framework/env
+export { cloneEnv, getActiveEnv, getActiveEnvName, getDependencyConfig, getEnv, getOriginalId, getPackageConfig, getPublishedAt, getRegisteredEnvs, getTypeOrigin, getTypeOriginAddresses, getTypeOriginAddressesFor, setActiveEnv, setActiveEnvWithConfig, } from '../_framework/env.js';

package/_generated/_envs/mainnet.d.ts

@@ -0,0 +1,2 @@
+import type { EnvConfig } from '../_framework/env';
+export declare const mainnetEnv: EnvConfig;