@parity/product-sdk-host 0.11.0 → 0.12.0

package/dist/index.d.ts

@@ -1,16 +1,15 @@
-import { JsonRpcProvider } from 'polkadot-api';
-import * as _novasamatech_host_api from '@novasamatech/host-api';
-import { Subscription, Transport, CodecType, AllocatableResource as AllocatableResource$1, AllocationOutcome as AllocationOutcome$1, RemotePermission as RemotePermission$1, DevicePermission, HexString } from '@novasamatech/host-api';
-export { HexString, PushNotificationError, assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow } from '@novasamatech/host-api';
-import * as _novasamatech_host_api_wrapper from '@novasamatech/host-api-wrapper';
-import { hostLocalStorage, createStatementStore, ProductAccountId as ProductAccountId$1, SignedStatement as SignedStatement$1, Statement as Statement$1, StatementTopicFilter as StatementTopicFilter$1, StatementsPage as StatementsPage$1, Topic as Topic$1, createAccountsProvider, preimageManager, ThemeMode as ThemeMode$1, createThemeProvider, ChatBotRegistrationResult as ChatBotRegistrationResult$1, ChatCustomMessageRenderer as ChatCustomMessageRenderer$1, ChatCustomMessageRendererParams as ChatCustomMessageRendererParams$1, createProductChatManager, ChatMessageContent as ChatMessageContent$1, ChatReceivedAction as ChatReceivedAction$1, ChatRoom as ChatRoom$1, ChatRoomRegistrationResult as ChatRoomRegistrationResult$1, PaymentBalance as PaymentBalance$1, paymentManager, PaymentStatus as PaymentStatus$1, TopUpSource as TopUpSource$1, notificationManager } from '@novasamatech/host-api-wrapper';
+import { JsonRpcProvider, PolkadotSigner } from 'polkadot-api';
+import { Topic, RemoteStatementStoreSubscribeItem, Statement, StatementProof, SignedStatement, HexString, GenericError, TrUApiClient, AllocatableResource, AllocationOutcome, HostGetUserIdError, HostRequestLoginResponse, HostRequestLoginError, ProductAccountId, ProductAccount as ProductAccount$1, HostAccountGetError, HostAccountGetAliasResponse, LegacyAccount, RingLocation, HostAccountCreateProofError, HostAccountConnectionStatusSubscribeItem, HostDevicePermissionRequest, RemotePermission, HostThemeSubscribeItem, ChatBotRegistrationStatus, HostChatCreateRoomRequest, ChatRoomRegistrationStatus, HostChatRegisterBotRequest, ChatMessageContent, ChatRoom, HostChatActionSubscribeItem, HostPaymentBalanceSubscribeItem, PaymentPurseId, Balance, PaymentTopUpSource, HostPaymentStatusSubscribeItem, HostPushNotificationRequest, NotificationId } from '@parity/truapi';
+export { AllocatableResource, AllocationOutcome, ChatMessageContent, ChatRoom, HexString, HostPaymentBalanceSubscribeItem, HostPaymentStatusSubscribeItem, NotificationId, PaymentTopUpSource, ProductAccountId, HostPushNotificationError as PushNotificationError, RemotePermission, RingLocation, SignedStatement, Statement, StatementProof, ThemeName, ThemeVariant, Topic } from '@parity/truapi';
+import { ResultAsync as ResultAsync$1 } from 'neverthrow';
+export { isCorrectEnvironment as isInsideContainerSync } from '@parity/truapi/sandbox';
 
 /**
  * Public types for the host wrappers.
  *
- * These are re-exported from `@novasamatech/host-api-wrapper` (the runtime
- * objects the host getters cast to) rather than hand-mirrored, so the
- * Parity surface stays in lockstep with the upstream codec types.
+ * The statement-store types are re-exported from `@parity/truapi` so the Parity
+ * surface stays in lockstep with the in-house protocol codec types. Their fields
+ * are `0x`-prefixed hex strings (`HexString`) and their enums are `{ tag }` unions.
  */
 
 /**
@@ -20,59 +19,71 @@ import { hostLocalStorage, createStatementStore, ProductAccountId as ProductAcco
  * via {@link getHostLocalStorage} when you need raw host storage without the
  * KV abstraction.
  *
- * Type identical to `hostLocalStorage` from `@novasamatech/host-api-wrapper`.
- */
-type HostLocalStorage = typeof hostLocalStorage;
+ * Backed by `truApi.localStorage.*` (raw `read`/`write`/`clear` over hex bytes);
+ * {@link getHostLocalStorage} adapts that into this richer surface. `readString`
+ * resolves to `""` for a missing key and `readJSON`/`readBytes` to
+ * `null`/`undefined`.
+ */
+interface HostLocalStorage {
+    /** Read a UTF-8 string value; `""` when the key is absent. */
+    readString(key: string): Promise<string>;
+    /** Write a UTF-8 string value. */
+    writeString(key: string, value: string): Promise<void>;
+    /** Read and JSON-parse a value; `null` when the key is absent. */
+    readJSON(key: string): Promise<unknown>;
+    /** JSON-stringify and write a value. */
+    writeJSON(key: string, value: unknown): Promise<void>;
+    /** Read raw bytes; `undefined` when the key is absent. */
+    readBytes(key: string): Promise<Uint8Array | undefined>;
+    /** Write raw bytes. */
+    writeBytes(key: string, value: Uint8Array): Promise<void>;
+    /** Remove a key. */
+    clear(key: string): Promise<void>;
+}
 /**
- * Cryptographic proof attached to a statement before submission, returned by
- * {@link HostStatementStore.createProof}. Variants cover the supported
- * signature schemes - `Sr25519`, `Ed25519`, `Ecdsa`, and `OnChain` (chain-
- * attestation-based proofs).
+ * Topic-based subscription filter. The host delivers statements that match
+ * either *all* of the listed topics (`matchAll`) or *any* of them (`matchAny`).
  *
- * Inferred from `createStatementStore().createProof`'s return type so codec
- * changes surface here as compile errors, not runtime decode failures.
+ * This is a field-discriminated form of truapi's `RemoteStatementStoreSubscribeRequest`,
+ * which is a tagged union (`{ tag: "MatchAll"; value: Topic[] } | { tag: "MatchAny"; value: Topic[] }`).
+ * The transport maps between the two.
  */
-type StatementProof = Awaited<ReturnType<ReturnType<typeof createStatementStore>["createProof"]>>;
-/**
- * Topic-based subscription filter. The host delivers statements that match
- * either *all* of the listed topics (`matchAll`) or *any* of them
- * (`matchAny`). Re-exported from `@novasamatech/host-api-wrapper`.
- */
-type StatementTopicFilter = StatementTopicFilter$1;
-/** A single topic value used inside a {@link StatementTopicFilter}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type Topic = Topic$1;
-/** `[ss58Address, chainPrefix]` tuple identifying a product account at the codec layer. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ProductAccountId = ProductAccountId$1;
-/** Unsigned statement payload. Re-exported from `@novasamatech/host-api-wrapper`. */
-type Statement = Statement$1;
-/** Statement bundled with its {@link StatementProof}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type SignedStatement = SignedStatement$1;
+type StatementTopicFilter = {
+    matchAll: Topic[];
+} | {
+    matchAny: Topic[];
+};
 /**
  * A page of signed statements delivered by {@link HostStatementStore.subscribe}.
  *
- * Pages arrive sequentially. `isComplete` is `true` on the final page of a
- * subscription's initial backfill; subsequent pages contain new statements
- * as they appear on chain. `statements` is `SignedStatement[]` (typed,
- * not `unknown[]`).
+ * truapi's `RemoteStatementStoreSubscribeItem`, re-exported under a friendlier
+ * name. Pages arrive sequentially; `isComplete` is `false` while the host
+ * streams the historical backfill and `true` once it's done (and on every
+ * subsequent live-update page).
  */
-type StatementsPage = StatementsPage$1;
+type StatementsPage = RemoteStatementStoreSubscribeItem;
 /**
- * Subscription handle returned by the host - equivalent to
- * `Subscription<void>` from `@novasamatech/host-api`. Exposes
- * `unsubscribe()` plus an `onInterrupt` hook that fires if the host
- * interrupts the subscription server-side.
+ * Subscription handle returned by the host. Exposes `unsubscribe()` plus an
+ * `onInterrupt` hook that fires if the host interrupts the subscription
+ * server-side; `onInterrupt` returns a function that cancels the hook.
  */
-type HostSubscription = Subscription<void>;
+interface HostSubscription {
+    unsubscribe(): void;
+    onInterrupt(callback: (reason?: unknown) => void): () => void;
+}
 /**
- * Statement Store handle exposed by the host container. Provides
- * `subscribe`, `createProof`, and `submit` operations that go through the
- * host's native binary protocol; the `statement-store` package layers a
- * higher-level client on top.
- *
- * Type identical to `createStatementStore()` from
- * `@novasamatech/host-api-wrapper`.
- */
-type HostStatementStore = ReturnType<typeof createStatementStore>;
+ * Statement Store handle exposed by the host container, backed by
+ * `truApi.statementStore.*`. `subscribe` streams matching statements;
+ * `createProofAuthorized` signs a statement with the product's RFC-10 allowance
+ * account (the sponsored path — no per-call account id); `submit` publishes a
+ * signed statement. The `statement-store` package layers a higher-level client
+ * on top.
+ */
+interface HostStatementStore {
+    subscribe(filter: StatementTopicFilter, callback: (page: StatementsPage) => void): HostSubscription;
+    createProofAuthorized(statement: Statement): Promise<StatementProof>;
+    submit(signedStatement: SignedStatement): Promise<void>;
+}
 
 /**
  * Thrown by {@link getHostProvider} when the host container is reachable but does
@@ -95,56 +106,42 @@ declare class ChainNotSupportedError extends Error {
  *
  * The SDK is designed to run exclusively inside a host container. This function
  * is primarily useful for early validation or informational purposes.
- *
- * Uses product-sdk's sandboxProvider as primary detection.
- * Falls back to manual signal checks when product-sdk is not installed.
  */
 declare function isInsideContainer(): Promise<boolean>;
 /**
  * Get the Host API localStorage instance when running inside a container.
- * Returns null outside a container or when product-sdk is unavailable.
+ * Returns null outside a container or when the host transport is unavailable.
  */
 declare function getHostLocalStorage(): Promise<HostLocalStorage | null>;
 /**
- * Construct a fresh host-backed `HostLocalStorage` instance with an optional
- * custom transport. Use this when you need a non-default transport (e.g.
- * for tests); otherwise prefer {@link getHostLocalStorage}, which returns
- * the shared singleton.
- *
- * Mirrors `createLocalStorage` from `@novasamatech/host-api-wrapper`.
+ * Construct a host-backed `HostLocalStorage` instance. Retained for API
+ * compatibility; with the single cached TruAPI client this is equivalent to
+ * {@link getHostLocalStorage}.
  *
- * @param transport - Optional transport; defaults to the sandbox transport.
- * @returns A new `HostLocalStorage` instance, or `null` if unavailable.
+ * @returns A `HostLocalStorage` instance, or `null` if unavailable.
  */
-declare function createHostLocalStorage(transport?: Transport): Promise<HostLocalStorage | null>;
+declare function createHostLocalStorage(): Promise<HostLocalStorage | null>;
 /**
  * Get a PAPI-compatible JSON-RPC provider that routes through the host connection.
  *
- * When running inside a Polkadot container, this wraps the chain connection via the
- * host's `createPapiProvider`, enabling shared connections and efficient routing.
- * Returns `null` when `@novasamatech/host-api-wrapper` is unavailable or when not
- * running inside a container.
+ * When running inside a Polkadot container, this builds a `JsonRpcProvider` over
+ * `truApi.chain.*` (see {@link module:papi-provider}), enabling shared
+ * connections and efficient routing. Returns `null` when not running inside a
+ * container.
  *
  * @param genesisHash - Genesis hash of the target chain (`0x`-prefixed hex string).
  * @returns A host-routed `JsonRpcProvider`, or `null` if unavailable.
  * @throws {ChainNotSupportedError} When inside a container but the host can't serve
  *   the chain — surfaced instead of returning a provider that would hang forever.
  */
-declare function getHostProvider(genesisHash: `0x${string}`): Promise<JsonRpcProvider | null>;
+declare function getHostProvider(genesisHash: HexString): Promise<JsonRpcProvider | null>;
 /**
- * Synchronous container detection — fast heuristic check without product-sdk.
+ * Get the host statement store when running inside a container, backed by
+ * `truApi.statementStore.*`.
  *
- * Checks for iframe, webview marker, and host message port signals.
- * Use this when you need a quick sync check (e.g., in hot code paths).
- * For full detection including product-sdk, use {@link isInsideContainer} (async).
- */
-declare function isInsideContainerSync(): boolean;
-/**
- * Get the host API statement store when running inside a container.
- *
- * Returns a statement store with `subscribe`, `createProof`, and `submit` methods
- * that communicate through the host's native binary protocol — bypassing JSON-RPC
- * entirely. Returns `null` when `@novasamatech/host-api-wrapper` is unavailable.
+ * Returns a store with `subscribe`, `createProofAuthorized`, and `submit` that
+ * communicate through the host's native binary protocol — bypassing JSON-RPC
+ * entirely. Returns `null` outside a host container.
  *
  * @returns The host statement store, or `null` if unavailable.
  */
@@ -169,143 +166,195 @@ declare const BULLETIN_RPCS: {
 declare const DEFAULT_BULLETIN_ENDPOINT: string;
 
 /**
- * Extract a human-readable message from a host-side error. Hosts wrap
- * errors in versioned envelopes (`{ tag: "v1", value: CodecError }`); this
- * helper unwraps the envelope and renders the inner error's `name`/`message`
- * so callers see the host's actual diagnostic instead of `"[object Object]"`
- * (from `String(err)`) or a JSON-stringified envelope.
+ * Typed errors carried on the `err` channel of the host public API's
+ * {@link Result} returns.
+ *
+ * The hierarchy mirrors `@parity/product-sdk-signer`'s error classes
+ * (`HostUnavailableError` / `HostRejectedError`), so the two layers share one
+ * idiom: branch with `instanceof`, and every error is a real `Error` with a
+ * stack trace and `cause`. The structured truapi wire error
+ * ({@link HostErrorPayload}) rides along as {@link HostCallFailedError.payload}
+ * for callers that want fine-grained tag-level handling.
  *
- * Exported for the higher-level wrappers (`requestPermission`,
- * `deriveEntropy`, etc.) that build their `throw new Error(...)` messages.
+ * This module also owns {@link HostErrorPayload} (the wire-error shape) and
+ * {@link formatHostError} (renders a payload to a message) — co-located with the
+ * error classes that consume them so the host error model lives in one place.
+ *
+ * @module
  */
-declare function formatHostError(err: unknown): string;
 
 /**
- * The TruApi type - provides low-level methods for communicating with the host.
+ * The structured error payload `@parity/truapi` surfaces on the `Err` channel of
+ * a host call, once unwrapped from the versioned wire envelope. Every host error
+ * union is built from these:
+ *
+ * - the catch-all {@link GenericError} (`{ reason }`),
+ * - a unit tagged variant (`{ tag }`), or
+ * - a tagged variant carrying a reason (`{ tag, value: { reason } }`).
+ *
+ * `GenericError` is imported from `@parity/truapi`; the `{ tag }` members are a
+ * deliberate widening of truapi's per-domain named variants (the formatter is
+ * tag-agnostic). truapi has no umbrella error union to import today — once it
+ * exports a canonical tagged-error union from codegen, replace these local
+ * members with that import so the type is protocol-sourced rather than
+ * hand-widened.
+ *
+ * This is the *payload* the host public API carries inside a
+ * {@link HostCallFailedError} on the `err` channel of its `Result` returns — not
+ * the error type consumers branch on.
+ */
+type HostErrorPayload = GenericError | {
+    tag: string;
+    value?: undefined;
+} | {
+    tag: string;
+    value: {
+        reason: string;
+    };
+};
+/**
+ * Extract a human-readable message from a host-side error.
  *
- * Methods include:
- * - `navigateTo(url)` - Navigate to a URL within the host
- * - `permission(permissions)` - Request permissions from the host
- * - `localStorageRead/Write/Clear` - Host-backed storage
- * - `sign(payload)` - Request transaction signing
- * - `deriveEntropy(context)` - Derive deterministic entropy
- * - `themeSubscribe()` - Subscribe to host theme changes
- * - And many more...
+ * Renders the {@link HostErrorPayload} shapes `@parity/truapi` surfaces. Accepts
+ * `unknown` because it is also the catch-all formatter for thrown adapter-method
+ * `Error` messages, so it falls back to `Error`/string/JSON rendering for
+ * anything that isn't a recognized host error payload.
  *
- * Type identical to `hostApi` from `@novasamatech/host-api-wrapper` so that
- * `truApi.X(...)` calls keep their full inference (return types, method
- * names, parameter shapes) instead of decaying to `any`.
+ * Used by {@link HostCallFailedError} to render its message, and by the throwing
+ * adapter-method helper `unwrapHostResult`.
  */
-type TruApi = typeof _novasamatech_host_api_wrapper.hostApi;
+declare function formatHostError(error: unknown): string;
 /**
- * Get the TruAPI instance for direct low-level access.
- *
- * Returns the `hostApi` object from `@novasamatech/host-api-wrapper` which provides
- * methods for communicating directly with the host container. Returns `null`
- * when running outside a container or when the SDK is unavailable.
- *
- * For most use cases, prefer the higher-level functions like `getHostLocalStorage()`,
- * `getHostProvider()`, etc. Use this when you need direct access to host methods
- * like `navigateTo()`, `permission()`, or `deriveEntropy()`.
- *
- * @example
- * ```ts
- * import { getTruApi, enumValue } from "@parity/product-sdk-host";
- *
- * const truApi = await getTruApi();
- * if (truApi) {
- *   // Request permission
- *   const result = await truApi.permission([enumValue("ChainSubmit")]);
+ * Base class for all host errors. Use `instanceof HostError` (or {@link isHostError})
+ * to catch any host-related failure.
+ */
+declare class HostError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * The host API is not available — the app is running outside a Polkadot host
+ * container (no injected TruAPI transport). The dominant case during local
+ * development. Branch with `instanceof HostUnavailableError` to surface an
+ * "open this app in a Polkadot host" message.
+ */
+declare class HostUnavailableError extends HostError {
+    constructor(message?: string);
+}
+/**
+ * A host call reached the container but failed on the `Err` channel. Wraps the
+ * structured truapi {@link HostErrorPayload} as {@link payload} (also preserved
+ * as `cause`); the message is rendered via {@link formatHostError}.
+ */
+declare class HostCallFailedError extends HostError {
+    readonly payload: HostErrorPayload;
+    constructor(label: string, payload: HostErrorPayload);
+}
+/** Check whether a value is any {@link HostError}. */
+declare function isHostError(error: unknown): error is HostError;
+
+/**
+ * A lightweight tagged `Result` type for the host public API.
  *
- *   // Navigate to a URL
- *   await truApi.navigateTo("polkadot://settings");
+ * Host functions return `Promise<Result<T, HostError>>` rather than throwing, so
+ * consumers get typed errors on the `err` channel instead of opaque thrown
+ * `Error`s. The shape is intentionally identical to the one
+ * `@parity/product-sdk-signer` exposes (`{ ok: true; value } | { ok: false; error }`),
+ * so the two layers compose with no adapter — host's `Result` flows straight into
+ * the signer's pattern matching.
  *
- *   // Subscribe to theme changes
- *   const sub = truApi.themeSubscribe(undefined, (theme) => {
- *     console.log("Theme changed:", theme);
- *   });
- * }
- * ```
+ * NOTE: host owns its own copy because the dependency edge runs `signer → host`,
+ * so host cannot import the signer's definition. If a third package ever needs
+ * this shape, extract it into a shared `@parity/product-sdk-result` package and
+ * have both depend on that instead of duplicating.
  *
- * @returns The TruAPI instance, or `null` if unavailable.
+ * @module
  */
-declare function getTruApi(): Promise<TruApi | null>;
+/** A value that is either a success (`ok`) carrying `T`, or a failure (`err`) carrying `E`. */
+type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/** Create a successful {@link Result}. */
+declare function ok<T>(value: T): Result<T, never>;
+/** Create a failed {@link Result}. */
+declare function err<E>(error: E): Result<never, E>;
+
 /**
- * Get the preimage manager for bulletin chain operations.
+ * TruAPI - the protocol for communicating between apps and the Polkadot host container.
  *
- * The preimage manager handles uploading and looking up preimages (arbitrary data)
- * on the bulletin chain through the host's optimized path.
+ * This module centralizes access to the in-house `@parity/truapi` client,
+ * allowing other `@parity/product-sdk-*` packages to import from here rather
+ * than depending directly on the protocol package. The client is built and
+ * cached by {@link module:transport}; this module adds the accessor plus the
+ * two helpers the convenience wrappers fold truapi's `ResultAsync` through —
+ * {@link mapHostResult} (returns a `Result`, used by the public operations) and
+ * {@link unwrapHostResult} (throws, used by the adapter-object methods).
  *
- * @returns The preimage manager, or `null` if unavailable.
+ * @module
+ */
+
+/** Convert bytes to a `0x`-prefixed lower-case hex string. */
+declare function toHex(bytes: Uint8Array): HexString;
+/** Convert a hex string (with or without `0x`) to bytes. */
+declare function fromHex(hex: string): Uint8Array;
+
+/**
+ * The TruApi client — namespaced access to every host protocol domain
+ * (`permissions`, `entropy`, `signing`, `statementStore`, `system`,
+ * `localStorage`, …). Identical to `TrUApiClient` from `@parity/truapi`.
  *
  * @example
  * ```ts
- * import { getPreimageManager } from "@parity/product-sdk-host";
- *
- * const manager = await getPreimageManager();
- * if (manager) {
- *   // Submit a preimage
- *   const key = await manager.submit(new Uint8Array([1, 2, 3]));
- *
- *   // Look up a preimage
- *   const sub = manager.lookup(key, (data) => {
- *     if (data) console.log("Found:", data);
+ * const truApi = await getTruApi();
+ * if (truApi) {
+ *   await truApi.permissions.requestRemotePermission({
+ *     permission: { tag: "ChainSubmit", value: undefined },
  *   });
+ *   await truApi.system.navigateTo({ url: "polkadot://settings" });
  * }
  * ```
  */
-declare function getPreimageManager(): Promise<PreimageManager | null>;
+type TruApi = TrUApiClient;
 /**
- * Preimage manager handle for bulletin chain operations. `lookup` returns a
- * `Subscription<void>` (`unsubscribe` + `onInterrupt`); `submit` returns a
- * `0x`-prefixed hex preimage key.
+ * Get the TruAPI client for direct low-level access to host protocol domains.
  *
- * Type identical to `preimageManager` from `@novasamatech/host-api-wrapper`.
- */
-type PreimageManager = typeof preimageManager;
-/**
- * Construct a fresh `PreimageManager` instance with an optional custom
- * transport. Use this when you need a non-default transport; otherwise
- * prefer {@link getPreimageManager}, which returns the shared singleton.
+ * Returns the cached `@parity/truapi` client once the host transport is built
+ * and the handshake has run, or `null` when running outside a container.
  *
- * Mirrors `createPreimageManager` from `@novasamatech/host-api-wrapper`.
+ * For most use cases, prefer the higher-level functions like
+ * {@link requestPermission}, {@link deriveEntropy}, or `getHostLocalStorage()`.
  *
- * @param transport - Optional transport; defaults to the sandbox transport.
- * @returns A new `PreimageManager` instance, or `null` if unavailable.
+ * @returns The TruAPI client, or `null` if unavailable.
  */
-declare function createHostPreimageManager(transport?: _novasamatech_host_api.Transport): Promise<PreimageManager | null>;
-/**
- * Get the accounts provider for managing host accounts.
- *
- * @returns The accounts provider, or `null` if unavailable.
- */
-declare function getAccountsProvider(): Promise<AccountsProvider | null>;
+declare function getTruApi(): Promise<TruApi | null>;
 /**
- * Resource types requestable via {@link requestResourceAllocation}.
- * Derived from the upstream codec so variant renames surface as compile
- * errors, not runtime failures.
+ * Preimage manager handle for bulletin chain operations, backed by
+ * `truApi.preimage.*`. `lookup` opens a {@link HostSubscription} (`unsubscribe`
+ * + `onInterrupt`) that delivers the preimage bytes — or `null` until the host
+ * finds them; `submit` uploads a preimage and resolves to its `0x`-prefixed hex
+ * key.
  */
-type AllocatableResource = CodecType<typeof AllocatableResource$1>;
-/** Tag-only view of {@link AllocatableResource} for places that just need the variant name. */
-type AllocatableResourceTag = AllocatableResource["tag"];
+interface PreimageManager {
+    lookup(key: HexString, callback: (preimage: Uint8Array | null) => void): HostSubscription;
+    submit(value: Uint8Array): Promise<HexString>;
+}
 /**
- * Per-resource outcome from {@link requestResourceAllocation}.
- * The host strips secret payloads from `Allocated` before returning, so
- * `value` is always `undefined` on the product side.
+ * Get the preimage manager for bulletin chain operations.
+ *
+ * @returns The preimage manager, or `null` if unavailable (outside a container).
  */
-type AllocationOutcome = CodecType<typeof AllocationOutcome$1>;
-/** Tag-only view of {@link AllocationOutcome} (`"Allocated" | "Rejected" | "NotAvailable"`). */
-type AllocationOutcomeTag = AllocationOutcome["tag"];
+declare function getPreimageManager(): Promise<PreimageManager | null>;
 /**
- * Remote permission the dapp can ask the host to grant via
- * {@link requestPermission}.
+ * Construct a `PreimageManager`. Retained for API compatibility; with the single
+ * cached TruAPI client this is equivalent to {@link getPreimageManager}.
  *
- * Derived from the upstream codec so variant renames surface as compile
- * errors, not runtime failures.
+ * @returns A `PreimageManager` instance, or `null` if unavailable.
  */
-type RemotePermission = CodecType<typeof RemotePermission$1>;
-/** Tag-only view of {@link RemotePermission}. */
-type RemotePermissionTag = RemotePermission["tag"];
+declare function createHostPreimageManager(): Promise<PreimageManager | null>;
+
 /**
  * Request the host to pre-allocate one or more resource allowances.
  *
@@ -313,238 +362,232 @@ type RemotePermissionTag = RemotePermission["tag"];
  * granted allowance don't re-prompt.
  *
  * @param resources - Resources to request.
- * @returns Per-resource outcomes in the same order as `resources`.
- * @throws If the host is unavailable or the request fails.
+ * @returns `ok` with per-resource outcomes in the same order as `resources`, or
+ *   `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
- * const outcomes = await requestResourceAllocation([
+ * const r = await requestResourceAllocation([
  *   { tag: "BulletinAllowance", value: undefined },
  * ]);
- * if (outcomes[0].tag === "Allocated") { ... }
+ * if (r.ok && r.value[0] === "Allocated") { ... }
  * ```
  */
-declare function requestResourceAllocation(resources: AllocatableResource[]): Promise<AllocationOutcome[]>;
+declare function requestResourceAllocation(resources: AllocatableResource[]): Promise<Result<AllocationOutcome[], HostError>>;
 /**
- * Have the host sign a Statement using an allowance-bearing account it
- * picks internally — RFC-10 §"Statement Store allowance".
- *
- * The product passes only the Statement payload; the host chooses the
- * `//allowance//statement-store//{productId}` account that holds SSS
- * allowance and signs with it. Allowance is provisioned implicitly on
- * first use if the host hasn't already pre-allocated via
- * {@link requestResourceAllocation}; products never see the signing
- * account or its key material.
+ * Have the host sign a Statement using the product's allowance-bearing account,
+ * which it picks internally — RFC-10 §"Statement Store allowance". No per-call
+ * account id is needed (this is the sponsored-submission path).
  *
- * Pairs with {@link getStatementStore}'s `submit`: call this to obtain
- * a proof, attach it to the Statement, and submit the result.
+ * Pairs with {@link getStatementStore}'s `submit`: call this to obtain a proof,
+ * attach it to the Statement, and submit the result.
  *
  * @param statement - The Statement to be signed.
- * @returns The proof to attach before submitting.
- * @throws If the host is unavailable or the host-side signing fails.
+ * @returns `ok` with the proof to attach before submitting, or
+ *   `err(HostUnavailableError | HostCallFailedError)`.
+ */
+declare function createProofAuthorized(statement: Statement): Promise<Result<StatementProof, HostError>>;
+/**
+ * Neverthrow-style ResultAsync returned by product-sdk methods.
  *
- * @example
- * ```ts
- * import { createProofAuthorized, getStatementStore } from "@parity/product-sdk-host";
- *
- * const statement = {
- *     proof: undefined,
- *     decryptionKey: undefined,
- *     expiry: undefined,
- *     channel: undefined,
- *     topics: [],
- *     data: payload,
- * };
- * const proof = await createProofAuthorized(statement);
- * const store = await getStatementStore();
- * await store?.submit({ ...statement, proof });
- * ```
+ * Use `.match(onOk, onErr)` to handle success/error cases.
+ */
+interface ResultAsync<T, E> {
+    match: <A, B = A>(ok: (t: T) => A, err: (e: E) => B) => Promise<A | B>;
+}
+
+/**
+ * Host wallet accounts, backed by `truApi.account.*` and `truApi.signing.*`.
+ *
+ * `getAccountsProvider()` returns the full accounts surface — user identity
+ * (`getUserId` / `requestLogin`), the user's existing wallet accounts
+ * (`getLegacyAccounts`), app-scoped product accounts (`getProductAccount` /
+ * `getProductAccountAlias`), Ring VRF proofs (`createRingVRFProof`), connection
+ * status, and PAPI `PolkadotSigner` factories for both product and legacy
+ * accounts.
  *
- * @remarks
- * RFC-10 introduces this as a new, strictly additive TruAPI call. The
- * pre-existing `HostStatementStore.createProof(accountId, statement)`
- * surface stays available for products that own a non-allowance signing
- * account; this wrapper is the sponsored-submission path.
+ * The signer factories build a PAPI `PolkadotSigner` directly over
+ * `truApi.signing.createTransaction` (product) /
+ * `createTransactionWithLegacyAccount` (legacy) — `signTx` derives the
+ * metadata-driven `txExtVersion` and maps the signed extensions to the host's
+ * wire shape; `signBytes` calls `signing.signRaw(WithLegacyAccount)`. No PJS
+ * bridge is involved, so opaque signed extensions (e.g. Paseo Next's `AsPgas`)
+ * survive end-to-end.
+ *
+ * @module
  */
-declare function createProofAuthorized(statement: Statement): Promise<StatementProof>;
+
 /**
  * One of the user's existing wallet accounts, surfaced through the host and
  * identified by its public key and an optional name. Contrast with
  * {@link ProductAccount}, which is also user-controlled but derived by the
  * host for a specific app rather than picked from the user's existing keys.
+ *
+ * Derived from `@parity/truapi`'s `LegacyAccount`, with `publicKey` decoded to bytes.
  */
-interface HostAccount {
+type HostAccount = Omit<LegacyAccount, "publicKey"> & {
+    /** Raw public key bytes. */
     publicKey: Uint8Array;
-    name?: string;
-}
+};
 /**
  * A product account — an app-scoped derived account managed by the host wallet.
  *
  * The host derives a unique keypair for each app (identified by `dotNsIdentifier`)
  * so apps get their own account that the user controls but is scoped to the app.
+ *
+ * Combines `@parity/truapi`'s `ProductAccountId` (the `{ dotNsIdentifier,
+ * derivationIndex }` lookup key) with the `ProductAccount` payload, with
+ * `publicKey` decoded to bytes.
  */
-interface ProductAccount {
-    /** App identifier (e.g., "mark3t.dot"). */
-    dotNsIdentifier: string;
-    /** Derivation index within the app scope. Default: 0 */
-    derivationIndex: number;
-    /** Raw public key (32 bytes). */
+type ProductAccount = ProductAccountId & Omit<ProductAccount$1, "publicKey"> & {
+    /** Raw public key bytes. */
     publicKey: Uint8Array;
-}
+};
 /**
  * A contextual alias obtained from Ring VRF.
  *
  * Proves account membership in a ring without revealing which account.
- */
-interface ContextualAlias {
-    /** Ring context (32 bytes). */
-    context: Uint8Array;
-    /** The Ring VRF alias bytes. */
-    alias: Uint8Array;
-}
-/**
- * Neverthrow-style ResultAsync returned by product-sdk methods.
  *
- * Use `.match(onOk, onErr)` to handle success/error cases.
+ * Derived from `@parity/truapi`'s alias response, with both fields decoded to bytes.
  */
-interface ResultAsync<T, E> {
-    match: <A, B = A>(ok: (t: T) => A, err: (e: E) => B) => Promise<A | B>;
+type ContextualAlias = {
+    [K in keyof HostAccountGetAliasResponse]: Uint8Array;
+};
+/**
+ * Accounts provider handle, backed by `truApi.account.*` / `truApi.signing.*`.
+ * Surfaces the user's wallet accounts, app-scoped product accounts, Ring VRF,
+ * user identity, connection status, and `PolkadotSigner` factories.
+ *
+ * Lookup methods return a neverthrow `ResultAsync` (use `.match(ok, err)`);
+ * the signer factories return a synchronous PAPI `PolkadotSigner`.
+ */
+interface AccountsProvider {
+    getUserId(): ResultAsync$1<{
+        primaryUsername: string;
+    }, HostGetUserIdError>;
+    requestLogin(reason?: string): ResultAsync$1<HostRequestLoginResponse, HostRequestLoginError>;
+    getProductAccount(dotNsIdentifier: string, derivationIndex?: number): ResultAsync$1<ProductAccount, HostAccountGetError>;
+    getProductAccountAlias(dotNsIdentifier: string, derivationIndex?: number): ResultAsync$1<ContextualAlias, HostAccountGetError>;
+    getLegacyAccounts(): ResultAsync$1<HostAccount[], HostAccountGetError>;
+    createRingVRFProof(dotNsIdentifier: string, derivationIndex: number, location: RingLocation, message: Uint8Array): ResultAsync$1<Uint8Array, HostAccountCreateProofError>;
+    /**
+     * Build a `PolkadotSigner` for a product account. Signing routes through the
+     * host's `createTransaction` path: the host decodes the metadata and forwards
+     * the opaque signed-extension bytes, so unknown extensions survive end-to-end.
+     */
+    getProductAccountSigner(account: ProductAccount): PolkadotSigner;
+    /**
+     * Build a `PolkadotSigner` for one of the user's existing wallet accounts.
+     * `name` is accepted for callsite ergonomics but unused — the signer is
+     * derived from `publicKey` alone.
+     */
+    getLegacyAccountSigner(account: {
+        publicKey: Uint8Array;
+        name?: string;
+    }): PolkadotSigner;
+    subscribeAccountConnectionStatus(callback: (status: HostAccountConnectionStatusSubscribeItem) => void): HostSubscription;
 }
 /**
- * Accounts provider handle from `@novasamatech/host-api-wrapper`. Surfaces the
- * full upstream API - host wallet accounts, app-scoped product accounts,
- * Ring VRF, user identity (`getUserId`, `requestLogin`), and connection
- * status subscription.
+ * Get the accounts provider for managing host accounts, backed by
+ * `truApi.account.*` / `truApi.signing.*`. Returns `null` when running outside
+ * a host container.
  *
- * Type identical to `createAccountsProvider()` from
- * `@novasamatech/host-api-wrapper`; methods return neverthrow `ResultAsync`
- * values with typed `CodecError` variants in the error channel.
+ * @returns The accounts provider, or `null` if unavailable.
  */
-type AccountsProvider = ReturnType<typeof createAccountsProvider>;
+declare function getAccountsProvider(): Promise<AccountsProvider | null>;
 
 /**
  * Higher-level wrappers for the host's single-permission flows.
  *
- * `hostApi.permission` / `hostApi.devicePermission` take a versioned
- * envelope (`enumValue("v1", ...)`) and return a neverthrow `ResultAsync`
- * of an unwrapped versioned response. Consumers rebuild that wrap/unwrap
- * dance every time. {@link requestPermission} and
- * {@link requestDevicePermission} collapse it to one-liners that match the
- * shape of {@link requestResourceAllocation} (throws on error, returns
- * the unwrapped payload on success).
+ * `truApi.permissions.requestRemotePermission` / `requestDevicePermission`
+ * return a neverthrow `ResultAsync` of a `{ granted }` response.
+ * {@link requestPermission} and {@link requestDevicePermission} collapse that
+ * to one-liners returning a `Result<boolean, HostError>` — the granted flag on
+ * success, a typed {@link HostError} on the `err` channel.
  *
  * @module
  */
 
 /**
  * Device permission the dapp can ask the host to grant via
- * {@link requestDevicePermission}.
- *
- * Derived from the upstream codec so variant renames surface as compile
- * errors, not runtime failures.
+ * {@link requestDevicePermission}. A string union (`"Camera"`, `"Microphone"`,
+ * …) re-exported from `@parity/truapi`.
  */
-type DevicePermissionKind = CodecType<typeof DevicePermission>;
+type DevicePermissionKind = HostDevicePermissionRequest;
 /**
- * Alias of {@link RemotePermission} matching the upstream
- * `@novasamatech/host-api-wrapper` name. Use either freely.
+ * Legacy alias of {@link RemotePermission}, kept for back-compat with code that
+ * used the older name. Use either freely.
  */
 type RemotePermissionItem = RemotePermission;
 /**
  * Request a single remote permission from the host.
  *
- * Builds the `v1` envelope, calls `hostApi.permission`, unwraps the response,
- * and returns the host's boolean granted/denied outcome.
+ * Calls `truApi.permissions.requestRemotePermission` and returns the host's
+ * boolean granted/denied outcome.
  *
  * @param permission - The remote permission to request.
- * @returns `true` if the host granted the permission, `false` if denied.
- * @throws If the host is unavailable or the request fails.
+ * @returns `ok(true)` if the host granted the permission, `ok(false)` if denied,
+ *   or `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
- * const granted = await requestPermission({ tag: "ChainSubmit", value: undefined });
- * if (!granted) {
+ * const r = await requestPermission({ tag: "ChainSubmit", value: undefined });
+ * if (!r.ok || !r.value) {
  *   tellUserToReconnect();
  * }
  * ```
  */
-declare function requestPermission(permission: RemotePermission): Promise<boolean>;
+declare function requestPermission(permission: RemotePermission): Promise<Result<boolean, HostError>>;
 /**
  * Request a single device permission (camera, microphone, etc.) from the
  * host.
  *
- * Builds the `v1` envelope, calls `hostApi.devicePermission`, unwraps the
- * response, and returns the host's boolean granted/denied outcome.
+ * Calls `truApi.permissions.requestDevicePermission` and returns the host's
+ * boolean granted/denied outcome.
  *
  * @param permission - The device permission to request.
- * @returns `true` if the host granted the permission, `false` if denied.
- * @throws If the host is unavailable or the request fails.
+ * @returns `ok(true)` if the host granted the permission, `ok(false)` if denied,
+ *   or `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
- * const granted = await requestDevicePermission("Camera");
- * if (!granted) {
+ * const r = await requestDevicePermission("Camera");
+ * if (!r.ok || !r.value) {
  *   showCameraDeniedMessage();
  * }
  * ```
  */
-declare function requestDevicePermission(permission: DevicePermissionKind): Promise<boolean>;
+declare function requestDevicePermission(permission: DevicePermissionKind): Promise<Result<boolean, HostError>>;
 
 /**
- * Higher-level wrapper for the host's theme subscription.
- *
- * `hostApi.themeSubscribe` is reachable via {@link getTruApi}, but consumers
- * have to wire the subscription envelope themselves. `getThemeProvider`
- * returns the `@novasamatech/host-api-wrapper` theme provider object directly,
- * giving callers a `subscribeTheme(cb)` method that resolves to a typed
- * {@link ThemeMode} — a `{ name, variant }` struct where `variant` is
- * `"Light" | "Dark"` — and yields a `Subscription<void>` handle.
+ * Higher-level wrapper for the host's theme subscription, backed by
+ * `truApi.theme.subscribe`.
  *
- * @remarks
- * As of `host-api(-wrapper)` v0.8 the theme payload is a struct, not a flat
- * `"light" | "dark"` string: read {@link ThemeMode.variant} for the
- * light/dark value (now capitalized) and {@link ThemeMode.name} for the
- * active theme name (`Default`, or `Custom` carrying a string id).
+ * `getThemeProvider` returns a handle whose `subscribeTheme(cb)` delivers a
+ * typed {@link ThemeMode} — a `{ name, variant }` struct where `variant` is
+ * `"Light" | "Dark"` and `name` is `{ tag: "Default" }` or
+ * `{ tag: "Custom", value }` — and yields a {@link HostSubscription}
+ * (`unsubscribe` + `onInterrupt`).
  *
  * @module
  */
 
 /**
- * Host theme provider handle. Exposes `subscribeTheme(callback)` which
- * receives a typed {@link ThemeMode} struct on every change and returns a
- * `Subscription<void>` (`unsubscribe` + `onInterrupt`).
- *
- * Type identical to `createThemeProvider()` from
- * `@novasamatech/host-api-wrapper`.
+ * Host theme value. A `{ name, variant }` struct re-exported from
+ * `@parity/truapi`.
  */
-type ThemeProvider = ReturnType<typeof createThemeProvider>;
-/**
- * Host theme value. Re-exported from `@novasamatech/host-api-wrapper`.
- *
- * A `{ name, variant }` struct as of v0.8 (previously a flat
- * `"light" | "dark"` string).
- */
-type ThemeMode = ThemeMode$1;
-/** Light/dark variant of the active theme: `"Light" | "Dark"`. */
-type ThemeVariant = ThemeMode["variant"];
+type ThemeMode = HostThemeSubscribeItem;
+
 /**
- * Active theme name: `{ tag: "Default" }`, or `{ tag: "Custom", value }`
- * carrying the custom theme's string id.
+ * Host theme provider handle. `subscribeTheme(callback)` receives a typed
+ * {@link ThemeMode} on every change and returns a {@link HostSubscription}.
  */
-type ThemeName = ThemeMode["name"];
+interface ThemeProvider {
+    subscribeTheme(callback: (theme: ThemeMode) => void): HostSubscription;
+}
 /**
- * Get the host theme provider.
- *
- * Returns the theme-subscription handle exported by
- * `@novasamatech/host-api-wrapper`, or `null` if the package is unavailable
- * (running outside a host container or the optional peer dep isn't
- * installed).
- *
- * Implementation note: upstream `@novasamatech/host-api-wrapper` exports only
- * the `createThemeProvider` factory and no `themeProvider` singleton, so
- * this getter constructs a fresh instance on each call (unlike
- * {@link getPreimageManager} or {@link getHostLocalStorage}, which return
- * upstream singletons). The constructed provider is cheap to allocate; it
- * only opens a subscription when `subscribeTheme` is called.
+ * Get the host theme provider, backed by `truApi.theme.*`. Returns `null` when
+ * running outside a host container.
  *
  * @returns The theme provider, or `null` if unavailable.
  *
@@ -567,14 +610,14 @@ declare function getThemeProvider(): Promise<ThemeProvider | null>;
 /**
  * Higher-level wrapper for the host's entropy derivation (RFC-0007).
  *
- * `hostApi.deriveEntropy` is reachable via {@link getTruApi}, but consumers
- * have to wrap the value in the versioned envelope (`enumValue("v1", ...)`)
- * and unwrap the neverthrow `ResultAsync` themselves. `deriveEntropy`
- * collapses that to a throw-on-error Promise that matches the shape of
- * {@link requestPermission} and {@link requestResourceAllocation}.
+ * `truApi.entropy.derive` takes a hex `context` and returns a hex `entropy`
+ * payload wrapped in a neverthrow `ResultAsync`. `deriveEntropy` keeps the
+ * ergonomic `Uint8Array → Result<Uint8Array, HostError>` signature: it
+ * hex-encodes the context on the way in and decodes the entropy on the way out.
  *
  * @module
  */
+
 /**
  * Derive deterministic entropy from a context key (RFC-0007).
  *
@@ -583,61 +626,50 @@ declare function getThemeProvider(): Promise<ThemeProvider | null>;
  * different keys (or different wallets) yield uncorrelated entropy.
  *
  * @param key - Context key bytes (typically a SCALE-encoded discriminator).
- * @returns The derived entropy bytes.
- * @throws If the host is unavailable or the host-side derivation fails.
+ * @returns `ok` with the derived entropy bytes, or
+ *   `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
  * import { deriveEntropy } from "@parity/product-sdk-host";
  *
- * const seed = await deriveEntropy(new TextEncoder().encode("my-app:seed-v1"));
+ * const r = await deriveEntropy(new TextEncoder().encode("my-app:seed-v1"));
+ * if (r.ok) { const seed = r.value; }
  * ```
  */
-declare function deriveEntropy(key: Uint8Array): Promise<Uint8Array>;
+declare function deriveEntropy(key: Uint8Array): Promise<Result<Uint8Array, HostError>>;
 
 /**
- * Wrapper for the host's chat surface (`host_chat_*` family).
+ * Wrapper for the host's chat surface, backed by `truApi.chat.*`.
  *
- * Shipped flat-in-host rather than as `getTruApi().chat.*` (the shape
- * sketched in issue #93) because the upstream JS `hostApi` is itself a
- * flat object - there is no `.chat` accessor to mirror. A flat
- * `getChatManager()` matches the pattern already used by
- * {@link getThemeProvider}, {@link getAccountsProvider}, and
- * {@link getStatementStore}; if a namespaced view is desirable later, it
- * can be layered on top without breaking this surface.
+ * `getChatManager()` returns a manager for room/bot registration, message
+ * sending, and subscription to the room list and incoming actions.
  *
  * @module
  */
 
-/** Chat message payload variants. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatMessageContent = ChatMessageContent$1;
-/** Action received via {@link ChatManager.subscribeAction}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatReceivedAction = ChatReceivedAction$1;
-/** Room metadata delivered to {@link ChatManager.subscribeChatList}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatRoom = ChatRoom$1;
-/** Result of registering a chat room (`"New" | "Exists"`). Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatRoomRegistrationResult = ChatRoomRegistrationResult$1;
-/** Result of registering a bot (`"New" | "Exists"`). Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatBotRegistrationResult = ChatBotRegistrationResult$1;
-/** Renderer callback for custom message types. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatCustomMessageRenderer = ChatCustomMessageRenderer$1;
-/** Parameters passed to a {@link ChatCustomMessageRenderer}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type ChatCustomMessageRendererParams<T = Uint8Array> = ChatCustomMessageRendererParams$1<T>;
-/**
- * Chat manager handle. Exposes room/bot registration, message sending,
- * subscription to room list and incoming actions, and custom-renderer
- * registration.
- *
- * Type identical to `createProductChatManager()` from
- * `@novasamatech/host-api-wrapper`.
- */
-type ChatManager = ReturnType<typeof createProductChatManager>;
-/**
- * Get the host chat manager.
- *
- * Returns the chat manager from `@novasamatech/host-api-wrapper`, or `null` if
- * the package is unavailable (running outside a host container or the
- * optional peer dep isn't installed).
+/** Action received via {@link ChatManager.subscribeAction} (`{ roomId, peer, payload }`). Re-exported from `@parity/truapi`. */
+type ChatReceivedAction = HostChatActionSubscribeItem;
+/** Result of registering a chat room (`"New" | "Exists"`). Re-exported from `@parity/truapi`. */
+type ChatRoomRegistrationResult = ChatRoomRegistrationStatus;
+/** Result of registering a bot (`"New" | "Exists"`). Re-exported from `@parity/truapi`. */
+type ChatBotRegistrationResult = ChatBotRegistrationStatus;
+/**
+ * Chat manager handle. Exposes room/bot registration, message sending, and
+ * subscription to the room list and incoming actions.
+ */
+interface ChatManager {
+    registerRoom(request: HostChatCreateRoomRequest): Promise<ChatRoomRegistrationResult>;
+    registerBot(request: HostChatRegisterBotRequest): Promise<ChatBotRegistrationResult>;
+    sendMessage(roomId: string, payload: ChatMessageContent): Promise<{
+        messageId: string;
+    }>;
+    subscribeChatList(callback: (rooms: ChatRoom[]) => void): HostSubscription;
+    subscribeAction(callback: (action: ChatReceivedAction) => void): HostSubscription;
+}
+/**
+ * Get the host chat manager, backed by `truApi.chat.*`. Returns `null` when
+ * running outside a host container.
  *
  * @returns The chat manager, or `null` if unavailable.
  *
@@ -653,62 +685,38 @@ type ChatManager = ReturnType<typeof createProductChatManager>;
  * ```
  */
 declare function getChatManager(): Promise<ChatManager | null>;
-/**
- * Dispatch helper that composes multiple custom-message renderers into a
- * single {@link ChatCustomMessageRenderer} keyed by `messageType`.
- *
- * Mirrors `matchChatCustomRenderers` from `@novasamatech/host-api-wrapper`
- * inline (the upstream implementation is pure dispatch logic with no
- * transport / runtime dependency on Novasama), so callers get the same
- * sync signature instead of an async-with-null wrapper.
- *
- * @param map - Object mapping `messageType` strings to renderers.
- * @returns A composed renderer that dispatches to the entry matching
- *          `params.messageType`, or throws if no renderer is registered.
- */
-declare function matchChatCustomRenderers(map: Record<string, ChatCustomMessageRenderer>): ChatCustomMessageRenderer;
 
 /**
- * Wrapper for the host's payment manager (RFC-0006).
- *
- * Shipped flat-in-host rather than as `getTruApi().payment.*` because the
- * upstream JS `hostApi` is itself a flat object - there is no `.payment`
- * accessor to mirror. A flat `getPaymentManager()` matches the singleton
- * pattern already used by {@link getPreimageManager},
- * {@link getHostLocalStorage}, and {@link getAccountsProvider}.
+ * Wrapper for the host's payment manager (RFC-0006), backed by
+ * `truApi.payment.*`.
  *
- * Returns the shared `paymentManager` singleton from
- * `@novasamatech/host-api-wrapper` (not a fresh `createPaymentManager()`
- * instance) so callers share one wrapper + hostApi closure across the app.
- *
- * Distinct from the CoinPayment / merchant-payments surface tracked under
- * `@parity/product-sdk-merchant-payments` (RFC-0017). RFC-0006 is the
- * user-initiated balance / top-up / payment-request flow; RFC-0017 is the
- * merchant-initiated checkout flow.
+ * Exposes balance subscription, top-up, payment requests, and payment-status
+ * subscription. Distinct from the CoinPayment / merchant-payments surface
+ * (RFC-0017): RFC-0006 is the user-initiated balance / top-up / payment-request
+ * flow.
  *
  * @module
  */
 
-/** Available balance for the user's payment account. Re-exported from `@novasamatech/host-api-wrapper`. */
-type PaymentBalance = PaymentBalance$1;
-/** Status of an in-flight payment request. Re-exported from `@novasamatech/host-api-wrapper`. */
-type PaymentStatus = PaymentStatus$1;
-/** Source for {@link PaymentManager.topUp}. Re-exported from `@novasamatech/host-api-wrapper`. */
-type TopUpSource = TopUpSource$1;
 /**
  * Payment manager handle. Exposes balance subscription, top-up, payment
- * requests, and payment status subscription.
- *
- * Type identical to `paymentManager` from `@novasamatech/host-api-wrapper`.
- */
-type PaymentManager = typeof paymentManager;
+ * requests, and payment-status subscription.
+ *
+ * The balance / status / top-up-source shapes are `@parity/truapi`'s
+ * `HostPaymentBalanceSubscribeItem`, `HostPaymentStatusSubscribeItem`, and
+ * `PaymentTopUpSource` — used directly rather than re-aliased.
+ */
+interface PaymentManager {
+    subscribeBalance(callback: (balance: HostPaymentBalanceSubscribeItem) => void, purse?: PaymentPurseId): HostSubscription;
+    topUp(amount: Balance, source: PaymentTopUpSource, into?: PaymentPurseId): Promise<void>;
+    requestPayment(amount: Balance, destination: HexString, from?: PaymentPurseId): Promise<{
+        id: string;
+    }>;
+    subscribePaymentStatus(paymentId: string, callback: (status: HostPaymentStatusSubscribeItem) => void): HostSubscription;
+}
 /**
- * Get the host payment manager.
- *
- * Returns the shared `paymentManager` singleton from
- * `@novasamatech/host-api-wrapper`, or `null` if the package is unavailable
- * (running outside a host container or the optional peer dep isn't
- * installed).
+ * Get the host payment manager, backed by `truApi.payment.*`. Returns `null`
+ * when running outside a host container.
  *
  * @returns The payment manager, or `null` if unavailable.
  *
@@ -719,9 +727,8 @@ type PaymentManager = typeof paymentManager;
  * const payments = await getPaymentManager();
  * if (payments) {
  *   const sub = payments.subscribeBalance((b) => { ... });
- *   await payments.topUp(1_000_000n, { type: "productAccount", derivationIndex: 0 });
- *   const destination = new Uint8Array(32);
- *   const { id } = await payments.requestPayment(500n, destination);
+ *   await payments.topUp(1_000_000n, { tag: "ProductAccount", value: { derivationIndex: 0 } });
+ *   const { id } = await payments.requestPayment(500n, "0x…");
  *   sub.unsubscribe();
  * }
  * ```
@@ -729,59 +736,41 @@ type PaymentManager = typeof paymentManager;
 declare function getPaymentManager(): Promise<PaymentManager | null>;
 
 /**
- * Wrapper for the host's scheduled push-notification surface.
+ * Wrapper for the host's scheduled push-notification surface (RFC-0019),
+ * backed by `truApi.notifications.*`.
  *
- * Shipped flat-in-host rather than as `getTruApi().notification.*` because
- * the upstream JS `hostApi` is itself a flat object - there is no
- * `.notification` accessor to mirror. A flat `getNotificationManager()`
- * matches the singleton pattern already used by {@link getPaymentManager},
- * {@link getPreimageManager}, and {@link getHostLocalStorage}.
- *
- * Returns the shared `notificationManager` singleton from
- * `@novasamatech/host-api-wrapper` (not a fresh `createNotificationManager()`
- * instance) so callers share one wrapper + hostApi closure across the app.
- *
- * {@link PushNotificationError} is re-exported from `@novasamatech/host-api`
- * so consumers can branch on `err instanceof
- * PushNotificationError.ScheduleLimitReached` (the host's pending-notification
- * cap) without importing the novasama packages directly.
+ * `getNotificationManager()` returns a handle exposing `push(input)` (resolves
+ * to a {@link NotificationId}) and `cancel(id)`, matching the singleton
+ * pattern already used by {@link getPaymentManager}, {@link getPreimageManager},
+ * and {@link getHostLocalStorage}.
  *
  * @module
  */
 
 /**
- * Host notification manager handle. Exposes `push(input)` (resolves to a
- * {@link NotificationId}) and `cancel(id)`.
- *
- * Type identical to `notificationManager` from
- * `@novasamatech/host-api-wrapper`.
- */
-type NotificationManager = typeof notificationManager;
-/**
- * Host-assigned id for a scheduled notification — pass to
- * {@link NotificationManager.cancel}. Derived from the manager's `push`
- * return type so codec changes surface here as compile errors.
+ * Push payload: `text`, an optional `deeplink`, and an optional `scheduledAt`
+ * (Unix timestamp in milliseconds; omit for immediate delivery). Re-exported
+ * from the truapi wire request type so the shape stays in lockstep with the
+ * protocol.
  */
-type NotificationId = Awaited<ReturnType<NotificationManager["push"]>>;
+type PushNotificationInput = HostPushNotificationRequest;
 /**
- * Push payload: `text`, an optional `deeplink`, and an optional
- * `scheduledAt` (omit for immediate delivery). Derived from the manager's
- * `push` parameter so the shape stays in lockstep with upstream.
+ * Host notification manager handle. Exposes `push(input)` (resolves to a
+ * {@link NotificationId}) and `cancel(id)`.
  */
-type PushNotificationInput = Parameters<NotificationManager["push"]>[0];
+interface NotificationManager {
+    push(input: PushNotificationInput): Promise<NotificationId>;
+    cancel(id: NotificationId): Promise<void>;
+}
 /**
- * Get the host notification manager.
- *
- * Returns the shared `notificationManager` singleton from
- * `@novasamatech/host-api-wrapper`, or `null` if the package is unavailable
- * (running outside a host container or the optional peer dep isn't
- * installed).
+ * Get the host notification manager, backed by `truApi.notifications.*`.
+ * Returns `null` when running outside a host container.
  *
  * @returns The notification manager, or `null` if unavailable.
  *
  * @example
  * ```ts
- * import { getNotificationManager, PushNotificationError } from "@parity/product-sdk-host";
+ * import { getNotificationManager, type PushNotificationError } from "@parity/product-sdk-host";
  *
  * const notifications = await getNotificationManager();
  * if (notifications) {
@@ -792,7 +781,8 @@ type PushNotificationInput = Parameters<NotificationManager["push"]>[0];
  *     });
  *     // later: await notifications.cancel(id);
  *   } catch (err) {
- *     if (err instanceof PushNotificationError.ScheduleLimitReached) {
+ *     const cause = (err as Error).cause as PushNotificationError | undefined;
+ *     if (cause?.tag === "ScheduleLimitReached") {
  *       // host hit its pending-notification cap — surface to the user
  *     }
  *   }
@@ -804,44 +794,43 @@ declare function getNotificationManager(): Promise<NotificationManager | null>;
 /**
  * Higher-level wrapper for the host's deep-link navigation.
  *
- * `hostApi.navigateTo` is reachable via {@link getTruApi}, but consumers have
- * to wrap the URL in the versioned envelope (`enumValue("v1", ...)`) and
- * unwrap the neverthrow `ResultAsync` themselves. {@link navigateTo} collapses
- * that to a throw-on-error Promise that matches the shape of
- * {@link requestPermission} and {@link deriveEntropy}.
+ * `truApi.system.navigateTo` returns a neverthrow `ResultAsync`; consumers
+ * still have to unwrap it themselves. {@link navigateTo} collapses that to a
+ * `Result<void, HostError>`-returning Promise.
  *
  * @module
  */
+
 /**
  * Ask the host to navigate to a URL (deep link or external link).
  *
- * Builds the `v1` envelope, calls `hostApi.navigateTo`, and unwraps the
- * response. The host resolves the destination itself — a `dot`-suffixed
- * deep link (e.g. `"https://search.dot"`) routes to another app/route inside
- * the container, an `https://` URL opens externally.
+ * Calls `truApi.system.navigateTo` and unwraps the response. The host resolves
+ * the destination itself — a `dot`-suffixed deep link (e.g.
+ * `"https://search.dot"`) routes to another app/route inside the container, an
+ * `https://` URL opens externally.
  *
  * @param url - The URL to navigate to.
- * @throws If the host is unavailable, denies the navigation
- *   (`NavigateToErr::PermissionDenied`), or fails for any other reason
- *   (`NavigateToErr::Unknown`).
+ * @returns `ok` on success, or `err`: {@link HostUnavailableError} if the host
+ *   is unavailable, or {@link HostCallFailedError} if it denies the navigation
+ *   (`NavigateToErr::PermissionDenied`) or fails otherwise (`NavigateToErr::Unknown`).
  *
  * @example
  * ```ts
  * import { navigateTo } from "@parity/product-sdk-host";
  *
- * await navigateTo("https://search.dot");
+ * const r = await navigateTo("https://search.dot");
+ * if (!r.ok) handle(r.error);
  * ```
  */
-declare function navigateTo(url: string): Promise<void>;
+declare function navigateTo(url: string): Promise<Result<void, HostError>>;
 
 /**
  * Higher-level wrappers for the host's feature-support probe.
  *
- * `hostApi.featureSupported` is reachable via {@link getTruApi}, but consumers
- * have to wrap the feature in the versioned envelope (`enumValue("v1", ...)`)
- * and unwrap the neverthrow `ResultAsync` themselves. {@link featureSupported}
- * collapses that to a throw-on-error Promise; {@link isChainSupported} is a
- * convenience over the only feature variant the host exposes today (`Chain`).
+ * `truApi.system.featureSupported` returns a neverthrow `ResultAsync`;
+ * {@link featureSupported} collapses that to a `Result` carrying the host's
+ * boolean answer. {@link isChainSupported} is a convenience over the only
+ * feature variant the host exposes today (`Chain`).
  *
  * @module
  */
@@ -849,10 +838,11 @@ declare function navigateTo(url: string): Promise<void>;
 /**
  * A feature the host can be probed for via {@link featureSupported}.
  *
- * As of `host-api` v0.8 the only variant is `Chain`, carrying the chain's
- * `0x`-prefixed genesis hash. Modeled locally (rather than derived from an
- * upstream codec) because the protocol exposes the feature only inline; new
- * variants surface here as a widening of the union.
+ * The only variant today is `Chain`, carrying the chain's `0x`-prefixed genesis
+ * hash. This is a flattened form of truapi's `HostFeatureSupportedRequest`,
+ * which nests the hash as `{ tag: "Chain"; value: { genesisHash } }` — we
+ * inline `value` as the `HexString` for ergonomics and re-nest it at the call
+ * site. New variants surface here as a widening of the union.
  */
 type Feature = {
     tag: "Chain";
@@ -861,49 +851,51 @@ type Feature = {
 /**
  * Probe the host for support of a specific feature.
  *
- * Builds the `v1` envelope, calls `hostApi.featureSupported`, unwraps the
- * response, and returns the host's boolean answer.
+ * Calls `truApi.system.featureSupported`, unwraps the response, and returns the
+ * host's boolean answer.
  *
  * @param feature - The feature to probe for.
- * @returns `true` if the host supports the feature, `false` otherwise.
- * @throws If the host is unavailable or the probe fails (`GenericError`).
+ * @returns `ok(true)` if the host supports the feature, `ok(false)` otherwise,
+ *   or `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
  * import { featureSupported } from "@parity/product-sdk-host";
  *
- * const ok = await featureSupported({ tag: "Chain", value: genesisHash });
+ * const r = await featureSupported({ tag: "Chain", value: genesisHash });
+ * if (r.ok && r.value) { ... }
  * ```
  */
-declare function featureSupported(feature: Feature): Promise<boolean>;
+declare function featureSupported(feature: Feature): Promise<Result<boolean, HostError>>;
 /**
  * Convenience probe: is the chain with the given genesis hash supported by the
  * host? Wraps {@link featureSupported} for the `Chain` feature variant.
  *
  * @param genesisHash - The chain's `0x`-prefixed genesis hash.
- * @returns `true` if the host supports the chain, `false` otherwise.
- * @throws If the host is unavailable or the probe fails.
+ * @returns `ok(true)` if the host supports the chain, `ok(false)` otherwise, or
+ *   `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
  * import { isChainSupported } from "@parity/product-sdk-host";
  *
- * if (!(await isChainSupported(genesisHash))) {
+ * const r = await isChainSupported(genesisHash);
+ * if (!r.ok || !r.value) {
  *   tellUserChainUnavailable();
  * }
  * ```
  */
-declare function isChainSupported(genesisHash: HexString): Promise<boolean>;
+declare function isChainSupported(genesisHash: HexString): Promise<Result<boolean, HostError>>;
 
 /**
  * Higher-level wrapper for the host's chain-spec lookups.
  *
- * The host exposes three separate chain-spec calls — `chainSpecGenesisHash`,
- * `chainSpecChainName`, and `chainSpecProperties` — each reachable via
- * {@link getTruApi} but each requiring its own `enumValue("v1", ...)` wrap
- * and neverthrow `ResultAsync` unwrap. {@link getChainSpec} fetches all three
- * in one call and returns a single struct so callers read whichever field
- * they need, matching the JSON-RPC `chainSpec_v1_*` family they mirror.
+ * The host exposes three separate chain-spec calls — `chain.getSpecGenesisHash`,
+ * `chain.getSpecChainName`, and `chain.getSpecProperties` — each reachable via
+ * {@link getTruApi} and each returning a neverthrow `ResultAsync`.
+ * {@link getChainSpec} fetches all three in one call and returns a single
+ * struct so callers read whichever field they need, matching the JSON-RPC
+ * `chainSpec_v1_*` family they mirror.
  *
  * @module
  */
@@ -914,8 +906,8 @@ declare function isChainSupported(genesisHash: HexString): Promise<boolean>;
  *
  * The host returns this as a JSON string (mirroring the substrate
  * `chainSpec_v1_properties` JSON-RPC, whose payload is an open-ended object).
- * {@link getChainSpec} parses it into {@link properties} and also surfaces the
- * untouched JSON as {@link propertiesRaw}. The well-known substrate fields are
+ * {@link getChainSpec} parses it into {@link ChainSpec.properties} and also
+ * surfaces the untouched JSON as {@link ChainSpec.propertiesRaw}. The well-known substrate fields are
  * typed for convenience; the index signature keeps any chain-specific extras
  * reachable without `any` at the call site.
  */
@@ -949,37 +941,41 @@ interface ChainSpec {
  * Fetch a chain's full spec (genesis hash, name, and properties) from the host
  * in one call.
  *
- * Issues the three underlying `chainSpec*` requests concurrently, unwraps each
- * `v1` envelope, and parses the properties JSON. Note the `genesisHash` in the
- * result is the value the host echoes back from `chainSpecGenesisHash` for the
+ * Issues the three underlying `chain.getSpec*` requests concurrently, unwraps
+ * each response, and parses the properties JSON. Note the `genesisHash` in the
+ * result is the value the host echoes back from `getSpecGenesisHash` for the
  * looked-up chain — pass the chain's known genesis hash as the lookup key.
  *
+ * `null` (outside a container) is preserved as an `ok` value — it is an
+ * expected state, not a failure — so callers branch on `r.ok && r.value`. A
+ * real host-call failure surfaces on the `err` channel.
+ *
  * @param genesisHash - The `0x`-prefixed genesis hash identifying the chain.
- * @returns The combined {@link ChainSpec}, or `null` if the host is
- *   unavailable (running outside a container).
- * @throws If any of the underlying host calls fail (`GenericError`).
+ * @returns `ok(spec)` with the combined {@link ChainSpec}, `ok(null)` if the
+ *   host is unavailable (running outside a container), or
+ *   `err(HostCallFailedError)` if any underlying host call fails.
  *
  * @example
  * ```ts
  * import { getChainSpec } from "@parity/product-sdk-host";
  *
- * const spec = await getChainSpec(genesisHash);
- * if (spec) {
- *   console.log(spec.name, spec.properties?.tokenSymbol);
+ * const r = await getChainSpec(genesisHash);
+ * if (r.ok && r.value) {
+ *   console.log(r.value.name, r.value.properties?.tokenSymbol);
  * }
  * ```
  */
-declare function getChainSpec(genesisHash: HexString): Promise<ChainSpec | null>;
+declare function getChainSpec(genesisHash: HexString): Promise<Result<ChainSpec | null, HostError>>;
 
 /**
  * Higher-level wrappers for the host's transaction broadcast lifecycle.
  *
- * `hostApi.chainTransactionBroadcast` / `hostApi.chainTransactionStop` are
- * reachable via {@link getTruApi}, but consumers have to build the versioned
- * envelope (`enumValue("v1", ...)`) and unwrap the neverthrow `ResultAsync`
- * themselves. {@link broadcastTransaction} and {@link stopTransaction}
- * collapse that to throw-on-error Promises, mirroring the JSON-RPC
- * `transaction_v1_broadcast` / `transaction_v1_stop` pair they wrap.
+ * `truApi.chain.broadcastTransaction` / `truApi.chain.stopTransaction` are
+ * reachable via {@link getTruApi}, but consumers have to unwrap the neverthrow
+ * `ResultAsync` themselves. {@link broadcastTransaction} and
+ * {@link stopTransaction} collapse that to `Result`-returning Promises, mirroring
+ * the JSON-RPC `transaction_v1_broadcast` / `transaction_v1_stop` pair they
+ * wrap.
  *
  * @module
  */
@@ -987,43 +983,41 @@ declare function getChainSpec(genesisHash: HexString): Promise<ChainSpec | null>
 /**
  * Broadcast a signed transaction to the network via the host.
  *
- * Builds the `v1` envelope, calls `hostApi.chainTransactionBroadcast`, and
- * unwraps the response. The host keeps re-broadcasting until the transaction
- * is finalized/dropped or {@link stopTransaction} is called with the returned
- * operation id.
+ * Calls `truApi.chain.broadcastTransaction` and unwraps the response. The host
+ * keeps re-broadcasting until the transaction is finalized/dropped or
+ * {@link stopTransaction} is called with the returned operation id.
  *
  * @param genesisHash - The `0x`-prefixed genesis hash of the target chain.
  * @param transaction - The `0x`-prefixed SCALE-encoded signed transaction.
- * @returns The operation id to pass to {@link stopTransaction}, or `null` if
- *   the host accepted the broadcast without issuing one.
- * @throws If the host is unavailable or the broadcast fails (`GenericError`).
+ * @returns `ok` with the operation id to pass to {@link stopTransaction} (or
+ *   `null` if the host accepted the broadcast without issuing one), or
+ *   `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
  * import { broadcastTransaction, stopTransaction } from "@parity/product-sdk-host";
  *
- * const operationId = await broadcastTransaction(genesisHash, signedTx);
+ * const r = await broadcastTransaction(genesisHash, signedTx);
  * // later, to stop re-broadcasting:
- * if (operationId) await stopTransaction(genesisHash, operationId);
+ * if (r.ok && r.value) await stopTransaction(genesisHash, r.value);
  * ```
  */
-declare function broadcastTransaction(genesisHash: HexString, transaction: HexString): Promise<string | null>;
+declare function broadcastTransaction(genesisHash: HexString, transaction: HexString): Promise<Result<string | null, HostError>>;
 /**
  * Stop an in-flight broadcast started by {@link broadcastTransaction}.
  *
- * Builds the `v1` envelope, calls `hostApi.chainTransactionStop`, and unwraps
- * the response.
+ * Calls `truApi.chain.stopTransaction` and unwraps the response.
  *
  * @param genesisHash - The `0x`-prefixed genesis hash of the target chain.
  * @param operationId - The operation id returned by
  *   {@link broadcastTransaction}.
- * @throws If the host is unavailable or the stop fails (`GenericError`).
+ * @returns `ok` on success, or `err(HostUnavailableError | HostCallFailedError)`.
  *
  * @example
  * ```ts
  * await stopTransaction(genesisHash, operationId);
  * ```
  */
-declare function stopTransaction(genesisHash: HexString, operationId: string): Promise<void>;
+declare function stopTransaction(genesisHash: HexString, operationId: string): Promise<Result<void, HostError>>;
 
-export { type AccountsProvider, type AllocatableResource, type AllocatableResourceTag, type AllocationOutcome, type AllocationOutcomeTag, BULLETIN_RPCS, ChainNotSupportedError, type ChainProperties, type ChainSpec, type ChatBotRegistrationResult, type ChatCustomMessageRenderer, type ChatCustomMessageRendererParams, type ChatManager, type ChatMessageContent, type ChatReceivedAction, type ChatRoom, type ChatRoomRegistrationResult, type ContextualAlias, DEFAULT_BULLETIN_ENDPOINT, type DevicePermissionKind, type Feature, type HostAccount, type HostLocalStorage, type HostStatementStore, type HostSubscription, type NotificationId, type NotificationManager, type PaymentBalance, type PaymentManager, type PaymentStatus, type PreimageManager, type ProductAccount, type ProductAccountId, type PushNotificationInput, type RemotePermission, type RemotePermissionItem, type RemotePermissionTag, type ResultAsync, type SignedStatement, type Statement, type StatementProof, type StatementTopicFilter, type StatementsPage, type ThemeMode, type ThemeName, type ThemeProvider, type ThemeVariant, type TopUpSource, type Topic, type TruApi, broadcastTransaction, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, featureSupported, formatHostError, getAccountsProvider, getChainSpec, getChatManager, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isChainSupported, isInsideContainer, isInsideContainerSync, matchChatCustomRenderers, navigateTo, requestDevicePermission, requestPermission, requestResourceAllocation, stopTransaction };
+export { type AccountsProvider, BULLETIN_RPCS, ChainNotSupportedError, type ChainProperties, type ChainSpec, type ChatBotRegistrationResult, type ChatManager, type ChatReceivedAction, type ChatRoomRegistrationResult, type ContextualAlias, DEFAULT_BULLETIN_ENDPOINT, type DevicePermissionKind, type Feature, type HostAccount, HostCallFailedError, HostError, type HostErrorPayload, type HostLocalStorage, type HostStatementStore, type HostSubscription, HostUnavailableError, type NotificationManager, type PaymentManager, type PreimageManager, type ProductAccount, type PushNotificationInput, type RemotePermissionItem, type Result, type ResultAsync, type StatementTopicFilter, type StatementsPage, type ThemeMode, type ThemeProvider, type TruApi, broadcastTransaction, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, err, featureSupported, formatHostError, fromHex, getAccountsProvider, getChainSpec, getChatManager, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isChainSupported, isHostError, isInsideContainer, navigateTo, ok, requestDevicePermission, requestPermission, requestResourceAllocation, stopTransaction, toHex };