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

package/dist/protocol/v1/sign.d.ts

@@ -0,0 +1,152 @@
+export declare const SigningErr: [import("scale-ts").Encoder<(Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "SigningErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "SigningErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "SigningErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "SigningErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "SigningErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "SigningErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly FailedToDecode: import("../commonCodecs.js").ErrCodec<undefined, "SigningErr::FailedToDecode">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "SigningErr::Rejected">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "SigningErr::Unknown">;
+};
+export declare const SigningResult: import("scale-ts").Codec<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}>;
+export declare const SignRawV1_request: import("scale-ts").Codec<{
+    address: string;
+    data: {
+        tag: "Bytes";
+        value: Uint8Array<ArrayBufferLike>;
+    } | {
+        tag: "Payload";
+        value: string;
+    };
+}>;
+export declare const SignRawV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}, (Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const SigningPayload: import("scale-ts").Codec<{
+    address: string;
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    era: `0x${string}`;
+    genesisHash: `0x${string}`;
+    method: `0x${string}`;
+    nonce: `0x${string}`;
+    specVersion: `0x${string}`;
+    tip: `0x${string}`;
+    transactionVersion: `0x${string}`;
+    signedExtensions: string[];
+    version: number;
+    assetId: `0x${string}` | undefined;
+    metadataHash: `0x${string}` | undefined;
+    mode: number | undefined;
+    withSignedTransaction: boolean | undefined;
+}>;
+export declare const SignPayloadV1_request: import("scale-ts").Codec<{
+    address: string;
+    blockHash: `0x${string}`;
+    blockNumber: `0x${string}`;
+    era: `0x${string}`;
+    genesisHash: `0x${string}`;
+    method: `0x${string}`;
+    nonce: `0x${string}`;
+    specVersion: `0x${string}`;
+    tip: `0x${string}`;
+    transactionVersion: `0x${string}`;
+    signedExtensions: string[];
+    version: number;
+    assetId: `0x${string}` | undefined;
+    metadataHash: `0x${string}` | undefined;
+    mode: number | undefined;
+    withSignedTransaction: boolean | undefined;
+}>;
+export declare const SignPayloadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    signature: `0x${string}`;
+    signedTransaction: `0x${string}` | undefined;
+}, (Error & {
+    name: "SigningErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "SigningErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "SigningErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/{interactions → protocol}/v1/sign.js

@@ -1,10 +1,10 @@
-import { Bytes, Enum, Option, Result, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
-import { GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
+import { Bytes, Option, Result, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
 // common structures
-export const SigningErr = Enum({
-    FailedToDecode: _void,
-    Rejected: _void,
-    Unknown: GenericErr,
+export const SigningErr = ErrEnum('SigningErr', {
+    FailedToDecode: [_void, 'Signing: failed to decode'],
+    Rejected: [_void, 'Signing: rejected'],
+    Unknown: [GenericErr, 'Signing: unknown error'],
 });
 export const SigningResult = Struct({
     signature: Hex(),

package/dist/{interactions → protocol}/v1/statementStore.d.ts

@@ -34,18 +34,72 @@ export declare const Statement: import("scale-ts").Codec<{
     topics: Uint8Array<ArrayBufferLike>[];
     data: Uint8Array<ArrayBufferLike> | undefined;
 }>;
-export declare const StatementProofErr: import("scale-ts").Codec<{
-    tag: "Unknown";
-    value: {
+export declare const StatementProofErr: [import("scale-ts").Encoder<(Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "UnableToSign";
-    value: undefined;
-} | {
-    tag: "UnknownAccount";
-    value: undefined;
-}>;
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "StatementProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StatementProofErr::UnableToSign";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "StatementProofErr::UnknownAccount";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "StatementProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StatementProofErr::UnableToSign";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "StatementProofErr::UnknownAccount";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly UnableToSign: import("../commonCodecs.js").ErrCodec<undefined, "StatementProofErr::UnableToSign">;
+    readonly UnknownAccount: import("../commonCodecs.js").ErrCodec<undefined, "StatementProofErr::UnknownAccount">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "StatementProofErr::Unknown">;
+};
 export declare const StatementStoreCreateProofV1_request: import("scale-ts").Codec<[[string, number], {
     proof: {
         tag: "Sr25519";
@@ -104,15 +158,18 @@ export declare const StatementStoreCreateProofV1_response: import("scale-ts").Co
         blockHash: Uint8Array<ArrayBufferLike>;
         event: bigint;
     };
-}, {
-    tag: "Unknown";
-    value: {
+}, (Error & {
+    name: "StatementProofErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "UnableToSign";
-    value: undefined;
-} | {
-    tag: "UnknownAccount";
-    value: undefined;
-}>>;
+}) | (Error & {
+    name: "StatementProofErr::UnableToSign";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "StatementProofErr::UnknownAccount";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/{interactions → protocol}/v1/statementStore.js

@@ -1,5 +1,5 @@
-import { Bytes, Enum, Option, Result, Struct, Tuple, Vector, _void, u32, u64 } from 'scale-ts';
-import { GenericErr } from '../commonCodecs.js';
+import { Bytes, Option, Result, Struct, Tuple, Vector, _void, u32, u64 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr } from '../commonCodecs.js';
 import { ProductAccountId } from './accounts.js';
 // structs definition
 export const Topic = Bytes(32);
@@ -38,10 +38,10 @@ export const Statement = Struct({
     data: Option(Bytes()),
 });
 // creating proof
-export const StatementProofErr = Enum({
-    UnableToSign: _void,
-    UnknownAccount: _void,
-    Unknown: GenericErr,
+export const StatementProofErr = ErrEnum('StatementProofErr', {
+    UnableToSign: [_void, 'StatementProof: unable to sign'],
+    UnknownAccount: [_void, 'StatementProof: unknown account'],
+    Unknown: [GenericErr, 'StatementProof: unknown error'],
 });
 export const StatementStoreCreateProofV1_request = Tuple(ProductAccountId, Statement);
 export const StatementStoreCreateProofV1_response = Result(StatementProof, StatementProofErr);

package/dist/protocol/v1/storage.d.ts

@@ -0,0 +1,87 @@
+export declare const StorageErr: [import("scale-ts").Encoder<(Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "StorageErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StorageErr::Full";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "StorageErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "StorageErr::Full";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly Full: import("../commonCodecs.js").ErrCodec<undefined, "StorageErr::Full">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "StorageErr::Unknown">;
+};
+export declare const StorageKey: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageValue: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const StorageReadV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageReadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike> | undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const StorageWriteV1_request: import("scale-ts").Codec<[`0x${string}`, Uint8Array<ArrayBufferLike>]>;
+export declare const StorageWriteV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const StorageClearV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const StorageClearV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "StorageErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "StorageErr::Full";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/{interactions → protocol}/v1/storage.js

@@ -1,9 +1,9 @@
-import { Bytes, Enum, Option, Result, Tuple, _void } from 'scale-ts';
-import { GenericErr, Hex } from '../commonCodecs.js';
+import { Bytes, Option, Result, Tuple, _void } from 'scale-ts';
+import { ErrEnum, GenericErr, Hex } from '../commonCodecs.js';
 // common structures
-export const StorageErr = Enum({
-    Full: _void,
-    Unknown: GenericErr,
+export const StorageErr = ErrEnum('StorageErr', {
+    Full: [_void, 'Storage is full'],
+    Unknown: [GenericErr, 'Storage: unknown error'],
 });
 export const StorageKey = Hex();
 export const StorageValue = Bytes();

package/dist/provider.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from './types.js';
+export type Provider = {
+    logger: Logger;
+    isCorrectEnvironment(): boolean;
+    postMessage(message: Uint8Array): void;
+    subscribe(callback: (message: Uint8Array) => void): () => void;
+    dispose(): void;
+};

package/dist/provider.js

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

package/dist/transport.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from './provider.js';
+import type { Transport } from './types.js';
+export declare function createTransport(provider: Provider): Transport;

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;
+}