@novasamatech/host-api-wrapper 0.9.4 → 0.10.1

package/README.md

@@ -402,6 +402,17 @@ const config = await storage.readJSON('config');
 
 // Clear a key
 await storage.clear('key');
+
+// Subscribe to a key. The callback fires with the current value right away,
+// then on every later write or clear. `undefined` means the key is absent.
+const sub = storage.subscribeBytes('key', (bytes) => {
+  console.log('key changed:', bytes);
+});
+storage.subscribeString('greeting', (text) => console.log(text));
+storage.subscribeJSON('config', (value) => console.log(value));
+
+// Stop receiving updates
+sub.unsubscribe();
 ```
 
 ### Derive Entropy
@@ -509,3 +520,37 @@ const statusSub = payments.subscribePaymentStatus(receipt.id, status => {
   if (status.type === 'failed') console.log('Payment failed:', status.reason);
 });
 ```
+
+### Coin payment (RFC 0017)
+
+Firewalled purses, cheques, and receivables. The long-running operations
+(rebalance, delete, deposit, refund, listen) stream clearing status through a
+callback and return a `Subscription`; `onInterrupt` fires with a
+`CoinPaymentErr` if the host tears the stream down.
+
+```ts
+import { createCoinPayment } from '@novasamatech/host-api-wrapper';
+
+const coinPayment = createCoinPayment();
+
+// Create a purse and read it back
+const purse = await coinPayment.createPurse('Terminal purse');
+const info = await coinPayment.queryPurse(purse);
+console.log('balance:', info.balance);
+
+// Pay a receivable with a cheque
+const receivable = await coinPayment.createReceivable(purse);
+const cheque = await coinPayment.createCheque(purse, receivable, 1000);
+
+// Claim the cheque, watching the coins clear
+const sub = coinPayment.deposit(cheque, status => {
+  if (status.tag === 'Done') console.log('cleared:', status.value.cleared);
+  if (status.tag === 'Failed') console.log('failed:', status.value.error);
+});
+sub.onInterrupt(err => console.log('deposit interrupted:', err));
+
+// Wait for a cheque delivered over a standard channel
+coinPayment.listenForPayment(receivable, item => {
+  if (item.tag === 'Cheque') console.log('received cheque:', item.value.amount);
+});
+```

package/dist/accounts.d.ts

@@ -1,6 +1,6 @@
 import type { AccountConnectionStatus as AccountConnectionStatusCodec, AccountSelector, CodecType, LegacyAccount as LegacyAccountCodec, ProductAccountId as ProductAccountIdCodec, RegisteredRingVrfKey as RegisteredRingVrfKeyCodec, RingVrfKeyDisclosure as RingVrfKeyDisclosureCodec, RingVrfKeyHandle as RingVrfKeyHandleCodec, Subscription, Transport, VrfTranscriptItem as VrfTranscriptItemCodec } from '@novasamatech/host-api';
 import { RingLocation } from '@novasamatech/host-api';
-import type { PolkadotSigner } from 'polkadot-api';
+import type { SignerTxCreator } from 'polkadot-api/tx-creator';
 export type { AccountSelector } from '@novasamatech/host-api';
 export type ProductAccountId = CodecType<typeof ProductAccountIdCodec>;
 export type ProductAccount = {
@@ -182,14 +182,16 @@ export declare const createAccountsProvider: (transport?: Transport) => {
         reason: string;
     }, "SignVrfErr::Unknown">>;
     /**
-     * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+     * Builds a `TxCreator` (polkadot-api v3) that delegates to the host via
+     * `host_create_transaction`. The host keeps ownership of extension inference
+     * and signing; the creator maps the v3 `TxPayloadV1` onto the host codec.
      *
-     * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
-     * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
+     * `publicKey` is exposed synchronously on the returned object and is taken
+     * from `account`, so no up-front `host_account_get` is needed.
      */
-    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): PolkadotSigner;
+    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): SignerTxCreator;
     subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): Subscription<void>;
-    getLegacyAccountSigner(account: LegacyAccount): PolkadotSigner;
+    getLegacyAccountSigner(account: LegacyAccount): SignerTxCreator;
 };
 export declare const accounts: {
     getUserId(): import("neverthrow").ResultAsync<{
@@ -328,12 +330,14 @@ export declare const accounts: {
         reason: string;
     }, "SignVrfErr::Unknown">>;
     /**
-     * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+     * Builds a `TxCreator` (polkadot-api v3) that delegates to the host via
+     * `host_create_transaction`. The host keeps ownership of extension inference
+     * and signing; the creator maps the v3 `TxPayloadV1` onto the host codec.
      *
-     * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
-     * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
+     * `publicKey` is exposed synchronously on the returned object and is taken
+     * from `account`, so no up-front `host_account_get` is needed.
      */
-    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): PolkadotSigner;
+    getProductAccountSigner(account: ProductAccount, signerType?: "signPayload" | "createTransaction"): SignerTxCreator;
     subscribeAccountConnectionStatus(callback: (status: AccountConnectionStatus) => void): Subscription<void>;
-    getLegacyAccountSigner(account: LegacyAccount): PolkadotSigner;
+    getLegacyAccountSigner(account: LegacyAccount): SignerTxCreator;
 };

package/dist/accounts.js

@@ -1,8 +1,9 @@
 import { CreateProofErr, GetAliasErr, GetUserIdErr, ListRingVrfKeysErr, LoginErr, ProductProofContext, RegisterRingVrfKeyErr, RequestCredentialsErr, RingLocation, RingVrfSignErr, SignVrfErr, SigningPayload, SigningPayloadWithoutAccount, SigningRawPayload, SigningRawPayloadWithoutAccount, assertEnumVariant, createHostApi, derivationIndexOf, enumValue, fromHex, isEnumVariant, toHex, } from '@novasamatech/host-api';
+import { createV4Tx } from '@polkadot-api/signers-common';
 import { decAnyMetadata, unifyMetadata } from '@polkadot-api/substrate-bindings';
 import { err, ok } from 'neverthrow';
 import { AccountId } from 'polkadot-api';
-import { getPolkadotSignerFromPjs } from 'polkadot-api/pjs-signer';
+import { getTxCreatorFromPjs } from 'polkadot-api/pjs-signer';
 import { sandboxTransport } from './sandboxTransport.js';
 /**
  * Builds a {@link RingVrfKeyHandle} for a key inside `owner`'s ring VRF domain.
@@ -206,10 +207,12 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
             });
         },
         /**
-         * Builds a `PolkadotSigner` that delegates to the host via `host_create_transaction`.
+         * Builds a `TxCreator` (polkadot-api v3) that delegates to the host via
+         * `host_create_transaction`. The host keeps ownership of extension inference
+         * and signing; the creator maps the v3 `TxPayloadV1` onto the host codec.
          *
-         * The factory is async because `PolkadotSigner.publicKey` must be a synchronous
-         * `Uint8Array` on the returned object — it is fetched up front via `host_account_get`.
+         * `publicKey` is exposed synchronously on the returned object and is taken
+         * from `account`, so no up-front `host_account_get` is needed.
          */
         getProductAccountSigner(account, signerType = 'createTransaction') {
             const hostApi = createHostApi(transport);
@@ -218,7 +221,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
              * @deprecated added for backward compatibility
              */
             if (signerType === 'signPayload') {
-                return getPolkadotSignerFromPjs(toHex(account.publicKey), async (payload) => {
+                return getTxCreatorFromPjs(toHex(account.publicKey), async (payload) => {
                     const codecPayload = {
                         account: productAccountId,
                         payload: buildSigningPayloadFields(payload),
@@ -262,51 +265,66 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
                     });
                 });
             }
-            return {
-                publicKey: account.publicKey,
-                async signTx(callData, signedExtensions, metadata) {
-                    const decMeta = unifyMetadata(decAnyMetadata(metadata));
-                    const { version: versions } = decMeta.extrinsic;
-                    const latestVersion = versions.reduce((acc, v) => Math.max(acc, v), 0);
-                    const txExtVersion = latestVersion === 4 ? 0 : latestVersion;
-                    const checkGenesis = signedExtensions['CheckGenesis'];
-                    if (!checkGenesis) {
-                        throw new Error("Can't find genesis hash on transaction");
+            // v3 `TxCreator`: a callable that turns a `TxPayloadV1` into a
+            // SCALE-encoded extrinsic (hex). A real signature is produced by the host
+            // via `host_create_transaction`; a mocked signature (fee estimation) is
+            // built locally with a zero-filled signature and no host round-trip,
+            // mirroring polkadot-api's own `getTxCreator`.
+            const createTx = async (payload, _opts, _bindings, mockedSignature) => {
+                // Fee estimation on a v4 extrinsic: build a zero-signed extrinsic
+                // locally, with no host round-trip and no real signature. polkadot-api
+                // has no local builder for other versions (e.g. v5), so those fall
+                // through to the host path below, which returns a well-formed extrinsic
+                // of the right size for estimation.
+                if (mockedSignature && (payload.txExtVersion ?? 0) === 0) {
+                    const decMeta = unifyMetadata(decAnyMetadata(payload.context.metadata));
+                    const v4Extensions = decMeta.extrinsic.extensionsByVersion[0];
+                    if (v4Extensions) {
+                        const extra = v4Extensions.map(({ identifier }) => {
+                            const extension = payload.extensions.find(({ id }) => id === identifier);
+                            if (!extension) {
+                                throw new Error(`Missing ${identifier} signed extension`);
+                            }
+                            return fromHex(extension.extra);
+                        });
+                        const mockSr25519Signature = new Uint8Array(64);
+                        return toHex(createV4Tx(decMeta, account.publicKey, mockSr25519Signature, extra, fromHex(payload.callData), 'Sr25519'));
                     }
-                    const txPayload = {
-                        signer: productAccountId,
-                        genesisHash: toHex(checkGenesis.additionalSigned),
-                        callData,
-                        extensions: Object.values(signedExtensions).map(({ identifier, value, additionalSigned }) => ({
-                            id: identifier,
-                            extra: value,
-                            additionalSigned: additionalSigned,
-                        })),
-                        txExtVersion,
-                    };
-                    const response = await hostApi.createTransaction(enumValue('v1', txPayload));
-                    return response.match(response => {
-                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-                        return response.value;
-                    }, err => {
-                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                        throw err.value;
-                    });
-                },
-                async signBytes(data) {
-                    const response = await hostApi.signRaw(enumValue('v1', {
-                        account: productAccountId,
-                        payload: { tag: 'Bytes', value: data },
-                    }));
-                    return response.match(response => {
-                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
-                        return fromHex(response.value.signature);
-                    }, err => {
-                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
-                        throw err.value;
-                    });
-                },
+                }
+                const txPayload = {
+                    signer: productAccountId,
+                    genesisHash: payload.context.genesisHash,
+                    callData: fromHex(payload.callData),
+                    extensions: payload.extensions.map(({ id, extra, additionalSigned }) => ({
+                        id,
+                        extra: fromHex(extra),
+                        additionalSigned: fromHex(additionalSigned),
+                    })),
+                    txExtVersion: payload.txExtVersion ?? deriveDefaultTxExtVersion(payload.context.metadata),
+                };
+                const response = await hostApi.createTransaction(enumValue('v1', txPayload));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return toHex(response.value);
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
             };
+            const signBytes = async (data) => {
+                const response = await hostApi.signRaw(enumValue('v1', {
+                    account: productAccountId,
+                    payload: { tag: 'Bytes', value: data },
+                }));
+                return response.match(response => {
+                    assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    return fromHex(response.value.signature);
+                }, err => {
+                    assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                    throw err.value;
+                });
+            };
+            return Object.assign(createTx, { publicKey: account.publicKey, signBytes });
         },
         subscribeAccountConnectionStatus(callback) {
             const subscriber = hostApi.accountConnectionStatusSubscribe(enumValue('v1', undefined), status => {
@@ -325,7 +343,7 @@ export const createAccountsProvider = (transport = sandboxTransport) => {
             // must be an SS58 address the wallet can match — not a raw hex public
             // key. Mirrors the injected-extension path, which uses accountId.dec.
             const accountId = AccountId();
-            return getPolkadotSignerFromPjs(accountId.dec(account.publicKey), async (payload) => {
+            return getTxCreatorFromPjs(accountId.dec(account.publicKey), async (payload) => {
                 const codecPayload = {
                     signer: payload.address,
                     payload: buildSigningPayloadFields(payload),
@@ -372,6 +390,13 @@ function asHex(v) {
         return v;
     return `0x${v}`;
 }
+// Default transaction-extension version to request when the caller leaves it
+// unset: 0 for extrinsic v4, the version itself otherwise (e.g. v5).
+function deriveDefaultTxExtVersion(metadata) {
+    const { version: versions } = unifyMetadata(decAnyMetadata(metadata)).extrinsic;
+    const latestVersion = versions.reduce((acc, v) => Math.max(acc, v), 0);
+    return latestVersion === 4 ? 0 : latestVersion;
+}
 function buildSigningPayloadFields(payload) {
     return {
         blockHash: asHex(payload.blockHash),

package/dist/coinPayment.d.ts

@@ -0,0 +1,35 @@
+import type { CodecType, CoinPaymentCheque, CoinPaymentErr, CoinPaymentListenForItem, CoinPaymentPurseInfo, CoinPaymentStatus, HexString, Subscription, Transport } from '@novasamatech/host-api';
+/** Purse identifier (RFC 0017). `0xffffffff` is the well-known main purse. */
+export type PurseId = number;
+/** Receivable public key, as a 0x-prefixed 32-byte hex string. */
+export type Receivable = HexString;
+export type PurseInfo = CodecType<typeof CoinPaymentPurseInfo>;
+export type Cheque = CodecType<typeof CoinPaymentCheque>;
+/** Clearing status streamed by rebalance, delete, deposit, and refund. */
+export type ClearingStatus = CodecType<typeof CoinPaymentStatus>;
+/** Item streamed by `listenForPayment`: a delivery channel, then the cheque. */
+export type PaymentDelivery = CodecType<typeof CoinPaymentListenForItem>;
+type CoinPaymentInterrupt = CodecType<typeof CoinPaymentErr>;
+export declare const createCoinPayment: (transport?: Transport) => {
+    createPurse(name: string): Promise<PurseId>;
+    queryPurse(purse: PurseId): Promise<PurseInfo>;
+    createReceivable(into: PurseId): Promise<Receivable>;
+    createCheque(from: PurseId, to: Receivable, amount: number): Promise<Cheque>;
+    rebalancePurse(from: PurseId, to: PurseId, amount: number, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    deletePurse(target: PurseId, drainInto: PurseId, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    deposit(cheque: Cheque, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    refund(receivable: Receivable, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    listenForPayment(receivable: Receivable, onDelivery: (item: PaymentDelivery) => void): Subscription<CoinPaymentInterrupt>;
+};
+export declare const hostCoinPayment: {
+    createPurse(name: string): Promise<PurseId>;
+    queryPurse(purse: PurseId): Promise<PurseInfo>;
+    createReceivable(into: PurseId): Promise<Receivable>;
+    createCheque(from: PurseId, to: Receivable, amount: number): Promise<Cheque>;
+    rebalancePurse(from: PurseId, to: PurseId, amount: number, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    deletePurse(target: PurseId, drainInto: PurseId, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    deposit(cheque: Cheque, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    refund(receivable: Receivable, onStatus: (status: ClearingStatus) => void): Subscription<CoinPaymentInterrupt>;
+    listenForPayment(receivable: Receivable, onDelivery: (item: PaymentDelivery) => void): Subscription<CoinPaymentInterrupt>;
+};
+export {};

package/dist/coinPayment.js

@@ -0,0 +1,67 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createCoinPayment = (transport = sandboxTransport) => {
+    const hostApi = createHostApi(transport);
+    const version = 'v1';
+    function stream(subscriber) {
+        return {
+            unsubscribe: subscriber.unsubscribe,
+            onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+        };
+    }
+    return {
+        // Create a new firewalled purse and resolve with its assigned id.
+        createPurse(name) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.coinPaymentCreatePurse(enumValue(version, { name })))).then(({ purse }) => purse);
+        },
+        // Query product-visible metadata and balance for a purse.
+        queryPurse(purse) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.coinPaymentQueryPurse(enumValue(version, { purse })))).then(({ info }) => info);
+        },
+        // Create a fresh receivable public key for depositing into a purse.
+        createReceivable(into) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.coinPaymentCreateReceivable(enumValue(version, { into })))).then(({ receivable }) => receivable);
+        },
+        // Create a cheque paying from a local purse to a receivable.
+        createCheque(from, to, amount) {
+            return resultToPromise(unwrapVersionedResult(version, hostApi.coinPaymentCreateCheque(enumValue(version, { from, to, amount })))).then(({ cheque }) => cheque);
+        },
+        // Transfer balance between local purses, streaming clearing status.
+        rebalancePurse(from, to, amount, onStatus) {
+            return stream(hostApi.coinPaymentRebalancePurse(enumValue(version, { from, to, amount }), payload => {
+                if (payload.tag === version)
+                    onStatus(payload.value);
+            }));
+        },
+        // Delete a purse after draining its balance into another local purse.
+        deletePurse(target, drainInto, onStatus) {
+            return stream(hostApi.coinPaymentDeletePurse(enumValue(version, { target, drainInto }), payload => {
+                if (payload.tag === version)
+                    onStatus(payload.value);
+            }));
+        },
+        // Claim coins from a cheque into the receivable's purse.
+        deposit(cheque, onStatus) {
+            return stream(hostApi.coinPaymentDeposit(enumValue(version, { cheque }), payload => {
+                if (payload.tag === version)
+                    onStatus(payload.value);
+            }));
+        },
+        // Attempt to return coins associated with a receivable.
+        refund(receivable, onStatus) {
+            return stream(hostApi.coinPaymentRefund(enumValue(version, { receivable }), payload => {
+                if (payload.tag === version)
+                    onStatus(payload.value);
+            }));
+        },
+        // Listen for a cheque delivered through a standard transmission channel.
+        listenForPayment(receivable, onDelivery) {
+            return stream(hostApi.coinPaymentListenForPayment(enumValue(version, { receivable }), payload => {
+                if (payload.tag === version)
+                    onDelivery(payload.value);
+            }));
+        },
+    };
+};
+export const hostCoinPayment = createCoinPayment();

package/dist/index.d.ts

@@ -10,9 +10,16 @@ export type { ProductAccountId, ProductAccountRef, SignedStatement, Statement, S
 export { createStatementStore } from './statementStore.js';
 export type { AccountConnectionStatus, AccountSelector, LegacyAccount, ProductAccount, ProofContext, RegisteredRingVrfKey, RingVrfKeyDisclosure, RingVrfKeyHandle, VrfTranscriptItem, } from './accounts.js';
 export { accounts, createAccountsProvider, ringVrfKeyHandle } from './accounts.js';
+export type { Locale } from './locale.js';
+export { createLocaleProvider } from './locale.js';
 export type { ThemeMode } from './theme.js';
 export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export { createWorker, hostWorker } from './worker.js';
+export type { HostInfo, HostPlatform, ProductContext } from './system.js';
+export { createSystem, hostSystem } from './system.js';
+export type { Cheque, ClearingStatus, PaymentDelivery, PurseInfo, Receivable } from './coinPayment.js';
+export { createCoinPayment, hostCoinPayment } from './coinPayment.js';
 export type { NotificationId, PushNotificationInput } from './notification.js';
 export { createNotificationManager, notificationManager } from './notification.js';
 export { createPreimageManager, preimageManager } from './preimage.js';

package/dist/index.js

@@ -7,8 +7,12 @@ export { createPapiProvider } from './papiProvider.js';
 export { createProductChatManager, matchChatCustomRenderers } from './chat.js';
 export { createStatementStore } from './statementStore.js';
 export { accounts, createAccountsProvider, ringVrfKeyHandle } from './accounts.js';
+export { createLocaleProvider } from './locale.js';
 export { createThemeProvider } from './theme.js';
 export { createLocalStorage, hostLocalStorage } from './localStorage.js';
+export { createWorker, hostWorker } from './worker.js';
+export { createSystem, hostSystem } from './system.js';
+export { createCoinPayment, hostCoinPayment } from './coinPayment.js';
 export { createNotificationManager, notificationManager } from './notification.js';
 export { createPreimageManager, preimageManager } from './preimage.js';
 export { createPaymentManager, paymentManager } from './payments.js';

package/dist/localStorage.d.ts

@@ -1,3 +1,4 @@
+import type { Subscription } from '@novasamatech/host-api';
 export declare const createLocalStorage: (transport?: import("@novasamatech/host-api").Transport) => {
     clear(key: string): Promise<undefined>;
     readBytes(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
@@ -6,6 +7,9 @@ export declare const createLocalStorage: (transport?: import("@novasamatech/host
     writeString(key: string, value: string): Promise<undefined>;
     readJSON(key: string): Promise<any>;
     writeJSON(key: string, value: unknown): Promise<undefined>;
+    subscribeBytes(key: string, callback: (value: Uint8Array | undefined) => void): Subscription<void>;
+    subscribeString(key: string, callback: (value: string | undefined) => void): Subscription<void>;
+    subscribeJSON(key: string, callback: (value: unknown) => void): Subscription<void>;
 };
 export declare const hostLocalStorage: {
     clear(key: string): Promise<undefined>;
@@ -15,4 +19,7 @@ export declare const hostLocalStorage: {
     writeString(key: string, value: string): Promise<undefined>;
     readJSON(key: string): Promise<any>;
     writeJSON(key: string, value: unknown): Promise<undefined>;
+    subscribeBytes(key: string, callback: (value: Uint8Array | undefined) => void): Subscription<void>;
+    subscribeString(key: string, callback: (value: string | undefined) => void): Subscription<void>;
+    subscribeJSON(key: string, callback: (value: unknown) => void): Subscription<void>;
 };

package/dist/localStorage.js

@@ -15,6 +15,17 @@ export const createLocalStorage = (transport = sandboxTransport) => {
     function clearKey(key) {
         return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageClear(enumValue(supportedVersion, key))));
     }
+    function subscribeBytes(key, callback) {
+        const subscriber = hostApi.localStorageSubscribe(enumValue(supportedVersion, { key }), item => {
+            if (item.tag === supportedVersion) {
+                callback(item.value.value);
+            }
+        });
+        return {
+            unsubscribe: subscriber.unsubscribe,
+            onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+        };
+    }
     return {
         async clear(key) {
             return clearKey(key);
@@ -40,6 +51,17 @@ export const createLocalStorage = (transport = sandboxTransport) => {
         async writeJSON(key, value) {
             return writeBytes(key, textEncoder.encode(JSON.stringify(value)));
         },
+        // Emits the current value immediately, then on every later write or clear
+        // of the key. `undefined` means the key was cleared or is absent.
+        subscribeBytes(key, callback) {
+            return subscribeBytes(key, callback);
+        },
+        subscribeString(key, callback) {
+            return subscribeBytes(key, bytes => callback(bytes === undefined ? undefined : textDecoder.decode(bytes)));
+        },
+        subscribeJSON(key, callback) {
+            return subscribeBytes(key, bytes => callback(bytes === undefined || bytes.length === 0 ? undefined : JSON.parse(textDecoder.decode(bytes))));
+        },
     };
 };
 export const hostLocalStorage = createLocalStorage();

package/dist/locale.d.ts

@@ -0,0 +1,6 @@
+import type { CodecType, Subscription, Transport } from '@novasamatech/host-api';
+import { HostLocale } from '@novasamatech/host-api';
+export type Locale = CodecType<typeof HostLocale>;
+export declare function createLocaleProvider(transport?: Transport): {
+    subscribeLocale(callback: (locale: Locale) => void): Subscription<void>;
+};

package/dist/locale.js

@@ -0,0 +1,18 @@
+import { HostLocale, createHostApi, enumValue } from '@novasamatech/host-api';
+import { sandboxTransport } from './sandboxTransport.js';
+export function createLocaleProvider(transport = sandboxTransport) {
+    const hostApi = createHostApi(transport);
+    return {
+        subscribeLocale(callback) {
+            const subscriber = hostApi.localeSubscribe(enumValue('v1', undefined), value => {
+                if (value.tag === 'v1') {
+                    callback(value.value);
+                }
+            });
+            return {
+                unsubscribe: subscriber.unsubscribe,
+                onInterrupt: cb => subscriber.onInterrupt(v => cb(v.value)),
+            };
+        },
+    };
+}

package/dist/papiProvider.js

@@ -1,4 +1,4 @@
-import { createHostApi, enumValue, unwrapResultOrThrow } from '@novasamatech/host-api';
+import { createHostApi, enumValue, isCallErrorFailure, unwrapResultOrThrow } from '@novasamatech/host-api';
 import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
 import { sandboxTransport } from './sandboxTransport.js';
 export function createPapiProvider(genesisHash, 
@@ -311,6 +311,8 @@ __fallback, internal) {
                 .then(payload => {
                 switch (payload.tag) {
                     case 'v1': {
+                        if (isCallErrorFailure(payload.value))
+                            return false;
                         return unwrapResultOrThrow(payload.value, e => new Error(e.payload.reason));
                     }
                     default:

package/dist/system.d.ts

@@ -0,0 +1,13 @@
+import type { CodecType, Transport } from '@novasamatech/host-api';
+import { HostInfo, HostPlatform, ProductContext } from '@novasamatech/host-api';
+export type HostPlatform = CodecType<typeof HostPlatform>;
+export type HostInfo = CodecType<typeof HostInfo>;
+export type ProductContext = CodecType<typeof ProductContext>;
+export declare const createSystem: (transport?: Transport) => {
+    info(): Promise<HostInfo>;
+    getProductContext(): Promise<ProductContext>;
+};
+export declare const hostSystem: {
+    info(): Promise<HostInfo>;
+    getProductContext(): Promise<ProductContext>;
+};

package/dist/system.js

@@ -0,0 +1,18 @@
+import { HostInfo, HostPlatform, ProductContext, createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createSystem = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    return {
+        // Identity and version of the host currently running the product.
+        async info() {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.info(enumValue(supportedVersion, undefined))));
+        },
+        // Product context bound to the current host runtime.
+        async getProductContext() {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.getProductContext(enumValue(supportedVersion, undefined))));
+        },
+    };
+};
+export const hostSystem = createSystem();

package/dist/worker.d.ts

@@ -0,0 +1,9 @@
+import type { Transport } from '@novasamatech/host-api';
+export declare const createWorker: (transport?: Transport) => {
+    beginOperation(label?: string): Promise<number>;
+    endOperation(id: number): Promise<void>;
+};
+export declare const hostWorker: {
+    beginOperation(label?: string): Promise<number>;
+    endOperation(id: number): Promise<void>;
+};

package/dist/worker.js

@@ -0,0 +1,22 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createWorker = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    return {
+        // Begin a pending operation. The host keeps this worker alive while it has
+        // at least one open operation, so a background task runs to completion even
+        // after the product's surface goes away. Returns the operation id.
+        async beginOperation(label) {
+            const { id } = await resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.workerBeginOperation(enumValue(supportedVersion, { label }))));
+            return id;
+        },
+        // End a pending operation. Idempotent: an unknown or already-ended id
+        // still resolves.
+        async endOperation(id) {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.workerEndOperation(enumValue(supportedVersion, { id }))));
+        },
+    };
+};
+export const hostWorker = createWorker();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api-wrapper",
   "type": "module",
-  "version": "0.9.4",
+  "version": "0.10.1",
   "description": "Host API wrapper: integrate and run your product inside Polkadot browser.",
   "license": "Apache-2.0",
   "repository": {
@@ -27,9 +27,10 @@
   "dependencies": {
     "@polkadot/extension-inject": "^0.63.1",
     "@polkadot-api/json-rpc-provider-proxy": "^0.4.0",
-    "@polkadot-api/substrate-bindings": "^0.20.3",
-    "@novasamatech/host-api": "0.9.4",
-    "polkadot-api": ">=2",
+    "@polkadot-api/signers-common": "^0.3.0",
+    "@polkadot-api/substrate-bindings": "^0.21.0",
+    "@novasamatech/host-api": "0.10.1",
+    "polkadot-api": ">=3",
     "neverthrow": "^8.2.0"
   },
   "publishConfig": {