@novasamatech/host-api 0.5.4 → 0.5.5

package/README.md

@@ -90,7 +90,7 @@ const hostApi = createHostApi(transport);
 
 // requesting data
 
-const storageValue = hostApi.storage_read(payload);
+const storageValue = hostApi.localStorageRead(payload);
 
 storageValue.match(
   (data) => console.log('success:', data),
@@ -99,7 +99,7 @@ storageValue.match(
 
 // subscribing to events
 
-const subscription = hostApi.chat_action_subscribe(params, (action) => {
+const subscription = hostApi.chatActionSubscribe(params, (action) => {
   console.log('action received:', action);
 });
 

package/dist/hostApi.d.ts

@@ -3,6 +3,7 @@ import type { Codec, CodecType } from 'scale-ts';
 import type { HostApiProtocol, VersionedProtocolRequest, VersionedProtocolSubscription } from './protocol/impl.js';
 import type { Subscription, Transport } from './types.js';
 type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
+type StripNamespace<S extends string> = S extends `host_${infer Rest}` ? Rest : S extends `remote_${infer Rest}` ? Rest : S;
 type Value<T extends Codec<any> | Codec<never>> = T extends Codec<any> ? CodecType<T> : unknown;
 type UnwrapVersionedResult<T> = T extends {
     tag: infer Tag;
@@ -26,7 +27,7 @@ type InferRequestMethod<Method extends VersionedProtocolRequest> = (args: Value<
 type InferSubscribeMethod<Method extends VersionedProtocolSubscription> = (args: Value<Method['start']>, callback: (payload: Value<Method['receive']>) => void) => Subscription;
 type InferMethod<Method extends VersionedProtocolRequest | VersionedProtocolSubscription> = Method extends VersionedProtocolRequest ? InferRequestMethod<Method> : Method extends VersionedProtocolSubscription ? InferSubscribeMethod<Method> : never;
 export type HostApi = {
-    [K in keyof HostApiProtocol as SnakeToCamelCase<K>]: InferMethod<HostApiProtocol[K]>;
+    [K in keyof HostApiProtocol as SnakeToCamelCase<StripNamespace<K>>]: InferMethod<HostApiProtocol[K]>;
 };
 export declare function createHostApi(transport: Transport): HostApi;
 export {};

package/dist/hostApi.js

@@ -5,13 +5,15 @@ import { CreateProofErr, RequestCredentialsErr } from './protocol/v1/accounts.js
 import { ChatBotRegistrationErr, ChatMessagePostingErr, ChatRoomRegistrationErr } from './protocol/v1/chat.js';
 import { CreateTransactionErr } from './protocol/v1/createTransaction.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
+import { StorageErr } from './protocol/v1/localStorage.js';
+import { NavigateToErr } from './protocol/v1/navigation.js';
+import { PreimageSubmitErr } from './protocol/v1/preimage.js';
 import { SigningErr } from './protocol/v1/sign.js';
 import { StatementProofErr } from './protocol/v1/statementStore.js';
-import { StorageErr } from './protocol/v1/storage.js';
 export function createHostApi(transport) {
     return {
         handshake(payload) {
-            const response = fromPromise(transport.request('handshake', payload), e => ({
+            const response = fromPromise(transport.request('host_handshake', payload), e => ({
                 tag: payload.tag,
                 value: new HandshakeErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -28,8 +30,8 @@ export function createHostApi(transport) {
                 });
             });
         },
-        feature(payload) {
-            const response = fromPromise(transport.request('feature', payload), e => ({
+        featureSupported(payload) {
+            const response = fromPromise(transport.request('host_feature_supported', payload), e => ({
                 tag: payload.tag,
                 value: new GenericError({ reason: extractErrorMessage(e) }),
             }));
@@ -46,8 +48,80 @@ export function createHostApi(transport) {
                 });
             });
         },
+        devicePermission(payload) {
+            const response = fromPromise(transport.request('host_device_permission', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        permission(payload) {
+            const response = fromPromise(transport.request('remote_permission', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        pushNotification(payload) {
+            const response = fromPromise(transport.request('host_push_notification', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        navigateTo(payload) {
+            const response = fromPromise(transport.request('host_navigate_to', payload), e => ({
+                tag: payload.tag,
+                value: new NavigateToErr.Unknown({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
         localStorageRead(payload) {
-            const response = fromPromise(transport.request('local_storage_read', payload), e => ({
+            const response = fromPromise(transport.request('host_local_storage_read', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -65,7 +139,7 @@ export function createHostApi(transport) {
             });
         },
         localStorageWrite(payload) {
-            const response = fromPromise(transport.request('local_storage_write', payload), e => ({
+            const response = fromPromise(transport.request('host_local_storage_write', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -83,7 +157,7 @@ export function createHostApi(transport) {
             });
         },
         localStorageClear(payload) {
-            const response = fromPromise(transport.request('local_storage_clear', payload), e => ({
+            const response = fromPromise(transport.request('host_local_storage_clear', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -101,7 +175,7 @@ export function createHostApi(transport) {
             });
         },
         accountGet(payload) {
-            const response = fromPromise(transport.request('account_get', payload), e => ({
+            const response = fromPromise(transport.request('host_account_get', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -119,7 +193,7 @@ export function createHostApi(transport) {
             });
         },
         accountGetAlias(payload) {
-            const response = fromPromise(transport.request('account_get_alias', payload), e => ({
+            const response = fromPromise(transport.request('host_account_get_alias', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -137,7 +211,7 @@ export function createHostApi(transport) {
             });
         },
         accountCreateProof(payload) {
-            const response = fromPromise(transport.request('account_create_proof', payload), e => ({
+            const response = fromPromise(transport.request('host_account_create_proof', payload), e => ({
                 tag: payload.tag,
                 value: new CreateProofErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -155,7 +229,7 @@ export function createHostApi(transport) {
             });
         },
         getNonProductAccounts(payload) {
-            const response = fromPromise(transport.request('get_non_product_accounts', payload), e => ({
+            const response = fromPromise(transport.request('host_get_non_product_accounts', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -173,7 +247,7 @@ export function createHostApi(transport) {
             });
         },
         createTransaction(payload) {
-            const response = fromPromise(transport.request('create_transaction', payload), e => ({
+            const response = fromPromise(transport.request('host_create_transaction', payload), e => ({
                 tag: payload.tag,
                 value: new CreateTransactionErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -191,7 +265,7 @@ export function createHostApi(transport) {
             });
         },
         createTransactionWithNonProductAccount(payload) {
-            const response = fromPromise(transport.request('create_transaction_with_non_product_account', payload), e => ({
+            const response = fromPromise(transport.request('host_create_transaction_with_non_product_account', payload), e => ({
                 tag: payload.tag,
                 value: new CreateTransactionErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -209,7 +283,7 @@ export function createHostApi(transport) {
             });
         },
         signRaw(payload) {
-            const response = fromPromise(transport.request('sign_raw', payload), e => ({
+            const response = fromPromise(transport.request('host_sign_raw', payload), e => ({
                 tag: payload.tag,
                 value: new SigningErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -227,7 +301,7 @@ export function createHostApi(transport) {
             });
         },
         signPayload(payload) {
-            const response = fromPromise(transport.request('sign_payload', payload), e => ({
+            const response = fromPromise(transport.request('host_sign_payload', payload), e => ({
                 tag: payload.tag,
                 value: new SigningErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -245,10 +319,10 @@ export function createHostApi(transport) {
             });
         },
         chatListSubscribe(args, callback) {
-            return transport.subscribe('chat_list_subscribe', args, callback);
+            return transport.subscribe('host_chat_list_subscribe', args, callback);
         },
         chatCreateRoom(payload) {
-            const response = fromPromise(transport.request('chat_create_room', payload), e => ({
+            const response = fromPromise(transport.request('host_chat_create_room', payload), e => ({
                 tag: payload.tag,
                 value: new ChatRoomRegistrationErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -266,7 +340,7 @@ export function createHostApi(transport) {
             });
         },
         chatRegisterBot(payload) {
-            const response = fromPromise(transport.request('chat_register_bot', payload), e => ({
+            const response = fromPromise(transport.request('host_chat_register_bot', payload), e => ({
                 tag: payload.tag,
                 value: new ChatBotRegistrationErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -284,7 +358,7 @@ export function createHostApi(transport) {
             });
         },
         chatPostMessage(payload) {
-            const response = fromPromise(transport.request('chat_post_message', payload), e => ({
+            const response = fromPromise(transport.request('host_chat_post_message', payload), e => ({
                 tag: payload.tag,
                 value: new ChatMessagePostingErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -302,12 +376,15 @@ export function createHostApi(transport) {
             });
         },
         chatActionSubscribe(args, callback) {
-            return transport.subscribe('chat_action_subscribe', args, callback);
+            return transport.subscribe('host_chat_action_subscribe', args, callback);
         },
-        statementStoreQuery(payload) {
-            const response = fromPromise(transport.request('statement_store_query', payload), e => ({
+        statementStoreSubscribe(args, callback) {
+            return transport.subscribe('remote_statement_store_subscribe', args, callback);
+        },
+        statementStoreCreateProof(payload) {
+            const response = fromPromise(transport.request('remote_statement_store_create_proof', payload), e => ({
                 tag: payload.tag,
-                value: new GenericError({ reason: extractErrorMessage(e) }),
+                value: new StatementProofErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
             return response.andThen(response => {
                 if (response.value.success) {
@@ -322,13 +399,10 @@ export function createHostApi(transport) {
                 });
             });
         },
-        statementStoreSubscribe(args, callback) {
-            return transport.subscribe('statement_store_subscribe', args, callback);
-        },
-        statementStoreCreateProof(payload) {
-            const response = fromPromise(transport.request('statement_store_create_proof', payload), e => ({
+        statementStoreSubmit(payload) {
+            const response = fromPromise(transport.request('remote_statement_store_submit', payload), e => ({
                 tag: payload.tag,
-                value: new StatementProofErr.Unknown({ reason: extractErrorMessage(e) }),
+                value: new GenericError({ reason: extractErrorMessage(e) }),
             }));
             return response.andThen(response => {
                 if (response.value.success) {
@@ -343,10 +417,13 @@ export function createHostApi(transport) {
                 });
             });
         },
-        statementStoreSubmit(payload) {
-            const response = fromPromise(transport.request('statement_store_submit', payload), e => ({
+        preimageLookupSubscribe(args, callback) {
+            return transport.subscribe('remote_preimage_lookup_subscribe', args, callback);
+        },
+        preimageSubmit(payload) {
+            const response = fromPromise(transport.request('remote_preimage_submit', payload), e => ({
                 tag: payload.tag,
-                value: new GenericError({ reason: extractErrorMessage(e) }),
+                value: new PreimageSubmitErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
             return response.andThen(response => {
                 if (response.value.success) {
@@ -362,7 +439,7 @@ export function createHostApi(transport) {
             });
         },
         jsonrpcMessageSend(payload) {
-            const response = fromPromise(transport.request('jsonrpc_message_send', payload), e => ({
+            const response = fromPromise(transport.request('host_jsonrpc_message_send', payload), e => ({
                 tag: payload.tag,
                 value: new GenericError({ reason: extractErrorMessage(e) }),
             }));
@@ -380,7 +457,7 @@ export function createHostApi(transport) {
             });
         },
         jsonrpcMessageSubscribe(args, callback) {
-            return transport.subscribe('jsonrpc_message_subscribe', args, callback);
+            return transport.subscribe('host_jsonrpc_message_subscribe', args, callback);
         },
     };
 }

package/dist/index.d.ts

@@ -17,4 +17,9 @@ export { ChatActionPayload, ChatBotRegistrationErr, ChatBotRegistrationStatus, C
 export { HandshakeErr } from './protocol/v1/handshake.js';
 export { SigningErr } from './protocol/v1/sign.js';
 export { SignedStatement, Statement, StatementProofErr, Topic } from './protocol/v1/statementStore.js';
-export { StorageErr } from './protocol/v1/storage.js';
+export { StorageErr } from './protocol/v1/localStorage.js';
+export { DevicePermissionRequest } from './protocol/v1/devicePermission.js';
+export { RemotePermissionRequest } from './protocol/v1/remotePermission.js';
+export { PushNotification } from './protocol/v1/notification.js';
+export { NavigateToErr } from './protocol/v1/navigation.js';
+export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';

package/dist/index.js

@@ -12,4 +12,9 @@ export { ChatActionPayload, ChatBotRegistrationErr, ChatBotRegistrationStatus, C
 export { HandshakeErr } from './protocol/v1/handshake.js';
 export { SigningErr } from './protocol/v1/sign.js';
 export { SignedStatement, Statement, StatementProofErr, Topic } from './protocol/v1/statementStore.js';
-export { StorageErr } from './protocol/v1/storage.js';
+export { StorageErr } from './protocol/v1/localStorage.js';
+export { DevicePermissionRequest } from './protocol/v1/devicePermission.js';
+export { RemotePermissionRequest } from './protocol/v1/remotePermission.js';
+export { PushNotification } from './protocol/v1/notification.js';
+export { NavigateToErr } from './protocol/v1/navigation.js';
+export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';

package/dist/protocol/impl.d.ts

@@ -16,12 +16,12 @@ export type VersionedProtocolSubscription<T extends VersionedArguments = Version
 };
 export type HostApiProtocol = typeof hostApiProtocol;
 export declare const hostApiProtocol: {
-    readonly handshake: VersionedProtocolRequest<{
+    readonly host_handshake: VersionedProtocolRequest<{
         readonly v1: [Codec<number>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "HandshakeErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "HandshakeErr::Timeout"> | import("@novasamatech/scale").CodecError<undefined, "HandshakeErr::UnsupportedProtocolVersion">>>];
     }>;
-    readonly feature: VersionedProtocolRequest<{
+    readonly host_feature_supported: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             tag: "Chain";
             value: `0x${string}`;
@@ -29,22 +29,51 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "GenericError">>>];
     }>;
-    readonly local_storage_read: VersionedProtocolRequest<{
+    readonly host_push_notification: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            text: string;
+            deeplink: string | undefined;
+        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly host_navigate_to: VersionedProtocolRequest<{
+        readonly v1: [Codec<string>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>>];
+    }>;
+    readonly host_device_permission: VersionedProtocolRequest<{
+        readonly v1: [Codec<"Camera" | "Microphone" | "Bluetooth" | "Location">, Codec<import("scale-ts").ResultPayload<boolean, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_permission: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            tag: "ExternalRequest";
+            value: string;
+        } | {
+            tag: "TransactionSubmit";
+            value: undefined;
+        }>, Codec<import("scale-ts").ResultPayload<boolean, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly host_local_storage_read: VersionedProtocolRequest<{
         readonly v1: [Codec<string>, Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike> | undefined, import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>];
     }>;
-    readonly local_storage_write: VersionedProtocolRequest<{
+    readonly host_local_storage_write: VersionedProtocolRequest<{
         readonly v1: [Codec<[string, Uint8Array<ArrayBufferLike>]>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>];
     }>;
-    readonly local_storage_clear: VersionedProtocolRequest<{
+    readonly host_local_storage_clear: VersionedProtocolRequest<{
         readonly v1: [Codec<string>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>];
     }>;
-    readonly account_get: VersionedProtocolRequest<{
+    readonly host_account_get: VersionedProtocolRequest<{
         readonly v1: [Codec<[string, number]>, Codec<import("scale-ts").ResultPayload<{
             publicKey: Uint8Array<ArrayBufferLike>;
             name: string | undefined;
@@ -52,7 +81,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "RequestCredentialsErr::Unknown">>>];
     }>;
-    readonly account_get_alias: VersionedProtocolRequest<{
+    readonly host_account_get_alias: VersionedProtocolRequest<{
         readonly v1: [Codec<[string, number]>, Codec<import("scale-ts").ResultPayload<{
             context: Uint8Array<ArrayBufferLike>;
             alias: Uint8Array<ArrayBufferLike>;
@@ -60,7 +89,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "RequestCredentialsErr::Unknown">>>];
     }>;
-    readonly account_create_proof: VersionedProtocolRequest<{
+    readonly host_account_create_proof: VersionedProtocolRequest<{
         readonly v1: [Codec<[[string, number], {
             genesisHash: `0x${string}`;
             ringRootHash: `0x${string}`;
@@ -71,7 +100,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "CreateProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateProofErr::RingNotFound">>>];
     }>;
-    readonly get_non_product_accounts: VersionedProtocolRequest<{
+    readonly host_get_non_product_accounts: VersionedProtocolRequest<{
         readonly v1: [Codec<undefined>, Codec<import("scale-ts").ResultPayload<{
             publicKey: Uint8Array<ArrayBufferLike>;
             name: string | undefined;
@@ -79,17 +108,17 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "RequestCredentialsErr::Unknown">>>];
     }>;
-    readonly create_transaction: VersionedProtocolRequest<{
+    readonly host_create_transaction: VersionedProtocolRequest<{
         readonly v1: [Codec<[[string, number], import("./v1/createTransaction.js").TxPayloadV1Public]>, Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "CreateTransactionErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::PermissionDenied"> | import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::FailedToDecode"> | import("@novasamatech/scale").CodecError<string, "CreateTransactionErr::NotSupported">>>];
     }>;
-    readonly create_transaction_with_non_product_account: VersionedProtocolRequest<{
+    readonly host_create_transaction_with_non_product_account: VersionedProtocolRequest<{
         readonly v1: [Codec<import("./v1/createTransaction.js").TxPayloadV1Public>, Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "CreateTransactionErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::PermissionDenied"> | import("@novasamatech/scale").CodecError<undefined, "CreateTransactionErr::FailedToDecode"> | import("@novasamatech/scale").CodecError<string, "CreateTransactionErr::NotSupported">>>];
     }>;
-    readonly sign_raw: VersionedProtocolRequest<{
+    readonly host_sign_raw: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             address: string;
             data: {
@@ -106,7 +135,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "SigningErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "SigningErr::PermissionDenied"> | import("@novasamatech/scale").CodecError<undefined, "SigningErr::FailedToDecode">>>];
     }>;
-    readonly sign_payload: VersionedProtocolRequest<{
+    readonly host_sign_payload: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             address: string;
             blockHash: `0x${string}`;
@@ -131,7 +160,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "SigningErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "SigningErr::PermissionDenied"> | import("@novasamatech/scale").CodecError<undefined, "SigningErr::FailedToDecode">>>];
     }>;
-    readonly chat_create_room: VersionedProtocolRequest<{
+    readonly host_chat_create_room: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             roomId: string;
             name: string;
@@ -142,7 +171,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "ChatRoomRegistrationErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "ChatRoomRegistrationErr::PermissionDenied">>>];
     }>;
-    readonly chat_register_bot: VersionedProtocolRequest<{
+    readonly host_chat_register_bot: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             botId: string;
             name: string;
@@ -153,13 +182,13 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "ChatBotRegistrationErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "ChatBotRegistrationErr::PermissionDenied">>>];
     }>;
-    readonly chat_list_subscribe: VersionedProtocolSubscription<{
+    readonly host_chat_list_subscribe: VersionedProtocolSubscription<{
         readonly v1: [Codec<undefined>, Codec<{
             roomId: string;
             participatingAs: "RoomHost" | "Bot";
         }[]>];
     }>;
-    readonly chat_post_message: VersionedProtocolRequest<{
+    readonly host_chat_post_message: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             roomId: string;
             payload: {
@@ -211,7 +240,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "ChatMessagePostingErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "ChatMessagePostingErr::MessageTooLarge">>>];
     }>;
-    readonly chat_action_subscribe: VersionedProtocolSubscription<{
+    readonly host_chat_action_subscribe: VersionedProtocolSubscription<{
         readonly v1: [Codec<undefined>, Codec<{
             roomId: string;
             peer: string;
@@ -276,44 +305,7 @@ export declare const hostApiProtocol: {
             };
         }>];
     }>;
-    readonly statement_store_query: VersionedProtocolRequest<{
-        readonly v1: [Codec<Uint8Array<ArrayBufferLike>[]>, Codec<import("scale-ts").ResultPayload<{
-            proof: {
-                tag: "Sr25519";
-                value: {
-                    signature: Uint8Array<ArrayBufferLike>;
-                    signer: Uint8Array<ArrayBufferLike>;
-                };
-            } | {
-                tag: "Ed25519";
-                value: {
-                    signature: Uint8Array<ArrayBufferLike>;
-                    signer: Uint8Array<ArrayBufferLike>;
-                };
-            } | {
-                tag: "Ecdsa";
-                value: {
-                    signature: Uint8Array<ArrayBufferLike>;
-                    signer: Uint8Array<ArrayBufferLike>;
-                };
-            } | {
-                tag: "OnChain";
-                value: {
-                    who: Uint8Array<ArrayBufferLike>;
-                    blockHash: Uint8Array<ArrayBufferLike>;
-                    event: bigint;
-                };
-            };
-            decryptionKey: Uint8Array<ArrayBufferLike> | undefined;
-            priority: number | undefined;
-            channel: Uint8Array<ArrayBufferLike> | undefined;
-            topics: Uint8Array<ArrayBufferLike>[];
-            data: Uint8Array<ArrayBufferLike> | undefined;
-        }[], import("@novasamatech/scale").CodecError<{
-            reason: string;
-        }, "GenericError">>>];
-    }>;
-    readonly statement_store_subscribe: VersionedProtocolSubscription<{
+    readonly remote_statement_store_subscribe: VersionedProtocolSubscription<{
         readonly v1: [Codec<Uint8Array<ArrayBufferLike>[]>, Codec<{
             proof: {
                 tag: "Sr25519";
@@ -348,7 +340,7 @@ export declare const hostApiProtocol: {
             data: Uint8Array<ArrayBufferLike> | undefined;
         }[]>];
     }>;
-    readonly statement_store_create_proof: VersionedProtocolRequest<{
+    readonly remote_statement_store_create_proof: VersionedProtocolRequest<{
         readonly v1: [Codec<[[string, number], {
             proof: {
                 tag: "Sr25519";
@@ -410,7 +402,7 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>>];
     }>;
-    readonly statement_store_submit: VersionedProtocolRequest<{
+    readonly remote_statement_store_submit: VersionedProtocolRequest<{
         readonly v1: [Codec<{
             proof: {
                 tag: "Sr25519";
@@ -447,12 +439,20 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "GenericError">>>];
     }>;
-    readonly jsonrpc_message_send: VersionedProtocolRequest<{
+    readonly remote_preimage_lookup_subscribe: VersionedProtocolSubscription<{
+        readonly v1: [Codec<`0x${string}`>, Codec<Uint8Array<ArrayBufferLike> | null>];
+    }>;
+    readonly remote_preimage_submit: VersionedProtocolRequest<{
+        readonly v1: [Codec<Uint8Array<ArrayBufferLike>>, Codec<import("scale-ts").ResultPayload<`0x${string}`, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PreimageSubmitErr::Unknown">>>];
+    }>;
+    readonly host_jsonrpc_message_send: VersionedProtocolRequest<{
         readonly v1: [Codec<[`0x${string}`, string]>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
             reason: string;
         }, "GenericError">>>];
     }>;
-    readonly jsonrpc_message_subscribe: VersionedProtocolSubscription<{
+    readonly host_jsonrpc_message_subscribe: VersionedProtocolSubscription<{
         readonly v1: [Codec<`0x${string}`>, Codec<string>];
     }>;
 };