@suilend/sdk 12.7.0 → 13.0.0-next.g122801a

package/_generated/_framework/env.js

@@ -0,0 +1,261 @@
+/**
+ * Environment management for sui-client-gen generated code.
+ *
+ * This module provides runtime environment switching, allowing generated code
+ * to work with different networks (mainnet, testnet, custom) without regeneration.
+ */
+// Environment registry - maps env name to config
+const envRegistry = {};
+// Active environment state
+let activeEnv = null;
+let activeEnvName = null;
+let publishedAtOverrides = {};
+/**
+ * Register an environment configuration.
+ * Called during init to register generated env configs.
+ */
+export function registerEnv(name, config) {
+    envRegistry[name] = config;
+}
+/**
+ * Get a registered environment configuration by name.
+ * Useful when building an ad-hoc config derived from a known env, e.g. via `cloneEnv`.
+ * @throws Error if the environment is not registered.
+ */
+export function getEnv(name) {
+    const config = envRegistry[name];
+    if (!config) {
+        const available = Object.keys(envRegistry).join(', ') || '(none registered)';
+        throw new Error(`Environment '${name}' not found. Available: ${available}`);
+    }
+    return config;
+}
+/**
+ * Produce a new `EnvConfig` by shallow-merging `overrides` onto `base`, per package.
+ *
+ * Only the fields you provide on each package are replaced — other fields (including
+ * the untouched packages) are preserved by reference. Useful for creating a scoped
+ * env for a single call (e.g. to target a historical `publishedAt`) without mutating
+ * any shared state.
+ *
+ * @example
+ *   const historical = cloneEnv(getEnv('mainnet'), {
+ *     packages: { 'my-app': { publishedAt: '0x...' } },
+ *   })
+ *   transfer(tx, typeArgs, args, { env: historical })
+ */
+export function cloneEnv(base, overrides) {
+    const mergeSection = (section, patch) => {
+        if (!patch)
+            return { ...section };
+        const merged = { ...section };
+        for (const [pkgName, pkgPatch] of Object.entries(patch)) {
+            const prior = section[pkgName];
+            if (!prior) {
+                throw new Error(`cloneEnv: cannot override unknown package '${pkgName}'. `
+                    + `Available: ${Object.keys(section).join(', ') || '(none)'}`);
+            }
+            merged[pkgName] = {
+                ...prior,
+                ...pkgPatch,
+                typeOrigins: { ...prior.typeOrigins, ...(pkgPatch.typeOrigins ?? {}) },
+            };
+        }
+        return merged;
+    };
+    return {
+        packages: mergeSection(base.packages, overrides?.packages),
+        dependencies: mergeSection(base.dependencies, overrides?.dependencies),
+    };
+}
+/**
+ * Set the active environment by name.
+ * @param name - The name of a registered environment
+ * @param overrides - Optional map of package names to publishedAt addresses to override
+ * @throws Error if the environment is not registered
+ */
+export function setActiveEnv(name, overrides) {
+    if (!envRegistry[name]) {
+        const available = Object.keys(envRegistry).join(', ') || '(none registered)';
+        throw new Error(`Environment '${name}' not found. Available: ${available}`);
+    }
+    activeEnv = envRegistry[name];
+    activeEnvName = name;
+    publishedAtOverrides = overrides ?? {};
+}
+/**
+ * Set the active environment using a custom config object.
+ * Use this to provide a custom environment configuration at runtime.
+ * @param config - A custom EnvConfig object
+ * @param overrides - Optional map of package names to publishedAt addresses to override
+ */
+export function setActiveEnvWithConfig(config, overrides) {
+    activeEnv = config;
+    activeEnvName = 'custom';
+    publishedAtOverrides = overrides ?? {};
+}
+/**
+ * Get the active environment configuration.
+ * @throws Error if no environment is set
+ */
+export function getActiveEnv() {
+    if (!activeEnv) {
+        throw new Error('No active environment. Call setActiveEnv() or import the envs module first.');
+    }
+    return activeEnv;
+}
+/**
+ * Get the active environment name.
+ * Returns null if no environment is set.
+ */
+export function getActiveEnvName() {
+    return activeEnvName;
+}
+/**
+ * Get the list of registered environment names.
+ */
+export function getRegisteredEnvs() {
+    return Object.keys(envRegistry);
+}
+/**
+ * Describe the env source for error messages: either a caller-supplied scope or
+ * the current active env (named).
+ */
+function envScopeLabel(env) {
+    return env ? 'supplied environment' : `active environment '${activeEnvName}'`;
+}
+/**
+ * Resolve an `EnvConfig` for a read: use the caller-supplied one if present, else
+ * fall back to the active global env. A missing active env throws.
+ */
+function resolveEnv(env) {
+    return env ?? getActiveEnv();
+}
+/**
+ * Get configuration for a top-level package.
+ * @throws Error if package not found
+ */
+export function getPackageConfig(pkgName, env) {
+    const source = resolveEnv(env);
+    const config = source.packages[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    return config;
+}
+/**
+ * Get configuration for a dependency package.
+ * @throws Error if dependency not found
+ */
+export function getDependencyConfig(pkgName, env) {
+    const source = resolveEnv(env);
+    const config = source.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Dependency '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    return config;
+}
+/**
+ * Get the publishedAt address for function calls.
+ *
+ * When an explicit `env` is supplied, it is authoritative and the module-level
+ * `publishedAtOverrides` (set via `setActiveEnv`) are ignored — callers that pass
+ * their own env own their own scope. Otherwise the active env is used with overrides
+ * applied on top.
+ *
+ * @throws Error if package not found
+ */
+export function getPublishedAt(pkgName, env) {
+    if (env) {
+        const config = env.packages[pkgName] || env.dependencies[pkgName];
+        if (!config) {
+            throw new Error(`Package '${pkgName}' not found in supplied environment`);
+        }
+        return config.publishedAt;
+    }
+    if (publishedAtOverrides[pkgName]) {
+        return publishedAtOverrides[pkgName];
+    }
+    const active = getActiveEnv();
+    const config = active.packages[pkgName] || active.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in active environment '${activeEnvName}'`);
+    }
+    return config.publishedAt;
+}
+/**
+ * Get the type origin address for a specific type.
+ * Used in $typeName construction for structs and enums.
+ * @param pkgName - Kebab-case package name
+ * @param moduleTypePath - "module::TypeName" format (e.g., "balance::Balance")
+ * @throws Error if package or type origin not found
+ */
+export function getTypeOrigin(pkgName, moduleTypePath, env) {
+    const source = resolveEnv(env);
+    const config = source.packages[pkgName] || source.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    const origin = config.typeOrigins[moduleTypePath];
+    if (!origin) {
+        throw new Error(`Type origin for '${moduleTypePath}' not found in package '${pkgName}'. `
+            + `Available: ${Object.keys(config.typeOrigins).join(', ') || '(none)'}`);
+    }
+    return origin;
+}
+/**
+ * Get the original package ID.
+ * Works for both packages and dependencies.
+ * @throws Error if package not found
+ */
+export function getOriginalId(pkgName, env) {
+    const source = resolveEnv(env);
+    const config = source.packages[pkgName] || source.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    return config.originalId;
+}
+/**
+ * Get all distinct addresses where types in this package were defined.
+ * Useful for understanding package upgrade history and querying objects.
+ * Works for both packages and dependencies.
+ * @param pkgName - Kebab-case package name
+ * @returns Array of unique addresses, sorted for determinism
+ * @throws Error if package not found
+ */
+export function getTypeOriginAddresses(pkgName, env) {
+    const source = resolveEnv(env);
+    const config = source.packages[pkgName] || source.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    const uniqueAddresses = new Set(Object.values(config.typeOrigins));
+    return Array.from(uniqueAddresses).sort();
+}
+/**
+ * Get distinct addresses where specific types are defined.
+ * Useful for querying objects of specific types.
+ * Works for both packages and dependencies.
+ * @param pkgName - Kebab-case package name
+ * @param moduleTypePaths - Array of "module::TypeName" strings (e.g., ["balance::Balance", "coin::Coin"])
+ * @returns Array of unique addresses, sorted for determinism
+ * @throws Error if package not found or any type origin not found
+ */
+export function getTypeOriginAddressesFor(pkgName, moduleTypePaths, env) {
+    const source = resolveEnv(env);
+    const config = source.packages[pkgName] || source.dependencies[pkgName];
+    if (!config) {
+        throw new Error(`Package '${pkgName}' not found in ${envScopeLabel(env)}`);
+    }
+    const addresses = new Set();
+    for (const path of moduleTypePaths) {
+        const origin = config.typeOrigins[path];
+        if (!origin) {
+            throw new Error(`Type origin for '${path}' not found in package '${pkgName}'. `
+                + `Available: ${Object.keys(config.typeOrigins).join(', ') || '(none)'}`);
+        }
+        addresses.add(origin);
+    }
+    return Array.from(addresses).sort();
+}

package/_generated/_framework/reified.d.ts

@@ -1,7 +1,7 @@
-import { BcsType } from "@mysten/sui/bcs";
-import { FieldsWithTypes } from "./util";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-export { vector } from "./vector";
+import { BcsType } from '@mysten/sui/bcs';
+import type { ClientWithCoreApi, SuiClientTypes } from '@mysten/sui/client';
+import { FieldsWithTypes } from './util';
+export { vector } from './vector';
 export interface StructClass {
     readonly $typeName: string;
     readonly $fullTypeName: string;
@@ -12,7 +12,7 @@ export interface StructClass {
     __StructClass: true;
 }
 export interface VectorClass {
-    readonly $typeName: "vector";
+    readonly $typeName: 'vector';
     readonly $fullTypeName: string;
     readonly $typeArgs: [string];
     readonly $isPhantom: readonly [false];
@@ -21,13 +21,23 @@ export interface VectorClass {
     readonly elements: any;
     __VectorClass: true;
 }
-export type Primitive = "bool" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "address";
-export type TypeArgument = StructClass | Primitive | VectorClass;
+export interface EnumVariantClass {
+    readonly $typeName: string;
+    readonly $fullTypeName: string;
+    readonly $variantName: string;
+    readonly $typeArgs: string[];
+    readonly $isPhantom: readonly boolean[];
+    toJSONField(): Record<string, any>;
+    toJSON(): Record<string, any>;
+    __EnumVariantClass: true;
+}
+export type Primitive = 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | 'address';
+export type TypeArgument = StructClass | Primitive | VectorClass | EnumVariantClass;
 export interface StructClassReified<T extends StructClass, Fields> {
-    typeName: T["$typeName"];
+    typeName: T['$typeName'];
     fullTypeName: ToTypeStr<T>;
-    typeArgs: T["$typeArgs"];
-    isPhantom: T["$isPhantom"];
+    typeArgs: T['$typeArgs'];
+    isPhantom: T['$isPhantom'];
     reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>;
     bcs: BcsType<any>;
     fromFields(fields: Record<string, any>): T;
@@ -35,14 +45,17 @@ export interface StructClassReified<T extends StructClass, Fields> {
     fromBcs(data: Uint8Array): T;
     fromJSONField: (field: any) => T;
     fromJSON: (json: Record<string, any>) => T;
-    fetch: (client: SuiGrpcClient, id: string) => Promise<T>;
+    fromCoreObject: (obj: SuiClientTypes.Object<{
+        content: true;
+    }>) => T;
+    fetch: (client: ClientWithCoreApi, id: string) => Promise<T>;
     new: (fields: Fields) => T;
-    kind: "StructClassReified";
+    kind: 'StructClassReified';
 }
 export interface VectorClassReified<T extends VectorClass, Elements> {
-    typeName: T["$typeName"];
+    typeName: T['$typeName'];
     fullTypeName: ToTypeStr<T>;
-    typeArgs: T["$typeArgs"];
+    typeArgs: T['$typeArgs'];
     isPhantom: readonly [false];
     reifiedTypeArgs: Array<Reified<TypeArgument, any>>;
     bcs: BcsType<any>;
@@ -52,48 +65,67 @@ export interface VectorClassReified<T extends VectorClass, Elements> {
     fromJSONField: (field: any) => T;
     fromJSON: (json: Record<string, any>) => T;
     new: (elements: Elements) => T;
-    kind: "VectorClassReified";
+    kind: 'VectorClassReified';
 }
-export type Reified<T extends TypeArgument, Fields> = T extends Primitive ? Primitive : T extends StructClass ? StructClassReified<T, Fields> : T extends VectorClass ? VectorClassReified<T, Fields> : never;
-export type ToTypeArgument<T extends Primitive | StructClassReified<StructClass, any> | VectorClassReified<VectorClass, any>> = T extends Primitive ? T : T extends StructClassReified<infer U, any> ? U : T extends VectorClassReified<infer U, any> ? U : never;
+export interface EnumClassReified<T extends EnumVariantClass, Fields> {
+    typeName: T['$typeName'];
+    fullTypeName: T['$fullTypeName'];
+    typeArgs: T['$typeArgs'];
+    isPhantom: T['$isPhantom'];
+    reifiedTypeArgs: Array<Reified<TypeArgument, any> | PhantomReified<PhantomTypeArgument>>;
+    bcs: BcsType<any>;
+    fromFields(fields: Record<string, any>): T;
+    fromFieldsWithTypes(item: FieldsWithTypes): T;
+    fromBcs(data: Uint8Array): T;
+    fromJSONField: (field: any) => T;
+    fromJSON: (json: Record<string, any>) => T;
+    new: (variant: string, fields: Fields) => T;
+    kind: 'EnumClassReified';
+}
+export type Reified<T extends TypeArgument, Fields> = T extends Primitive ? Primitive : T extends StructClass ? StructClassReified<T, Fields> : T extends VectorClass ? VectorClassReified<T, Fields> : T extends EnumVariantClass ? EnumClassReified<T, Fields> : never;
+export type ToTypeArgument<T extends Primitive | StructClassReified<StructClass, any> | VectorClassReified<VectorClass, any> | EnumClassReified<EnumVariantClass, any>> = T extends Primitive ? T : T extends StructClassReified<infer U, any> ? U : T extends VectorClassReified<infer U, any> ? U : T extends EnumClassReified<infer U, any> ? U : never;
 export type ToPhantomTypeArgument<T extends PhantomReified<PhantomTypeArgument>> = T extends PhantomReified<infer U> ? U : never;
 export type PhantomTypeArgument = string;
 export interface PhantomReified<P> {
-    phantomType: P;
-    kind: "PhantomReified";
+    readonly phantomType: P;
+    kind: 'PhantomReified';
 }
 export declare function phantom<T extends Reified<TypeArgument, any>>(reified: T): PhantomReified<ToTypeStr<ToTypeArgument<T>>>;
 export declare function phantom<P extends PhantomTypeArgument>(phantomType: P): PhantomReified<P>;
-export type ToTypeStr<T extends TypeArgument> = T extends Primitive ? T : T extends StructClass ? T["$fullTypeName"] : T extends VectorClass ? T["$fullTypeName"] : never;
+export type ToTypeStr<T extends TypeArgument> = T extends Primitive ? T : T extends StructClass ? T['$fullTypeName'] : T extends VectorClass ? T['$fullTypeName'] : never;
 export type PhantomToTypeStr<T extends PhantomTypeArgument> = T extends PhantomTypeArgument ? T : never;
-export type ToJSON<T extends TypeArgument> = T extends "bool" ? boolean : T extends "u8" ? number : T extends "u16" ? number : T extends "u32" ? number : T extends "u64" ? string : T extends "u128" ? string : T extends "u256" ? string : T extends "address" ? string : T extends {
-    $typeName: "0x1::string::String";
+export type ToJSON<T extends TypeArgument> = T extends 'bool' ? boolean : T extends 'u8' ? number : T extends 'u16' ? number : T extends 'u32' ? number : T extends 'u64' ? string : T extends 'u128' ? string : T extends 'u256' ? string : T extends 'address' ? string : T extends {
+    $typeName: '0x1::string::String';
 } ? string : T extends {
-    $typeName: "0x1::ascii::String";
+    $typeName: '0x1::ascii::String';
 } ? string : T extends {
-    $typeName: "0x2::object::UID";
+    $typeName: '0x2::object::UID';
 } ? string : T extends {
-    $typeName: "0x2::object::ID";
+    $typeName: '0x2::object::ID';
 } ? string : T extends {
-    $typeName: "0x2::url::Url";
+    $typeName: '0x2::url::Url';
 } ? string : T extends {
-    $typeName: "0x1::option::Option";
+    $typeName: '0x1::type_name::TypeName';
+} ? string : T extends {
+    $typeName: '0x1::option::Option';
     __inner: infer U extends TypeArgument;
-} ? ToJSON<U> | null : T extends VectorClass ? ReturnType<T["toJSONField"]> : T extends StructClass ? ReturnType<T["toJSONField"]> : never;
-export type ToField<T extends TypeArgument> = T extends "bool" ? boolean : T extends "u8" ? number : T extends "u16" ? number : T extends "u32" ? number : T extends "u64" ? bigint : T extends "u128" ? bigint : T extends "u256" ? bigint : T extends "address" ? string : T extends {
-    $typeName: "0x1::string::String";
+} ? ToJSON<U> | null : T extends VectorClass ? ReturnType<T['toJSONField']> : T extends StructClass ? ReturnType<T['toJSONField']> : T extends EnumVariantClass ? ReturnType<T['toJSONField']> : never;
+export type ToField<T extends TypeArgument> = T extends 'bool' ? boolean : T extends 'u8' ? number : T extends 'u16' ? number : T extends 'u32' ? number : T extends 'u64' ? bigint : T extends 'u128' ? bigint : T extends 'u256' ? bigint : T extends 'address' ? string : T extends {
+    $typeName: '0x1::string::String';
+} ? string : T extends {
+    $typeName: '0x1::ascii::String';
 } ? string : T extends {
-    $typeName: "0x1::ascii::String";
+    $typeName: '0x2::object::UID';
 } ? string : T extends {
-    $typeName: "0x2::object::UID";
+    $typeName: '0x2::object::ID';
 } ? string : T extends {
-    $typeName: "0x2::object::ID";
+    $typeName: '0x2::url::Url';
 } ? string : T extends {
-    $typeName: "0x2::url::Url";
+    $typeName: '0x1::type_name::TypeName';
 } ? string : T extends {
-    $typeName: "0x1::option::Option";
+    $typeName: '0x1::option::Option';
     __inner: infer U extends TypeArgument;
-} ? ToField<U> | null : T extends VectorClass ? T["elements"] : T extends StructClass ? T : never;
+} ? ToField<U> | null : T extends VectorClass ? T['elements'] : T extends StructClass ? T : T extends EnumVariantClass ? T : never;
 export declare function toBcs<T extends Reified<TypeArgument, any>>(arg: T): BcsType<any>;
 export declare function extractType<T extends Reified<TypeArgument, any>>(reified: T): ToTypeStr<ToTypeArgument<T>>;
 export declare function extractType<T extends PhantomReified<PhantomTypeArgument>>(reified: T): PhantomToTypeStr<ToPhantomTypeArgument<T>>;