@novasamatech/host-api 0.5.4-9 → 0.5.5

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

@@ -56,16 +56,20 @@ export declare const ChatBotRequest: import("scale-ts").Codec<{
     name: string;
     icon: string;
 }>;
-export declare const ChatCreateBotV1_request: import("scale-ts").Codec<{
+export declare const ChatBotRegistrationStatus: import("scale-ts").Codec<"New" | "Exists">;
+export declare const ChatBotRegistrationResult: import("scale-ts").Codec<{
+    status: "New" | "Exists";
+}>;
+export declare const ChatRegisterBotV1_request: import("scale-ts").Codec<{
     botId: string;
     name: string;
     icon: string;
 }>;
-export declare const ChatCreateBotV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const ChatRegisterBotV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
     status: "New" | "Exists";
 }, import("@novasamatech/scale").CodecError<{
     reason: string;
-}, "ChatRoomRegistrationErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "ChatRoomRegistrationErr::PermissionDenied">>>;
+}, "ChatBotRegistrationErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "ChatBotRegistrationErr::PermissionDenied">>>;
 export declare const ChatRoomParticipation: import("scale-ts").Codec<"RoomHost" | "Bot">;
 export declare const ChatRoom: import("scale-ts").Codec<{
     roomId: string;
@@ -226,6 +230,7 @@ export declare const ChatPostMessageV1_response: import("scale-ts").Codec<import
 export declare const ActionTrigger: import("scale-ts").Codec<{
     messageId: string;
     actionId: string;
+    payload: Uint8Array<ArrayBufferLike> | undefined;
 }>;
 export declare const ChatCommand: import("scale-ts").Codec<{
     command: string;
@@ -281,6 +286,7 @@ export declare const ChatActionPayload: import("scale-ts").Codec<{
     value: {
         messageId: string;
         actionId: string;
+        payload: Uint8Array<ArrayBufferLike> | undefined;
     };
 } | {
     tag: "Command";
@@ -342,6 +348,7 @@ export declare const ReceivedChatAction: import("scale-ts").Codec<{
         value: {
             messageId: string;
             actionId: string;
+            payload: Uint8Array<ArrayBufferLike> | undefined;
         };
     } | {
         tag: "Command";
@@ -405,6 +412,7 @@ export declare const ChatActionSubscribeV1_receive: import("scale-ts").Codec<{
         value: {
             messageId: string;
             actionId: string;
+            payload: Uint8Array<ArrayBufferLike> | undefined;
         };
     } | {
         tag: "Command";

package/dist/protocol/v1/chat.js

@@ -1,5 +1,5 @@
 import { Enum, ErrEnum, Status } from '@novasamatech/scale';
-import { Option, Result, Struct, Vector, _void, str, u64 } from 'scale-ts';
+import { Bytes, Option, Result, Struct, Vector, _void, str, u64 } from 'scale-ts';
 import { GenericErr } from '../commonCodecs.js';
 // room registration
 export const ChatRoomRegistrationErr = ErrEnum('ChatRoomRegistrationErr', {
@@ -27,8 +27,12 @@ export const ChatBotRequest = Struct({
     name: str,
     icon: str, // URL or base64-encoded image for contact
 });
-export const ChatCreateBotV1_request = ChatBotRequest;
-export const ChatCreateBotV1_response = Result(ChatRoomRegistrationResult, ChatRoomRegistrationErr);
+export const ChatBotRegistrationStatus = Status('New', 'Exists');
+export const ChatBotRegistrationResult = Struct({
+    status: ChatBotRegistrationStatus,
+});
+export const ChatRegisterBotV1_request = ChatBotRequest;
+export const ChatRegisterBotV1_response = Result(ChatBotRegistrationResult, ChatBotRegistrationErr);
 // receiving rooms
 export const ChatRoomParticipation = Status('RoomHost', 'Bot');
 export const ChatRoom = Struct({
@@ -91,6 +95,7 @@ export const ChatPostMessageV1_response = Result(ChatPostMessageResult, ChatMess
 export const ActionTrigger = Struct({
     messageId: str,
     actionId: str,
+    payload: Option(Bytes()),
 });
 export const ChatCommand = Struct({
     command: str,

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

@@ -0,0 +1,5 @@
+export declare const DevicePermissionRequest: import("scale-ts").Codec<"Camera" | "Microphone" | "Bluetooth" | "Location">;
+export declare const DevicePermissionV1_request: import("scale-ts").Codec<"Camera" | "Microphone" | "Bluetooth" | "Location">;
+export declare const DevicePermissionV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;

package/dist/protocol/v1/devicePermission.js

@@ -0,0 +1,6 @@
+import { Status } from '@novasamatech/scale';
+import { Result, bool } from 'scale-ts';
+import { GenericError } from '../commonCodecs.js';
+export const DevicePermissionRequest = Status('Camera', 'Microphone', 'Bluetooth', 'Location');
+export const DevicePermissionV1_request = DevicePermissionRequest;
+export const DevicePermissionV1_response = Result(bool, GenericError);

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

@@ -0,0 +1,31 @@
+export declare const StorageErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>;
+} & {
+    readonly Full: import("@novasamatech/scale").ErrCodec<undefined, "StorageErr::Full">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "StorageErr::Unknown">;
+};
+export declare const StorageKey: import("scale-ts").Codec<string>;
+export declare const StorageValue: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const StorageReadV1_request: import("scale-ts").Codec<string>;
+export declare const StorageReadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike> | undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>;
+export declare const StorageWriteV1_request: import("scale-ts").Codec<[string, Uint8Array<ArrayBufferLike>]>;
+export declare const StorageWriteV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>;
+export declare const StorageClearV1_request: import("scale-ts").Codec<string>;
+export declare const StorageClearV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>;

package/dist/protocol/v1/localStorage.js

@@ -0,0 +1,17 @@
+import { ErrEnum } from '@novasamatech/scale';
+import { Bytes, Option, Result, Tuple, _void, str } from 'scale-ts';
+import { GenericErr } from '../commonCodecs.js';
+// common structures
+export const StorageErr = ErrEnum('StorageErr', {
+    Full: [_void, 'Storage is full'],
+    Unknown: [GenericErr, 'Unknown storage error'],
+});
+export const StorageKey = str;
+export const StorageValue = Bytes();
+// actions
+export const StorageReadV1_request = StorageKey;
+export const StorageReadV1_response = Result(Option(StorageValue), StorageErr);
+export const StorageWriteV1_request = Tuple(StorageKey, StorageValue);
+export const StorageWriteV1_response = Result(_void, StorageErr);
+export const StorageClearV1_request = StorageKey;
+export const StorageClearV1_response = Result(_void, StorageErr);

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

@@ -0,0 +1,21 @@
+export declare const NavigateToErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>;
+} & {
+    readonly PermissionDenied: import("@novasamatech/scale").ErrCodec<undefined, "NavigateToErr::PermissionDenied">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "NavigateToErr::Unknown">;
+};
+export declare const NavigateToV1_request: import("scale-ts").Codec<string>;
+export declare const NavigateToV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>>;

package/dist/protocol/v1/navigation.js

@@ -0,0 +1,9 @@
+import { ErrEnum } from '@novasamatech/scale';
+import { Result, _void, str } from 'scale-ts';
+import { GenericErr } from '../commonCodecs.js';
+export const NavigateToErr = ErrEnum('NavigateToErr', {
+    PermissionDenied: [_void, 'Permission denied'],
+    Unknown: [GenericErr, 'Unknown error'],
+});
+export const NavigateToV1_request = str;
+export const NavigateToV1_response = Result(_void, NavigateToErr);

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

@@ -0,0 +1,11 @@
+export declare const PushNotification: import("scale-ts").Codec<{
+    text: string;
+    deeplink: string | undefined;
+}>;
+export declare const PushNotificationV1_request: import("scale-ts").Codec<{
+    text: string;
+    deeplink: string | undefined;
+}>;
+export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/dist/err.js").CodecError<{
+    reason: string;
+}, "GenericError">>>;

package/dist/protocol/v1/notification.js

@@ -0,0 +1,8 @@
+import { Option, Result, Struct, _void, str } from 'scale-ts';
+import { GenericError } from '../commonCodecs.js';
+export const PushNotification = Struct({
+    text: str,
+    deeplink: Option(str),
+});
+export const PushNotificationV1_request = PushNotification;
+export const PushNotificationV1_response = Result(_void, GenericError);

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

@@ -0,0 +1,24 @@
+export declare const PreimageKey: import("scale-ts").Codec<`0x${string}`>;
+export declare const PreimageValue: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const PreimageLookupSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;
+export declare const PreimageLookupSubscribeV1_receive: import("scale-ts").Codec<Uint8Array<ArrayBufferLike> | null>;
+export declare const PreimageSubmitErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PreimageSubmitErr::Unknown">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PreimageSubmitErr::Unknown">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PreimageSubmitErr::Unknown">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PreimageSubmitErr::Unknown">>;
+} & {
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PreimageSubmitErr::Unknown">;
+};
+export declare const PreimageSubmitV1_request: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const PreimageSubmitV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<`0x${string}`, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PreimageSubmitErr::Unknown">>>;

package/dist/protocol/v1/preimage.js

@@ -0,0 +1,12 @@
+import { ErrEnum, Hex, Nullable } from '@novasamatech/scale';
+import { Bytes, Result } from 'scale-ts';
+import { GenericErr } from '../commonCodecs.js';
+export const PreimageKey = Hex();
+export const PreimageValue = Bytes();
+export const PreimageLookupSubscribeV1_start = PreimageKey;
+export const PreimageLookupSubscribeV1_receive = Nullable(PreimageValue);
+export const PreimageSubmitErr = ErrEnum('PreimageSubmitErr', {
+    Unknown: [GenericErr, 'Unknown error'],
+});
+export const PreimageSubmitV1_request = PreimageValue;
+export const PreimageSubmitV1_response = Result(PreimageKey, PreimageSubmitErr);

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

@@ -0,0 +1,17 @@
+export declare const RemotePermissionRequest: import("scale-ts").Codec<{
+    tag: "ExternalRequest";
+    value: string;
+} | {
+    tag: "TransactionSubmit";
+    value: undefined;
+}>;
+export declare const RemotePermissionV1_request: import("scale-ts").Codec<{
+    tag: "ExternalRequest";
+    value: string;
+} | {
+    tag: "TransactionSubmit";
+    value: undefined;
+}>;
+export declare const RemotePermissionV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;

package/dist/protocol/v1/remotePermission.js

@@ -0,0 +1,9 @@
+import { Enum } from '@novasamatech/scale';
+import { Result, _void, bool, str } from 'scale-ts';
+import { GenericError } from '../commonCodecs.js';
+export const RemotePermissionRequest = Enum({
+    ExternalRequest: str, // URL
+    TransactionSubmit: _void,
+});
+export const RemotePermissionV1_request = RemotePermissionRequest;
+export const RemotePermissionV1_response = Result(bool, GenericError);

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

@@ -67,42 +67,6 @@ export declare const SignedStatement: import("scale-ts").Codec<{
     topics: Uint8Array<ArrayBufferLike>[];
     data: Uint8Array<ArrayBufferLike> | undefined;
 }>;
-export declare const StatementStoreQueryV1_request: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>[]>;
-export declare const StatementStoreQueryV1_response: import("scale-ts").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">>>;
 export declare const StatementStoreSubscribeV1_start: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>[]>;
 export declare const StatementStoreSubscribeV1_receive: import("scale-ts").Codec<{
     proof: {

package/dist/protocol/v1/statementStore.js

@@ -46,9 +46,7 @@ export const SignedStatement = Struct({
     topics: Vector(Topic),
     data: Option(Bytes()),
 });
-// query
-export const StatementStoreQueryV1_request = Vector(Topic);
-export const StatementStoreQueryV1_response = Result(Vector(SignedStatement), GenericError);
+// subscription
 export const StatementStoreSubscribeV1_start = Vector(Topic);
 export const StatementStoreSubscribeV1_receive = Vector(SignedStatement);
 // creating proof

package/dist/transport.js

@@ -62,7 +62,7 @@ export function createTransport(provider) {
                     handshakeAbortController.signal.removeEventListener('abort', unsubscribe);
                 };
                 return new Promise(resolve => {
-                    const unsubscribe = transport.listenMessages('handshake_response', responseId => {
+                    const unsubscribe = transport.listenMessages('host_handshake_response', responseId => {
                         if (responseId === id) {
                             cleanup(interval, unsubscribe);
                             resolved = true;
@@ -76,7 +76,7 @@ export function createTransport(provider) {
                             resolve(false);
                             return;
                         }
-                        transport.postMessage(id, enumValue('handshake_request', enumValue('v1', codecVersion)));
+                        transport.postMessage(id, enumValue('host_handshake_request', enumValue('v1', codecVersion)));
                     }, HANDSHAKE_INTERVAL);
                 }).then(success => {
                     if (!success && !resolved) {
@@ -233,7 +233,7 @@ export function createTransport(provider) {
         },
     };
     if (provider.isCorrectEnvironment()) {
-        transport.handleRequest('handshake', async (version) => {
+        transport.handleRequest('host_handshake', async (version) => {
             switch (version.tag) {
                 case 'v1': {
                     codecVersion = version.value;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.5.4-9",
+  "version": "0.5.5",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+    "url": "git+https://github.com/Polkadot-Community-Foundation/triangle-js-sdks.git"
   },
   "main": "dist/index.js",
   "exports": {
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.5.4-9",
+    "@novasamatech/scale": "0.5.5",
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.6",