@novasamatech/host-api-wrapper 0.10.0 → 0.10.1

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/index.d.ts

@@ -10,10 +10,14 @@ 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';

package/dist/index.js

@@ -7,9 +7,11 @@ 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';

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api-wrapper",
   "type": "module",
-  "version": "0.10.0",
+  "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.10.0",
-    "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": {