@novasamatech/host-api 0.5.2 → 0.5.4-0

package/README.md

@@ -29,7 +29,7 @@ Transport is a low-level wrapper around protocol and provider.
 It encapsulates serialization/deserialization and request/subscription logic.
 
 ```typescript
-import { createTransport, okResult } from '@novasamatech/host-api';
+import { createTransport, resultOk } from '@novasamatech/host-api';
 import { provider } from './custom-provider.js';
 
 const transport = createTransport(provider);
@@ -43,9 +43,9 @@ const response = await transport.request('storage_read', payload);
 const stop = transport.handleRequest('storage_read', async (payload) => {
   try {
     const result = await readFromStorage(payload);
-    return okResult(result);
+    return resultOk(result);
   } catch (e) {
-    return errResult(e);
+    return resultErr(e);
   }
 });
 

package/dist/helpers.d.ts

@@ -1,6 +1,4 @@
-import type { ResultPayload } from 'scale-ts';
 import type { ComposeMessageAction } from './protocol/messageCodec.js';
-import type { HexString } from './protocol/types.js';
 export declare function delay(ttl: number): Promise<void>;
 type PromiseWithResolvers<T> = {
     promise: Promise<T>;
@@ -8,34 +6,7 @@ type PromiseWithResolvers<T> = {
     reject: (reason: unknown) => void;
 };
 export declare const promiseWithResolvers: <const T>() => PromiseWithResolvers<T>;
-export declare function unwrapResultOrThrow<Ok, Err>(response: ResultPayload<Ok, Err>, toError: (e: Err) => Error): Ok;
-export declare function okResult<const T>(value: T): {
-    success: true;
-    value: T;
-};
-export declare function errResult<const T>(e: T): {
-    success: false;
-    value: T;
-};
-export declare function enumValue<const Tag extends string, const Value>(tag: Tag, value: Value): {
-    tag: Tag;
-    value: Value;
-};
-export declare function isEnumVariant<const Enum extends {
-    tag: string;
-    value: unknown;
-}, const Tag extends Enum['tag']>(v: Enum, tag: Tag): v is Extract<Enum, {
-    tag: Tag;
-}>;
-export declare function assertEnumVariant<const Enum extends {
-    tag: string;
-    value: unknown;
-}, const Tag extends Enum['tag']>(v: Enum, tag: Tag, message: string): asserts v is Extract<Enum, {
-    tag: Tag;
-}>;
 export declare function composeAction<const Method extends string, const Suffix extends string>(method: Method, suffix: Suffix): ComposeMessageAction<Method, Suffix>;
 export declare function createRequestId(): string;
 export declare function extractErrorMessage(err: unknown): string;
-export declare function toHex(value: Uint8Array): HexString;
-export declare function fromHex(value: string): Uint8Array;
 export {};

package/dist/helpers.js

@@ -1,4 +1,3 @@
-import { fromHex as papiFromHex, toHex as papiToHex } from '@polkadot-api/utils';
 import { nanoid } from 'nanoid';
 export function delay(ttl) {
     return new Promise(resolve => setTimeout(resolve, ttl));
@@ -13,29 +12,6 @@ export const promiseWithResolvers = () => {
     // @ts-expect-error before assign
     return { promise, resolve, reject };
 };
-export function unwrapResultOrThrow(response, toError) {
-    if (response.success) {
-        return response.value;
-    }
-    throw toError(response.value);
-}
-export function okResult(value) {
-    return { success: true, value };
-}
-export function errResult(e) {
-    return { success: false, value: e };
-}
-export function enumValue(tag, value) {
-    return { tag, value };
-}
-export function isEnumVariant(v, tag) {
-    return v.tag === tag;
-}
-export function assertEnumVariant(v, tag, message) {
-    if (!isEnumVariant(v, tag)) {
-        throw new Error(message);
-    }
-}
 export function composeAction(method, suffix) {
     return `${method}_${suffix}`;
 }
@@ -51,9 +27,3 @@ export function extractErrorMessage(err) {
     }
     return 'Unknown error occurred.';
 }
-export function toHex(value) {
-    return papiToHex(value);
-}
-export function fromHex(value) {
-    return papiFromHex(value);
-}

package/dist/hostApi.d.ts

@@ -2,6 +2,7 @@ import type { ResultAsync } from 'neverthrow';
 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 Value<T extends Codec<any> | Codec<never>> = T extends Codec<any> ? CodecType<T> : unknown;
 type UnwrapVersionedResult<T> = T extends {
     tag: infer Tag;
@@ -24,8 +25,8 @@ type ErrorResponse<T> = T extends {
 type InferRequestMethod<Method extends VersionedProtocolRequest> = (args: Value<Method['request']>) => UnwrapVersionedResult<Value<Method['response']>>;
 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;
-type HostApi = {
-    [K in keyof HostApiProtocol]: InferMethod<HostApiProtocol[K]>;
+export type HostApi = {
+    [K in keyof HostApiProtocol as SnakeToCamelCase<K>]: InferMethod<HostApiProtocol[K]>;
 };
 export declare function createHostApi(transport: Transport): HostApi;
 export {};

package/dist/hostApi.js

@@ -2,10 +2,9 @@ import { errAsync, fromPromise, okAsync } from 'neverthrow';
 import { extractErrorMessage } from './helpers.js';
 import { GenericError } from './protocol/commonCodecs.js';
 import { CreateProofErr, RequestCredentialsErr } from './protocol/v1/accounts.js';
-import { ChatContactRegistrationErr, ChatMessagePostingErr } from './protocol/v1/chat.js';
+import { ChatMessagePostingErr, ChatRoomRegistrationErr } from './protocol/v1/chat.js';
 import { CreateTransactionErr } from './protocol/v1/createTransaction.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
-import { PermissionErr } from './protocol/v1/permission.js';
 import { SigningErr } from './protocol/v1/sign.js';
 import { StatementProofErr } from './protocol/v1/statementStore.js';
 import { StorageErr } from './protocol/v1/storage.js';
@@ -47,26 +46,8 @@ export function createHostApi(transport) {
                 });
             });
         },
-        permission_request(payload) {
-            const response = fromPromise(transport.request('permission_request', payload), e => ({
-                tag: payload.tag,
-                value: new PermissionErr.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,
-                });
-            });
-        },
-        storage_read(payload) {
-            const response = fromPromise(transport.request('storage_read', payload), e => ({
+        localStorageRead(payload) {
+            const response = fromPromise(transport.request('local_storage_read', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -83,8 +64,8 @@ export function createHostApi(transport) {
                 });
             });
         },
-        storage_write(payload) {
-            const response = fromPromise(transport.request('storage_write', payload), e => ({
+        localStorageWrite(payload) {
+            const response = fromPromise(transport.request('local_storage_write', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -101,8 +82,8 @@ export function createHostApi(transport) {
                 });
             });
         },
-        storage_clear(payload) {
-            const response = fromPromise(transport.request('storage_clear', payload), e => ({
+        localStorageClear(payload) {
+            const response = fromPromise(transport.request('local_storage_clear', payload), e => ({
                 tag: payload.tag,
                 value: new StorageErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
@@ -119,7 +100,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        account_get(payload) {
+        accountGet(payload) {
             const response = fromPromise(transport.request('account_get', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -137,7 +118,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        account_get_alias(payload) {
+        accountGetAlias(payload) {
             const response = fromPromise(transport.request('account_get_alias', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -155,7 +136,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        account_create_proof(payload) {
+        accountCreateProof(payload) {
             const response = fromPromise(transport.request('account_create_proof', payload), e => ({
                 tag: payload.tag,
                 value: new CreateProofErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -173,7 +154,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        get_non_product_accounts(payload) {
+        getNonProductAccounts(payload) {
             const response = fromPromise(transport.request('get_non_product_accounts', payload), e => ({
                 tag: payload.tag,
                 value: new RequestCredentialsErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -191,7 +172,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        create_transaction(payload) {
+        createTransaction(payload) {
             const response = fromPromise(transport.request('create_transaction', payload), e => ({
                 tag: payload.tag,
                 value: new CreateTransactionErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -209,7 +190,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        create_transaction_with_non_product_account(payload) {
+        createTransactionWithNonProductAccount(payload) {
             const response = fromPromise(transport.request('create_transaction_with_non_product_account', payload), e => ({
                 tag: payload.tag,
                 value: new CreateTransactionErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -227,7 +208,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        sign_raw(payload) {
+        signRaw(payload) {
             const response = fromPromise(transport.request('sign_raw', payload), e => ({
                 tag: payload.tag,
                 value: new SigningErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -245,7 +226,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        sign_payload(payload) {
+        signPayload(payload) {
             const response = fromPromise(transport.request('sign_payload', payload), e => ({
                 tag: payload.tag,
                 value: new SigningErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -263,10 +244,13 @@ export function createHostApi(transport) {
                 });
             });
         },
-        chat_create_contact(payload) {
-            const response = fromPromise(transport.request('chat_create_contact', payload), e => ({
+        chatListSubscribe(args, callback) {
+            return transport.subscribe('chat_list_subscribe', args, callback);
+        },
+        chatCreateRoom(payload) {
+            const response = fromPromise(transport.request('chat_create_room', payload), e => ({
                 tag: payload.tag,
-                value: new ChatContactRegistrationErr.Unknown({ reason: extractErrorMessage(e) }),
+                value: new ChatRoomRegistrationErr.Unknown({ reason: extractErrorMessage(e) }),
             }));
             return response.andThen(response => {
                 if (response.value.success) {
@@ -281,7 +265,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        chat_post_message(payload) {
+        chatPostMessage(payload) {
             const response = fromPromise(transport.request('chat_post_message', payload), e => ({
                 tag: payload.tag,
                 value: new ChatMessagePostingErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -299,10 +283,31 @@ export function createHostApi(transport) {
                 });
             });
         },
-        chat_action_subscribe(args, callback) {
+        chatActionSubscribe(args, callback) {
             return transport.subscribe('chat_action_subscribe', args, callback);
         },
-        statement_store_create_proof(payload) {
+        statementStoreQuery(payload) {
+            const response = fromPromise(transport.request('statement_store_query', 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,
+                });
+            });
+        },
+        statementStoreSubscribe(args, callback) {
+            return transport.subscribe('statement_store_subscribe', args, callback);
+        },
+        statementStoreCreateProof(payload) {
             const response = fromPromise(transport.request('statement_store_create_proof', payload), e => ({
                 tag: payload.tag,
                 value: new StatementProofErr.Unknown({ reason: extractErrorMessage(e) }),
@@ -320,7 +325,25 @@ export function createHostApi(transport) {
                 });
             });
         },
-        jsonrpc_message_send(payload) {
+        statementStoreSubmit(payload) {
+            const response = fromPromise(transport.request('statement_store_submit', 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,
+                });
+            });
+        },
+        jsonrpcMessageSend(payload) {
             const response = fromPromise(transport.request('jsonrpc_message_send', payload), e => ({
                 tag: payload.tag,
                 value: new GenericError({ reason: extractErrorMessage(e) }),
@@ -338,7 +361,7 @@ export function createHostApi(transport) {
                 });
             });
         },
-        jsonrpc_message_subscribe(args, callback) {
+        jsonrpcMessageSubscribe(args, callback) {
             return transport.subscribe('jsonrpc_message_subscribe', args, callback);
         },
     };

package/dist/index.d.ts

@@ -1,19 +1,20 @@
-export type { ConnectionStatus, Logger, Transport } from './types.js';
+export type { ConnectionStatus, Logger, Subscription, Transport } from './types.js';
 export type { Provider } from './provider.js';
-export { assertEnumVariant, createRequestId, enumValue, errResult, fromHex, isEnumVariant, okResult, toHex, unwrapResultOrThrow, } from './helpers.js';
-export type { HexString } from './protocol/types.js';
+export { createRequestId } from './helpers.js';
+export type { HostApi } from './hostApi.js';
 export { createHostApi } from './hostApi.js';
 export { createTransport } from './transport.js';
 export { createDefaultLogger } from './logger.js';
 export type { HostApiProtocol, VersionedProtocolRequest, VersionedProtocolSubscription } from './protocol/impl.js';
 export { hostApiProtocol } from './protocol/impl.js';
 export type { Codec, CodecType } from 'scale-ts';
+export type { HexString } from '@novasamatech/scale';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from '@novasamatech/scale';
 export { GenericError } from './protocol/commonCodecs.js';
 export { CreateTransactionErr, VersionedPublicTxPayload } from './protocol/v1/createTransaction.js';
-export { Account, AccountId, CreateProofErr, ProductAccountId, RequestCredentialsErr } from './protocol/v1/accounts.js';
-export { ChatContactRegistrationErr, ChatContactRegistrationStatus, ChatMessage, ChatMessagePostingErr, ReceivedChatAction, } from './protocol/v1/chat.js';
+export { Account, AccountId, CreateProofErr, ProductAccountId, RequestCredentialsErr, RingLocation, } from './protocol/v1/accounts.js';
+export { ChatActionPayload, ChatMessageContent, ChatMessagePostingErr, ChatRoom, ChatRoomRegistrationErr, ChatRoomRegistrationResult, ReceivedChatAction, } from './protocol/v1/chat.js';
 export { HandshakeErr } from './protocol/v1/handshake.js';
-export { PermissionErr } from './protocol/v1/permission.js';
 export { SigningErr } from './protocol/v1/sign.js';
-export { StatementProofErr } from './protocol/v1/statementStore.js';
+export { SignedStatement, Statement, StatementProofErr, Topic } from './protocol/v1/statementStore.js';
 export { StorageErr } from './protocol/v1/storage.js';

package/dist/index.js

@@ -1,15 +1,15 @@
-export { assertEnumVariant, createRequestId, enumValue, errResult, fromHex, isEnumVariant, okResult, toHex, unwrapResultOrThrow, } from './helpers.js';
+export { createRequestId } from './helpers.js';
 export { createHostApi } from './hostApi.js';
 export { createTransport } from './transport.js';
 export { createDefaultLogger } from './logger.js';
 export { hostApiProtocol } from './protocol/impl.js';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from '@novasamatech/scale';
 // Codecs
 export { GenericError } from './protocol/commonCodecs.js';
 export { CreateTransactionErr, VersionedPublicTxPayload } from './protocol/v1/createTransaction.js';
-export { Account, AccountId, CreateProofErr, ProductAccountId, RequestCredentialsErr } from './protocol/v1/accounts.js';
-export { ChatContactRegistrationErr, ChatContactRegistrationStatus, ChatMessage, ChatMessagePostingErr, ReceivedChatAction, } from './protocol/v1/chat.js';
+export { Account, AccountId, CreateProofErr, ProductAccountId, RequestCredentialsErr, RingLocation, } from './protocol/v1/accounts.js';
+export { ChatActionPayload, ChatMessageContent, ChatMessagePostingErr, ChatRoom, ChatRoomRegistrationErr, ChatRoomRegistrationResult, ReceivedChatAction, } from './protocol/v1/chat.js';
 export { HandshakeErr } from './protocol/v1/handshake.js';
-export { PermissionErr } from './protocol/v1/permission.js';
 export { SigningErr } from './protocol/v1/sign.js';
-export { StatementProofErr } from './protocol/v1/statementStore.js';
+export { SignedStatement, Statement, StatementProofErr, Topic } from './protocol/v1/statementStore.js';
 export { StorageErr } from './protocol/v1/storage.js';

package/dist/protocol/commonCodecs.d.ts

@@ -1,42 +1,7 @@
-import type { Codec, CodecType, StringRecord } from 'scale-ts';
-type FilterStringRecord<T extends Record<string, Codec<any>>> = T extends StringRecord<Codec<any>> ? T : never;
-export type EnumCodec<T extends Record<string, Codec<any>>> = ReturnType<typeof Enum<T>>;
-export declare const Enum: <T extends Record<string, Codec<any>>>(inner: T) => Codec<(FilterStringRecord<T> extends infer T_1 extends StringRecord<Codec<any>> ? { [K in keyof T_1]: {
-    tag: K;
-    value: CodecType<T_1[K]>;
-}; } : never)[keyof FilterStringRecord<T>]>;
-/**
- * Enum without values
- */
-export declare function Status<T extends string>(...list: T[]): Codec<T>;
-export declare function Nullable<T>(inner: Codec<T>): Codec<T | null>;
-type Constructor<A extends Array<any>, T> = new (...args: A) => T;
-type CodecError<T, Name extends string> = Error & {
-    name: Name;
-    className: string;
-    payload: T;
-};
-type CodecErrorConstructor<T, Name extends string> = Constructor<T extends undefined ? [void] : [T], CodecError<T, Name>>;
-export type ErrCodec<T, Name extends string> = Codec<CodecError<T, Name>> & CodecErrorConstructor<T, Name>;
-export declare function Err<const T, const Name extends string>(name: Name, value: Codec<T>, message: string | ((value: NoInfer<T>) => string), className?: string): ErrCodec<T, Name>;
-type MapErrEnum<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
-    [K in keyof T]: ErrCodec<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
-};
-type ErrEnumInput<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
-    [K in keyof T]: CodecError<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
-}[keyof T];
-type ErrEnumArguments<T> = [value: Codec<T>, message: string | ((value: T) => string)];
-export declare function ErrEnum<const Name extends string, const T extends Record<string, ErrEnumArguments<any>>>(name: Name, inner: T): Codec<ErrEnumInput<Name, T>> & MapErrEnum<Name, T>;
-/**
- * Wrapper around Bytes codec. Every usage of Hex codec should be threaded as raw Bytes with mapping to hex string.
- * @param [length] Optional, corresponds to byte array size, not the length of hex string.
- */
-export declare const Hex: (length?: number) => Codec<`0x${string}`>;
-export declare const GenesisHash: Codec<`0x${string}`>;
-export declare const GenericErr: Codec<{
+export declare const GenesisHash: import("scale-ts").Codec<`0x${string}`>;
+export declare const GenericErr: import("scale-ts").Codec<{
     reason: string;
 }>;
-export declare const GenericError: ErrCodec<{
+export declare const GenericError: import("@novasamatech/scale").ErrCodec<{
     reason: string;
 }, "GenericError">;
-export {};

package/dist/protocol/commonCodecs.js

@@ -1,62 +1,5 @@
-import { Bytes, Enum as ScaleEnum, Option, Struct, _void, enhanceCodec, str, u8 } from 'scale-ts';
-import { fromHex, toHex } from '../helpers.js';
-export const Enum = (inner) => ScaleEnum(inner);
-/**
- * Enum without values
- */
-export function Status(...list) {
-    return enhanceCodec(u8, v => {
-        const i = list.indexOf(v);
-        if (i === -1) {
-            throw new Error(`Unknown status value: ${v}`);
-        }
-        return i;
-    }, i => {
-        const v = list.at(i);
-        if (v === undefined) {
-            throw new Error(`Unknown status index: ${i}`);
-        }
-        return v;
-    });
-}
-export function Nullable(inner) {
-    return enhanceCodec(Option(inner), v => (v === null ? undefined : v), v => (v === undefined ? null : v));
-}
-export function Err(name, value, message, className = name) {
-    // Defining class with dynamic name
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const C = {
-        [className]: class extends Error {
-            className = className;
-            name = name;
-            payload;
-            constructor(data) {
-                super(typeof message === 'function' ? message(data) : message);
-                this.payload = data;
-            }
-            // workaround for codec array destructuring
-            static [Symbol.iterator]() {
-                return errorCodec[Symbol.iterator]();
-            }
-        },
-    }[className];
-    const errorCodec = enhanceCodec(value, v => v.payload, 
-    // @ts-expect-error don't want to fix it really
-    v => new C(v));
-    return Object.assign(C, errorCodec);
-}
-export function ErrEnum(name, inner) {
-    const values = Object.fromEntries(Object.entries(inner).map(([k, [value, message]]) => {
-        return [k, Err(`${name}::${k}`, value, message, k)];
-    }));
-    const codec = enhanceCodec(Enum(values), v => ({ tag: v.className, value: v }), v => v.value);
-    return Object.assign(codec, values);
-}
-/**
- * Wrapper around Bytes codec. Every usage of Hex codec should be threaded as raw Bytes with mapping to hex string.
- * @param [length] Optional, corresponds to byte array size, not the length of hex string.
- */
-export const Hex = (length) => enhanceCodec(Bytes(length), fromHex, toHex);
+import { Err, Hex } from '@novasamatech/scale';
+import { Struct, str } from 'scale-ts';
 export const GenesisHash = Hex();
 export const GenericErr = Struct({
     reason: str,

package/dist/protocol/impl.d.ts

@@ -1,26 +1,25 @@
+import type { EnumCodec } from '@novasamatech/scale';
 import type { Codec } from 'scale-ts';
-import type { EnumCodec } from './commonCodecs.js';
 import { AccountCreateProofV1_request, AccountCreateProofV1_response, AccountGetAliasV1_request, AccountGetAliasV1_response, AccountGetV1_request, AccountGetV1_response, GetNonProductAccountsV1_request, GetNonProductAccountsV1_response } from './v1/accounts.js';
-import { ChatActionSubscribeV1_receive, ChatActionSubscribeV1_start, ChatCreateContactV1_request, ChatCreateContactV1_response, ChatPostMessageV1_request, ChatPostMessageV1_response } from './v1/chat.js';
+import { ChatActionSubscribeV1_receive, ChatActionSubscribeV1_start, ChatCreateRoomV1_request, ChatCreateRoomV1_response, ChatListSubscribeV1_receive, ChatListSubscribeV1_start, ChatPostMessageV1_request, ChatPostMessageV1_response } from './v1/chat.js';
 import { CreateTransactionV1_request, CreateTransactionV1_response, CreateTransactionWithNonProductAccountV1_request, CreateTransactionWithNonProductAccountV1_response } from './v1/createTransaction.js';
 import { FeatureV1_request, FeatureV1_response } from './v1/feature.js';
 import { HandshakeV1_request, HandshakeV1_response } from './v1/handshake.js';
 import { JsonRpcMessageSendV1_request, JsonRpcMessageSendV1_response, JsonRpcMessageSubscribeV1_receive, JsonRpcMessageSubscribeV1_start } from './v1/jsonRpc.js';
-import { PermissionRequestV1_request, PermissionRequestV1_response } from './v1/permission.js';
 import { SignPayloadV1_request, SignPayloadV1_response, SignRawV1_request, SignRawV1_response } from './v1/sign.js';
-import { StatementStoreCreateProofV1_request, StatementStoreCreateProofV1_response } from './v1/statementStore.js';
+import { StatementStoreCreateProofV1_request, StatementStoreCreateProofV1_response, StatementStoreQueryV1_request, StatementStoreQueryV1_response, StatementStoreSubmitV1_request, StatementStoreSubmitV1_response, StatementStoreSubscribeV1_receive, StatementStoreSubscribeV1_start } from './v1/statementStore.js';
 import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request, StorageReadV1_response, StorageWriteV1_request, StorageWriteV1_response } from './v1/storage.js';
 export type VersionedArguments = Record<string, [Codec<any>, Codec<any>]>;
 type InferVersionedArgument<EnumValues extends VersionedArguments, N extends number> = {
     [V in keyof EnumValues]: EnumValues[V][N];
 };
 export type VersionedProtocolRequest<T extends VersionedArguments = VersionedArguments> = {
-    type: 'request';
+    method: 'request';
     request: EnumCodec<InferVersionedArgument<T, 0>>;
     response: EnumCodec<InferVersionedArgument<T, 1>>;
 };
 export type VersionedProtocolSubscription<T extends VersionedArguments = VersionedArguments> = {
-    type: 'subscription';
+    method: 'subscribe';
     start: EnumCodec<InferVersionedArgument<T, 0>>;
     receive: EnumCodec<InferVersionedArgument<T, 1>>;
 };
@@ -31,16 +30,13 @@ export type HostApiProtocol = {
     feature: VersionedProtocolRequest<{
         v1: [typeof FeatureV1_request, typeof FeatureV1_response];
     }>;
-    permission_request: VersionedProtocolRequest<{
-        v1: [typeof PermissionRequestV1_request, typeof PermissionRequestV1_response];
-    }>;
-    storage_read: VersionedProtocolRequest<{
+    local_storage_read: VersionedProtocolRequest<{
         v1: [typeof StorageReadV1_request, typeof StorageReadV1_response];
     }>;
-    storage_write: VersionedProtocolRequest<{
+    local_storage_write: VersionedProtocolRequest<{
         v1: [typeof StorageWriteV1_request, typeof StorageWriteV1_response];
     }>;
-    storage_clear: VersionedProtocolRequest<{
+    local_storage_clear: VersionedProtocolRequest<{
         v1: [typeof StorageClearV1_request, typeof StorageClearV1_response];
     }>;
     account_get: VersionedProtocolRequest<{
@@ -70,8 +66,11 @@ export type HostApiProtocol = {
     sign_payload: VersionedProtocolRequest<{
         v1: [typeof SignPayloadV1_request, typeof SignPayloadV1_response];
     }>;
-    chat_create_contact: VersionedProtocolRequest<{
-        v1: [typeof ChatCreateContactV1_request, typeof ChatCreateContactV1_response];
+    chat_create_room: VersionedProtocolRequest<{
+        v1: [typeof ChatCreateRoomV1_request, typeof ChatCreateRoomV1_response];
+    }>;
+    chat_list_subscribe: VersionedProtocolSubscription<{
+        v1: [typeof ChatListSubscribeV1_start, typeof ChatListSubscribeV1_receive];
     }>;
     chat_post_message: VersionedProtocolRequest<{
         v1: [typeof ChatPostMessageV1_request, typeof ChatPostMessageV1_response];
@@ -79,9 +78,18 @@ export type HostApiProtocol = {
     chat_action_subscribe: VersionedProtocolSubscription<{
         v1: [typeof ChatActionSubscribeV1_start, typeof ChatActionSubscribeV1_receive];
     }>;
+    statement_store_query: VersionedProtocolRequest<{
+        v1: [typeof StatementStoreQueryV1_request, typeof StatementStoreQueryV1_response];
+    }>;
+    statement_store_subscribe: VersionedProtocolSubscription<{
+        v1: [typeof StatementStoreSubscribeV1_start, typeof StatementStoreSubscribeV1_receive];
+    }>;
     statement_store_create_proof: VersionedProtocolRequest<{
         v1: [typeof StatementStoreCreateProofV1_request, typeof StatementStoreCreateProofV1_response];
     }>;
+    statement_store_submit: VersionedProtocolRequest<{
+        v1: [typeof StatementStoreSubmitV1_request, typeof StatementStoreSubmitV1_response];
+    }>;
     jsonrpc_message_send: VersionedProtocolRequest<{
         v1: [typeof JsonRpcMessageSendV1_request, typeof JsonRpcMessageSendV1_response];
     }>;