@parity/product-sdk 0.0.0-dev.312.0 → 0.0.0-dev.329.1

package/src/core/createApp.ts

@@ -16,6 +16,7 @@ import type {
     CloudStorageApi,
     LocalStorageApi,
 } from "./types.js";
+import { createLocalStorageApi } from "./local-storage-api.js";
 import { configure, createLogger } from "@parity/product-sdk-logger";
 import { createLocalKvStore } from "@parity/product-sdk-local-storage";
 import { SignerManager } from "@parity/product-sdk-signer";
@@ -33,7 +34,12 @@ import {
     destroyAll,
 } from "@parity/product-sdk-chain-client";
 import { accountIdBytes } from "@parity/product-sdk-address";
-import { getAccountsProvider } from "@parity/product-sdk-host";
+import {
+    getAccountsProvider,
+    getTruApi,
+    HostCallFailedError,
+    HostUnavailableError,
+} from "@parity/product-sdk-host";
 import {
     accountIdBytesToHex,
     type PeopleUsernameQueryApi,
@@ -54,19 +60,16 @@ const log = createLogger("app");
  *
  * // Default: cloud storage enabled with paseo environment
  * const app = await createApp({
- *   name: 'my-app',
  *   logLevel: 'info',
  * });
  *
  * // Custom cloud storage environment
  * const prodApp = await createApp({
- *   name: 'my-app',
  *   cloudStorage: { environment: 'polkadot' },
  * });
  *
  * // Disable cloud storage entirely
  * const noCloudStorageApp = await createApp({
- *   name: 'my-app',
  *   cloudStorage: false,
  * });
  *
@@ -82,20 +85,40 @@ const log = createLogger("app");
  * }
  * ```
  */
-export async function createApp(config: AppConfig): Promise<App> {
+export async function createApp(config: AppConfig = {}): Promise<App> {
     // Set log level if specified
     if (config.logLevel) {
         configure({ level: config.logLevel });
     }
 
-    log.info("Creating Product SDK app", { name: config.name });
+    if (config.name !== undefined) {
+        log.warn(
+            "createApp: name is deprecated and ignored. Remove the name option. The SDK resolves the app name from system.getProductContext(), dropping the product ID's final domain suffix (my-app.dot -> my-app). Local development IDs stay unchanged.",
+        );
+    }
+
+    const truApi = await getTruApi();
+    if (!truApi) {
+        throw new HostUnavailableError("createApp requires a host product context");
+    }
+    const { productId } = await truApi.system.getProductContext().match(
+        (context) => context,
+        (error) => {
+            throw new HostCallFailedError("system.getProductContext", error);
+        },
+    );
+
+    const isLocalHost = /^(?:localhost|127\.0\.0\.1|[^:]+\.localhost)(?::\d+)?$/i.test(productId);
+    const name = isLocalHost ? productId : productId.replace(/\.[^.]+$/, "");
+
+    log.info("Creating Product SDK app", { name });
 
     // Initialize storage (container-only - will throw if not in container)
-    const localKvStore = await createLocalKvStore({ prefix: config.name });
+    const localKvStore = await createLocalKvStore({ prefix: name });
 
     // Initialize signer manager
     const signerManager = new SignerManager({
-        dappName: config.name,
+        dappName: productId,
     });
 
     // Initialize cloud storage client (configurable, defaults to paseo).
@@ -124,18 +147,8 @@ export async function createApp(config: AppConfig): Promise<App> {
         log.debug("Cloud Storage client disabled");
     }
 
-    // Create storage API adapter
-    const localStorageApi: LocalStorageApi = {
-        get: (key) => localKvStore.get(key),
-        set: (key, value) => localKvStore.set(key, value),
-        getJSON: <T>(key: string) => localKvStore.getJSON<T>(key),
-        setJSON: <T>(key: string, value: T) => localKvStore.setJSON(key, value),
-        remove: (key) => localKvStore.remove(key),
-        clear: async () => {
-            // LocalKvStore doesn't have clear - this is a no-op
-            log.debug("clear() is not supported in container storage mode");
-        },
-    };
+    // Storage API adapter — shared with `createFakeApp` so the two cannot drift.
+    const localStorageApi: LocalStorageApi = createLocalStorageApi(localKvStore);
 
     // Create wallet API adapter
     const walletApi = createWalletApi(signerManager);
@@ -206,7 +219,7 @@ export async function createApp(config: AppConfig): Promise<App> {
         : null;
 
     log.info("Product SDK app created", {
-        name: config.name,
+        name,
         cloudStorage: cloudStorageEnabled ? cloudStorageEnvironment : "disabled",
     });
 
@@ -215,7 +228,7 @@ export async function createApp(config: AppConfig): Promise<App> {
         localStorage: localStorageApi,
         chain: chainApi,
         cloudStorage: cloudStorageApi,
-        getAppInfo: () => ({ ...config }),
+        getAppInfo: () => ({ ...config, name }),
     };
 }
 

package/src/core/local-storage-api.ts

@@ -0,0 +1,74 @@
+// Copyright 2026 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * The one adapter from a {@link LocalKvStore} to the SDK's {@link LocalStorageApi}.
+ *
+ * Both `createApp` (host-backed store) and `createFakeApp` (in-memory store)
+ * build their `localStorage` through here, so the shipped adapter and the test
+ * fake cannot drift — which is exactly how `clear()` came to be a no-op in
+ * production while the fake emptied (#344). The in-source test below drives one
+ * assertion set through this factory over an in-memory store; anything the fake
+ * exposes, the real path exposes the same way.
+ */
+import type { LocalKvStore } from "@parity/product-sdk-local-storage";
+import type { LocalStorageApi } from "./types.js";
+
+/** Wrap a {@link LocalKvStore} as the SDK's {@link LocalStorageApi}. */
+export function createLocalStorageApi(kv: LocalKvStore): LocalStorageApi {
+    return {
+        get: (key) => kv.get(key),
+        set: (key, value) => kv.set(key, value),
+        getJSON: <T>(key: string) => kv.getJSON<T>(key),
+        setJSON: <T>(key: string, value: T) => kv.setJSON(key, value),
+        remove: (key) => kv.remove(key),
+    };
+}
+
+if (import.meta.vitest) {
+    const { describe, test, expect } = import.meta.vitest;
+
+    /** A minimal in-memory {@link LocalKvStore}, string- and JSON-aware. */
+    function memoryKvStore(): LocalKvStore {
+        const store = new Map<string, string>();
+        return {
+            async get(key) {
+                return store.get(key) ?? null;
+            },
+            async set(key, value) {
+                store.set(key, value);
+            },
+            async remove(key) {
+                store.delete(key);
+            },
+            async getJSON<T>(key: string) {
+                const raw = store.get(key);
+                return raw === undefined ? null : (JSON.parse(raw) as T);
+            },
+            async setJSON(key, value) {
+                store.set(key, JSON.stringify(value));
+            },
+        };
+    }
+
+    describe("createLocalStorageApi", () => {
+        test("round-trips strings and JSON, and remove deletes one key", async () => {
+            const api = createLocalStorageApi(memoryKvStore());
+
+            await api.set("k", "v");
+            await api.setJSON("o", { n: 1 });
+            expect(await api.get("k")).toBe("v");
+            expect(await api.getJSON("o")).toEqual({ n: 1 });
+            expect(await api.get("missing")).toBeNull();
+
+            await api.remove("k");
+            expect(await api.get("k")).toBeNull();
+            // No clear-all: an untouched key stays.
+            expect(await api.getJSON("o")).toEqual({ n: 1 });
+        });
+
+        test("exposes exactly the LocalStorageApi surface — no clear()", () => {
+            const api = createLocalStorageApi(memoryKvStore());
+            expect(Object.keys(api).sort()).toEqual(["get", "getJSON", "remove", "set", "setJSON"]);
+        });
+    });
+}

package/src/core/types.ts

@@ -25,8 +25,8 @@ export interface CloudStorageConfig {
 
 /** Configuration for createApp */
 export interface AppConfig {
-    /** Application name - used to derive product accounts and namespace storage */
-    name: string;
+    /** @deprecated Ignored with a warning. The host product ID supplies the app name. */
+    name?: string;
     /** Log level for SDK operations (default: 'info') */
     logLevel?: LogLevel;
     /**
@@ -37,6 +37,12 @@ export interface AppConfig {
     cloudStorage?: CloudStorageConfig | false;
 }
 
+/** App configuration with the identity resolved from the host. */
+export interface AppInfo extends Omit<AppConfig, "name"> {
+    /** App name and storage prefix, omitting the host ID's final domain suffix. Local host IDs stay unchanged. */
+    name: string;
+}
+
 /** Wallet API exposed by the SDK */
 export interface WalletApi {
     /** Connect to available wallet providers */
@@ -72,7 +78,14 @@ export interface WalletApi {
     createProof(message: Uint8Array): Promise<Uint8Array>;
 }
 
-/** Storage API exposed by the SDK */
+/**
+ * Storage API exposed by the SDK: per-key get / set / remove, string and JSON.
+ *
+ * There is no `clear()`. Host localStorage exposes no key enumeration (only
+ * per-key read / write / remove), so a clear-all cannot be implemented — it was
+ * a silent no-op in a host container. Remove keys individually with `remove`,
+ * or track the keys your app writes and remove them.
+ */
 export interface LocalStorageApi {
     /** Get a value by key */
     get(key: string): Promise<string | null>;
@@ -84,8 +97,6 @@ export interface LocalStorageApi {
     setJSON<T = unknown>(key: string, value: T): Promise<void>;
     /** Remove a value by key */
     remove(key: string): Promise<void>;
-    /** Clear all values */
-    clear(): Promise<void>;
 }
 
 /** Chain API exposed by the SDK */
@@ -171,8 +182,8 @@ export interface App {
     chain: ChainApi;
     /** Cloud Storage operations (null if disabled via config) */
     cloudStorage: CloudStorageApi | null;
-    /** Get app configuration */
-    getAppInfo(): AppConfig;
+    /** Get app configuration with the host-derived name. */
+    getAppInfo(): AppInfo;
 }
 
 /** Account information */

package/src/identity/dotns-abis.ts

@@ -238,6 +238,39 @@ export const DOTNS_PROTOCOL_REGISTRY_ABI: AbiEntry[] = [
         outputs: [{ name: "node", type: "bytes32" }],
         stateMutability: "view",
     },
+    {
+        type: "function",
+        name: "get",
+        inputs: [{ name: "key", type: "bytes32" }],
+        outputs: [{ name: "addr", type: "address" }],
+        stateMutability: "view",
+    },
+];
+
+/**
+ * `RootGatewayDispatcher.TARGET`, the PoP controller it forwards to. `immutable`,
+ * so a rotation means a new dispatcher and a new pallet value, which is why
+ * discovery starts at the pallet rather than here.
+ */
+export const DOTNS_ROOT_GATEWAY_DISPATCHER_ABI: AbiEntry[] = [
+    {
+        type: "function",
+        name: "TARGET",
+        inputs: [],
+        outputs: [{ name: "", type: "address" }],
+        stateMutability: "view",
+    },
+];
+
+/** `DotnsPopController.protocolRegistry`, the only hop that names the registry. */
+export const DOTNS_POP_CONTROLLER_ABI: AbiEntry[] = [
+    {
+        type: "function",
+        name: "protocolRegistry",
+        inputs: [],
+        outputs: [{ name: "", type: "address" }],
+        stateMutability: "view",
+    },
 ];
 
 /** `IPopRules.PopStatus`. Ordering is meaningful: a user meets a tier when `userStatus >= status`. */
@@ -248,21 +281,23 @@ export const POP_STATUS = { NoStatus: 0, PopLite: 1, PopFull: 2, Reserved: 3 } a
  *
  * Not a per-network table, despite what the old name (`PASEO_ASSETHUB_DOTNS`)
  * implied: every DotNS network is deployed through the same CREATE3 factory, so
- * the addresses are identical everywhere and **only the TLD differs**. Verified
- * on both Paseo Asset Hub Next V2 and Previewnet — `protocolRegistry.get(...)`
- * returns the same registry on each, and all six addresses hold contracts on
- * both. `paritytech/dotns` `DEPLOYMENTS.md` states the mechanism, and
+ * the addresses are identical everywhere and **only the TLD differs**, `.paseo`
+ * on Paseo Asset Hub Next V2 and `.test` on Previewnet. Verified on both:
+ * `protocolRegistry.get(...)` returns the same registry on each, and all six
+ * addresses hold contracts on both. `paritytech/dotns` `DEPLOYMENTS.md` states the mechanism, and
  * `preview-net-v1` confirms it from the deploy side: the TLD is passed only as
  * registry init calldata, so it moves no address.
  *
  * So extending this module to another network means resolving its TLD, which
  * `resolveTld` already does — not adding a second address table.
  *
- * Each address answers `DotnsProtocolRegistry.get(bytes32)` under its
- * `DotnsConstants` key (the name below, right-padded to 32 bytes) and has a
- * `Revive.AccountInfoOf` entry. They are pinned rather than resolved at runtime,
- * so re-verify after a redeploy; `protocolRegistry` is the address to walk from
- * if we ever resolve the rest dynamically.
+ * Five answer `DotnsProtocolRegistry.get(bytes32)` under the keys in
+ * `DOTNS_REGISTRY_KEYS`, two of which differ from the field name used here.
+ * `protocolRegistry` has no key and comes from the gateway walk. All six have a
+ * `Revive.AccountInfoOf` entry.
+ *
+ * Pinned, not resolved at runtime: re-verify after a redeploy, or have the
+ * client do it with `verifyDotNsAddresses`.
  */
 export const DOTNS_ADDRESSES = {
     registry: "0xf34054fd76BbF85f216cf9908226D5f0A72E50CA",