@parity/product-sdk-host 0.16.0 → 0.18.0

package/dist/index.js

@@ -1,11 +1,12 @@
-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';
 export { err, ok } from '@parity/result';
 export { isSdkError } from '@parity/product-sdk-errors';
 import { unifyMetadata, decAnyMetadata } from '@polkadot-api/substrate-bindings';
+import { ResultAsync } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
 
 // src/errors.ts
@@ -62,12 +63,41 @@ var HostCallFailedError = class extends HostError {
     this.payload = payload;
   }
 };
+var HostResponseDecodeError = class extends HostError {
+  /** The host-API call whose response failed to decode, e.g. `"createRingVRFProof"`. */
+  call;
+  constructor(call, cause) {
+    super(
+      `Could not process the host's response to ${call}: ${formatHostError(cause)}. The usual cause is a protocol-version skew between the host app and the @parity/truapi version this product is built against; a host channel that closed mid-call looks the same.`,
+      { cause }
+    );
+    this.name = "HostResponseDecodeError";
+    this.call = call;
+  }
+};
 function isHostError(error) {
   return error instanceof HostError;
 }
 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 +204,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 +219,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 +297,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 +324,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 +346,8 @@ function createHostPapiProvider(client, genesisHash) {
             follow.unsubscribe();
             activeFollows.delete(followSubId);
           }
+          followOperations.delete(followSubId);
+          pendingOperationStarts.delete(followSubId);
           sendJsonRpcResponse(id, null);
           break;
         }
@@ -255,13 +361,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 +371,7 @@ function createHostPapiProvider(client, genesisHash) {
             key: item.key,
             queryType: convertStorageType(item.type)
           }));
+          const storageStart = startOperationRequest(id, followSubscriptionId);
           chain.getHeadStorage({
             genesisHash,
             followSubscriptionId,
@@ -281,30 +383,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 +411,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 +481,8 @@ function createHostPapiProvider(client, genesisHash) {
           handle.unsubscribe();
         }
         activeFollows.clear();
+        followOperations.clear();
+        pendingOperationStarts.clear();
         for (const operationId of activeBroadcasts) {
           chain.stopTransaction({ genesisHash, operationId }).match(
             () => {
@@ -403,18 +499,59 @@ function createHostPapiProvider(client, genesisHash) {
 
 // src/truapi.ts
 var log2 = createLogger("host");
+async function matchGuarded(result, label, onOk, onErr, onDecode) {
+  try {
+    return await result.match(
+      (value) => {
+        try {
+          return onOk(value);
+        } catch (thrown) {
+          throw new HandlerThrow(thrown);
+        }
+      },
+      (error) => {
+        try {
+          return onErr(error);
+        } catch (thrown) {
+          throw new HandlerThrow(thrown);
+        }
+      }
+    );
+  } catch (cause) {
+    if (cause instanceof HandlerThrow) throw cause.thrown;
+    return onDecode(
+      cause instanceof HostResponseDecodeError ? cause : new HostResponseDecodeError(label, cause)
+    );
+  }
+}
+var HandlerThrow = class {
+  constructor(thrown) {
+    this.thrown = thrown;
+  }
+  thrown;
+};
 function unwrapHostResult(result, label) {
-  return result.match(
+  return matchGuarded(
+    result,
+    label,
     (value) => value,
     (error) => {
       throw new Error(`${label}: ${formatHostError(error)}`, { cause: error });
+    },
+    // A response the client can't decode would otherwise reject with a raw
+    // `RangeError`; throw it as a typed, named error instead.
+    (decodeError) => {
+      throw decodeError;
     }
   );
 }
 function mapHostResult(result, map, label) {
-  return result.match(
+  return matchGuarded(
+    result,
+    label,
     (value) => ok(map(value)),
-    (error) => err(new HostCallFailedError(label, error))
+    (error) => err(new HostCallFailedError(label, error)),
+    (decodeError) => err(decodeError)
   );
 }
 function toHex(bytes) {
@@ -575,6 +712,7 @@ 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: []
@@ -665,13 +803,25 @@ function sameRingLocation(a, b) {
 function findRingVrfKeyHandle(keys, ring) {
   return keys.find((key) => key.rings.some((candidate) => sameRingLocation(candidate, ring)))?.handle;
 }
-function deriveTxExtVersion(metadata) {
-  const versions = unifyMetadata(decAnyMetadata(metadata)).extrinsic.version;
-  if (versions.length === 0) {
+var GENERAL_TX_EXT_VERSION = 5;
+function selectHostTxExtVersion(formatVersions, txExtVersions) {
+  if (formatVersions.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 (formatVersions.includes(4)) {
+    return 0;
+  }
+  if (txExtVersions.includes(GENERAL_TX_EXT_VERSION)) {
+    return GENERAL_TX_EXT_VERSION;
+  }
+  throw new Error(
+    `Runtime offers no V4 extrinsic and no transaction-extension version ${GENERAL_TX_EXT_VERSION} (supported: ${txExtVersions.join(", ") || "none"}); cannot select a txExtVersion the host can assemble.`
+  );
+}
+function deriveTxExtVersion(metadata) {
+  const extrinsic = unifyMetadata(decAnyMetadata(metadata)).extrinsic;
+  const txExtVersions = Object.keys(extrinsic.signedExtensions).map(Number);
+  return selectHostTxExtVersion(extrinsic.version, txExtVersions);
 }
 var deps = { deriveTxExtVersion };
 function toHostExtensions(signedExtensions) {
@@ -687,91 +837,127 @@ function toWireProductAccountId({
 }) {
   return { dotNsIdentifier, derivationIndex: { tag: "Index", value: derivationIndex } };
 }
+function guardDecode(call, result) {
+  return ResultAsync.fromPromise(
+    Promise.resolve(result),
+    (cause) => new HostResponseDecodeError(call, cause)
+  ).andThen((inner) => inner);
+}
 function adaptAccountsProvider(client) {
   const account = client.account;
   const signing = client.signing;
   return {
     getUserId() {
-      return account.getUserId().map((response) => ({
-        primaryUsername: response.primaryUsername
-      }));
+      return guardDecode(
+        "getUserId",
+        account.getUserId().map((response) => ({
+          primaryUsername: response.primaryUsername
+        }))
+      );
     },
     requestLogin(reason) {
-      return account.requestLogin({ reason });
+      return guardDecode("requestLogin", account.requestLogin({ reason }));
     },
     getProductAccount(dotNsIdentifier, derivationIndex = 0) {
-      return account.getAccount({
-        productAccountId: toWireProductAccountId({ dotNsIdentifier, derivationIndex })
-      }).map((response) => ({
-        publicKey: fromHex(response.account.publicKey),
-        dotNsIdentifier,
-        derivationIndex
-      }));
+      return guardDecode(
+        "getProductAccount",
+        account.getAccount({
+          productAccountId: toWireProductAccountId({
+            dotNsIdentifier,
+            derivationIndex
+          })
+        }).map((response) => ({
+          publicKey: fromHex(response.account.publicKey),
+          dotNsIdentifier,
+          derivationIndex
+        }))
+      );
     },
     registerRingVrfKey(index, ring) {
-      return account.registerRingVrfKey({ index: { tag: "Index", value: index }, ring }).map(fromHex);
+      return guardDecode(
+        "registerRingVrfKey",
+        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)
-        }))
+      return guardDecode(
+        "listRingVrfKeys",
+        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)
-      }));
+      return guardDecode(
+        "getProductAccountAlias",
+        account.getAccountAlias({
+          keyHandle,
+          context,
+          ringLocation: location
+        }).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
-        }))
+      return guardDecode(
+        "getLegacyAccounts",
+        account.getLegacyAccounts().map(
+          (response) => response.accounts.map((a) => ({
+            publicKey: fromHex(a.publicKey),
+            name: a.name
+          }))
+        )
       );
     },
     createRingVRFProof(keyHandle, context, location, message) {
-      return account.createAccountProof({
-        keyHandle,
-        context,
-        ringLocation: location,
-        message: toHex(message)
-      }).map((response) => ({
-        proof: fromHex(response.proof),
-        contextualAlias: {
-          context: fromHex(response.contextualAlias.context),
-          alias: fromHex(response.contextualAlias.alias)
-        },
-        ringIndex: response.ringIndex,
-        ringRevision: response.ringRevision
-      }));
+      return guardDecode(
+        "createRingVRFProof",
+        account.createAccountProof({
+          keyHandle,
+          context,
+          ringLocation: location,
+          message: toHex(message)
+        }).map((response) => ({
+          proof: fromHex(response.proof),
+          contextualAlias: {
+            context: fromHex(response.contextualAlias.context),
+            alias: fromHex(response.contextualAlias.alias)
+          },
+          ringIndex: response.ringIndex,
+          ringRevision: response.ringRevision
+        }))
+      );
     },
     ringVrfSign(keyHandle, message) {
-      return account.ringVrfSign({
-        keyHandle,
-        message: toHex(message)
-      }).map(fromHex);
+      return guardDecode(
+        "ringVrfSign",
+        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)
+      return guardDecode(
+        "signVrf",
+        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)
         }))
-      }).map((response) => ({
-        preOutput: fromHex(response.preOutput),
-        proof: fromHex(response.proof)
-      }));
+      );
     },
     getProductAccountSigner(account_) {
       const productAccountId = toWireProductAccountId(account_);
@@ -1100,6 +1286,6 @@ async function stopTransaction(genesisHash, operationId) {
   );
 }
 
-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 };
+export { BULLETIN_RPCS, ChainNotSupportedError, DEFAULT_BULLETIN_ENDPOINT, HostCallFailedError, HostError, HostResponseDecodeError, 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