@novasamatech/host-api 0.5.0-18 → 0.5.0-19

package/dist/types.d.ts

@@ -1,23 +1,23 @@
-import type { MessagePayloadSchema, MessageType, PickMessagePayload, PickMessagePayloadValue } from './messageEncoder.js';
-export type HexString = `0x${string}`;
+import type { ComposeMessageAction, MessageAction, MessagePayloadSchema, PickMessagePayload, PickMessagePayloadValue } from './protocol/messageCodec.js';
+import type { Provider } from './provider.js';
 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 RequestHandler<Method extends string> = (message: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>) => PromiseLike<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
+export type SubscriptionHandler<Method extends string> = (params: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, send: (value: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void, interrupt: () => void) => VoidFunction;
+export type Subscription = {
+    unsubscribe: VoidFunction;
+    onInterrupt(callback: VoidFunction): VoidFunction;
+};
 export type Transport = {
-    readonly provider: TransportProvider;
+    readonly provider: Provider;
     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;
+    request<const Method extends string>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>, signal?: AbortSignal): Promise<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
+    handleRequest<const Method extends string>(method: Method, handler: RequestHandler<Method>): VoidFunction;
+    subscribe<const Method extends string>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, callback: (payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void): Subscription;
+    handleSubscription<const Method extends string>(method: Method, handler: SubscriptionHandler<Method>): VoidFunction;
+    postMessage(requestId: string, payload: MessagePayloadSchema): void;
+    listenMessages<const Action extends MessageAction>(action: Action, callback: (requestId: string, data: PickMessagePayload<Action>) => void, onError?: (error: unknown) => void): VoidFunction;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.5.0-18",
+  "version": "0.5.0-19",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -24,11 +24,9 @@
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.6",
+    "neverthrow": "^8.2.0",
     "scale-ts": "1.6.1"
   },
-  "peerDependencies": {
-    "@polkadot-api/pjs-signer": "^0.6.17"
-  },
   "publishConfig": {
     "access": "public"
   }

package/dist/commonEncoders.d.ts

@@ -1,2 +0,0 @@
-import type { Codec } from 'scale-ts';
-export declare const hexCodec: Codec<`0x${string}`>;

package/dist/commonEncoders.js

@@ -1,8 +0,0 @@
-import { fromHex, toHex } from '@polkadot-api/utils';
-import { Bytes } from 'scale-ts';
-import { createTransportEncoder } from './createTransportEncoder.js';
-export const hexCodec = createTransportEncoder({
-    codec: Bytes(),
-    from: v => toHex(v),
-    to: fromHex,
-});

package/dist/createTransport.d.ts

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

package/dist/createTransport.js

@@ -1,183 +0,0 @@
-import { createNanoEvents } from 'nanoevents';
-import { nanoid } from 'nanoid';
-import { HANDSHAKE_INTERVAL } from './constants.js';
-import { delay, promiseWithResolvers } from './helpers.js';
-import { messageEncoder } from './messageEncoder.js';
-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 = createNanoEvents();
-    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) {
-            callback(connectionStatus);
-            return events.on('connectionStatus', callback);
-        },
-        dispose() {
-            disposed = true;
-            provider.dispose();
-            changeConnectionStatus('disconnected');
-            events.events = {};
-            handshakeAbortController.abort('Transport disposed');
-        },
-    };
-    if (provider.isCorrectEnvironment()) {
-        transportInstance.handleMessage('handshakeRequestV1', async () => ({
-            tag: 'handshakeResponseV1',
-            value: {
-                success: true,
-                value: undefined,
-            },
-        }));
-    }
-    return transportInstance;
-}

package/dist/createTransportEncoder.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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/interactions/accounts.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,40 +0,0 @@
-import { Enum, Option, Struct, Vector, _void, str } from 'scale-ts';
-import { hexCodec } from '../commonEncoders.js';
-import { createTransportEncoder } from '../createTransportEncoder.js';
-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(hexCodec),
-    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/commonCodecs.d.ts

@@ -1,7 +0,0 @@
-import type { Codec } from 'scale-ts';
-export declare const Nullable: <T>(inner: Codec<T>) => Codec<T | null>;
-export declare const Hex: (length?: number) => Codec<`0x${string}`>;
-export declare const GenericErr: Codec<{
-    reason: string;
-}>;
-export declare const GenesisHash: Codec<`0x${string}`>;

package/dist/interactions/commonCodecs.js

@@ -1,8 +0,0 @@
-import { fromHex, toHex } from '@polkadot-api/utils';
-import { Bytes, Option, Struct, enhanceCodec, str } from 'scale-ts';
-export const Nullable = (inner) => enhanceCodec(Option(inner), v => v ?? undefined, v => v ?? null);
-export const Hex = (length) => enhanceCodec(Bytes(length), fromHex, v => toHex(v));
-export const GenericErr = Struct({
-    reason: str,
-});
-export const GenesisHash = Hex();

package/dist/interactions/features.d.ts

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

package/dist/interactions/features.js

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

package/dist/interactions/handshake.d.ts

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

package/dist/interactions/handshake.js

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