@parity/product-sdk-host 0.15.1 → 0.17.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { getClient, isCorrectEnvironment, subscribeWithInterrupt } from './chunk-GDXSV7JV.js';
-export { isCorrectEnvironment as isInsideContainerSync } from './chunk-GDXSV7JV.js';
+import { getClient, isCorrectEnvironment, subscribeWithInterrupt } from './chunk-PAKEUP2Q.js';
+export { isCorrectEnvironment as isInsideContainerSync, subscribeConnectionStatus } from './chunk-PAKEUP2Q.js';
 import { createLogger } from '@parity/product-sdk-logger';
 import { scale } from '@parity/truapi';
 import { err, ok } from '@parity/result';
@@ -68,6 +68,23 @@ function isHostError(error) {
 var log = createLogger("host:papi");
 var JSON_RPC_INTERNAL_ERROR = -32603;
 var JSON_RPC_METHOD_NOT_FOUND = -32601;
+function followOperationId(item) {
+  switch (item.tag) {
+    case "OperationBodyDone":
+    case "OperationCallDone":
+    case "OperationStorageItems":
+    case "OperationStorageDone":
+    case "OperationWaitingForContinue":
+    case "OperationInaccessible":
+    case "OperationError":
+      return item.value.operationId;
+    default:
+      return void 0;
+  }
+}
+function isTerminalOperationItem(item) {
+  return item.tag === "OperationBodyDone" || item.tag === "OperationCallDone" || item.tag === "OperationStorageDone" || item.tag === "OperationInaccessible" || item.tag === "OperationError";
+}
 var STORAGE_TYPE_MAP = {
   value: "Value",
   hash: "Hash",
@@ -174,6 +191,8 @@ function createHostPapiProvider(client, genesisHash) {
   return (onMessage) => {
     const activeFollows = /* @__PURE__ */ new Map();
     const activeBroadcasts = /* @__PURE__ */ new Set();
+    const followOperations = /* @__PURE__ */ new Map();
+    const pendingOperationStarts = /* @__PURE__ */ new Map();
     function sendJsonRpcResponse(id, result) {
       onMessage({ jsonrpc: "2.0", id, result });
     }
@@ -187,6 +206,72 @@ function createHostPapiProvider(client, genesisHash) {
         params: { subscription, result: event }
       });
     }
+    function forwardFollowItem(followSubscriptionId, item) {
+      const operationId = followOperationId(item);
+      if (operationId === void 0) {
+        sendFollowEvent(followSubscriptionId, convertFollowEventToJsonRpc(item));
+        return;
+      }
+      const operations = followOperations.get(followSubscriptionId);
+      if (!operations) return;
+      let operation = operations.get(operationId);
+      if (!operation) {
+        if ((pendingOperationStarts.get(followSubscriptionId) ?? 0) === 0) {
+          sendFollowEvent(followSubscriptionId, convertFollowEventToJsonRpc(item));
+          return;
+        }
+        operation = { announced: false, items: [] };
+        operations.set(operationId, operation);
+      }
+      if (!operation.announced) {
+        operation.items.push(item);
+        return;
+      }
+      sendFollowEvent(followSubscriptionId, convertFollowEventToJsonRpc(item));
+      if (isTerminalOperationItem(item)) {
+        operations.delete(operationId);
+      }
+    }
+    function sendOperationStartedResponse(id, followSubscriptionId, result) {
+      sendJsonRpcResponse(id, convertOperationResultToJsonRpc(result));
+      if (result.tag !== "Started") return;
+      const operations = followOperations.get(followSubscriptionId);
+      if (!operations) return;
+      const operationId = result.value.operationId;
+      let operation = operations.get(operationId);
+      if (!operation) {
+        operation = { announced: true, items: [] };
+        operations.set(operationId, operation);
+        return;
+      }
+      operation.announced = true;
+      const pendingItems = operation.items;
+      operation.items = [];
+      for (const item of pendingItems) {
+        forwardFollowItem(followSubscriptionId, item);
+      }
+    }
+    function startOperationRequest(id, followSubscriptionId) {
+      const pending = pendingOperationStarts.get(followSubscriptionId);
+      if (pending !== void 0) {
+        pendingOperationStarts.set(followSubscriptionId, pending + 1);
+      }
+      const settle = () => {
+        const outstanding = pendingOperationStarts.get(followSubscriptionId);
+        if (outstanding === void 0) return;
+        pendingOperationStarts.set(followSubscriptionId, Math.max(0, outstanding - 1));
+      };
+      return {
+        ok: (response) => {
+          settle();
+          sendOperationStartedResponse(id, followSubscriptionId, response.operation);
+        },
+        err: (error) => {
+          settle();
+          hostError(id)(error);
+        }
+      };
+    }
     const hostError = (id) => (error) => sendJsonRpcError(id, JSON_RPC_INTERNAL_ERROR, formatHostError(error));
     function handleMessage(message) {
       const { id, method } = message;
@@ -199,8 +284,10 @@ function createHostPapiProvider(client, genesisHash) {
           const forwardItem = (followSubscriptionId2, item) => {
             if (item.tag === "Stop" && activeFollows.delete(followSubscriptionId2)) {
               ref.handle?.unsubscribe();
+              followOperations.delete(followSubscriptionId2);
+              pendingOperationStarts.delete(followSubscriptionId2);
             }
-            sendFollowEvent(followSubscriptionId2, convertFollowEventToJsonRpc(item));
+            forwardFollowItem(followSubscriptionId2, item);
           };
           ref.handle = subscribeWithInterrupt(
             chain.followHeadSubscribe({ request: { genesisHash, withRuntime } }),
@@ -224,11 +311,15 @@ function createHostPapiProvider(client, genesisHash) {
             break;
           }
           ref.handle.onInterrupt(() => {
+            followOperations.delete(followSubscriptionId);
+            pendingOperationStarts.delete(followSubscriptionId);
             if (activeFollows.delete(followSubscriptionId)) {
               sendFollowEvent(followSubscriptionId, { event: "stop" });
             }
           });
           activeFollows.set(followSubscriptionId, ref.handle);
+          followOperations.set(followSubscriptionId, /* @__PURE__ */ new Map());
+          pendingOperationStarts.set(followSubscriptionId, 0);
           sendJsonRpcResponse(id, followSubscriptionId);
           for (const item of pendingItems) {
             forwardItem(followSubscriptionId, item);
@@ -242,6 +333,8 @@ function createHostPapiProvider(client, genesisHash) {
             follow.unsubscribe();
             activeFollows.delete(followSubId);
           }
+          followOperations.delete(followSubId);
+          pendingOperationStarts.delete(followSubId);
           sendJsonRpcResponse(id, null);
           break;
         }
@@ -255,13 +348,8 @@ function createHostPapiProvider(client, genesisHash) {
         }
         case "chainHead_v1_body": {
           const [followSubscriptionId, hash] = params;
-          chain.getHeadBody({ genesisHash, followSubscriptionId, hash }).match(
-            (response) => sendJsonRpcResponse(
-              id,
-              convertOperationResultToJsonRpc(response.operation)
-            ),
-            hostError(id)
-          );
+          const bodyStart = startOperationRequest(id, followSubscriptionId);
+          chain.getHeadBody({ genesisHash, followSubscriptionId, hash }).match(bodyStart.ok, bodyStart.err);
           break;
         }
         case "chainHead_v1_storage": {
@@ -270,6 +358,7 @@ function createHostPapiProvider(client, genesisHash) {
             key: item.key,
             queryType: convertStorageType(item.type)
           }));
+          const storageStart = startOperationRequest(id, followSubscriptionId);
           chain.getHeadStorage({
             genesisHash,
             followSubscriptionId,
@@ -281,30 +370,19 @@ function createHostPapiProvider(client, genesisHash) {
             // 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)
-          );
+          }).match(storageStart.ok, storageStart.err);
           break;
         }
         case "chainHead_v1_call": {
           const [followSubscriptionId, hash, fn, callParameters] = params;
+          const callStart = startOperationRequest(id, followSubscriptionId);
           chain.callHead({
             genesisHash,
             followSubscriptionId,
             hash,
             function: fn,
             callParameters
-          }).match(
-            (response) => sendJsonRpcResponse(
-              id,
-              convertOperationResultToJsonRpc(response.operation)
-            ),
-            hostError(id)
-          );
+          }).match(callStart.ok, callStart.err);
           break;
         }
         case "chainHead_v1_unpin": {
@@ -320,7 +398,10 @@ function createHostPapiProvider(client, genesisHash) {
         }
         case "chainHead_v1_stopOperation": {
           const [followSubscriptionId, operationId] = params;
-          chain.stopHeadOperation({ genesisHash, followSubscriptionId, operationId }).match(() => sendJsonRpcResponse(id, null), hostError(id));
+          chain.stopHeadOperation({ genesisHash, followSubscriptionId, operationId }).match(() => {
+            followOperations.get(followSubscriptionId)?.delete(operationId);
+            sendJsonRpcResponse(id, null);
+          }, hostError(id));
           break;
         }
         case "chainSpec_v1_genesisHash": {
@@ -387,6 +468,8 @@ function createHostPapiProvider(client, genesisHash) {
           handle.unsubscribe();
         }
         activeFollows.clear();
+        followOperations.clear();
+        pendingOperationStarts.clear();
         for (const operationId of activeBroadcasts) {
           chain.stopTransaction({ genesisHash, operationId }).match(
             () => {
@@ -575,18 +658,109 @@ async function getStatementStore() {
 // src/chains.ts
 var BULLETIN_RPCS = {
   paseo: ["wss://paseo-bulletin-next-rpc.polkadot.io"],
+  previewnet: ["wss://previewnet.substrate.dev/bulletin"],
   devnet: ["wss://bulletin-paseo.tservices.es:8443"],
   polkadot: [],
   kusama: []
 };
 var DEFAULT_BULLETIN_ENDPOINT = BULLETIN_RPCS.paseo[0];
-function deriveTxExtVersion(metadata) {
-  const versions = unifyMetadata(decAnyMetadata(metadata)).extrinsic.version;
+var log3 = createLogger("host");
+var TRANSIENT_FAILURE = /* @__PURE__ */ Symbol("transient-failure");
+var PROBE_TIMEOUT_MS = 3e3;
+var discoveryCache = /* @__PURE__ */ new WeakMap();
+async function getHostChainInfo(identifiers) {
+  const client = await getClient();
+  if (!client) return null;
+  let bySet = discoveryCache.get(client);
+  if (!bySet) {
+    bySet = /* @__PURE__ */ new Map();
+    discoveryCache.set(client, bySet);
+  }
+  const key = [...identifiers].sort().join(",");
+  let cached = bySet.get(key);
+  if (!cached) {
+    cached = fetchChainInfo(client, identifiers).then((result) => {
+      if (result === TRANSIENT_FAILURE) {
+        bySet.delete(key);
+        return null;
+      }
+      return result;
+    });
+    bySet.set(key, cached);
+  }
+  return cached;
+}
+async function fetchChainInfo(client, identifiers) {
+  try {
+    let timer;
+    const probe = Promise.all(
+      identifiers.map(
+        (id) => client.chain.getChainInfo({ chain: id }).match(
+          (value) => ({ id, ok: value }),
+          (error) => ({ id, err: error })
+        )
+      )
+    );
+    const outcomes = await Promise.race([
+      probe,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), PROBE_TIMEOUT_MS);
+      })
+    ]).finally(() => clearTimeout(timer));
+    if (outcomes === "timeout") {
+      log3.warn("getChainInfo probe timed out, treating the host as pre-discovery for now");
+      return TRANSIENT_FAILURE;
+    }
+    let network;
+    const chains = {};
+    for (const outcome of outcomes) {
+      if ("ok" in outcome) {
+        network = outcome.ok.network;
+        chains[outcome.id] = outcome.ok.genesisHash;
+        continue;
+      }
+      if (outcome.err.tag === "Unsupported") return null;
+      if (isNotSupported(outcome.err)) continue;
+      log3.warn(`getChainInfo failed: ${formatHostError(outcome.err)}`);
+      return TRANSIENT_FAILURE;
+    }
+    if (network === void 0) return null;
+    return { network, chains };
+  } catch (error) {
+    log3.warn(`getChainInfo failed: ${formatHostError(error)}`);
+    return TRANSIENT_FAILURE;
+  }
+}
+function isNotSupported(error) {
+  return error.tag === "Domain" && error.value.value.tag === "NotSupported";
+}
+function sameRingLocation(a, b) {
+  if (a.chainId.toLowerCase() !== b.chainId.toLowerCase() || a.junctions.length !== b.junctions.length) {
+    return false;
+  }
+  return a.junctions.every((junction, index) => {
+    const candidate = b.junctions[index];
+    if (junction.tag === "PalletInstance") {
+      return candidate.tag === "PalletInstance" && junction.value === candidate.value;
+    }
+    return candidate.tag === "CollectionId" && junction.value.toLowerCase() === candidate.value.toLowerCase();
+  });
+}
+function findRingVrfKeyHandle(keys, ring) {
+  return keys.find((key) => key.rings.some((candidate) => sameRingLocation(candidate, ring)))?.handle;
+}
+function selectHostTxExtVersion(versions) {
   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;
+  if (versions.includes(4)) {
+    return 0;
+  }
+  return versions.reduce((acc, version) => Math.max(acc, version), 0);
+}
+function deriveTxExtVersion(metadata) {
+  const versions = unifyMetadata(decAnyMetadata(metadata)).extrinsic.version;
+  return selectHostTxExtVersion(versions);
 }
 var deps = { deriveTxExtVersion };
 function toHostExtensions(signedExtensions) {
@@ -596,8 +770,11 @@ function toHostExtensions(signedExtensions) {
     additionalSigned: toHex(ext.additionalSigned)
   }));
 }
-function toWireProductAccountId(dotNsIdentifier, derivationIndex) {
-  return { dotNsIdentifier, derivationIndex: { tag: "Left", value: derivationIndex } };
+function toWireProductAccountId({
+  dotNsIdentifier,
+  derivationIndex = 0
+}) {
+  return { dotNsIdentifier, derivationIndex: { tag: "Index", value: derivationIndex } };
 }
 function adaptAccountsProvider(client) {
   const account = client.account;
@@ -613,15 +790,31 @@ function adaptAccountsProvider(client) {
     },
     getProductAccount(dotNsIdentifier, derivationIndex = 0) {
       return account.getAccount({
-        productAccountId: toWireProductAccountId(dotNsIdentifier, derivationIndex)
+        productAccountId: toWireProductAccountId({ dotNsIdentifier, derivationIndex })
       }).map((response) => ({
         publicKey: fromHex(response.account.publicKey),
         dotNsIdentifier,
         derivationIndex
       }));
     },
-    getProductAccountAlias(context, location) {
-      return account.getAccountAlias({ context, ringLocation: location }).map((response) => ({
+    registerRingVrfKey(index, ring) {
+      return account.registerRingVrfKey({ index: { tag: "Index", value: index }, ring }).map(fromHex);
+    },
+    listRingVrfKeys(owner, disclosure = "Anonymized") {
+      return account.listRingVrfKeys({ owner, disclosure }).map(
+        (keys) => keys.map((key) => ({
+          ...key,
+          handle: key.handle,
+          publicKey: key.publicKey === void 0 ? void 0 : fromHex(key.publicKey)
+        }))
+      );
+    },
+    getProductAccountAlias(keyHandle, context, location) {
+      return account.getAccountAlias({
+        keyHandle,
+        context,
+        ringLocation: location
+      }).map((response) => ({
         context: fromHex(response.context),
         alias: fromHex(response.alias)
       }));
@@ -634,8 +827,9 @@ function adaptAccountsProvider(client) {
         }))
       );
     },
-    createRingVRFProof(context, location, message) {
+    createRingVRFProof(keyHandle, context, location, message) {
       return account.createAccountProof({
+        keyHandle,
         context,
         ringLocation: location,
         message: toHex(message)
@@ -649,11 +843,27 @@ function adaptAccountsProvider(client) {
         ringRevision: response.ringRevision
       }));
     },
+    ringVrfSign(keyHandle, message) {
+      return account.ringVrfSign({
+        keyHandle,
+        message: toHex(message)
+      }).map(fromHex);
+    },
+    signVrf(account_, transcriptLabel, items) {
+      return account.signVrf({
+        account: toWireProductAccountId(account_),
+        transcriptLabel: toHex(transcriptLabel),
+        items: items.map(({ label, value }) => ({
+          label: toHex(label),
+          value: toHex(value)
+        }))
+      }).map((response) => ({
+        preOutput: fromHex(response.preOutput),
+        proof: fromHex(response.proof)
+      }));
+    },
     getProductAccountSigner(account_) {
-      const productAccountId = toWireProductAccountId(
-        account_.dotNsIdentifier,
-        account_.derivationIndex
-      );
+      const productAccountId = toWireProductAccountId(account_);
       return {
         publicKey: account_.publicKey,
         async signTx(callData, signedExtensions, metadata) {
@@ -728,13 +938,13 @@ async function getAccountsProvider() {
   const client = await getClient();
   return client ? adaptAccountsProvider(client) : null;
 }
-var log3 = createLogger("host:permissions");
+var log4 = createLogger("host:permissions");
 async function requestPermission(permission) {
   const truApi = await getTruApi();
   if (!truApi) {
     return err(new HostUnavailableError("requestPermission: TruAPI unavailable"));
   }
-  log3.debug("requestPermission", { tag: permission.tag });
+  log4.debug("requestPermission", { tag: permission.tag });
   return mapHostResult(
     truApi.permissions.requestRemotePermission({ permission }),
     (response) => response.granted,
@@ -746,7 +956,7 @@ async function requestDevicePermission(permission) {
   if (!truApi) {
     return err(new HostUnavailableError("requestDevicePermission: TruAPI unavailable"));
   }
-  log3.debug("requestDevicePermission", { permission });
+  log4.debug("requestDevicePermission", { permission });
   return mapHostResult(
     truApi.permissions.requestDevicePermission(permission),
     (response) => response.granted,
@@ -766,13 +976,13 @@ async function getThemeProvider() {
   const client = await getClient();
   return client ? adaptThemeProvider(client) : null;
 }
-var log4 = createLogger("host:entropy");
+var log5 = createLogger("host:entropy");
 async function deriveEntropy(key) {
   const truApi = await getTruApi();
   if (!truApi) {
     return err(new HostUnavailableError("deriveEntropy: TruAPI unavailable"));
   }
-  log4.debug("deriveEntropy", { keyLen: key.length });
+  log5.debug("deriveEntropy", { keyLen: key.length });
   return mapHostResult(
     truApi.entropy.derive({ context: toHex(key) }),
     (response) => fromHex(response.entropy),
@@ -885,22 +1095,22 @@ async function getNotificationManager() {
   const client = await getClient();
   return client ? adaptNotificationManager(client) : null;
 }
-var log5 = createLogger("host:navigation");
+var log6 = createLogger("host:navigation");
 async function navigateTo(url) {
   const truApi = await getTruApi();
   if (!truApi) {
     return err(new HostUnavailableError("navigateTo: TruAPI unavailable"));
   }
-  log5.debug("navigateTo", { url });
+  log6.debug("navigateTo", { url });
   return mapHostResult(truApi.system.navigateTo({ url }), () => void 0, "navigateTo failed");
 }
-var log6 = createLogger("host:features");
+var log7 = 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 });
+  log7.debug("featureSupported", { tag: feature.tag });
   return mapHostResult(
     truApi.system.featureSupported({ tag: feature.tag, value: { genesisHash: feature.value } }),
     (response) => response.supported,
@@ -910,14 +1120,14 @@ async function featureSupported(feature) {
 async function isChainSupported(genesisHash) {
   return featureSupported({ tag: "Chain", value: genesisHash });
 }
-var log7 = createLogger("host:chain-spec");
+var log8 = createLogger("host:chain-spec");
 async function getChainSpec(genesisHash) {
   const truApi = await getTruApi();
   if (!truApi) {
-    log7.debug("getChainSpec: TruAPI unavailable");
+    log8.debug("getChainSpec: TruAPI unavailable");
     return ok(null);
   }
-  log7.debug("getChainSpec", { genesisHash });
+  log8.debug("getChainSpec", { genesisHash });
   const [genesisHashResult, nameResult, propertiesResult] = await Promise.all([
     mapHostResult(
       truApi.chain.getSpecGenesisHash({ genesisHash }),
@@ -943,7 +1153,7 @@ async function getChainSpec(genesisHash) {
   try {
     properties = JSON.parse(propertiesRaw);
   } catch (parseError) {
-    log7.debug("getChainSpec: properties JSON parse failed", parseError);
+    log8.debug("getChainSpec: properties JSON parse failed", parseError);
     properties = null;
   }
   return ok({
@@ -953,13 +1163,13 @@ async function getChainSpec(genesisHash) {
     propertiesRaw
   });
 }
-var log8 = createLogger("host:chain-transaction");
+var log9 = 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 });
+  log9.debug("broadcastTransaction", { genesisHash });
   return mapHostResult(
     truApi.chain.broadcastTransaction({ genesisHash, transaction }),
     (response) => response.operationId ?? null,
@@ -971,7 +1181,7 @@ async function stopTransaction(genesisHash, operationId) {
   if (!truApi) {
     return err(new HostUnavailableError("stopTransaction: TruAPI unavailable"));
   }
-  log8.debug("stopTransaction", { genesisHash, operationId });
+  log9.debug("stopTransaction", { genesisHash, operationId });
   return mapHostResult(
     truApi.chain.stopTransaction({ genesisHash, operationId }),
     () => void 0,
@@ -979,6 +1189,6 @@ async function stopTransaction(genesisHash, operationId) {
   );
 }
 
-export { BULLETIN_RPCS, ChainNotSupportedError, DEFAULT_BULLETIN_ENDPOINT, HostCallFailedError, HostError, HostUnavailableError, broadcastTransaction, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, featureSupported, formatHostError, fromHex, getAccountsProvider, getChainSpec, getChatManager, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isChainSupported, isHostError, isInsideContainer, navigateTo, requestDevicePermission, requestPermission, requestResourceAllocation, stopTransaction, toHex };
+export { BULLETIN_RPCS, ChainNotSupportedError, DEFAULT_BULLETIN_ENDPOINT, HostCallFailedError, HostError, HostUnavailableError, broadcastTransaction, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, featureSupported, findRingVrfKeyHandle, formatHostError, fromHex, getAccountsProvider, getChainSpec, getChatManager, getHostChainInfo, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isChainSupported, isHostError, isInsideContainer, navigateTo, requestDevicePermission, requestPermission, requestResourceAllocation, stopTransaction, toHex };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map