@novasamatech/host-api-wrapper 0.7.9-5

package/dist/injectWeb3.js

@@ -0,0 +1,157 @@
+import { assertEnumVariant, createHostApi, enumValue, fromHex, toHex } from '@novasamatech/host-api';
+import { injectExtension } from '@polkadot/extension-inject';
+import { AccountId } from 'polkadot-api';
+import { createAccountsProvider } from './accounts.js';
+import { SpektrExtensionName, Version } from './constants.js';
+import { sandboxTransport } from './sandboxTransport.js';
+const UNSUPPORTED_VERSION_ERROR = 'Unsupported message version';
+export async function createLegacyExtensionEnableFactory(transport) {
+    const ready = await transport.isReady();
+    if (!ready)
+        return null;
+    const accountsManager = createAccountsProvider(transport);
+    const hostApi = createHostApi(transport);
+    const accountId = AccountId();
+    async function enable() {
+        async function getAccounts() {
+            return await accountsManager
+                .getLegacyAccounts()
+                .map(response => {
+                return response.map(account => ({
+                    name: account.name,
+                    address: accountId.dec(account.publicKey),
+                    type: 'sr25519',
+                }));
+            })
+                .match(x => x, x => {
+                throw x;
+            });
+        }
+        return {
+            accounts: {
+                async get() {
+                    return getAccounts();
+                },
+                subscribe(callback) {
+                    getAccounts().then(callback);
+                    return () => {
+                        // empty
+                    };
+                },
+            },
+            signer: {
+                async signRaw(raw) {
+                    const payload = {
+                        signer: raw.address,
+                        payload: raw.type === 'bytes'
+                            ? {
+                                tag: 'Bytes',
+                                value: fromHex(raw.data),
+                            }
+                            : {
+                                tag: 'Payload',
+                                value: raw.data,
+                            },
+                    };
+                    const response = await hostApi.signRawWithLegacyAccount(enumValue('v1', payload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                },
+                async signPayload(payload) {
+                    const codecPayload = {
+                        signer: payload.address,
+                        payload: {
+                            blockHash: payload.blockHash,
+                            blockNumber: payload.blockNumber,
+                            era: payload.era,
+                            genesisHash: payload.genesisHash,
+                            nonce: payload.nonce,
+                            method: payload.method,
+                            specVersion: payload.specVersion,
+                            transactionVersion: payload.transactionVersion,
+                            metadataHash: payload.metadataHash,
+                            tip: payload.tip,
+                            assetId: payload.assetId,
+                            mode: payload.mode,
+                            withSignedTransaction: payload.withSignedTransaction,
+                            signedExtensions: payload.signedExtensions,
+                            version: payload.version,
+                        },
+                    };
+                    const response = await hostApi.signPayloadWithLegacyAccount(enumValue('v1', codecPayload));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return {
+                            id: 0,
+                            signature: response.value.signature,
+                            signedTransaction: response.value.signedTransaction,
+                        };
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                },
+                async createTransaction(payload) {
+                    if (payload.version !== 1) {
+                        throw new Error(`Signer support only v1 transaction, got version = ${payload.version}`);
+                    }
+                    const { signer } = payload;
+                    if (!signer) {
+                        throw new Error("Signer can't route transaction to the right account without signer hint.");
+                    }
+                    const checkGenesis = payload.extensions.find(x => x.id === 'CheckGenesis');
+                    if (!checkGenesis) {
+                        throw new Error("Can't find genesis hash on transaction");
+                    }
+                    const possibleAccountId = accountId.enc(signer);
+                    const response = await hostApi.createTransactionWithLegacyAccount(enumValue('v1', {
+                        signer: possibleAccountId,
+                        genesisHash: fromHex(checkGenesis.additionalSigned),
+                        callData: fromHex(payload.callData),
+                        txExtVersion: payload.txExtVersion,
+                        extensions: payload.extensions.map(e => ({
+                            id: e.id,
+                            additionalSigned: fromHex(e.additionalSigned),
+                            extra: fromHex(e.extra),
+                        })),
+                    }));
+                    return response.match(response => {
+                        assertEnumVariant(response, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        return toHex(response.value);
+                    }, err => {
+                        assertEnumVariant(err, 'v1', UNSUPPORTED_VERSION_ERROR);
+                        throw err.value;
+                    });
+                },
+            },
+        };
+    }
+    return enable;
+}
+export async function injectSpektrExtension(transport = sandboxTransport) {
+    if (!transport)
+        return false;
+    try {
+        const enable = await createLegacyExtensionEnableFactory(transport);
+        if (enable) {
+            injectExtension(enable, { name: SpektrExtensionName, version: Version });
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    catch (e) {
+        transport.provider.logger.error('Error injecting extension', e);
+        return false;
+    }
+}

package/dist/localStorage.d.ts

@@ -0,0 +1,18 @@
+export declare const createLocalStorage: (transport?: import("@novasamatech/host-api").Transport) => {
+    clear(key: string): Promise<undefined>;
+    readBytes(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    writeBytes(key: string, value: Uint8Array): Promise<undefined>;
+    readString(key: string): Promise<string>;
+    writeString(key: string, value: string): Promise<undefined>;
+    readJSON(key: string): Promise<any>;
+    writeJSON(key: string, value: unknown): Promise<undefined>;
+};
+export declare const hostLocalStorage: {
+    clear(key: string): Promise<undefined>;
+    readBytes(key: string): Promise<Uint8Array<ArrayBufferLike> | undefined>;
+    writeBytes(key: string, value: Uint8Array): Promise<undefined>;
+    readString(key: string): Promise<string>;
+    writeString(key: string, value: string): Promise<undefined>;
+    readJSON(key: string): Promise<any>;
+    writeJSON(key: string, value: unknown): Promise<undefined>;
+};

package/dist/localStorage.js

@@ -0,0 +1,44 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createLocalStorage = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder();
+    function readBytes(key) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageRead(enumValue(supportedVersion, key))));
+    }
+    function writeBytes(key, value) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageWrite(enumValue(supportedVersion, [key, value]))));
+    }
+    function clearKey(key) {
+        return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.localStorageClear(enumValue(supportedVersion, key))));
+    }
+    return {
+        async clear(key) {
+            return clearKey(key);
+        },
+        async readBytes(key) {
+            return readBytes(key);
+        },
+        async writeBytes(key, value) {
+            return writeBytes(key, value);
+        },
+        async readString(key) {
+            return readBytes(key).then(bytes => textDecoder.decode(bytes));
+        },
+        async writeString(key, value) {
+            return writeBytes(key, textEncoder.encode(value));
+        },
+        async readJSON(key) {
+            return readBytes(key)
+                .then(bytes => textDecoder.decode(bytes))
+                .then(JSON.parse);
+        },
+        async writeJSON(key, value) {
+            return writeBytes(key, textEncoder.encode(JSON.stringify(value)));
+        },
+    };
+};
+export const hostLocalStorage = createLocalStorage();

package/dist/metaProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ConnectionStatus, Transport } from '@novasamatech/host-api';
+export declare function createMetaProvider(transport?: Transport): {
+    subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
+};
+export declare const metaProvider: {
+    subscribeConnectionStatus(callback: (connectionStatus: ConnectionStatus) => void): VoidFunction;
+};

package/dist/metaProvider.js

@@ -0,0 +1,24 @@
+import { sandboxTransport } from './sandboxTransport.js';
+export function createMetaProvider(transport = sandboxTransport) {
+    // if (transport.isCorrectEnvironment() && typeof window !== 'undefined') {
+    //   const getUrl = () => {
+    //     return window.location.pathname + window.location.hash + window.location.search;
+    //   };
+    //
+    //   window.addEventListener('hashchange', () => {
+    //     transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    //   });
+    //
+    //   window.addEventListener('popstate', () => {
+    //     transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    //   });
+    //
+    //   transport.postMessage('_', { tag: 'locationChangedV1', value: getUrl() });
+    // }
+    return {
+        subscribeConnectionStatus(callback) {
+            return transport.onConnectionStatusChange(callback);
+        },
+    };
+}
+export const metaProvider = createMetaProvider();

package/dist/notification.d.ts

@@ -0,0 +1,15 @@
+export type NotificationId = number;
+export type PushNotificationInput = {
+    text: string;
+    deeplink?: string;
+    /** Unix timestamp in milliseconds (UTC). Omit for immediate delivery. Past values fire immediately. */
+    scheduledAt?: number;
+};
+export declare const createNotificationManager: (transport?: import("@novasamatech/host-api").Transport) => {
+    push({ text, deeplink, scheduledAt }: PushNotificationInput): Promise<NotificationId>;
+    cancel(id: NotificationId): Promise<void>;
+};
+export declare const notificationManager: {
+    push({ text, deeplink, scheduledAt }: PushNotificationInput): Promise<NotificationId>;
+    cancel(id: NotificationId): Promise<void>;
+};

package/dist/notification.js

@@ -0,0 +1,20 @@
+import { createHostApi, enumValue } from '@novasamatech/host-api';
+import { resultToPromise, unwrapVersionedResult } from './helpers.js';
+import { sandboxTransport } from './sandboxTransport.js';
+export const createNotificationManager = (transport = sandboxTransport) => {
+    const supportedVersion = 'v1';
+    const hostApi = createHostApi(transport);
+    return {
+        push({ text, deeplink, scheduledAt }) {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.pushNotification(enumValue(supportedVersion, {
+                text,
+                deeplink,
+                scheduledAt: scheduledAt === undefined ? undefined : BigInt(scheduledAt),
+            }))));
+        },
+        cancel(id) {
+            return resultToPromise(unwrapVersionedResult(supportedVersion, hostApi.pushNotificationCancel(enumValue(supportedVersion, id))));
+        },
+    };
+};
+export const notificationManager = createNotificationManager();

package/dist/papiProvider.d.ts

@@ -0,0 +1,7 @@
+import type { HexString, Transport } from '@novasamatech/host-api';
+import type { JsonRpcProvider } from 'polkadot-api';
+type InternalParams = {
+    transport?: Transport;
+};
+export declare function createPapiProvider(genesisHash: HexString, __fallback?: JsonRpcProvider, internal?: InternalParams): JsonRpcProvider;
+export {};

package/dist/papiProvider.js

@@ -0,0 +1,349 @@
+import { createHostApi, enumValue, unwrapResultOrThrow } from '@novasamatech/host-api';
+import { getSyncProvider } from '@polkadot-api/json-rpc-provider-proxy';
+import { sandboxTransport } from './sandboxTransport.js';
+export function createPapiProvider(genesisHash, 
+// for testing purposes only, should not be used in real production code
+__fallback, internal) {
+    const version = 'v1';
+    const transport = internal?.transport ?? sandboxTransport;
+    if (!transport.isCorrectEnvironment()) {
+        throw new Error('PapiProvider can only be used in a product environment');
+    }
+    const hostApi = createHostApi(transport);
+    const typedProvider = onMessage => {
+        const activeFollows = new Map();
+        const activeBroadcasts = new Set();
+        let nextSubId = 0;
+        function getNextSubId() {
+            return `follow_${nextSubId++}`;
+        }
+        function sendJsonRpcResponse(id, result) {
+            onMessage({ jsonrpc: '2.0', id, result });
+        }
+        function sendJsonRpcError(id, code, message) {
+            onMessage({ jsonrpc: '2.0', id, error: { code, message } });
+        }
+        function sendFollowEvent(syntheticSubId, event) {
+            onMessage({
+                jsonrpc: '2.0',
+                method: 'chainHead_v1_followEvent',
+                params: { subscription: syntheticSubId, result: event },
+            });
+        }
+        function convertTypedEventToJsonRpc(event) {
+            switch (event.tag) {
+                case 'Initialized': {
+                    const v = event.value;
+                    return {
+                        event: 'initialized',
+                        finalizedBlockHashes: v.finalizedBlockHashes,
+                        finalizedBlockRuntime: convertRuntimeToJsonRpc(v.finalizedBlockRuntime),
+                    };
+                }
+                case 'NewBlock': {
+                    const v = event.value;
+                    return {
+                        event: 'newBlock',
+                        blockHash: v.blockHash,
+                        parentBlockHash: v.parentBlockHash,
+                        newRuntime: convertRuntimeToJsonRpc(v.newRuntime),
+                    };
+                }
+                case 'BestBlockChanged': {
+                    const v = event.value;
+                    return { event: 'bestBlockChanged', bestBlockHash: v.bestBlockHash };
+                }
+                case 'Finalized': {
+                    const v = event.value;
+                    return {
+                        event: 'finalized',
+                        finalizedBlockHashes: v.finalizedBlockHashes,
+                        prunedBlockHashes: v.prunedBlockHashes,
+                    };
+                }
+                case 'OperationBodyDone': {
+                    const v = event.value;
+                    return { event: 'operationBodyDone', operationId: v.operationId, value: v.value };
+                }
+                case 'OperationCallDone': {
+                    const v = event.value;
+                    return { event: 'operationCallDone', operationId: v.operationId, output: v.output };
+                }
+                case 'OperationStorageItems': {
+                    const v = event.value;
+                    return {
+                        event: 'operationStorageItems',
+                        operationId: v.operationId,
+                        items: v.items,
+                    };
+                }
+                case 'OperationStorageDone': {
+                    const v = event.value;
+                    return { event: 'operationStorageDone', operationId: v.operationId };
+                }
+                case 'OperationWaitingForContinue': {
+                    const v = event.value;
+                    return { event: 'operationWaitingForContinue', operationId: v.operationId };
+                }
+                case 'OperationInaccessible': {
+                    const v = event.value;
+                    return { event: 'operationInaccessible', operationId: v.operationId };
+                }
+                case 'OperationError': {
+                    const v = event.value;
+                    return { event: 'operationError', operationId: v.operationId, error: v.error };
+                }
+                case 'Stop':
+                    return { event: 'stop' };
+                default:
+                    return { event: 'stop' };
+            }
+        }
+        function convertRuntimeToJsonRpc(runtime) {
+            if (!runtime || typeof runtime !== 'object')
+                return null;
+            const rt = runtime;
+            if (rt.tag === 'Valid') {
+                const spec = rt.value;
+                const apisObj = {};
+                for (const [name, ver] of spec.apis) {
+                    apisObj[name] = ver;
+                }
+                return {
+                    type: 'valid',
+                    spec: {
+                        specName: spec.specName,
+                        implName: spec.implName,
+                        specVersion: spec.specVersion,
+                        implVersion: spec.implVersion,
+                        transactionVersion: spec.transactionVersion,
+                        apis: apisObj,
+                    },
+                };
+            }
+            if (rt.tag === 'Invalid') {
+                const v = rt.value;
+                return { type: 'invalid', error: v.error };
+            }
+            return null;
+        }
+        function convertStorageTypeToTyped(type) {
+            const map = {
+                value: 'Value',
+                hash: 'Hash',
+                closestDescendantMerkleValue: 'ClosestDescendantMerkleValue',
+                descendantsValues: 'DescendantsValues',
+                descendantsHashes: 'DescendantsHashes',
+            };
+            return map[type] ?? 'Value';
+        }
+        function convertOperationResultToJsonRpc(result) {
+            if (result.tag === 'Started') {
+                const v = result.value;
+                return { result: 'started', operationId: v.operationId };
+            }
+            return { result: 'limitReached' };
+        }
+        function handleMessage(message) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const id = message.id;
+            const { method, params } = message;
+            switch (method) {
+                case 'chainHead_v1_follow': {
+                    const [withRuntime] = params;
+                    const syntheticSubId = getNextSubId();
+                    const subscription = hostApi.chainHeadFollowSubscribe(enumValue(version, { genesisHash, withRuntime }), payload => {
+                        if (payload.tag !== version)
+                            return;
+                        const typed = payload.value;
+                        // On Stop, release the host-api subscription BEFORE forwarding
+                        // the event. The consumer's substrate-client refollows
+                        // synchronously inside the event handler; transport.subscribe
+                        // dedupes by (method, payload-hash), so unless this dead
+                        // subscription is gone first, the refollow's subscribe shares
+                        // it and never reaches the host — events stop flowing.
+                        if (typed.tag === 'Stop' && activeFollows.delete(syntheticSubId)) {
+                            subscription.unsubscribe();
+                        }
+                        sendFollowEvent(syntheticSubId, convertTypedEventToJsonRpc(typed));
+                    });
+                    activeFollows.set(syntheticSubId, { syntheticSubId, subscription, genesisHash });
+                    sendJsonRpcResponse(id, syntheticSubId);
+                    break;
+                }
+                case 'chainHead_v1_unfollow': {
+                    const [followSubId] = params;
+                    const follow = activeFollows.get(followSubId);
+                    if (follow) {
+                        follow.subscription.unsubscribe();
+                        activeFollows.delete(followSubId);
+                    }
+                    sendJsonRpcResponse(id, null);
+                    break;
+                }
+                case 'chainHead_v1_header': {
+                    const [followSubId, hash] = params;
+                    hostApi.chainHeadHeader(enumValue(version, { genesisHash, followSubscriptionId: followSubId, hash })).match(result => sendJsonRpcResponse(id, result.value), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_body': {
+                    const [followSubId, hash] = params;
+                    hostApi.chainHeadBody(enumValue(version, { genesisHash, followSubscriptionId: followSubId, hash })).match(result => sendJsonRpcResponse(id, convertOperationResultToJsonRpc(result.value)), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_storage': {
+                    const [followSubId, hash, items, childTrie] = params;
+                    const typedItems = items.map(item => ({
+                        key: item.key,
+                        type: convertStorageTypeToTyped(item.type),
+                    }));
+                    hostApi
+                        .chainHeadStorage(enumValue(version, {
+                        genesisHash,
+                        followSubscriptionId: followSubId,
+                        hash,
+                        items: typedItems,
+                        childTrie,
+                    }))
+                        .match(result => sendJsonRpcResponse(id, convertOperationResultToJsonRpc(result.value)), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_call': {
+                    const [followSubId, hash, fn, callParameters] = params;
+                    hostApi
+                        .chainHeadCall(enumValue(version, {
+                        genesisHash,
+                        followSubscriptionId: followSubId,
+                        hash,
+                        function: fn,
+                        callParameters,
+                    }))
+                        .match(result => sendJsonRpcResponse(id, convertOperationResultToJsonRpc(result.value)), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_unpin': {
+                    const [followSubId, hashOrHashes] = params;
+                    const hashes = Array.isArray(hashOrHashes) ? hashOrHashes : [hashOrHashes];
+                    hostApi.chainHeadUnpin(enumValue(version, { genesisHash, followSubscriptionId: followSubId, hashes })).match(() => sendJsonRpcResponse(id, null), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_continue': {
+                    const [followSubId, operationId] = params;
+                    hostApi
+                        .chainHeadContinue(enumValue(version, { genesisHash, followSubscriptionId: followSubId, operationId }))
+                        .match(() => sendJsonRpcResponse(id, null), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainHead_v1_stopOperation': {
+                    const [followSubId, operationId] = params;
+                    hostApi
+                        .chainHeadStopOperation(enumValue(version, { genesisHash, followSubscriptionId: followSubId, operationId }))
+                        .match(() => sendJsonRpcResponse(id, null), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainSpec_v1_genesisHash': {
+                    hostApi.chainSpecGenesisHash(enumValue(version, genesisHash)).match(result => sendJsonRpcResponse(id, result.value), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainSpec_v1_chainName': {
+                    hostApi.chainSpecChainName(enumValue(version, genesisHash)).match(result => sendJsonRpcResponse(id, result.value), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'chainSpec_v1_properties': {
+                    hostApi.chainSpecProperties(enumValue(version, genesisHash)).match(result => {
+                        try {
+                            sendJsonRpcResponse(id, JSON.parse(result.value));
+                        }
+                        catch {
+                            sendJsonRpcResponse(id, result.value);
+                        }
+                    }, error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'transaction_v1_broadcast': {
+                    const [transaction] = params;
+                    hostApi.chainTransactionBroadcast(enumValue(version, { genesisHash, transaction })).match(result => {
+                        if (result.value !== null) {
+                            activeBroadcasts.add(result.value);
+                        }
+                        sendJsonRpcResponse(id, result.value);
+                    }, error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                case 'transaction_v1_stop': {
+                    const [operationId] = params;
+                    activeBroadcasts.delete(operationId);
+                    hostApi.chainTransactionStop(enumValue(version, { genesisHash, operationId })).match(() => sendJsonRpcResponse(id, null), error => sendJsonRpcError(id, -32603, error.value.payload.reason));
+                    break;
+                }
+                default: {
+                    sendJsonRpcError(id, -32601, `Method "${method}" is not supported by HostAPI`);
+                    break;
+                }
+            }
+        }
+        return {
+            send(message) {
+                handleMessage(message);
+            },
+            disconnect() {
+                for (const follow of activeFollows.values()) {
+                    follow.subscription.unsubscribe();
+                }
+                activeFollows.clear();
+                for (const operationId of activeBroadcasts) {
+                    hostApi.chainTransactionStop(enumValue(version, { genesisHash, operationId })).match(() => {
+                        /* fire-and-forget on disconnect */
+                    }, () => {
+                        /* transport may already be torn down */
+                    });
+                }
+                activeBroadcasts.clear();
+            },
+        };
+    };
+    function checkIfReady() {
+        return transport.isReady().then(ready => {
+            if (!ready)
+                return false;
+            return transport
+                .request('host_feature_supported', enumValue('v1', enumValue('Chain', genesisHash)))
+                .then(payload => {
+                switch (payload.tag) {
+                    case 'v1': {
+                        return unwrapResultOrThrow(payload.value, e => new Error(e.payload.reason));
+                    }
+                    default:
+                        throw new Error(`Unknown message version ${payload.tag}`);
+                }
+            })
+                .catch(e => {
+                transport.provider.logger.error('Error checking chain support', e);
+                return false;
+            });
+        });
+    }
+    return getSyncProvider(onResult => {
+        checkIfReady().then(ready => {
+            if (ready) {
+                onResult((onMessage, _onHalt) => typedProvider(onMessage));
+            }
+            else if (__fallback) {
+                onResult((onMessage, _onHalt) => __fallback(onMessage));
+            }
+            else {
+                onResult((_onMessage, _onHalt) => ({
+                    send() {
+                        transport.provider.logger.error(`Provider for chain ${genesisHash} was not started because Host doesn't support it`);
+                    },
+                    disconnect() {
+                        /* empty */
+                    },
+                }));
+            }
+        });
+        return () => {
+            /* empty */
+        };
+    });
+}