@parity/product-sdk-host 0.10.3 → 0.12.0

package/dist/index.js

@@ -1,9 +1,482 @@
 import { createLogger } from '@parity/product-sdk-logger';
-import { enumValue } from '@novasamatech/host-api';
-export { PushNotificationError, assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow } from '@novasamatech/host-api';
+import { isCorrectEnvironment, getClientSync } from '@parity/truapi/sandbox';
+export { isCorrectEnvironment as isInsideContainerSync } from '@parity/truapi/sandbox';
+import { scale } from '@parity/truapi';
+import { unifyMetadata, decAnyMetadata } from '@polkadot-api/substrate-bindings';
+import { AccountId } from 'polkadot-api';
+
+// src/errors.ts
+function isHostErrorPayload(error) {
+  if (error == null || typeof error !== "object") return false;
+  const obj = error;
+  return typeof obj.reason === "string" || typeof obj.tag === "string";
+}
+function formatHostError(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  if (isHostErrorPayload(error)) {
+    if ("tag" in error) {
+      if (error.value != null && typeof error.value.reason === "string") {
+        return `${error.tag}: ${error.value.reason}`;
+      }
+      return error.tag;
+    }
+    return error.reason;
+  }
+  if (error != null && typeof error === "object" && "message" in error) {
+    const message = error.message;
+    if (typeof message === "string") return message;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+var HostError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "HostError";
+  }
+};
+var HostUnavailableError = class extends HostError {
+  constructor(message = "Host API is not available") {
+    super(message);
+    this.name = "HostUnavailableError";
+  }
+};
+var HostCallFailedError = class extends HostError {
+  payload;
+  constructor(label, payload) {
+    super(`${label}: ${formatHostError(payload)}`, { cause: payload });
+    this.name = "HostCallFailedError";
+    this.payload = payload;
+  }
+};
+function isHostError(error) {
+  return error instanceof HostError;
+}
+async function getClient() {
+  return getClientSync();
+}
+function subscribeWithInterrupt(observable, onNext) {
+  let interruptCallback;
+  const sub = observable.subscribe({
+    next: onNext,
+    error: (reason) => interruptCallback?.(reason),
+    complete: () => interruptCallback?.()
+  });
+  return {
+    unsubscribe: () => sub.unsubscribe(),
+    onInterrupt: (callback) => {
+      interruptCallback = callback;
+      return () => {
+        if (interruptCallback === callback) interruptCallback = void 0;
+      };
+    }
+  };
+}
+
+// src/papi-provider.ts
+var log = createLogger("host:papi");
+var JSON_RPC_INTERNAL_ERROR = -32603;
+var JSON_RPC_METHOD_NOT_FOUND = -32601;
+var STORAGE_TYPE_MAP = {
+  value: "Value",
+  hash: "Hash",
+  closestDescendantMerkleValue: "ClosestDescendantMerkleValue",
+  descendantsValues: "DescendantsValues",
+  descendantsHashes: "DescendantsHashes"
+};
+function convertRuntimeToJsonRpc(runtime) {
+  if (!runtime || typeof runtime !== "object") return null;
+  if (runtime.tag === "Valid") {
+    const spec = runtime.value;
+    const apis = {};
+    for (const api of spec.apis) {
+      apis[api.name] = api.version;
+    }
+    return {
+      type: "valid",
+      spec: {
+        specName: spec.specName,
+        implName: spec.implName,
+        specVersion: spec.specVersion,
+        implVersion: spec.implVersion,
+        transactionVersion: spec.transactionVersion,
+        apis
+      }
+    };
+  }
+  if (runtime.tag === "Invalid") {
+    return { type: "invalid", error: runtime.value.error };
+  }
+  return null;
+}
+function convertFollowEventToJsonRpc(item) {
+  switch (item.tag) {
+    case "Initialized":
+      return {
+        event: "initialized",
+        finalizedBlockHashes: item.value.finalizedBlockHashes,
+        finalizedBlockRuntime: convertRuntimeToJsonRpc(item.value.finalizedBlockRuntime)
+      };
+    case "NewBlock":
+      return {
+        event: "newBlock",
+        blockHash: item.value.blockHash,
+        parentBlockHash: item.value.parentBlockHash,
+        newRuntime: convertRuntimeToJsonRpc(item.value.newRuntime)
+      };
+    case "BestBlockChanged":
+      return { event: "bestBlockChanged", bestBlockHash: item.value.bestBlockHash };
+    case "Finalized":
+      return {
+        event: "finalized",
+        finalizedBlockHashes: item.value.finalizedBlockHashes,
+        prunedBlockHashes: item.value.prunedBlockHashes
+      };
+    case "OperationBodyDone":
+      return {
+        event: "operationBodyDone",
+        operationId: item.value.operationId,
+        value: item.value.value
+      };
+    case "OperationCallDone":
+      return {
+        event: "operationCallDone",
+        operationId: item.value.operationId,
+        output: item.value.output
+      };
+    case "OperationStorageItems":
+      return {
+        event: "operationStorageItems",
+        operationId: item.value.operationId,
+        items: item.value.items
+      };
+    case "OperationStorageDone":
+      return { event: "operationStorageDone", operationId: item.value.operationId };
+    case "OperationWaitingForContinue":
+      return { event: "operationWaitingForContinue", operationId: item.value.operationId };
+    case "OperationInaccessible":
+      return { event: "operationInaccessible", operationId: item.value.operationId };
+    case "OperationError":
+      return {
+        event: "operationError",
+        operationId: item.value.operationId,
+        error: item.value.error
+      };
+    case "Stop":
+      return { event: "stop" };
+    default: {
+      return { event: "stop" };
+    }
+  }
+}
+function convertStorageType(type) {
+  return STORAGE_TYPE_MAP[type] ?? "Value";
+}
+function convertOperationResultToJsonRpc(result) {
+  if (result.tag === "Started") {
+    return { result: "started", operationId: result.value.operationId };
+  }
+  return { result: "limitReached" };
+}
+function createHostPapiProvider(client, genesisHash) {
+  const chain = client.chain;
+  return (onMessage) => {
+    const activeFollows = /* @__PURE__ */ new Map();
+    const activeBroadcasts = /* @__PURE__ */ new Set();
+    let nextSubId = 0;
+    const getNextSubId = () => `follow_${nextSubId++}`;
+    function sendJsonRpcResponse(id, result) {
+      onMessage({ jsonrpc: "2.0", id, result });
+    }
+    function sendJsonRpcError(id, code, message) {
+      onMessage({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    function sendFollowEvent(subscription, event) {
+      onMessage({
+        jsonrpc: "2.0",
+        method: "chainHead_v1_followEvent",
+        params: { subscription, result: event }
+      });
+    }
+    const hostError = (id) => (error) => sendJsonRpcError(id, JSON_RPC_INTERNAL_ERROR, formatHostError(error));
+    function handleMessage(message) {
+      const { id, method } = message;
+      const params = message.params ?? [];
+      switch (method) {
+        case "chainHead_v1_follow": {
+          const [withRuntime] = params;
+          const syntheticSubId = getNextSubId();
+          const ref = {};
+          ref.handle = subscribeWithInterrupt(
+            chain.followHeadSubscribe({ request: { genesisHash, withRuntime } }),
+            (item) => {
+              if (item.tag === "Stop" && activeFollows.delete(syntheticSubId)) {
+                ref.handle?.unsubscribe();
+              }
+              sendFollowEvent(syntheticSubId, convertFollowEventToJsonRpc(item));
+            }
+          );
+          ref.handle.onInterrupt(() => {
+            if (activeFollows.delete(syntheticSubId)) {
+              sendFollowEvent(syntheticSubId, { event: "stop" });
+            }
+          });
+          activeFollows.set(syntheticSubId, ref.handle);
+          sendJsonRpcResponse(id, syntheticSubId);
+          break;
+        }
+        case "chainHead_v1_unfollow": {
+          const [followSubId] = params;
+          const follow = activeFollows.get(followSubId);
+          if (follow) {
+            follow.unsubscribe();
+            activeFollows.delete(followSubId);
+          }
+          sendJsonRpcResponse(id, null);
+          break;
+        }
+        case "chainHead_v1_header": {
+          const [followSubscriptionId, hash] = params;
+          chain.getHeadHeader({ genesisHash, followSubscriptionId, hash }).match(
+            (response) => sendJsonRpcResponse(id, response.header ?? null),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainHead_v1_body": {
+          const [followSubscriptionId, hash] = params;
+          chain.getHeadBody({ genesisHash, followSubscriptionId, hash }).match(
+            (response) => sendJsonRpcResponse(
+              id,
+              convertOperationResultToJsonRpc(response.operation)
+            ),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainHead_v1_storage": {
+          const [followSubscriptionId, hash, items, childTrie] = params;
+          const queryItems = items.map((item) => ({
+            key: item.key,
+            queryType: convertStorageType(item.type)
+          }));
+          chain.getHeadStorage({
+            genesisHash,
+            followSubscriptionId,
+            hash,
+            items: queryItems,
+            // PAPI passes `null` for an absent child trie, but the
+            // truapi codec encodes the optional `childTrie` field as
+            // `Option<Hex>` — it treats `undefined` as None yet runs
+            // the inner Hex codec on `null`, which throws
+            // (`null.startsWith`). Coerce `null` → `undefined`.
+            childTrie: childTrie ?? void 0
+          }).match(
+            (response) => sendJsonRpcResponse(
+              id,
+              convertOperationResultToJsonRpc(response.operation)
+            ),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainHead_v1_call": {
+          const [followSubscriptionId, hash, fn, callParameters] = params;
+          chain.callHead({
+            genesisHash,
+            followSubscriptionId,
+            hash,
+            function: fn,
+            callParameters
+          }).match(
+            (response) => sendJsonRpcResponse(
+              id,
+              convertOperationResultToJsonRpc(response.operation)
+            ),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainHead_v1_unpin": {
+          const [followSubscriptionId, hashOrHashes] = params;
+          const hashes = Array.isArray(hashOrHashes) ? hashOrHashes : [hashOrHashes];
+          chain.unpinHead({ genesisHash, followSubscriptionId, hashes }).match(() => sendJsonRpcResponse(id, null), hostError(id));
+          break;
+        }
+        case "chainHead_v1_continue": {
+          const [followSubscriptionId, operationId] = params;
+          chain.continueHead({ genesisHash, followSubscriptionId, operationId }).match(() => sendJsonRpcResponse(id, null), hostError(id));
+          break;
+        }
+        case "chainHead_v1_stopOperation": {
+          const [followSubscriptionId, operationId] = params;
+          chain.stopHeadOperation({ genesisHash, followSubscriptionId, operationId }).match(() => sendJsonRpcResponse(id, null), hostError(id));
+          break;
+        }
+        case "chainSpec_v1_genesisHash": {
+          chain.getSpecGenesisHash({ genesisHash }).match(
+            (response) => sendJsonRpcResponse(id, response.genesisHash),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainSpec_v1_chainName": {
+          chain.getSpecChainName({ genesisHash }).match(
+            (response) => sendJsonRpcResponse(id, response.chainName),
+            hostError(id)
+          );
+          break;
+        }
+        case "chainSpec_v1_properties": {
+          chain.getSpecProperties({ genesisHash }).match((response) => {
+            try {
+              sendJsonRpcResponse(id, JSON.parse(response.properties));
+            } catch {
+              sendJsonRpcResponse(id, response.properties);
+            }
+          }, hostError(id));
+          break;
+        }
+        case "transaction_v1_broadcast": {
+          const [transaction] = params;
+          chain.broadcastTransaction({ genesisHash, transaction }).match((response) => {
+            const operationId = response.operationId ?? null;
+            if (operationId !== null) activeBroadcasts.add(operationId);
+            sendJsonRpcResponse(id, operationId);
+          }, hostError(id));
+          break;
+        }
+        case "transaction_v1_stop": {
+          const [operationId] = params;
+          activeBroadcasts.delete(operationId);
+          chain.stopTransaction({ genesisHash, operationId }).match(() => sendJsonRpcResponse(id, null), hostError(id));
+          break;
+        }
+        default:
+          sendJsonRpcError(
+            id,
+            JSON_RPC_METHOD_NOT_FOUND,
+            `Method "${method}" is not supported by the host`
+          );
+          break;
+      }
+    }
+    return {
+      send(message) {
+        try {
+          handleMessage(message);
+        } catch (error) {
+          log.warn("send: handler threw before settling the request", {
+            error: formatHostError(error)
+          });
+          sendJsonRpcError(message.id, JSON_RPC_INTERNAL_ERROR, formatHostError(error));
+        }
+      },
+      disconnect() {
+        for (const handle of activeFollows.values()) {
+          handle.unsubscribe();
+        }
+        activeFollows.clear();
+        for (const operationId of activeBroadcasts) {
+          chain.stopTransaction({ genesisHash, operationId }).match(
+            () => {
+            },
+            () => {
+            }
+          );
+        }
+        activeBroadcasts.clear();
+      }
+    };
+  };
+}
+
+// src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/truapi.ts
+var log2 = createLogger("host");
+function unwrapHostResult(result, label) {
+  return result.match(
+    (value) => value,
+    (error) => {
+      throw new Error(`${label}: ${formatHostError(error)}`, { cause: error });
+    }
+  );
+}
+function mapHostResult(result, map, label) {
+  return result.match(
+    (value) => ok(map(value)),
+    (error) => err(new HostCallFailedError(label, error))
+  );
+}
+function toHex(bytes) {
+  return scale.bytesToHex(bytes);
+}
+function fromHex(hex) {
+  return scale.hexToBytes(hex);
+}
+async function getTruApi() {
+  return getClient();
+}
+function adaptPreimageManager(client) {
+  const preimage = client.preimage;
+  return {
+    lookup(key, callback) {
+      return subscribeWithInterrupt(
+        preimage.lookupSubscribe({ request: { key } }),
+        (item) => callback(item.value !== void 0 ? fromHex(item.value) : null)
+      );
+    },
+    submit(value) {
+      return unwrapHostResult(preimage.submit(toHex(value)), "preimage submit failed");
+    }
+  };
+}
+async function getPreimageManager() {
+  const client = await getClient();
+  return client ? adaptPreimageManager(client) : null;
+}
+async function createHostPreimageManager() {
+  return getPreimageManager();
+}
+async function requestResourceAllocation(resources) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("requestResourceAllocation: TruAPI unavailable"));
+  }
+  log2.debug("requestResourceAllocation", { resources: resources.map((r) => r.tag) });
+  return mapHostResult(
+    truApi.resourceAllocation.request({ resources }),
+    (response) => response.outcomes,
+    "requestResourceAllocation failed"
+  );
+}
+async function createProofAuthorized(statement) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("createProofAuthorized: TruAPI unavailable"));
+  }
+  log2.debug("createProofAuthorized", { topics: statement.topics.length });
+  return mapHostResult(
+    truApi.statementStore.createProofAuthorized(statement),
+    (response) => response.proof,
+    "createProofAuthorized failed"
+  );
+}
 
 // src/container.ts
-var log = createLogger("host:container");
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
 var ChainNotSupportedError = class extends Error {
   /** Genesis hash of the chain the host refused, for programmatic detection. */
   genesisHash;
@@ -15,93 +488,90 @@ var ChainNotSupportedError = class extends Error {
     this.genesisHash = genesisHash;
   }
 };
-async function isChainSupportedByHost(sdk, genesisHash) {
-  const ready = await sdk.sandboxTransport.isReady();
-  if (!ready) {
-    throw new Error(
-      `Host connection did not become ready; cannot verify support for chain ${genesisHash}.`
-    );
-  }
-  const result = await sdk.hostApi.featureSupported(
-    enumValue("v1", enumValue("Chain", genesisHash))
-  );
-  return result.match(
-    (ok) => ok.value === true,
-    (err) => {
-      const value = err?.value;
-      const reason = value?.payload?.reason ?? value?.reason ?? "unknown reason";
-      throw new Error(`Host rejected the chain-support check for ${genesisHash}: ${reason}`);
+async function isChainSupportedByHost(client, genesisHash) {
+  return client.system.featureSupported({ tag: "Chain", value: { genesisHash } }).match(
+    (response) => response.supported,
+    (error) => {
+      throw new Error(
+        `Host rejected the chain-support check for ${genesisHash}: ${formatHostError(error)}`
+      );
     }
   );
 }
 async function isInsideContainer() {
-  if (typeof window === "undefined") return false;
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.sandboxProvider.isCorrectEnvironment();
-  } catch {
-    return isInsideContainerSync();
+  return isCorrectEnvironment();
+}
+function adaptLocalStorage(client) {
+  const ls = client.localStorage;
+  async function readBytes(key) {
+    const response = await unwrapHostResult(ls.read({ key }), "host localStorage read failed");
+    return response.value !== void 0 ? fromHex(response.value) : void 0;
   }
+  async function writeBytes(key, value) {
+    await unwrapHostResult(
+      ls.write({ key, value: toHex(value) }),
+      "host localStorage write failed"
+    );
+  }
+  async function readString(key) {
+    const bytes = await readBytes(key);
+    return bytes ? textDecoder.decode(bytes) : "";
+  }
+  async function writeString(key, value) {
+    return writeBytes(key, textEncoder.encode(value));
+  }
+  async function readJSON(key) {
+    const text = await readString(key);
+    return text ? JSON.parse(text) : null;
+  }
+  async function writeJSON(key, value) {
+    return writeString(key, JSON.stringify(value));
+  }
+  async function clear(key) {
+    await unwrapHostResult(ls.clear({ key }), "host localStorage clear failed");
+  }
+  return { readString, writeString, readJSON, writeJSON, readBytes, writeBytes, clear };
 }
 async function getHostLocalStorage() {
-  if (!await isInsideContainer()) return null;
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.hostLocalStorage;
-  } catch (err) {
-    log.debug("getHostLocalStorage unavailable", err);
-    return null;
-  }
+  const client = await getClient();
+  return client ? adaptLocalStorage(client) : null;
 }
-async function createHostLocalStorage(transport) {
-  if (!await isInsideContainer()) return null;
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createLocalStorage(transport);
-  } catch (err) {
-    log.debug("createHostLocalStorage unavailable", err);
-    return null;
-  }
+async function createHostLocalStorage() {
+  return getHostLocalStorage();
 }
 async function getHostProvider(genesisHash) {
-  let sdk;
-  try {
-    sdk = await import('@novasamatech/host-api-wrapper');
-  } catch (err) {
-    log.debug("getHostProvider unavailable", err);
-    return null;
-  }
-  return resolveHostProvider(sdk, genesisHash);
+  const client = await getClient();
+  if (!client) return null;
+  return resolveHostProvider(client, genesisHash);
 }
-async function resolveHostProvider(sdk, genesisHash) {
-  if (!sdk.sandboxTransport.isCorrectEnvironment()) {
-    return null;
-  }
-  if (!await isChainSupportedByHost(sdk, genesisHash)) {
+async function resolveHostProvider(client, genesisHash) {
+  if (!await isChainSupportedByHost(client, genesisHash)) {
     throw new ChainNotSupportedError(genesisHash);
   }
-  return sdk.createPapiProvider(genesisHash);
+  return createHostPapiProvider(client, genesisHash);
 }
-function isInsideContainerSync() {
-  if (typeof window === "undefined") return false;
-  const win = window;
-  try {
-    if (window !== window.top) return true;
-  } catch {
-    return true;
-  }
-  if (win.__HOST_WEBVIEW_MARK__ === true) return true;
-  if (win.__HOST_API_PORT__ != null) return true;
-  return false;
+function adaptStatementStore(client) {
+  const ss = client.statementStore;
+  return {
+    subscribe(filter, callback) {
+      const request = "matchAll" in filter ? { tag: "MatchAll", value: filter.matchAll } : { tag: "MatchAny", value: filter.matchAny };
+      return subscribeWithInterrupt(ss.subscribe({ request }), callback);
+    },
+    async createProofAuthorized(statement) {
+      const response = await unwrapHostResult(
+        ss.createProofAuthorized(statement),
+        "createProofAuthorized failed"
+      );
+      return response.proof;
+    },
+    async submit(signedStatement) {
+      await unwrapHostResult(ss.submit(signedStatement), "statement submit failed");
+    }
+  };
 }
 async function getStatementStore() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createStatementStore();
-  } catch (err) {
-    log.debug("getStatementStore unavailable", err);
-    return null;
-  }
+  const client = await getClient();
+  return client ? adaptStatementStore(client) : null;
 }
 
 // src/chains.ts
@@ -112,191 +582,392 @@ var BULLETIN_RPCS = {
   kusama: []
 };
 var DEFAULT_BULLETIN_ENDPOINT = BULLETIN_RPCS.paseo[0];
-var log2 = createLogger("host");
-function formatHostError(err) {
-  const inner = isVersionedEnvelope(err) ? err.value : err;
-  if (inner instanceof Error) return inner.message;
-  if (typeof inner === "string") return inner;
-  if (inner != null && typeof inner === "object" && "message" in inner && typeof inner.message === "string") {
-    const named = inner;
-    return typeof named.name === "string" ? `${named.name}: ${named.message}` : named.message;
-  }
-  try {
-    return JSON.stringify(inner);
-  } catch {
-    return String(inner);
-  }
-}
-function isVersionedEnvelope(value) {
-  return value != null && typeof value === "object" && "tag" in value && "value" in value && typeof value.tag === "string";
-}
-var cachedTruApi = null;
-async function getTruApi() {
-  if (cachedTruApi) return cachedTruApi;
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    cachedTruApi = sdk.hostApi;
-    log2.debug("TruAPI loaded");
-    return cachedTruApi;
-  } catch {
-    log2.debug("TruAPI unavailable (not in container or SDK not installed)");
-    return null;
+function deriveTxExtVersion(metadata) {
+  const versions = unifyMetadata(decAnyMetadata(metadata)).extrinsic.version;
+  if (versions.length === 0) {
+    throw new Error("No extrinsic version found in metadata");
   }
+  const latestVersion = versions.reduce((acc, v) => Math.max(acc, v), 0);
+  return latestVersion === 4 ? 0 : latestVersion;
 }
-async function getPreimageManager() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.preimageManager;
-  } catch (err) {
-    log2.debug("getPreimageManager unavailable", err);
-    return null;
-  }
+var deps = { deriveTxExtVersion };
+function toHostExtensions(signedExtensions) {
+  return Object.values(signedExtensions).map((ext) => ({
+    id: ext.identifier,
+    extra: toHex(ext.value),
+    additionalSigned: toHex(ext.additionalSigned)
+  }));
 }
-async function createHostPreimageManager(transport) {
-  if (!await isInsideContainer()) return null;
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createPreimageManager(transport);
-  } catch (err) {
-    log2.debug("createHostPreimageManager unavailable", err);
-    return null;
-  }
-}
-async function getAccountsProvider() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createAccountsProvider();
-  } catch (err) {
-    log2.debug("getAccountsProvider unavailable", err);
-    return null;
-  }
-}
-async function requestResourceAllocation(resources) {
-  const truApi = await getTruApi();
-  if (!truApi) {
-    throw new Error("requestResourceAllocation: TruAPI unavailable");
-  }
-  log2.debug("requestResourceAllocation", { resources: resources.map((r) => r.tag) });
-  return await truApi.requestResourceAllocation(enumValue("v1", resources)).match(
-    (envelope) => envelope.value,
-    (err) => {
-      throw new Error(`requestResourceAllocation failed: ${formatHostError(err)}`, {
-        cause: err
-      });
+function adaptAccountsProvider(client) {
+  const account = client.account;
+  const signing = client.signing;
+  return {
+    getUserId() {
+      return account.getUserId().map((response) => ({
+        primaryUsername: response.primaryUsername
+      }));
+    },
+    requestLogin(reason) {
+      return account.requestLogin({ reason });
+    },
+    getProductAccount(dotNsIdentifier, derivationIndex = 0) {
+      return account.getAccount({ productAccountId: { dotNsIdentifier, derivationIndex } }).map((response) => ({
+        publicKey: fromHex(response.account.publicKey),
+        dotNsIdentifier,
+        derivationIndex
+      }));
+    },
+    getProductAccountAlias(dotNsIdentifier, derivationIndex = 0) {
+      return account.getAccountAlias({ productAccountId: { dotNsIdentifier, derivationIndex } }).map((response) => ({
+        context: fromHex(response.context),
+        alias: fromHex(response.alias)
+      }));
+    },
+    getLegacyAccounts() {
+      return account.getLegacyAccounts().map(
+        (response) => response.accounts.map((a) => ({
+          publicKey: fromHex(a.publicKey),
+          name: a.name
+        }))
+      );
+    },
+    createRingVRFProof(dotNsIdentifier, derivationIndex, location, message) {
+      return account.createAccountProof({
+        productAccountId: { dotNsIdentifier, derivationIndex },
+        ringLocation: location,
+        context: toHex(message)
+      }).map((response) => fromHex(response.proof));
+    },
+    getProductAccountSigner(account_) {
+      const productAccountId = {
+        dotNsIdentifier: account_.dotNsIdentifier,
+        derivationIndex: account_.derivationIndex
+      };
+      return {
+        publicKey: account_.publicKey,
+        async signTx(callData, signedExtensions, metadata) {
+          const checkGenesis = signedExtensions.CheckGenesis;
+          if (!checkGenesis) {
+            throw new Error("Can't find genesis hash on transaction");
+          }
+          const response = await unwrapHostResult(
+            signing.createTransaction({
+              signer: productAccountId,
+              genesisHash: toHex(checkGenesis.additionalSigned),
+              callData: toHex(callData),
+              extensions: toHostExtensions(signedExtensions),
+              txExtVersion: deps.deriveTxExtVersion(metadata)
+            }),
+            "createTransaction failed"
+          );
+          return fromHex(response.transaction);
+        },
+        async signBytes(data) {
+          const response = await unwrapHostResult(
+            signing.signRaw({
+              account: productAccountId,
+              payload: { tag: "Bytes", value: { bytes: toHex(data) } }
+            }),
+            "signRaw failed"
+          );
+          return fromHex(response.signature);
+        }
+      };
+    },
+    getLegacyAccountSigner(account_) {
+      const signerHex = toHex(account_.publicKey);
+      const ss58Address = AccountId().dec(account_.publicKey);
+      return {
+        publicKey: account_.publicKey,
+        async signTx(callData, signedExtensions, metadata) {
+          const checkGenesis = signedExtensions.CheckGenesis;
+          if (!checkGenesis) {
+            throw new Error("Can't find genesis hash on transaction");
+          }
+          const response = await unwrapHostResult(
+            signing.createTransactionWithLegacyAccount({
+              signer: signerHex,
+              genesisHash: toHex(checkGenesis.additionalSigned),
+              callData: toHex(callData),
+              extensions: toHostExtensions(signedExtensions),
+              txExtVersion: deps.deriveTxExtVersion(metadata)
+            }),
+            "createTransactionWithLegacyAccount failed"
+          );
+          return fromHex(response.transaction);
+        },
+        async signBytes(data) {
+          const response = await unwrapHostResult(
+            signing.signRawWithLegacyAccount({
+              signer: ss58Address,
+              payload: { tag: "Bytes", value: { bytes: toHex(data) } }
+            }),
+            "signRawWithLegacyAccount failed"
+          );
+          return fromHex(response.signature);
+        }
+      };
+    },
+    subscribeAccountConnectionStatus(callback) {
+      return subscribeWithInterrupt(account.connectionStatusSubscribe(), callback);
     }
-  );
+  };
 }
-async function createProofAuthorized(statement) {
-  const truApi = await getTruApi();
-  if (!truApi) {
-    throw new Error("createProofAuthorized: TruAPI unavailable");
-  }
-  log2.debug("createProofAuthorized", {
-    topics: statement.topics.length,
-    dataLen: statement.data?.length ?? 0
-  });
-  return await truApi.statementStoreCreateProofAuthorized(enumValue("v1", statement)).match(
-    (envelope) => envelope.value,
-    (err) => {
-      throw new Error(`createProofAuthorized failed: ${formatHostError(err)}`, {
-        cause: err
-      });
-    }
-  );
+async function getAccountsProvider() {
+  const client = await getClient();
+  return client ? adaptAccountsProvider(client) : null;
 }
 var log3 = createLogger("host:permissions");
 async function requestPermission(permission) {
   const truApi = await getTruApi();
   if (!truApi) {
-    throw new Error("requestPermission: TruAPI unavailable");
+    return err(new HostUnavailableError("requestPermission: TruAPI unavailable"));
   }
   log3.debug("requestPermission", { tag: permission.tag });
-  return await truApi.permission(enumValue("v1", permission)).match(
-    (envelope) => envelope.value,
-    (err) => {
-      throw new Error(`requestPermission failed: ${formatHostError(err)}`, { cause: err });
-    }
+  return mapHostResult(
+    truApi.permissions.requestRemotePermission({ permission }),
+    (response) => response.granted,
+    "requestPermission failed"
   );
 }
 async function requestDevicePermission(permission) {
   const truApi = await getTruApi();
   if (!truApi) {
-    throw new Error("requestDevicePermission: TruAPI unavailable");
+    return err(new HostUnavailableError("requestDevicePermission: TruAPI unavailable"));
   }
   log3.debug("requestDevicePermission", { permission });
-  return await truApi.devicePermission(enumValue("v1", permission)).match(
-    (envelope) => envelope.value,
-    (err) => {
-      throw new Error(`requestDevicePermission failed: ${formatHostError(err)}`, {
-        cause: err
-      });
-    }
+  return mapHostResult(
+    truApi.permissions.requestDevicePermission(permission),
+    (response) => response.granted,
+    "requestDevicePermission failed"
   );
 }
-var log4 = createLogger("host:theme");
+
+// src/theme.ts
+function adaptThemeProvider(client) {
+  return {
+    subscribeTheme(callback) {
+      return subscribeWithInterrupt(client.theme.subscribe(), callback);
+    }
+  };
+}
 async function getThemeProvider() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createThemeProvider();
-  } catch (err) {
-    log4.debug("getThemeProvider unavailable", err);
-    return null;
-  }
+  const client = await getClient();
+  return client ? adaptThemeProvider(client) : null;
 }
-var log5 = createLogger("host:entropy");
+var log4 = createLogger("host:entropy");
 async function deriveEntropy(key) {
   const truApi = await getTruApi();
   if (!truApi) {
-    throw new Error("deriveEntropy: TruAPI unavailable");
+    return err(new HostUnavailableError("deriveEntropy: TruAPI unavailable"));
   }
-  log5.debug("deriveEntropy", { keyLen: key.length });
-  return await truApi.deriveEntropy(enumValue("v1", key)).match(
-    (envelope) => envelope.value,
-    (err) => {
-      throw new Error(`deriveEntropy failed: ${formatHostError(err)}`, { cause: err });
-    }
+  log4.debug("deriveEntropy", { keyLen: key.length });
+  return mapHostResult(
+    truApi.entropy.derive({ context: toHex(key) }),
+    (response) => fromHex(response.entropy),
+    "deriveEntropy failed"
   );
 }
-var log6 = createLogger("host:chat");
+
+// src/chat.ts
+function adaptChatManager(client) {
+  const chat = client.chat;
+  const roomStatus = /* @__PURE__ */ new Map();
+  const botStatus = /* @__PURE__ */ new Map();
+  return {
+    async registerRoom(request) {
+      const cached = roomStatus.get(request.roomId);
+      if (cached) return cached;
+      const response = await unwrapHostResult(
+        chat.createRoom(request),
+        "chat registerRoom failed"
+      );
+      roomStatus.set(request.roomId, response.status);
+      return response.status;
+    },
+    async registerBot(request) {
+      const cached = botStatus.get(request.botId);
+      if (cached) return cached;
+      const response = await unwrapHostResult(
+        chat.registerBot(request),
+        "chat registerBot failed"
+      );
+      botStatus.set(request.botId, response.status);
+      return response.status;
+    },
+    async sendMessage(roomId, payload) {
+      const response = await unwrapHostResult(
+        chat.postMessage({ roomId, payload }),
+        "chat sendMessage failed"
+      );
+      return { messageId: response.messageId };
+    },
+    subscribeChatList(callback) {
+      return subscribeWithInterrupt(chat.listSubscribe(), (item) => callback(item.rooms));
+    },
+    subscribeAction(callback) {
+      return subscribeWithInterrupt(chat.actionSubscribe(), callback);
+    }
+  };
+}
 async function getChatManager() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.createProductChatManager();
-  } catch (err) {
-    log6.debug("getChatManager unavailable", err);
-    return null;
-  }
+  const client = await getClient();
+  return client ? adaptChatManager(client) : null;
 }
-function matchChatCustomRenderers(map) {
-  return (params, render) => {
-    const renderer = map[params.messageType];
-    if (!renderer) {
-      throw new Error(`Renderer for message type ${params.messageType} is not defined`);
+
+// src/payments.ts
+function adaptPaymentManager(client) {
+  const payment = client.payment;
+  return {
+    subscribeBalance(callback, purse) {
+      return subscribeWithInterrupt(
+        payment.balanceSubscribe({ request: { purse } }),
+        callback
+      );
+    },
+    topUp(amount, source, into) {
+      return unwrapHostResult(
+        payment.topUp({ into, amount, source }),
+        "payment topUp failed"
+      );
+    },
+    async requestPayment(amount, destination, from) {
+      const response = await unwrapHostResult(
+        payment.request({ from, amount, destination }),
+        "payment requestPayment failed"
+      );
+      return { id: response.id };
+    },
+    subscribePaymentStatus(paymentId, callback) {
+      return subscribeWithInterrupt(
+        payment.statusSubscribe({ request: { paymentId } }),
+        callback
+      );
     }
-    return renderer(params, render);
   };
 }
-var log7 = createLogger("host:payments");
 async function getPaymentManager() {
-  try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.paymentManager;
-  } catch (err) {
-    log7.debug("getPaymentManager unavailable", err);
-    return null;
-  }
+  const client = await getClient();
+  return client ? adaptPaymentManager(client) : null;
+}
+
+// src/notifications.ts
+function adaptNotificationManager(client) {
+  const notifications = client.notifications;
+  return {
+    async push(input) {
+      const response = await unwrapHostResult(
+        notifications.sendPushNotification(input),
+        "notification push failed"
+      );
+      return response.id;
+    },
+    async cancel(id) {
+      await unwrapHostResult(
+        notifications.cancelPushNotification({ id }),
+        "notification cancel failed"
+      );
+    }
+  };
 }
-var log8 = createLogger("host:notifications");
 async function getNotificationManager() {
+  const client = await getClient();
+  return client ? adaptNotificationManager(client) : null;
+}
+var log5 = createLogger("host:navigation");
+async function navigateTo(url) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("navigateTo: TruAPI unavailable"));
+  }
+  log5.debug("navigateTo", { url });
+  return mapHostResult(truApi.system.navigateTo({ url }), () => void 0, "navigateTo failed");
+}
+var log6 = createLogger("host:features");
+async function featureSupported(feature) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("featureSupported: TruAPI unavailable"));
+  }
+  log6.debug("featureSupported", { tag: feature.tag });
+  return mapHostResult(
+    truApi.system.featureSupported({ tag: feature.tag, value: { genesisHash: feature.value } }),
+    (response) => response.supported,
+    "featureSupported failed"
+  );
+}
+async function isChainSupported(genesisHash) {
+  return featureSupported({ tag: "Chain", value: genesisHash });
+}
+var log7 = createLogger("host:chain-spec");
+async function getChainSpec(genesisHash) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    log7.debug("getChainSpec: TruAPI unavailable");
+    return ok(null);
+  }
+  log7.debug("getChainSpec", { genesisHash });
+  const [genesisHashResult, nameResult, propertiesResult] = await Promise.all([
+    mapHostResult(
+      truApi.chain.getSpecGenesisHash({ genesisHash }),
+      (response) => response.genesisHash,
+      "getChainSpec (genesisHash) failed"
+    ),
+    mapHostResult(
+      truApi.chain.getSpecChainName({ genesisHash }),
+      (response) => response.chainName,
+      "getChainSpec (chainName) failed"
+    ),
+    mapHostResult(
+      truApi.chain.getSpecProperties({ genesisHash }),
+      (response) => response.properties,
+      "getChainSpec (properties) failed"
+    )
+  ]);
+  if (!genesisHashResult.ok) return genesisHashResult;
+  if (!nameResult.ok) return nameResult;
+  if (!propertiesResult.ok) return propertiesResult;
+  const propertiesRaw = propertiesResult.value;
+  let properties;
   try {
-    const sdk = await import('@novasamatech/host-api-wrapper');
-    return sdk.notificationManager;
-  } catch (err) {
-    log8.debug("getNotificationManager unavailable", err);
-    return null;
+    properties = JSON.parse(propertiesRaw);
+  } catch (parseError) {
+    log7.debug("getChainSpec: properties JSON parse failed", parseError);
+    properties = null;
   }
+  return ok({
+    genesisHash: genesisHashResult.value,
+    name: nameResult.value,
+    properties,
+    propertiesRaw
+  });
+}
+var log8 = createLogger("host:chain-transaction");
+async function broadcastTransaction(genesisHash, transaction) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("broadcastTransaction: TruAPI unavailable"));
+  }
+  log8.debug("broadcastTransaction", { genesisHash });
+  return mapHostResult(
+    truApi.chain.broadcastTransaction({ genesisHash, transaction }),
+    (response) => response.operationId ?? null,
+    "broadcastTransaction failed"
+  );
+}
+async function stopTransaction(genesisHash, operationId) {
+  const truApi = await getTruApi();
+  if (!truApi) {
+    return err(new HostUnavailableError("stopTransaction: TruAPI unavailable"));
+  }
+  log8.debug("stopTransaction", { genesisHash, operationId });
+  return mapHostResult(
+    truApi.chain.stopTransaction({ genesisHash, operationId }),
+    () => void 0,
+    "stopTransaction failed"
+  );
 }
 
-export { BULLETIN_RPCS, ChainNotSupportedError, DEFAULT_BULLETIN_ENDPOINT, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, formatHostError, getAccountsProvider, getChatManager, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isInsideContainer, isInsideContainerSync, matchChatCustomRenderers, requestDevicePermission, requestPermission, requestResourceAllocation };
+export { BULLETIN_RPCS, ChainNotSupportedError, DEFAULT_BULLETIN_ENDPOINT, HostCallFailedError, HostError, HostUnavailableError, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map