@objectid/oid-provider 1.0.6

package/dist/onchain/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/onchain/defaults.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAqB;IAC1D,OAAO,EAAE,oEAAoE;IAC7E,OAAO,EAAE,oEAAoE;CAC9E,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAA2B;IACrE,OAAO,EAAE,oEAAoE;IAC7E,OAAO,EAAE,oEAAoE;CAC9E,CAAC"}

package/dist/onchain/getObjects.d.ts

@@ -0,0 +1,17 @@
+import type { IotaObjectData, IotaClient } from "@iota/iota-sdk/client";
+import type { ObjectEdge } from "../types/types";
+/**
+ * Returns all owned object IDs matching a specific Move type.
+ * Paginates through the full owned-objects list for the owner (RPC).
+ */
+export declare function getObjectIdsByType(client: IotaClient, owner: string, targetType: string): Promise<string[]>;
+/**
+ * Fetches a single object by id (RPC).
+ */
+export declare function getObject(client: IotaClient, id: string): Promise<IotaObjectData | null>;
+/**
+ * Searches Move objects by type AND owner using GraphQL endpoint.
+ * Paginates until completion.
+ */
+export declare function searchObjectsByTypeAndOwner(graphqlProvider: string, objectType: string, owner: string): Promise<ObjectEdge[]>;
+//# sourceMappingURL=getObjects.d.ts.map

package/dist/onchain/getObjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getObjects.d.ts","sourceRoot":"","sources":["../../src/onchain/getObjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA4B,cAAc,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGlG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAqCjH;AAED;;GAEG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAiB9F;AASD;;;GAGG;AACH,wBAAsB,2BAA2B,CAC/C,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,UAAU,EAAE,CAAC,CAkDvB"}

package/dist/onchain/getObjects.js

@@ -0,0 +1,112 @@
+import { IotaGraphQLClient } from "@iota/iota-sdk/graphql";
+import { graphql } from "@iota/iota-sdk/graphql/schemas/2025.2";
+/**
+ * Returns all owned object IDs matching a specific Move type.
+ * Paginates through the full owned-objects list for the owner (RPC).
+ */
+export async function getObjectIdsByType(client, owner, targetType) {
+    const found = [];
+    let cursor = null;
+    for (;;) {
+        const page = await client.getOwnedObjects({
+            owner,
+            cursor,
+            options: {
+                showType: true,
+                showContent: true, // fallback if .type is missing
+            },
+        });
+        const items = page?.data ?? [];
+        for (const item of items) {
+            const objId = item.data?.objectId;
+            if (!objId)
+                continue;
+            // Fast path
+            if (item.data?.type === targetType) {
+                found.push(objId);
+                continue;
+            }
+            // Fallback
+            const content = item.data?.content;
+            if (content?.type === targetType) {
+                found.push(objId);
+            }
+        }
+        if (!page?.hasNextPage || !page.nextCursor)
+            break;
+        cursor = page.nextCursor;
+    }
+    return found;
+}
+/**
+ * Fetches a single object by id (RPC).
+ */
+export async function getObject(client, id) {
+    if (!id)
+        return null;
+    const { data } = await client.getObject({
+        id,
+        options: {
+            showType: true,
+            showOwner: false,
+            showPreviousTransaction: false,
+            showDisplay: true,
+            showContent: true,
+            showBcs: true,
+            showStorageRebate: false,
+        },
+    });
+    return data ?? null;
+}
+/**
+ * Searches Move objects by type AND owner using GraphQL endpoint.
+ * Paginates until completion.
+ */
+export async function searchObjectsByTypeAndOwner(graphqlProvider, objectType, owner) {
+    const gqlClient = new IotaGraphQLClient({ url: graphqlProvider });
+    const query = graphql(`
+    query ObjectsByTypeAndOwner($type: String!, $after: String, $owner: IotaAddress) {
+      objects(filter: { type: $type, owner: $owner }, first: 50, after: $after) {
+        edges {
+          node {
+            address
+            asMoveObject {
+              contents {
+                type {
+                  repr
+                }
+                data
+              }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `);
+    const edges = [];
+    let after = null;
+    try {
+        for (;;) {
+            const res = await gqlClient.query({
+                query,
+                variables: { type: objectType, after, owner },
+            });
+            const page = res?.data?.objects;
+            if (!page?.edges?.length)
+                break;
+            edges.push(...page.edges);
+            if (!page.pageInfo.hasNextPage || !page.pageInfo.endCursor)
+                break;
+            after = page.pageInfo.endCursor;
+        }
+    }
+    catch {
+        return [];
+    }
+    return edges;
+}
+//# sourceMappingURL=getObjects.js.map

package/dist/onchain/getObjects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getObjects.js","sourceRoot":"","sources":["../../src/onchain/getObjects.ts"],"names":[],"mappings":"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"}

package/dist/onchain/identity.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=identity.d.ts.map

package/dist/onchain/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/onchain/identity.ts"],"names":[],"mappings":""}

package/dist/onchain/identity.js

@@ -0,0 +1,9 @@
+let _modP = null;
+async function getIdentityMod() {
+    if (_modP)
+        return _modP;
+    _modP = import("@iota/identity-wasm/web");
+    return _modP;
+}
+export {};
+//# sourceMappingURL=identity.js.map

package/dist/onchain/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/onchain/identity.ts"],"names":[],"mappings":"AAIA,IAAI,KAAK,GAAwB,IAAI,CAAC;AAEtC,KAAK,UAAU,cAAc;IAC3B,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IACxB,KAAK,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC;IAC1C,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/react/ObjectIdProvider.d.ts

@@ -0,0 +1,53 @@
+import type { ObjectIdApi } from "../api";
+import type { ConfigPackageIds, LoadedConfig } from "../onchain/config";
+type Session = {
+    network: string;
+    seed: string;
+    gasBudget?: number;
+};
+type ActiveConfig = LoadedConfig & {
+    source: "default" | "object";
+};
+type Ctx = {
+    api: ObjectIdApi | null;
+    /** Session is set only after connect(). */
+    session: Session | null;
+    /** The public/shared config for the currently selected network. */
+    publicConfig: LoadedConfig | null;
+    /** The active config used by the API (public by default, or overridden by applyCfg/applyCfgObject). */
+    activeConfig: ActiveConfig | null;
+    status: "idle" | "loading" | "ready" | "error";
+    error: string | null;
+    /** Selected network even before connect(). Defaults to testnet. */
+    selectedNetwork: string;
+    /** Loads the public config for `network` and makes it active (drops any previous override). */
+    selectNetwork: (network: string) => Promise<void>;
+    /** Sets seed and network, loads the public config for that network, and initializes the API with it. */
+    connect: (session: Session) => Promise<void>;
+    /** Clears session, API, and overrides; reloads public config for testnet and makes it active. */
+    disconnect: () => Promise<void>;
+    /** Reloads public config for current selectedNetwork; if active is public, updates it too. */
+    refreshPublicConfig: () => Promise<void>;
+    /** Forces active config back to public config (does not delete any on-chain objects). */
+    usePublicConfig: () => Promise<void>;
+    /**
+     * Applies a JSON config by:
+     * - creating a PRIVATE (owned) oid_config::Config on-chain
+     * - returning the created objectId
+     * - setting it as active config (and rebuilding API)
+     */
+    applyCfg: (json: Record<string, any>) => Promise<string>;
+    /** Loads a config objectId and sets it as active config (and rebuilds API). */
+    applyCfgObject: (objectId: string) => Promise<string>;
+};
+export type ObjectIDProps = {
+    /** Optional. If omitted, the SDK uses DEFAULT_CONFIG_PACKAGE_IDS. */
+    configPackageIds?: ConfigPackageIds;
+    children: React.ReactNode;
+};
+export declare function ObjectID({ configPackageIds, children }: ObjectIDProps): import("react/jsx-runtime").JSX.Element;
+export declare function useOptionalObjectId(): ObjectIdApi | null;
+export declare function useObjectId(): ObjectIdApi;
+export declare function useObjectIDSession(): Ctx;
+export {};
+//# sourceMappingURL=ObjectIdProvider.d.ts.map

package/dist/react/ObjectIdProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectIdProvider.d.ts","sourceRoot":"","sources":["../../src/react/ObjectIdProvider.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAK1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAMxE,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,YAAY,GAAG,YAAY,GAAG;IAEjC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;CAC9B,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;IAExB,2CAA2C;IAC3C,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAExB,mEAAmE;IACnE,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAElC,uGAAuG;IACvG,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAElC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;IAC/C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAErB,mEAAmE;IACnE,eAAe,EAAE,MAAM,CAAC;IAExB,+FAA+F;IAC/F,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAElD,wGAAwG;IACxG,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7C,iGAAiG;IACjG,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC,8FAA8F;IAC9F,mBAAmB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzC,yFAAyF;IACzF,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;;;;OAKG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzD,+EAA+E;IAC/E,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACvD,CAAC;AAIF,MAAM,MAAM,aAAa,GAAG;IAC1B,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAAC;AA0GF,wBAAgB,QAAQ,CAAC,EAAE,gBAAgB,EAAE,QAAQ,EAAE,EAAE,aAAa,2CAoXrE;AAED,wBAAgB,mBAAmB,IAAI,WAAW,GAAG,IAAI,CAIxD;AAED,wBAAgB,WAAW,IAAI,WAAW,CAKzC;AAED,wBAAgB,kBAAkB,QAIjC"}

package/dist/react/ObjectIdProvider.js

@@ -0,0 +1,431 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, useRef } from "react";
+import { getFullnodeUrl, IotaClient } from "@iota/iota-sdk/client";
+import { Ed25519Keypair } from "@iota/iota-sdk/keypairs/ed25519";
+import { Transaction } from "@iota/iota-sdk/transactions";
+import { createObjectIdApi } from "../api";
+import { signAndExecute } from "../utils/tx";
+import { loadPublicConfig, loadConfigJsonByObjectId } from "../onchain/config";
+import { DEFAULT_CONFIG_PACKAGE_IDS } from "../onchain/defaults";
+const C = createContext(undefined);
+function isNonEmptyString(x) {
+    return typeof x === "string" && x.trim().length > 0;
+}
+function withTimeout(p, ms = 15_000, label = "operation") {
+    return Promise.race([
+        p,
+        new Promise((_, rej) => setTimeout(() => rej(new Error(`${label} timeout (${ms}ms)`)), ms)),
+    ]);
+}
+function cacheKey(network) {
+    return `objectid_public_cfg_${network}`;
+}
+function readCachedPublic(network) {
+    try {
+        const raw = localStorage.getItem(cacheKey(network));
+        if (!raw)
+            return null;
+        const obj = JSON.parse(raw);
+        if (!obj || typeof obj !== "object")
+            return null;
+        if (typeof obj.objectId !== "string" || !obj.objectId)
+            return null;
+        if (!obj.json || typeof obj.json !== "object")
+            return null;
+        return { objectId: obj.objectId, json: obj.json };
+    }
+    catch {
+        return null;
+    }
+}
+function writeCachedPublic(network, cfg) {
+    try {
+        localStorage.setItem(cacheKey(network), JSON.stringify({ objectId: cfg.objectId, json: cfg.json }));
+    }
+    catch {
+        // ignore quota / privacy mode
+    }
+}
+function mapJsonToProviderConfig(base, j) {
+    const objectPackages = j.objectPackages ?? j.object_packages;
+    const documentPackages = j.documentPackages ?? j.document_packages;
+    if (!Array.isArray(objectPackages) || objectPackages.length === 0) {
+        const keys = Object.keys(j ?? {}).join(", ");
+        throw new Error(`Missing required field in on-chain config JSON: objectPackages (keys: ${keys})`);
+    }
+    if (!Array.isArray(documentPackages) || documentPackages.length === 0) {
+        const keys = Object.keys(j ?? {}).join(", ");
+        throw new Error(`Missing required field in on-chain config JSON: documentPackages (keys: ${keys})`);
+    }
+    const objectDefaultPackageVersion = j.objectDefaultPackageVersion ?? j.objectDefaultPackageVersione ?? j.object_default_package_version ?? 0;
+    const documentDefaultPackageVersion = j.documentDefaultPackageVersion ?? j.documentDefaultPackageVersione ?? j.document_default_package_version ?? 0;
+    const graphqlProvider = j.graphqlProvider ?? j.graphql_provider;
+    if (!isNonEmptyString(graphqlProvider)) {
+        const keys = Object.keys(j ?? {}).join(", ");
+        throw new Error(`Missing required field in on-chain config JSON: graphqlProvider (keys: ${keys})`);
+    }
+    const useGasStation = !!(j.useGasStation ?? j.use_gas_station);
+    const gasStation = j.gasStation ?? j.gas_station;
+    return {
+        network: base.network,
+        seed: base.seed,
+        gasBudget: base.gasBudget,
+        graphqlProvider: String(graphqlProvider),
+        objectPackages,
+        documentPackages,
+        objectDefaultPackageVersion: Number(objectDefaultPackageVersion) || 0,
+        documentDefaultPackageVersion: Number(documentDefaultPackageVersion) || 0,
+        useGasStation,
+        gasStation: gasStation && typeof gasStation === "object" ? gasStation : undefined,
+    };
+}
+function hexToU8a(hex) {
+    const s = String(hex || "")
+        .trim()
+        .replace(/^0x/i, "");
+    if (!s)
+        throw new Error("Missing seed");
+    if (s.length % 2 !== 0)
+        throw new Error("Seed hex length must be even");
+    const bytes = new Uint8Array(s.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        const byte = s.slice(i * 2, i * 2 + 2);
+        const v = Number.parseInt(byte, 16);
+        if (Number.isNaN(v))
+            throw new Error("Invalid seed hex");
+        bytes[i] = v;
+    }
+    return bytes;
+}
+export function ObjectID({ configPackageIds, children }) {
+    const effectiveConfigPackageIds = configPackageIds ?? DEFAULT_CONFIG_PACKAGE_IDS;
+    const [selectedNetwork, setSelectedNetwork] = useState("testnet");
+    const [session, setSession] = useState(null);
+    const [publicConfig, setPublicConfig] = useState(null);
+    const [activeConfig, setActiveConfig] = useState(null);
+    const [api, setApi] = useState(null);
+    const [status, setStatus] = useState("idle");
+    const [error, setError] = useState(null);
+    const clientsRef = useRef({});
+    const getClientForNetwork = useCallback((net) => {
+        const key = String(net);
+        if (!clientsRef.current[key]) {
+            clientsRef.current[key] = new IotaClient({ url: getFullnodeUrl(net) });
+        }
+        return clientsRef.current[key];
+    }, []);
+    // Load public config at startup (selectedNetwork defaults to testnet).
+    // Uses localStorage cache to avoid blocking reloads; refreshes in background.
+    useEffect(() => {
+        let cancelled = false;
+        const net = selectedNetwork;
+        // 1) Fast path: cached public config
+        const cached = readCachedPublic(net);
+        if (cached) {
+            setPublicConfig({ source: "default", objectId: cached.objectId, json: cached.json });
+            setActiveConfig({ source: "default", objectId: cached.objectId, json: cached.json });
+            setStatus("ready");
+            setError(null);
+        }
+        else {
+            setStatus("loading");
+            setError(null);
+        }
+        // 2) Refresh from chain (always), but never leave infinite loading
+        (async () => {
+            try {
+                const cfg = await withTimeout(loadPublicConfig(net), 15_000, `loadPublicConfig(${net})`);
+                if (cancelled)
+                    return;
+                setPublicConfig(cfg);
+                setActiveConfig((prev) => {
+                    // if active is public OR nothing yet, update active too; if active is object, keep it
+                    if (!prev || prev.source === "default")
+                        return { ...cfg, source: "default" };
+                    return prev;
+                });
+                writeCachedPublic(net, { objectId: cfg.objectId, json: cfg.json });
+                // If we were loading with no cache, mark ready now.
+                setStatus("ready");
+                setError(null);
+            }
+            catch (e) {
+                if (cancelled)
+                    return;
+                // If we already had cache, keep ready and show no blocking error.
+                // If we had no cache and were loading, move to error (not infinite loading).
+                setStatus(cached ? "ready" : "error");
+                setError(e?.message ?? String(e));
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [selectedNetwork]);
+    const buildApi = useCallback((sess, cfgJson) => {
+        const gasBudget = Number(sess.gasBudget ?? 10_000_000);
+        const providerCfg = mapJsonToProviderConfig({ network: sess.network, seed: sess.seed, gasBudget }, cfgJson);
+        return createObjectIdApi(providerCfg);
+    }, []);
+    const selectNetwork = useCallback(async (network) => {
+        setStatus("loading");
+        setError(null);
+        try {
+            const cfg = await loadPublicConfig(network);
+            setSelectedNetwork(network);
+            setPublicConfig(cfg);
+            setActiveConfig({ ...cfg, source: "default" });
+            // If already connected, rebuild API using PUBLIC config for the chosen network
+            if (session) {
+                const nextSession = { ...session, network };
+                setSession(nextSession);
+                const nextApi = buildApi(nextSession, cfg.json);
+                setApi(nextApi);
+            }
+            setStatus("ready");
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [buildApi, session]);
+    const connect = useCallback(async (sess) => {
+        setStatus("loading");
+        setError(null);
+        try {
+            // Always start from PUBLIC config for chosen network (no auto private cfg)
+            const cfg = await loadPublicConfig(sess.network);
+            setSelectedNetwork(sess.network);
+            setSession(sess);
+            setPublicConfig(cfg);
+            setActiveConfig({ ...cfg, source: "default" });
+            const finalApi = buildApi(sess, cfg.json);
+            setApi(finalApi);
+            setStatus("ready");
+        }
+        catch (e) {
+            setApi(null);
+            setSession(null);
+            setPublicConfig(null);
+            setActiveConfig(null);
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [buildApi]);
+    const disconnect = useCallback(async () => {
+        setStatus("loading");
+        setError(null);
+        try {
+            setApi(null);
+            setSession(null);
+            // Reset to testnet public config
+            const cfg = await loadPublicConfig("testnet");
+            setSelectedNetwork("testnet");
+            setPublicConfig(cfg);
+            setActiveConfig({ ...cfg, source: "default" });
+            setStatus("ready");
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, []);
+    const refreshPublicConfig = useCallback(async () => {
+        setStatus("loading");
+        setError(null);
+        try {
+            const cfg = await loadPublicConfig(selectedNetwork);
+            setPublicConfig(cfg);
+            // If active is public, refresh active too.
+            setActiveConfig((prev) => {
+                if (!prev || prev.source === "default")
+                    return { ...cfg, source: "default" };
+                return prev;
+            });
+            // If connected and active is public, rebuild api.
+            if (session) {
+                setApi((prevApi) => {
+                    if (!prevApi)
+                        return buildApi(session, cfg.json);
+                    // if active is public, we rebuild; if active is object, keep current api.
+                    if (!activeConfig || activeConfig.source === "default")
+                        return buildApi(session, cfg.json);
+                    return prevApi;
+                });
+            }
+            setStatus("ready");
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [activeConfig, buildApi, selectedNetwork, session]);
+    const usePublicConfig = useCallback(async () => {
+        setStatus("loading");
+        setError(null);
+        try {
+            const cfg = publicConfig ?? (await loadPublicConfig(selectedNetwork));
+            setPublicConfig(cfg);
+            setActiveConfig({ ...cfg, source: "default" });
+            if (session) {
+                const nextApi = buildApi(session, cfg.json);
+                setApi(nextApi);
+            }
+            else {
+                setApi(null);
+            }
+            setStatus("ready");
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [buildApi, publicConfig, selectedNetwork, session]);
+    const applyCfg = useCallback(async (json) => {
+        if (!session)
+            throw new Error("Not connected");
+        const cfgPkg = session.network === "mainnet" ? effectiveConfigPackageIds.mainnet : effectiveConfigPackageIds.testnet;
+        if (!cfgPkg)
+            throw new Error(`Missing config packageId for network=${session.network}`);
+        setStatus("loading");
+        setError(null);
+        try {
+            const s = JSON.stringify(json);
+            const bytes = Array.from(new TextEncoder().encode(s));
+            const keyPair = Ed25519Keypair.deriveKeypairFromSeed(session.seed);
+            const client = new IotaClient({ url: getFullnodeUrl(session.network) });
+            const sender = keyPair.toIotaAddress();
+            const tx = new Transaction();
+            tx.moveCall({
+                target: `${cfgPkg}::oid_config::create_user_config`,
+                arguments: [tx.pure.vector("u8", bytes)],
+            });
+            const gasBudget = Number(session.gasBudget ?? 10_000_000);
+            tx.setGasBudget(gasBudget);
+            tx.setSender(sender);
+            const useGasStation = !!(json.useGasStation ?? json.use_gas_station);
+            const gasStation = (json.gasStation ?? json.gas_station);
+            const r = await signAndExecute(client, keyPair, tx, {
+                network: String(session.network),
+                gasBudget,
+                useGasStation,
+                gasStation,
+            });
+            if (!r.success) {
+                throw new Error(`create_user_config failed: ${String(r.error ?? "")}`);
+            }
+            const createdId = r.txEffect?.effects?.created?.[0]?.reference?.objectId ||
+                r.txEffect?.effects?.created?.[0]?.objectId ||
+                r?.createdObjectId;
+            if (!createdId) {
+                throw new Error("create_user_config succeeded but cannot extract created objectId from tx effects");
+            }
+            // Activate this config and rebuild api
+            setActiveConfig({ source: "object", objectId: String(createdId), json });
+            const nextApi = buildApi(session, json);
+            setApi(nextApi);
+            setStatus("ready");
+            return String(createdId);
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [buildApi, effectiveConfigPackageIds, session]);
+    const applyCfgObject = useCallback(async (objectId) => {
+        setStatus("loading");
+        setError(null);
+        try {
+            const net = session?.network ?? selectedNetwork;
+            const json = await loadConfigJsonByObjectId(net, objectId);
+            setActiveConfig({ source: "object", objectId: String(objectId), json });
+            if (session) {
+                const nextApi = buildApi(session, json);
+                setApi(nextApi);
+            }
+            setStatus("ready");
+            return String(objectId);
+        }
+        catch (e) {
+            setStatus("error");
+            setError(e?.message ?? String(e));
+            throw e;
+        }
+    }, [buildApi, selectedNetwork, session]);
+    const getCfgJsonForNet = useCallback(async (net) => {
+        // Se connesso e la rete combacia, usa active/public già in memoria
+        if (session?.network === net) {
+            const j = activeConfig?.json ?? publicConfig?.json;
+            if (j)
+                return j;
+        }
+        // Se non connesso (o rete diversa), usa cache localStorage per quella rete
+        const cached = readCachedPublic(net);
+        if (cached?.json)
+            return cached.json;
+        // Fallback: carica on-chain e aggiorna cache
+        const cfg = await loadPublicConfig(net);
+        writeCachedPublic(net, { objectId: cfg.objectId, json: cfg.json });
+        return cfg.json;
+    }, [activeConfig, publicConfig, session]);
+    const value = useMemo(() => ({
+        api,
+        session,
+        publicConfig,
+        activeConfig,
+        status,
+        error,
+        selectedNetwork,
+        selectNetwork,
+        connect,
+        disconnect,
+        refreshPublicConfig,
+        usePublicConfig,
+        applyCfg,
+        applyCfgObject,
+    }), [
+        api,
+        session,
+        publicConfig,
+        activeConfig,
+        status,
+        error,
+        selectedNetwork,
+        selectNetwork,
+        connect,
+        disconnect,
+        refreshPublicConfig,
+        usePublicConfig,
+        applyCfg,
+        applyCfgObject,
+    ]);
+    return _jsx(C.Provider, { value: value, children: children });
+}
+export function useOptionalObjectId() {
+    const ctx = useContext(C);
+    if (!ctx)
+        throw new Error("useOptionalObjectId must be used within ObjectID");
+    return ctx.api;
+}
+export function useObjectId() {
+    const ctx = useContext(C);
+    if (!ctx)
+        throw new Error("useObjectId must be used within ObjectID");
+    if (!ctx.api)
+        throw new Error("ObjectID API not initialized. Call connect({network, seed}) first.");
+    return ctx.api;
+}
+export function useObjectIDSession() {
+    const ctx = useContext(C);
+    if (!ctx)
+        throw new Error("useObjectIDSession must be used within ObjectID");
+    return ctx;
+}
+//# sourceMappingURL=ObjectIdProvider.js.map