@novasamatech/host-api 0.4.0

package/README.md

@@ -0,0 +1,9 @@
+# @novasamatech/host-api
+
+Protocol and transport implementation for host <=> product interaction inside Polkadot ecosystem. 
+
+## Installation
+
+```shell
+npm install @novasamatech/host-api --save -E
+```

package/dist/commonEncoders.d.ts

@@ -0,0 +1,16 @@
+import type { Codec } from 'scale-ts';
+export declare const hexEncoder: Codec<`0x${string}`>;
+export declare function responseEncoder<T>(codec: Codec<T>): Codec<{
+    tag: "success";
+    value: T;
+} | {
+    tag: "error";
+    value: string;
+}>;
+export declare function createNullableEncoder<T>(codec: Codec<T>): Codec<{
+    tag: "value";
+    value: T;
+} | {
+    tag: "null";
+    value: undefined;
+}>;

package/dist/commonEncoders.js

@@ -0,0 +1,20 @@
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Bytes, Enum, _void, str } from 'scale-ts';
+import { createTransportEncoder } from './createTransportEncoder';
+export const hexEncoder = createTransportEncoder({
+    codec: Bytes(),
+    from: v => toHex(v),
+    to: fromHex,
+});
+export function responseEncoder(codec) {
+    return Enum({
+        success: codec,
+        error: str,
+    });
+}
+export function createNullableEncoder(codec) {
+    return Enum({
+        value: codec,
+        null: _void,
+    });
+}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const HANDSHAKE_INTERVAL = 50;

package/dist/constants.js

@@ -0,0 +1 @@
+export const HANDSHAKE_INTERVAL = 50;

package/dist/createTransport.d.ts

@@ -0,0 +1,6 @@
+import type { Transport, TransportProvider } from './types';
+type TransportParams = Partial<{
+    handshakeTimeout: number;
+}>;
+export declare function createTransport(provider: TransportProvider, params?: TransportParams): Transport;
+export {};

package/dist/createTransport.js

@@ -0,0 +1,186 @@
+import mitt from 'mitt';
+import { nanoid } from 'nanoid';
+import { HANDSHAKE_INTERVAL } from './constants';
+import { delay, promiseWithResolvers } from './helpers';
+import { messageEncoder } from './messageEncoder';
+export function createTransport(provider, params) {
+    const handshakeTimeout = params?.handshakeTimeout ?? Number.POSITIVE_INFINITY;
+    const handshakeAbortController = new AbortController();
+    let handshakePromise = null;
+    let connectionStatusResolved = false;
+    let connectionStatus = 'disconnected';
+    let disposed = false;
+    const events = mitt();
+    events.on('connectionStatus', value => {
+        connectionStatus = value;
+    });
+    function changeConnectionStatus(status) {
+        events.emit('connectionStatus', status);
+    }
+    function throwIfDisposed() {
+        if (disposed) {
+            throw new Error('Transport is disposed');
+        }
+    }
+    function throwIfIncorrectEnvironment() {
+        if (!provider.isCorrectEnvironment()) {
+            throw new Error('Environment is not correct');
+        }
+    }
+    function connectionStatusToBoolean(connectionStatus) {
+        switch (connectionStatus) {
+            case 'disconnected':
+            case 'connecting':
+                return false;
+            case 'connected':
+                return true;
+        }
+    }
+    const transportInstance = {
+        provider,
+        isCorrectEnvironment() {
+            return provider.isCorrectEnvironment();
+        },
+        isReady() {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            if (connectionStatusResolved) {
+                return Promise.resolve(connectionStatusToBoolean(connectionStatus));
+            }
+            if (handshakePromise) {
+                return handshakePromise;
+            }
+            changeConnectionStatus('connecting');
+            let resolved = false;
+            const request = new Promise(resolve => {
+                const id = nanoid();
+                const unsubscribe = transportInstance.subscribe('handshakeResponseV1', responseId => {
+                    if (responseId !== id)
+                        return;
+                    clearInterval(interval);
+                    unsubscribe();
+                    handshakeAbortController.signal.removeEventListener('abort', unsubscribe);
+                    resolved = true;
+                    resolve(true);
+                });
+                handshakeAbortController.signal.addEventListener('abort', unsubscribe, { once: true });
+                const interval = setInterval(() => {
+                    if (handshakeAbortController.signal.aborted) {
+                        clearInterval(interval);
+                        resolve(false);
+                        return;
+                    }
+                    transportInstance.postMessage(id, { tag: 'handshakeRequestV1', value: undefined });
+                }, HANDSHAKE_INTERVAL);
+            });
+            const promise = handshakeTimeout === Number.POSITIVE_INFINITY
+                ? request
+                : Promise.race([
+                    request,
+                    delay(handshakeTimeout).then(() => {
+                        if (!resolved) {
+                            handshakeAbortController.abort('Timeout');
+                        }
+                        return false;
+                    }),
+                ]);
+            handshakePromise = promise.then(result => {
+                handshakePromise = null;
+                connectionStatusResolved = true;
+                changeConnectionStatus(result ? 'connected' : 'disconnected');
+                return result;
+            });
+            return handshakePromise;
+        },
+        subscribeAny(callback) {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            return provider.subscribe(message => {
+                let result;
+                try {
+                    result = messageEncoder.dec(message);
+                }
+                catch {
+                    return;
+                }
+                callback(result.id, result.payload);
+            });
+        },
+        subscribe(type, callback) {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            return transportInstance.subscribeAny((id, message) => {
+                if (message.tag == type) {
+                    callback(id, message.value);
+                }
+            });
+        },
+        postMessage(id, payload) {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            const encoded = messageEncoder.enc({ id, payload });
+            provider.postMessage(encoded);
+            return id;
+        },
+        async request(payload, response, abortSignal) {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            const ready = await transportInstance.isReady();
+            if (!ready) {
+                throw new Error('Polkadot host is not ready');
+            }
+            abortSignal?.throwIfAborted();
+            const requestId = nanoid();
+            const { resolve, reject, promise } = promiseWithResolvers();
+            const unsubscribe = transportInstance.subscribe(response, (receivedId, payload) => {
+                if (receivedId === requestId) {
+                    abortSignal?.removeEventListener('abort', stop);
+                    unsubscribe();
+                    resolve(payload);
+                }
+            });
+            const stop = () => {
+                unsubscribe();
+                reject(abortSignal?.reason ?? new Error('Request aborted'));
+            };
+            abortSignal?.addEventListener('abort', stop, { once: true });
+            transportInstance.postMessage(requestId, payload);
+            return promise;
+        },
+        handleMessage(type, handler) {
+            throwIfIncorrectEnvironment();
+            throwIfDisposed();
+            return transportInstance.subscribe(type, (id, payload) => {
+                handler(payload).then(result => {
+                    if (!result)
+                        return;
+                    transportInstance.postMessage(id, result);
+                });
+            });
+        },
+        onConnectionStatusChange(callback) {
+            events.on('connectionStatus', callback);
+            callback(connectionStatus);
+            return () => {
+                events.off('connectionStatus', callback);
+            };
+        },
+        dispose() {
+            disposed = true;
+            provider.dispose();
+            changeConnectionStatus('disconnected');
+            events.all.clear();
+            handshakeAbortController.abort('Transport disposed');
+        },
+    };
+    if (provider.isCorrectEnvironment()) {
+        transportInstance.handleMessage('handshakeRequestV1', async () => ({
+            tag: 'handshakeResponseV1',
+            value: {
+                tag: 'success',
+                value: undefined,
+            },
+        }));
+    }
+    return transportInstance;
+}

package/dist/createTransportEncoder.d.ts

@@ -0,0 +1,7 @@
+import type { Codec, CodecType } from 'scale-ts';
+export type TransportEncoder<Public, Transported extends Codec<any>> = {
+    codec: Transported;
+    from: (decoded: CodecType<Transported>) => Public;
+    to: (value: Public) => CodecType<Transported>;
+};
+export declare function createTransportEncoder<Public, Transported extends Codec<any>>(encoder: TransportEncoder<Public, Transported>): Codec<Public>;

package/dist/createTransportEncoder.js

@@ -0,0 +1,5 @@
+import { enhanceCodec } from 'scale-ts';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createTransportEncoder(encoder) {
+    return enhanceCodec(encoder.codec, encoder.to, encoder.from);
+}

package/dist/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function delay(ttl: number): Promise<void>;
+type PromiseWithResolvers<T> = {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};
+export declare const promiseWithResolvers: <const T>() => PromiseWithResolvers<T>;
+export {};

package/dist/helpers.js

@@ -0,0 +1,13 @@
+export function delay(ttl) {
+    return new Promise(resolve => setTimeout(resolve, ttl));
+}
+export const promiseWithResolvers = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    // @ts-expect-error before assign
+    return { promise, resolve, reject };
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { messageEncoder, unwrapResponseOrThrow } from './messageEncoder';
+export { type MessagePayloadSchema, type MessageType, type PickMessagePayload, type PickMessagePayloadValue, } from './messageEncoder';
+export { createTransport } from './createTransport';
+export type { ConnectionStatus, HexString, Logger, Transport, TransportProvider } from './types';
+export { createDefaultLogger } from './logger';
+export { type InjectedAccountSchema } from './interactions/accounts';
+export { type TxPayloadV1 } from './interactions/sign';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { messageEncoder, unwrapResponseOrThrow } from './messageEncoder';
+export {} from './messageEncoder';
+export { createTransport } from './createTransport';
+export { createDefaultLogger } from './logger';
+export {} from './interactions/accounts';
+export {} from './interactions/sign';

package/dist/interactions/accounts.d.ts

@@ -0,0 +1,12 @@
+import type { InjectedAccount } from '@polkadot-api/pjs-signer';
+import type { Codec, CodecType } from 'scale-ts';
+/**
+ * @see {import('@polkadot/extension-inject/types').InjectedAccount}
+ */
+export type InjectedAccountSchema = CodecType<typeof injectedAccountEncoder>;
+declare const injectedAccountEncoder: Codec<InjectedAccount>;
+export declare const getAccountsRequestV1Encoder: Codec<undefined>;
+export declare const getAccountsResponseV1Encoder: Codec<InjectedAccount[]>;
+export declare const accountSubscriptionV1Encoder: Codec<undefined>;
+export declare const accountUnsubscriptionV1Encoder: Codec<undefined>;
+export {};

package/dist/interactions/accounts.js

@@ -0,0 +1,39 @@
+import { Enum, Option, Struct, Vector, _void, str } from 'scale-ts';
+import { createTransportEncoder } from '../createTransportEncoder';
+const keypairCodec = Enum({
+    ed25519: _void,
+    sr25519: _void,
+    ecdsa: _void,
+});
+const keypairEncoder = createTransportEncoder({
+    codec: keypairCodec,
+    from: v => v.tag,
+    to: keypair => ({
+        tag: keypair,
+        value: undefined,
+    }),
+});
+const injectedAccountCodec = Struct({
+    address: str,
+    genesisHash: Option(str),
+    name: Option(str),
+    type: Option(keypairEncoder),
+});
+const injectedAccountEncoder = createTransportEncoder({
+    codec: injectedAccountCodec,
+    from(decoded) {
+        return decoded;
+    },
+    to(value) {
+        return {
+            address: value.address,
+            genesisHash: value.genesisHash ? value.genesisHash : undefined,
+            name: value.name,
+            type: value.type,
+        };
+    },
+});
+export const getAccountsRequestV1Encoder = _void;
+export const getAccountsResponseV1Encoder = Vector(injectedAccountEncoder);
+export const accountSubscriptionV1Encoder = _void;
+export const accountUnsubscriptionV1Encoder = _void;

package/dist/interactions/features.d.ts

@@ -0,0 +1,13 @@
+export declare const supportFeatureRequestV1Encoder: import("scale-ts").Codec<{
+    tag: "chain";
+    value: {
+        chainId: `0x${string}`;
+    };
+}>;
+export declare const supportFeatureResponseV1: import("scale-ts").Codec<{
+    tag: "chain";
+    value: {
+        chainId: `0x${string}`;
+        result: boolean;
+    };
+}>;

package/dist/interactions/features.js

@@ -0,0 +1,13 @@
+import { Enum, Struct, bool } from 'scale-ts';
+import { hexEncoder } from '../commonEncoders';
+export const supportFeatureRequestV1Encoder = Enum({
+    chain: Struct({
+        chainId: hexEncoder,
+    }),
+});
+export const supportFeatureResponseV1 = Enum({
+    chain: Struct({
+        chainId: hexEncoder,
+        result: bool,
+    }),
+});

package/dist/interactions/handshake.d.ts

@@ -0,0 +1,2 @@
+export declare const handshakeRequestV1Encoder: import("scale-ts").Codec<undefined>;
+export declare const handshakeResponseV1Encoder: import("scale-ts").Codec<undefined>;

package/dist/interactions/handshake.js

@@ -0,0 +1,3 @@
+import { _void } from 'scale-ts';
+export const handshakeRequestV1Encoder = _void;
+export const handshakeResponseV1Encoder = _void;

package/dist/interactions/papiProvider.d.ts

@@ -0,0 +1,8 @@
+export declare const papiProviderSendMessageV1Encoder: import("scale-ts").Codec<{
+    chainId: string;
+    message: string;
+}>;
+export declare const papiProviderReceiveMessageV1Encoder: import("scale-ts").Codec<{
+    chainId: string;
+    message: string;
+}>;

package/dist/interactions/papiProvider.js

@@ -0,0 +1,9 @@
+import { Struct, str } from 'scale-ts';
+export const papiProviderSendMessageV1Encoder = Struct({
+    chainId: str,
+    message: str,
+});
+export const papiProviderReceiveMessageV1Encoder = Struct({
+    chainId: str,
+    message: str,
+});

package/dist/interactions/sign.d.ts

@@ -0,0 +1,101 @@
+import type { SignerPayloadJSON, SignerPayloadRaw, SignerResult } from '@polkadot/types/types';
+import type { CodecType } from 'scale-ts';
+import type { HexString } from '../types';
+/**
+ * @see {import('@polkadot/types/types').SignerPayloadRaw}
+ */
+export type SignRawRequestSchema = CodecType<typeof signRawRequestV1Encoder>;
+export declare const signRawRequestV1Encoder: import("scale-ts").Codec<SignerPayloadRaw>;
+/**
+ * @see {import('@polkadot/types/types').SignerPayloadJSON}
+ */
+export type SignPayloadRequestSchema = CodecType<typeof signPayloadRequestV1Encoder>;
+export declare const signPayloadCodec: import("scale-ts").Codec<{
+    address: string;
+    assetId: `0x${string}` | undefined;
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    era: `0x${string}`;
+    genesisHash: `0x${string}`;
+    metadataHash: `0x${string}` | undefined;
+    method: string;
+    mode: number | undefined;
+    nonce: `0x${string}`;
+    specVersion: `0x${string}`;
+    tip: `0x${string}`;
+    transactionVersion: `0x${string}`;
+    signedExtensions: string[];
+    version: number;
+    withSignedTransaction: boolean | undefined;
+}>;
+export declare const signPayloadRequestV1Encoder: import("scale-ts").Codec<SignerPayloadJSON>;
+export declare const signResponseV1Encoder: import("scale-ts").Codec<SignerResult>;
+/**
+ * createTransaction implementation
+ * @see https://github.com/polkadot-js/api/issues/6213
+ */
+export interface TxPayloadV1 {
+    /** Payload version. MUST be 1. */
+    version: 1;
+    /**
+     * Signer selection hint. Allows the implementer to identify which private-key / scheme to use.
+     * - Use a wallet-defined handle (e.g., address/SS58, account-name, etc). This identifier
+     * was previously made available to the consumer.
+     * - Set `null` to let the implementer pick the signer (or if the signer is implied).
+     */
+    signer: string | null;
+    /**
+     * SCALE-encoded Call (module indicator + function indicator + params).
+     */
+    callData: HexString;
+    /**
+     * Transaction extensions supplied by the caller (order irrelevant).
+     * The consumer SHOULD provide every extension that is relevant to them.
+     * The implementer MAY infer missing ones.
+     */
+    extensions: Array<{
+        /** Identifier as defined in metadata (e.g., "CheckSpecVersion", "ChargeAssetTxPayment"). */
+        id: string;
+        /**
+         * Explicit "extra" to sign (goes into the extrinsic body).
+         * SCALE-encoded per the extension's "extra" type as defined in the metadata.
+         */
+        extra: HexString;
+        /**
+         * "Implicit" data to sign (known by the chain, not included into the extrinsic body).
+         * SCALE-encoded per the extension's "additionalSigned" type as defined in the metadata.
+         */
+        additionalSigned: HexString;
+    }>;
+    /**
+     * Transaction Extension Version.
+     * - For Extrinsic V4 MUST be 0.
+     * - For Extrinsic V5, set to any version supported by the runtime.
+     * The implementer:
+     *  - MUST use this field to determine the required extensions for creating the extrinsic.
+     *  - MAY use this field to infer missing extensions that the implementer could know how to handle.
+     */
+    txExtVersion: number;
+    /**
+     * Context needed for decoding, display, and (optionally) inferring certain extensions.
+     */
+    context: {
+        /**
+         * RuntimeMetadataPrefixed blob (SCALE), starting with ASCII "meta" magic (`0x6d657461`),
+         * then a metadata version (V14+). For V5+ versioned extensions, MUST provide V16+.
+         */
+        metadata: HexString;
+        /**
+         * Native token display info (used by some implementers), also needed to compute
+         * the `CheckMetadataHash` value.
+         */
+        tokenSymbol: string;
+        tokenDecimals: number;
+        /**
+         * Highest known block number to aid mortality UX.
+         */
+        bestBlockHeight: number;
+    };
+}
+export declare const createTransactionRequestV1Encoder: import("scale-ts").Codec<TxPayloadV1>;
+export declare const createTransactionResponseV1Encoder: import("scale-ts").Codec<`0x${string}`>;

package/dist/interactions/sign.js

@@ -0,0 +1,177 @@
+import { Bytes, Enum, Option, Struct, Vector, _void, bool, str, u16, u32 } from 'scale-ts';
+import { createNullableEncoder, hexEncoder } from '../commonEncoders';
+import { createTransportEncoder } from '../createTransportEncoder';
+const signRawRequestCodec = Struct({
+    address: str,
+    data: str,
+    type: Enum({
+        bytes: _void,
+        payload: _void,
+    }),
+});
+export const signRawRequestV1Encoder = createTransportEncoder({
+    codec: signRawRequestCodec,
+    from(decoded) {
+        return {
+            address: decoded.address,
+            data: decoded.data,
+            type: decoded.type.tag,
+        };
+    },
+    to(value) {
+        return {
+            address: value.address,
+            data: value.data,
+            type: {
+                tag: value.type,
+                value: undefined,
+            },
+        };
+    },
+});
+export const signPayloadCodec = Struct({
+    address: str,
+    assetId: Option(hexEncoder),
+    blockHash: hexEncoder,
+    blockNumber: hexEncoder,
+    era: hexEncoder,
+    genesisHash: hexEncoder,
+    metadataHash: Option(hexEncoder),
+    method: str,
+    mode: Option(u32),
+    nonce: hexEncoder,
+    specVersion: hexEncoder,
+    tip: hexEncoder,
+    transactionVersion: hexEncoder,
+    signedExtensions: Vector(str),
+    version: u32,
+    withSignedTransaction: Option(bool),
+});
+export const signPayloadRequestV1Encoder = createTransportEncoder({
+    codec: signPayloadCodec,
+    from(decoded) {
+        return {
+            address: decoded.address,
+            assetId: decoded.assetId,
+            blockHash: decoded.blockHash,
+            blockNumber: decoded.blockNumber,
+            era: decoded.era,
+            genesisHash: decoded.genesisHash,
+            metadataHash: decoded.metadataHash,
+            method: decoded.method,
+            mode: decoded.mode,
+            nonce: decoded.nonce,
+            specVersion: decoded.specVersion,
+            tip: decoded.tip,
+            transactionVersion: decoded.transactionVersion,
+            signedExtensions: decoded.signedExtensions,
+            version: decoded.version,
+            withSignedTransaction: decoded.withSignedTransaction,
+        };
+    },
+    to(value) {
+        return {
+            address: value.address,
+            assetId: value.assetId,
+            blockHash: value.blockHash,
+            blockNumber: value.blockNumber,
+            era: value.era,
+            genesisHash: value.genesisHash,
+            metadataHash: value.metadataHash,
+            method: value.method,
+            mode: value.mode,
+            nonce: value.nonce,
+            specVersion: value.specVersion,
+            tip: value.tip,
+            transactionVersion: value.transactionVersion,
+            signedExtensions: value.signedExtensions,
+            version: value.version,
+            withSignedTransaction: value.withSignedTransaction,
+        };
+    },
+});
+const signResult = Struct({
+    id: u32,
+    signature: hexEncoder,
+    signedTransaction: Option(Enum({
+        hex: hexEncoder,
+        buffer: Bytes(),
+    })),
+});
+export const signResponseV1Encoder = createTransportEncoder({
+    codec: signResult,
+    from(decoded) {
+        return {
+            id: decoded.id,
+            signature: decoded.signature,
+            signedTransaction: decoded.signedTransaction ? decoded.signedTransaction.value : undefined,
+        };
+    },
+    to(value) {
+        let signedTransaction = undefined;
+        if (value.signedTransaction) {
+            if (typeof value.signedTransaction === 'string') {
+                signedTransaction = {
+                    tag: 'hex',
+                    value: value.signedTransaction,
+                };
+            }
+            else {
+                signedTransaction = {
+                    tag: 'buffer',
+                    value: value.signedTransaction,
+                };
+            }
+        }
+        return {
+            id: value.id,
+            signature: value.signature,
+            signedTransaction: signedTransaction,
+        };
+    },
+});
+const createTransactionRequestCodec = Struct({
+    version: u16,
+    signer: createNullableEncoder(str),
+    callData: hexEncoder,
+    extensions: Vector(Struct({
+        id: str,
+        extra: hexEncoder,
+        additionalSigned: hexEncoder,
+    })),
+    txExtVersion: u16,
+    context: Struct({
+        metadata: hexEncoder,
+        tokenSymbol: str,
+        tokenDecimals: u32,
+        bestBlockHeight: u32,
+    }),
+});
+export const createTransactionRequestV1Encoder = createTransportEncoder({
+    codec: createTransactionRequestCodec,
+    from({ version, signer, ...rest }) {
+        if (version !== 1) {
+            throw new Error(`TxPayload supported version are: 1. Got ${version}`);
+        }
+        return {
+            version,
+            signer: signer.value ?? null,
+            ...rest,
+        };
+    },
+    to({ signer, ...rest }) {
+        return {
+            signer: typeof signer === 'string'
+                ? {
+                    tag: 'value',
+                    value: signer,
+                }
+                : {
+                    tag: 'null',
+                    value: undefined,
+                },
+            ...rest,
+        };
+    },
+});
+export const createTransactionResponseV1Encoder = hexEncoder;

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from './types';
+export declare function createDefaultLogger(): Logger;

package/dist/logger.js

@@ -0,0 +1,8 @@
+export function createDefaultLogger() {
+    return {
+        info: (...args) => console.info(...args),
+        error: (...args) => console.error(...args),
+        warn: (...args) => console.warn(...args),
+        log: (...args) => console.log(...args),
+    };
+}

package/dist/messageEncoder.d.ts

@@ -0,0 +1,217 @@
+import type { CodecType } from 'scale-ts';
+import { responseEncoder } from './commonEncoders';
+export declare function unwrapResponseOrThrow<T>(response: CodecType<ReturnType<typeof responseEncoder<T>>>): T;
+export type MessagePayloadSchema = CodecType<typeof messagePayloadEncoder>;
+export declare const messagePayloadEncoder: import("scale-ts").Codec<{
+    tag: "handshakeRequestV1";
+    value: undefined;
+} | {
+    tag: "handshakeResponseV1";
+    value: {
+        tag: "success";
+        value: undefined;
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "getAccountsRequestV1";
+    value: undefined;
+} | {
+    tag: "getAccountsResponseV1";
+    value: {
+        tag: "success";
+        value: import("@polkadot-api/pjs-signer").InjectedAccount[];
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "accountSubscriptionV1";
+    value: undefined;
+} | {
+    tag: "accountUnsubscriptionV1";
+    value: undefined;
+} | {
+    tag: "supportFeatureRequestV1";
+    value: {
+        tag: "chain";
+        value: {
+            chainId: `0x${string}`;
+        };
+    };
+} | {
+    tag: "supportFeatureResponseV1";
+    value: {
+        tag: "success";
+        value: {
+            tag: "chain";
+            value: {
+                chainId: `0x${string}`;
+                result: boolean;
+            };
+        };
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "papiProviderSendMessageV1";
+    value: {
+        chainId: string;
+        message: string;
+    };
+} | {
+    tag: "papiProviderReceiveMessageV1";
+    value: {
+        tag: "success";
+        value: {
+            chainId: string;
+            message: string;
+        };
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "signRawRequestV1";
+    value: import("@polkadot/types/types").SignerPayloadRaw;
+} | {
+    tag: "signPayloadRequestV1";
+    value: import("@polkadot/types/types").SignerPayloadJSON;
+} | {
+    tag: "signResponseV1";
+    value: {
+        tag: "success";
+        value: import("@polkadot/types/types").SignerResult;
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "createTransactionRequestV1";
+    value: import(".").TxPayloadV1;
+} | {
+    tag: "createTransactionResponseV1";
+    value: {
+        tag: "success";
+        value: `0x${string}`;
+    } | {
+        tag: "error";
+        value: string;
+    };
+} | {
+    tag: "locationChangedV1";
+    value: string;
+}>;
+export type MessageSchema = CodecType<typeof messageEncoder>;
+export declare const messageEncoder: import("scale-ts").Codec<{
+    id: string;
+    payload: {
+        tag: "handshakeRequestV1";
+        value: undefined;
+    } | {
+        tag: "handshakeResponseV1";
+        value: {
+            tag: "success";
+            value: undefined;
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "getAccountsRequestV1";
+        value: undefined;
+    } | {
+        tag: "getAccountsResponseV1";
+        value: {
+            tag: "success";
+            value: import("@polkadot-api/pjs-signer").InjectedAccount[];
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "accountSubscriptionV1";
+        value: undefined;
+    } | {
+        tag: "accountUnsubscriptionV1";
+        value: undefined;
+    } | {
+        tag: "supportFeatureRequestV1";
+        value: {
+            tag: "chain";
+            value: {
+                chainId: `0x${string}`;
+            };
+        };
+    } | {
+        tag: "supportFeatureResponseV1";
+        value: {
+            tag: "success";
+            value: {
+                tag: "chain";
+                value: {
+                    chainId: `0x${string}`;
+                    result: boolean;
+                };
+            };
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "papiProviderSendMessageV1";
+        value: {
+            chainId: string;
+            message: string;
+        };
+    } | {
+        tag: "papiProviderReceiveMessageV1";
+        value: {
+            tag: "success";
+            value: {
+                chainId: string;
+                message: string;
+            };
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "signRawRequestV1";
+        value: import("@polkadot/types/types").SignerPayloadRaw;
+    } | {
+        tag: "signPayloadRequestV1";
+        value: import("@polkadot/types/types").SignerPayloadJSON;
+    } | {
+        tag: "signResponseV1";
+        value: {
+            tag: "success";
+            value: import("@polkadot/types/types").SignerResult;
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "createTransactionRequestV1";
+        value: import(".").TxPayloadV1;
+    } | {
+        tag: "createTransactionResponseV1";
+        value: {
+            tag: "success";
+            value: `0x${string}`;
+        } | {
+            tag: "error";
+            value: string;
+        };
+    } | {
+        tag: "locationChangedV1";
+        value: string;
+    };
+}>;
+export type MessageType = MessagePayloadSchema['tag'];
+export type PickMessagePayload<T extends MessageType> = Extract<MessagePayloadSchema, {
+    tag: T;
+}>;
+export type PickMessagePayloadValue<T extends MessageType> = PickMessagePayload<T>['value'];

package/dist/messageEncoder.js

@@ -0,0 +1,37 @@
+import { Enum, Struct, str } from 'scale-ts';
+import { responseEncoder } from './commonEncoders';
+import { accountSubscriptionV1Encoder, accountUnsubscriptionV1Encoder, getAccountsRequestV1Encoder, getAccountsResponseV1Encoder, } from './interactions/accounts';
+import { supportFeatureRequestV1Encoder, supportFeatureResponseV1 } from './interactions/features';
+import { handshakeRequestV1Encoder, handshakeResponseV1Encoder } from './interactions/handshake';
+import { papiProviderReceiveMessageV1Encoder, papiProviderSendMessageV1Encoder } from './interactions/papiProvider';
+import { createTransactionRequestV1Encoder, createTransactionResponseV1Encoder, signPayloadRequestV1Encoder, signRawRequestV1Encoder, signResponseV1Encoder, } from './interactions/sign';
+export function unwrapResponseOrThrow(response) {
+    if (response.tag === 'success') {
+        return response.value;
+    }
+    else {
+        throw new Error(response.value);
+    }
+}
+export const messagePayloadEncoder = Enum({
+    handshakeRequestV1: handshakeRequestV1Encoder,
+    handshakeResponseV1: responseEncoder(handshakeResponseV1Encoder),
+    getAccountsRequestV1: getAccountsRequestV1Encoder,
+    getAccountsResponseV1: responseEncoder(getAccountsResponseV1Encoder),
+    accountSubscriptionV1: accountSubscriptionV1Encoder,
+    accountUnsubscriptionV1: accountUnsubscriptionV1Encoder,
+    supportFeatureRequestV1: supportFeatureRequestV1Encoder,
+    supportFeatureResponseV1: responseEncoder(supportFeatureResponseV1),
+    papiProviderSendMessageV1: papiProviderSendMessageV1Encoder,
+    papiProviderReceiveMessageV1: responseEncoder(papiProviderReceiveMessageV1Encoder),
+    signRawRequestV1: signRawRequestV1Encoder,
+    signPayloadRequestV1: signPayloadRequestV1Encoder,
+    signResponseV1: responseEncoder(signResponseV1Encoder),
+    createTransactionRequestV1: createTransactionRequestV1Encoder,
+    createTransactionResponseV1: responseEncoder(createTransactionResponseV1Encoder),
+    locationChangedV1: str,
+});
+export const messageEncoder = Struct({
+    id: str,
+    payload: messagePayloadEncoder,
+});

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+import type { MessagePayloadSchema, MessageType, PickMessagePayload, PickMessagePayloadValue } from './messageEncoder';
+export type HexString = `0x${string}`;
+export type Logger = Record<'info' | 'warn' | 'error' | 'log', (...args: unknown[]) => void>;
+export type TransportProvider = {
+    logger: Logger;
+    isCorrectEnvironment(): boolean;
+    postMessage(message: Uint8Array): void;
+    subscribe(callback: (message: Uint8Array) => void): () => void;
+    dispose(): void;
+};
+export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
+export type Transport = {
+    readonly provider: TransportProvider;
+    isCorrectEnvironment(): boolean;
+    isReady(): Promise<boolean>;
+    subscribeAny(callback: (id: string, payload: MessagePayloadSchema) => void): VoidFunction;
+    subscribe<const Type extends MessageType>(type: Type, callback: (id: string, payload: PickMessagePayloadValue<Type>) => void): VoidFunction;
+    postMessage(id: string, payload: MessagePayloadSchema): string;
+    request<Response extends MessageType>(payload: MessagePayloadSchema, response: Response, abortSignal?: AbortSignal): Promise<PickMessagePayloadValue<Response>>;
+    handleMessage<Request extends MessageType, Response extends MessageType>(type: Request, handler: (message: PickMessagePayloadValue<Request>) => Promise<PickMessagePayload<Response> | void>): VoidFunction;
+    onConnectionStatusChange(callback: (status: ConnectionStatus) => void): VoidFunction;
+    dispose(): void;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@novasamatech/host-api",
+  "type": "module",
+  "version": "0.4.0",
+  "description": "Host API: transport implementation for host - product integration.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+  },
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polkadot-api/utils": "0.2.0",
+    "mitt": "3.0.1",
+    "nanoid": "5.1.6",
+    "scale-ts": "1.6.1"
+  },
+  "peerDependencies": {
+    "@polkadot-api/pjs-signer": "^0.6.17"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}