@novasamatech/host-api 0.5.0-9 → 0.5.0

package/dist/transport.js

@@ -0,0 +1,248 @@
+import { createNanoEvents } from 'nanoevents';
+import { HANDSHAKE_INTERVAL, HANDSHAKE_TIMEOUT, JAM_CODEC_PROTOCOL_ID } from './constants.js';
+import { composeAction, createRequestId, delay, enumValue, errResult, isEnumVariant, okResult, promiseWithResolvers, } from './helpers.js';
+import { Message } from './protocol/messageCodec.js';
+import { HandshakeErr } from './protocol/v1/handshake.js';
+const isConnected = (status) => status === 'connected';
+export function createTransport(provider) {
+    let codecVersion = JAM_CODEC_PROTOCOL_ID;
+    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 throwIfInvalidCodecVersion() {
+        if (codecVersion !== JAM_CODEC_PROTOCOL_ID) {
+            throw new Error(`Unsupported codec version: ${codecVersion}`);
+        }
+    }
+    function checks() {
+        throwIfDisposed();
+        throwIfIncorrectEnvironment();
+        throwIfInvalidCodecVersion();
+    }
+    const transport = {
+        provider,
+        isCorrectEnvironment() {
+            return provider.isCorrectEnvironment();
+        },
+        isReady() {
+            checks();
+            if (connectionStatusResolved) {
+                return Promise.resolve(isConnected(connectionStatus));
+            }
+            if (handshakePromise) {
+                return handshakePromise;
+            }
+            changeConnectionStatus('connecting');
+            const performHandshake = () => {
+                const id = createRequestId();
+                let resolved = false;
+                const cleanup = (interval, unsubscribe) => {
+                    clearInterval(interval);
+                    unsubscribe();
+                    handshakeAbortController.signal.removeEventListener('abort', unsubscribe);
+                };
+                return new Promise(resolve => {
+                    const unsubscribe = transport.listenMessages('handshake_response', responseId => {
+                        if (responseId === id) {
+                            cleanup(interval, unsubscribe);
+                            resolved = true;
+                            resolve(true);
+                        }
+                    });
+                    handshakeAbortController.signal.addEventListener('abort', unsubscribe, { once: true });
+                    const interval = setInterval(() => {
+                        if (handshakeAbortController.signal.aborted) {
+                            clearInterval(interval);
+                            resolve(false);
+                            return;
+                        }
+                        transport.postMessage(id, enumValue('handshake_request', enumValue('v1', codecVersion)));
+                    }, HANDSHAKE_INTERVAL);
+                }).then(success => {
+                    if (!success && !resolved) {
+                        handshakeAbortController.abort('Timeout');
+                    }
+                    return success;
+                });
+            };
+            const timedOutRequest = Promise.race([performHandshake(), delay(HANDSHAKE_TIMEOUT).then(() => false)]);
+            handshakePromise = timedOutRequest.then(result => {
+                handshakePromise = null;
+                connectionStatusResolved = true;
+                changeConnectionStatus(result ? 'connected' : 'disconnected');
+                return result;
+            });
+            return handshakePromise;
+        },
+        async request(method, payload, signal) {
+            checks();
+            if (!(await transport.isReady())) {
+                throw new Error('Polkadot host is not ready');
+            }
+            signal?.throwIfAborted();
+            const requestId = createRequestId();
+            const requestAction = composeAction(method, 'request');
+            const responseAction = composeAction(method, 'response');
+            const { resolve, reject, promise } = promiseWithResolvers();
+            const cleanup = () => {
+                unsubscribe();
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const onAbort = () => {
+                cleanup();
+                reject(signal?.reason ?? new Error('Request aborted'));
+            };
+            const unsubscribe = transport.listenMessages(responseAction, (receivedId, payload) => {
+                if (receivedId === requestId) {
+                    cleanup();
+                    resolve(payload.value);
+                }
+            });
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const requestMessage = enumValue(requestAction, payload);
+            transport.postMessage(requestId, requestMessage);
+            return promise;
+        },
+        handleRequest(method, handler) {
+            checks();
+            const requestAction = composeAction(method, 'request');
+            const responseAction = composeAction(method, 'response');
+            return transport.listenMessages(requestAction, (requestId, payload) => {
+                handler(payload.value).then(result => {
+                    const responseMessage = enumValue(responseAction, result);
+                    transport.postMessage(requestId, responseMessage);
+                });
+            });
+        },
+        subscribe(method, payload, callback) {
+            checks();
+            const events = createNanoEvents();
+            const requestId = createRequestId();
+            const startAction = composeAction(method, 'start');
+            const stopAction = composeAction(method, 'stop');
+            const interruptAction = composeAction(method, 'interrupt');
+            const receiveAction = composeAction(method, 'receive');
+            const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
+                if (receivedId === requestId) {
+                    callback(data.value);
+                }
+            });
+            const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
+                if (receivedId === requestId) {
+                    events.emit('interrupt');
+                    stopSubscription();
+                }
+            });
+            const stopSubscription = () => {
+                unsubscribeReceive();
+                unsubscribeInterrupt();
+                events.events = {};
+            };
+            const startPayload = enumValue(startAction, payload);
+            transport.postMessage(requestId, startPayload);
+            return {
+                unsubscribe() {
+                    stopSubscription();
+                    const stopPayload = enumValue(stopAction, undefined);
+                    transport.postMessage(requestId, stopPayload);
+                },
+                onInterrupt(callback) {
+                    return events.on('interrupt', callback);
+                },
+            };
+        },
+        handleSubscription(method, handler) {
+            checks();
+            const startAction = composeAction(method, 'start');
+            const stopAction = composeAction(method, 'stop');
+            const interruptAction = composeAction(method, 'interrupt');
+            const receiveAction = composeAction(method, 'receive');
+            const subscriptions = new Map();
+            const unsubStart = transport.listenMessages(startAction, (requestId, payload) => {
+                if (subscriptions.has(requestId))
+                    return;
+                const unsubscribe = handler(payload.value, value => {
+                    const receivePayload = enumValue(receiveAction, value);
+                    transport.postMessage(requestId, receivePayload);
+                }, () => {
+                    transport.postMessage(requestId, enumValue(interruptAction, undefined));
+                });
+                subscriptions.set(requestId, unsubscribe);
+            });
+            const unsubStop = transport.listenMessages(stopAction, requestId => {
+                subscriptions.get(requestId)?.();
+            });
+            return () => {
+                subscriptions.forEach(unsub => unsub());
+                unsubStart();
+                unsubStop();
+            };
+        },
+        postMessage(requestId, payload) {
+            checks();
+            const encoded = Message.enc({ requestId, payload });
+            provider.postMessage(encoded);
+        },
+        listenMessages(action, callback, onError) {
+            return provider.subscribe(message => {
+                try {
+                    const result = Message.dec(message);
+                    if (isEnumVariant(result.payload, action)) {
+                        callback(result.requestId, result.payload);
+                    }
+                }
+                catch (e) {
+                    onError?.(e);
+                }
+            });
+        },
+        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()) {
+        transport.handleRequest('handshake', async (version) => {
+            switch (version.tag) {
+                case 'v1': {
+                    codecVersion = version.value;
+                    switch (version.value) {
+                        case JAM_CODEC_PROTOCOL_ID:
+                            return enumValue(version.tag, okResult(undefined));
+                        default:
+                            return enumValue(version.tag, errResult(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
+                    }
+                }
+                default:
+                    return enumValue(version.tag, errResult(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
+            }
+        });
+    }
+    return transport;
+}

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-9",
+  "version": "0.5.0",
   "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,9 +0,0 @@
-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;
-}>;

package/dist/commonEncoders.js

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

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: {
-                tag: 'success',
-                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,39 +0,0 @@
-import { Enum, Option, Struct, Vector, _void, str } from 'scale-ts';
-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(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

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

@@ -1,13 +0,0 @@
-import { Enum, Struct, bool } from 'scale-ts';
-import { hexEncoder } from '../commonEncoders.js';
-export const supportFeatureRequestV1Encoder = Enum({
-    chain: Struct({
-        chainId: hexEncoder,
-    }),
-});
-export const supportFeatureResponseV1 = Enum({
-    chain: Struct({
-        chainId: hexEncoder,
-        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;

package/dist/interactions/papiProvider.d.ts

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

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