@parity/product-sdk-host 0.15.0 → 0.16.0

package/dist/chain-discovery-nLrPzb3d.d.ts

@@ -0,0 +1,70 @@
+import { TrUApiClient, ChainIdentifier, HexString } from '@parity/truapi';
+
+/**
+ * Access to the in-house TruAPI client (`@parity/truapi`) for the host package.
+ *
+ * Environment detection and the lazily-built, cached client come from
+ * `@parity/truapi/sandbox`; this module layers the product-sdk-specific glue on
+ * top — an async {@link getClient} accessor and {@link subscribeWithInterrupt},
+ * which adapts a truapi stream into the host's {@link HostSubscription} shape.
+ *
+ * @module
+ */
+
+/**
+ * Test-only seam: force {@link getClient} / {@link getClientSync} to return
+ * `client`, and {@link isCorrectEnvironment} to report `true`. Pass `null` to
+ * restore normal detection. Exposed through `@parity/product-sdk-host/testing`,
+ * not the package's main entry.
+ *
+ * Calling this in a production build silently reroutes every host accessor to
+ * the injected client, so we warn — it almost always means a `/testing` import
+ * leaked into a production path.
+ */
+declare function setTruApiClient(client: TrUApiClient | null): void;
+/**
+ * Host-container detection. `true` when a test client is injected, otherwise the
+ * sandbox heuristic (iframe / webview marker / injected message port).
+ */
+declare function isCorrectEnvironment(): boolean;
+
+/**
+ * Host chain discovery. Resolves chain roles to genesis hashes against the
+ * host's configured environment instead of hard-coding them.
+ *
+ * The wire method takes one identifier per call, so the facade fires one
+ * concurrent call per requested identifier and caches the combined result
+ * for the lifetime of the connection. Consumed internally by chain-client.
+ * Products normally never call this directly.
+ *
+ * @module
+ */
+
+/**
+ * Chain-role identifier. A closed protocol enum, not a free-form name. The
+ * host maps each role to the concrete chain of its configured environment.
+ */
+type HostChainIdentifier = ChainIdentifier;
+/** The host's configured environment plus per-identifier resolved genesis hashes. */
+interface HostChainDiscovery {
+    /** Ecosystem the host is configured for, e.g. `"polkadot"`, `"paseo"`. */
+    network: string;
+    /** Present for every requested identifier the host serves. */
+    chains: Partial<Record<HostChainIdentifier, HexString>>;
+}
+/**
+ * Resolve chain roles against the current host.
+ *
+ * Returns `null` when discovery is unavailable: outside a container, on a
+ * legacy host, or when the host serves none of the requested identifiers.
+ * Callers treat `null` as "fall back to configured constants".
+ *
+ * One concurrent `getChainInfo` call is made per identifier. Identifiers
+ * the host answers `NotSupported` for are absent from `chains`. Stable
+ * answers are cached per client and identifier set. Unexpected wire failures
+ * and probe timeouts are logged, return `null` and are not cached, so a later
+ * call re-probes.
+ */
+declare function getHostChainInfo(identifiers: readonly HostChainIdentifier[]): Promise<HostChainDiscovery | null>;
+
+export { type HostChainDiscovery as H, type HostChainIdentifier as a, getHostChainInfo as g, isCorrectEnvironment as i, setTruApiClient as s };

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { JsonRpcProvider, PolkadotSigner } from 'polkadot-api';
-import { Topic, RemoteStatementStoreSubscribeItem, Statement, StatementProof, SignedStatement, HexString, scale, TrUApiClient, AllocatableResource, AllocationOutcome, VersionedHostGetUserIdError, HostRequestLoginResponse, VersionedHostRequestLoginError, ProductAccountId, ProductAccount as ProductAccount$1, VersionedHostAccountGetError, ProductProofContext, RingLocation, ContextualAlias as ContextualAlias$1, VersionedHostAccountGetAliasError, LegacyAccount, VersionedHostGetLegacyAccountsError, HostAccountCreateProofResponse, VersionedHostAccountCreateProofError, HostAccountConnectionStatusSubscribeItem, HostDevicePermissionRequest, RemotePermission, HostThemeSubscribeItem, ChatBotRegistrationStatus, HostChatCreateRoomRequest, ChatRoomRegistrationStatus, HostChatRegisterBotRequest, ChatMessageContent, ChatRoom, HostChatActionSubscribeItem, HostPaymentBalanceSubscribeItem, CoinPaymentPurseId, Balance, PaymentTopUpSource, HostPaymentStatusSubscribeItem, HostPushNotificationRequest, NotificationId } from '@parity/truapi';
-export { AllocatableResource, AllocationOutcome, ChatMessageContent, ChatRoom, DerivationIndex, HexString, HostPaymentBalanceSubscribeItem, HostPaymentStatusSubscribeItem, NotificationId, PaymentTopUpSource, ProductAccountId, ProductProofContext, HostPushNotificationError as PushNotificationError, RemotePermission, RingLocation, SignedStatement, Statement, StatementProof, ThemeName, ThemeVariant, Topic } from '@parity/truapi';
+import { Topic, RemoteStatementStoreSubscribeItem, Statement, StatementProof, SignedStatement, HexString, scale, TrUApiClient, AllocatableResource, AllocationOutcome, VersionedHostGetUserIdError, HostRequestLoginResponse, VersionedHostRequestLoginError, ProductAccountId, ProductAccount as ProductAccount$1, VersionedHostAccountGetError, RingLocation, VersionedHostAccountRegisterRingVrfKeyError, RingVrfKeyDisclosure, RegisteredRingVrfKey as RegisteredRingVrfKey$1, VersionedHostAccountListRingVrfKeysError, ProductProofContext, ContextualAlias as ContextualAlias$1, VersionedHostAccountGetAliasError, LegacyAccount, VersionedHostGetLegacyAccountsError, HostAccountCreateProofResponse, VersionedHostAccountCreateProofError, VersionedHostAccountRingVrfSignError, VrfTranscriptItem as VrfTranscriptItem$1, VrfSignature as VrfSignature$1, VersionedHostAccountSignVrfError, HostAccountConnectionStatusSubscribeItem, HostDevicePermissionRequest, RemotePermission, HostThemeSubscribeItem, ChatBotRegistrationStatus, HostChatCreateRoomRequest, ChatRoomRegistrationStatus, HostChatRegisterBotRequest, ChatMessageContent, ChatRoom, HostChatActionSubscribeItem, HostPaymentBalanceSubscribeItem, CoinPaymentPurseId, Balance, PaymentTopUpSource, HostPaymentStatusSubscribeItem, HostPushNotificationRequest, NotificationId } from '@parity/truapi';
+export { AllocatableResource, AllocationOutcome, ChatMessageContent, ChatRoom, DerivationIndex, HexString, HostPaymentBalanceSubscribeItem, HostPaymentStatusSubscribeItem, NotificationId, PaymentTopUpSource, ProductAccountId, ProductProofContext, HostPushNotificationError as PushNotificationError, RemotePermission, RingLocation, RingVrfKeyDisclosure, SignedStatement, Statement, StatementProof, ThemeName, ThemeVariant, Topic } from '@parity/truapi';
 import { SdkError } from '@parity/product-sdk-errors';
 export { SdkError, isSdkError } from '@parity/product-sdk-errors';
 import { Result } from '@parity/result';
 export { Result, err, ok } from '@parity/result';
+export { H as HostChainDiscovery, a as HostChainIdentifier, g as getHostChainInfo, i as isInsideContainerSync } from './chain-discovery-nLrPzb3d.js';
 import { ResultAsync as ResultAsync$1 } from 'neverthrow';
-export { i as isInsideContainerSync } from './transport-B0cdhwrp.js';
 
 /**
  * Public types for the host wrappers.
@@ -370,7 +370,8 @@ interface ResultAsync<T, E> {
  * `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
+ * `getProductAccountAlias`), Ring VRF proofs (`createRingVRFProof`), sr25519 VRF
+ * signatures over a caller-supplied Merlin transcript (`signVrf`), connection
  * status, and PAPI `PolkadotSigner` factories for both product and legacy
  * accounts.
  *
@@ -415,6 +416,41 @@ type ProductAccount = Omit<ProductAccountId, "derivationIndex"> & Omit<ProductAc
     /** Raw public key bytes. */
     publicKey: Uint8Array;
 };
+/**
+ * How callers address a product account: app identifier plus an optional index,
+ * defaulting to 0. A {@link ProductAccount} satisfies this, so an account from
+ * {@link AccountsProvider.getProductAccount} can be passed straight back in.
+ */
+type ProductAccountLookup = Omit<ProductAccountId, "derivationIndex"> & {
+    /** Plain account index within the product subtree. Defaults to 0. */
+    derivationIndex?: number;
+};
+declare const ringVrfKeyHandleBrand: unique symbol;
+/**
+ * Opaque public name of a registered ring-VRF key.
+ *
+ * Handles come from {@link AccountsProvider.listRingVrfKeys}; product code
+ * cannot construct one from a derivation index.
+ */
+type RingVrfKeyHandle = {
+    readonly [ringVrfKeyHandleBrand]: "RingVrfKeyHandle";
+};
+/** Ring-VRF member public key, decoded from the wire's hex string. */
+type RingVrfPublicKey = Uint8Array;
+/** Registered key metadata returned by the host. */
+type RegisteredRingVrfKey = Omit<RegisteredRingVrfKey$1, "handle" | "publicKey"> & {
+    /** Opaque handle to pass back for alias and proof requests. */
+    handle: RingVrfKeyHandle;
+    /** Present when public-key disclosure was granted. */
+    publicKey?: RingVrfPublicKey;
+};
+/**
+ * Select a registered key by its declared ring and return its opaque handle.
+ *
+ * Consumers must not hard-code another product's derivation index. Registry
+ * order breaks ties when an owner declares multiple keys for the same ring.
+ */
+declare function findRingVrfKeyHandle(keys: RegisteredRingVrfKey[], ring: RingLocation): RingVrfKeyHandle | undefined;
 /**
  * A contextual alias obtained from Ring VRF.
  *
@@ -439,6 +475,23 @@ type RingVRFProof = Omit<HostAccountCreateProofResponse, "proof" | "contextualAl
     /** Alias derived for the request's context. */
     contextualAlias: ContextualAlias;
 };
+/**
+ * One `append_message(label, value)` call replayed against a VRF transcript.
+ * Merlin labels are ASCII by convention: use `utf8ToBytes("round")`.
+ *
+ * Derived from `@parity/truapi`'s `VrfTranscriptItem`, decoded to bytes.
+ */
+type VrfTranscriptItem = {
+    [K in keyof VrfTranscriptItem$1]: Uint8Array;
+};
+/**
+ * An sr25519 VRF signature: the pre-output and its DLEQ proof.
+ *
+ * Derived from `@parity/truapi`'s `VrfSignature`, decoded to bytes.
+ */
+type VrfSignature = {
+    [K in keyof VrfSignature$1]: Uint8Array;
+};
 /**
  * Accounts provider handle, backed by `truApi.account.*` / `truApi.signing.*`.
  * Surfaces the user's wallet accounts, app-scoped product accounts, Ring VRF,
@@ -456,17 +509,53 @@ interface AccountsProvider {
     requestLogin(reason?: string): ResultAsync$1<HostRequestLoginResponse, scale.CallErrorValue<VersionedHostRequestLoginError>>;
     getProductAccount(dotNsIdentifier: string, derivationIndex?: number): ResultAsync$1<ProductAccount, scale.CallErrorValue<VersionedHostAccountGetError>>;
     /**
-     * Derive the contextual alias for a proof context and ring. The host
-     * selects the member key within the ring — no per-account addressing.
+     * Register a ring-VRF key owned by the calling product.
+     *
+     * `index` is the plain derivation index within the product's ring-VRF
+     * domain; the adapter wraps it into the wire's tagged selector.
+     *
+     * Registration returns the key's public key. Call {@link listRingVrfKeys}
+     * afterward to obtain the opaque handle required by alias and proof calls.
      */
-    getProductAccountAlias(context: ProductProofContext, location: RingLocation): ResultAsync$1<ContextualAlias, scale.CallErrorValue<VersionedHostAccountGetAliasError>>;
+    registerRingVrfKey(index: number, ring: RingLocation): ResultAsync$1<RingVrfPublicKey, scale.CallErrorValue<VersionedHostAccountRegisterRingVrfKeyError>>;
+    /** List an owner's registered ring-VRF keys. */
+    listRingVrfKeys(owner: string, disclosure?: RingVrfKeyDisclosure): ResultAsync$1<RegisteredRingVrfKey[], scale.CallErrorValue<VersionedHostAccountListRingVrfKeysError>>;
+    /** Derive a contextual alias with an explicitly registered ring-VRF key. */
+    getProductAccountAlias(keyHandle: RingVrfKeyHandle, context: ProductProofContext, location: RingLocation): ResultAsync$1<ContextualAlias, scale.CallErrorValue<VersionedHostAccountGetAliasError>>;
     getLegacyAccounts(): ResultAsync$1<HostAccount[], scale.CallErrorValue<VersionedHostGetLegacyAccountsError>>;
     /**
-     * Generate a Ring VRF proof binding `message` to the product-scoped
-     * `context`. The host selects the member key within the ring; the result
-     * carries the proof plus its verification values ({@link RingVRFProof}).
+     * Generate a Ring VRF proof with an explicitly registered key, binding
+     * `message` to the product-scoped `context`.
+     */
+    createRingVRFProof(keyHandle: RingVrfKeyHandle, context: ProductProofContext, location: RingLocation, message: Uint8Array): ResultAsync$1<RingVRFProof, scale.CallErrorValue<VersionedHostAccountCreateProofError>>;
+    /**
+     * Sign `message` directly with an explicitly registered ring-VRF key.
+     *
+     * Unlike {@link createRingVRFProof} this proves nothing about ring
+     * membership; it is the plain signature under the member key, for
+     * protocols that carry their own proof.
+     */
+    ringVrfSign(keyHandle: RingVrfKeyHandle, message: Uint8Array): ResultAsync$1<Uint8Array, scale.CallErrorValue<VersionedHostAccountRingVrfSignError>>;
+    /**
+     * Produce an sr25519 VRF signature from a product account (RFC-0023).
+     *
+     * The host builds a Merlin transcript from `transcriptLabel` and `items`,
+     * then signs it with the account's key. Unlike {@link createRingVRFProof},
+     * this names the signing account instead of proving ring membership.
+     *
+     * The caller owns four things the types cannot enforce:
+     *
+     * - Domain separation. A label borrowed from another protocol makes the
+     *   output replayable across both.
+     * - Freshness. The VRF is deterministic, so per-round values belong in
+     *   `items`.
+     * - Size. Hosts cap the transcript at 32 items and 8 KiB total.
+     * - Authorization. An `AutoSigning` allowance makes these calls silent. It
+     *   is not VRF-scoped, so it covers other signing by that account too.
+     *
+     * Hosts predating the call reject it through the error channel.
      */
-    createRingVRFProof(context: ProductProofContext, location: RingLocation, message: Uint8Array): ResultAsync$1<RingVRFProof, scale.CallErrorValue<VersionedHostAccountCreateProofError>>;
+    signVrf(account: ProductAccountLookup, transcriptLabel: Uint8Array, items: VrfTranscriptItem[]): ResultAsync$1<VrfSignature, scale.CallErrorValue<VersionedHostAccountSignVrfError>>;
     /**
      * Build a `PolkadotSigner` for a product account. Signing routes through the
      * host's `createTransaction` path: the host decodes the metadata and forwards
@@ -725,7 +814,7 @@ interface PaymentManager {
  * const payments = await getPaymentManager();
  * if (payments) {
  *   const sub = payments.subscribeBalance((b) => { ... });
- *   await payments.topUp(1_000_000n, { tag: "ProductAccount", value: { derivationIndex: { tag: "Left", value: 0 } } });
+ *   await payments.topUp(1_000_000n, { tag: "ProductAccount", value: { derivationIndex: { tag: "Index", value: 0 } } });
  *   const { id } = await payments.requestPayment(500n, "0x…");
  *   sub.unsubscribe();
  * }
@@ -1018,4 +1107,4 @@ declare function broadcastTransaction(genesisHash: HexString, transaction: HexSt
  */
 declare function stopTransaction(genesisHash: HexString, operationId: string): Promise<Result<void, HostError>>;
 
-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 ResultAsync, type RingVRFProof, type StatementTopicFilter, type StatementsPage, type ThemeMode, type ThemeProvider, type TruApi, 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 { 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 ProductAccountLookup, type PushNotificationInput, type RegisteredRingVrfKey, type RemotePermissionItem, type ResultAsync, type RingVRFProof, type RingVrfKeyHandle, type RingVrfPublicKey, type StatementTopicFilter, type StatementsPage, type ThemeMode, type ThemeProvider, type TruApi, type VrfSignature, type VrfTranscriptItem, broadcastTransaction, createHostLocalStorage, createHostPreimageManager, createProofAuthorized, deriveEntropy, featureSupported, findRingVrfKeyHandle, formatHostError, fromHex, getAccountsProvider, getChainSpec, getChatManager, getHostLocalStorage, getHostProvider, getNotificationManager, getPaymentManager, getPreimageManager, getStatementStore, getThemeProvider, getTruApi, isChainSupported, isHostError, isInsideContainer, navigateTo, requestDevicePermission, requestPermission, requestResourceAllocation, stopTransaction, toHex };

package/dist/index.js

@@ -580,6 +580,91 @@ var BULLETIN_RPCS = {
   kusama: []
 };
 var DEFAULT_BULLETIN_ENDPOINT = BULLETIN_RPCS.paseo[0];
+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 deriveTxExtVersion(metadata) {
   const versions = unifyMetadata(decAnyMetadata(metadata)).extrinsic.version;
   if (versions.length === 0) {
@@ -596,8 +681,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 +701,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 +738,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 +754,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 +849,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 +867,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 +887,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 +1006,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 +1031,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 +1064,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 +1074,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 +1092,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 +1100,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