@novasamatech/host-api 0.7.9-3 → 0.7.9-4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.7.9-3",
+  "version": "0.7.9-4",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -22,7 +22,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@novasamatech/scale": "0.7.9-3",
+    "@novasamatech/scale": "0.7.9-4",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0",

package/dist/protocol/commonCodecs.spec.d.ts

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

package/dist/protocol/commonCodecs.spec.js

@@ -1,72 +0,0 @@
-import { Struct, _void, bool } from 'scale-ts';
-import { describe, expect, it } from 'vitest';
-import { Err, ErrEnum, Hex, Status } from './commonCodecs.js';
-describe('Common codecs', () => {
-    describe('Hex', () => {
-        it('should correctly encode/decode Hex with arbitrary length', () => {
-            const hex = '0xffffff';
-            const codec = Hex();
-            expect(codec.enc(hex)).toEqual(new Uint8Array([12, 255, 255, 255]));
-            expect(codec.dec(codec.enc(hex))).toEqual(hex);
-        });
-        it('should correctly encode/decode Hex with fixed length', () => {
-            const hex = '0xffffff';
-            const codec = Hex(3);
-            expect(codec.enc(hex)).toEqual(new Uint8Array([255, 255, 255]));
-            expect(codec.dec(codec.enc(hex))).toEqual(hex);
-        });
-    });
-    describe('Status', () => {
-        it('should correctly encode/decode Status', () => {
-            const codec = Status('New', 'Used');
-            expect(codec.enc('New')).toEqual(new Uint8Array([0]));
-            expect(codec.enc('Used')).toEqual(new Uint8Array([1]));
-            expect(codec.dec('0x00')).toEqual('New');
-            expect(codec.dec('0x01')).toEqual('Used');
-            // @ts-expect-error for test
-            expect(() => codec.enc('Unknown')).toThrowErrorMatchingInlineSnapshot(`[Error: Unknown status value: Unknown]`);
-            expect(() => codec.dec('0x03')).toThrowErrorMatchingInlineSnapshot(`[Error: Unknown status index: 3]`);
-        });
-    });
-    describe('Err', () => {
-        it('should correctly construct Error', () => {
-            const ErrorCodec = Err('TestError', _void, 'Test message');
-            const error = new ErrorCodec(undefined);
-            expect(error).toBeInstanceOf(ErrorCodec);
-            expect(error.name).toBe('TestError');
-            expect(error.message).toBe('Test message');
-        });
-        it('should correctly encode/decode Err', () => {
-            const payload = Struct({ enable: bool });
-            const ErrorCodec = Err('TestError', payload, 'Test message');
-            const error = new ErrorCodec({ enable: true });
-            expect(ErrorCodec.enc(error)).toEqual(new Uint8Array([1]));
-            expect(ErrorCodec.dec(ErrorCodec.enc(error))).toEqual(new ErrorCodec({ enable: true }));
-        });
-    });
-    describe('ErrEnum', () => {
-        it('should correctly construct ErrorEnum field', () => {
-            const ErrorCodec = ErrEnum('ErrorCodec', {
-                TestError: [_void, 'Test message'],
-            });
-            const error = new ErrorCodec.TestError(undefined);
-            expect(error).toBeInstanceOf(ErrorCodec.TestError);
-            expect(error.name).toBe('ErrorCodec::TestError');
-            expect(error.message).toBe('Test message');
-        });
-        it('should correctly serialize/deserialize', () => {
-            const ErrorCodec = ErrEnum('ErrorCodec', {
-                First: [_void, 'First'],
-                Second: [_void, 'Second'],
-            });
-            const first = new ErrorCodec.First(undefined);
-            const second = new ErrorCodec.Second(undefined);
-            expect(ErrorCodec.enc(first)).toEqual(new Uint8Array([0]));
-            expect(ErrorCodec.enc(second)).toEqual(new Uint8Array([1]));
-            expect(ErrorCodec.dec(ErrorCodec.enc(first))).toEqual(first);
-            expect(ErrorCodec.dec(ErrorCodec.enc(second))).toEqual(second);
-            expect(ErrorCodec.dec(ErrorCodec.enc(first))).not.toEqual(second);
-            expect(ErrorCodec.dec(ErrorCodec.enc(second))).not.toEqual(first);
-        });
-    });
-});

package/dist/protocol/types.d.ts

@@ -1 +0,0 @@
-export type HexString = `0x${string}`;

package/dist/protocol/types.js

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

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

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

package/dist/protocol/v1/devicePermission.spec.js

@@ -1,60 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { GenericError } from '../commonCodecs.js';
-import { DevicePermission, DevicePermissionV1_request, DevicePermissionV1_response } from './devicePermission.js';
-describe('DevicePermission codec', () => {
-    it('encodes Notifications at index 0', () => {
-        expect(DevicePermission.enc('Notifications')).toEqual(new Uint8Array([0]));
-        expect(DevicePermission.dec(new Uint8Array([0]))).toEqual('Notifications');
-    });
-    it('encodes Camera at index 1', () => {
-        expect(DevicePermission.enc('Camera')).toEqual(new Uint8Array([1]));
-        expect(DevicePermission.dec(new Uint8Array([1]))).toEqual('Camera');
-    });
-    it('encodes Microphone at index 2', () => {
-        expect(DevicePermission.enc('Microphone')).toEqual(new Uint8Array([2]));
-        expect(DevicePermission.dec(new Uint8Array([2]))).toEqual('Microphone');
-    });
-    it('encodes Bluetooth at index 3', () => {
-        expect(DevicePermission.enc('Bluetooth')).toEqual(new Uint8Array([3]));
-        expect(DevicePermission.dec(new Uint8Array([3]))).toEqual('Bluetooth');
-    });
-    it('encodes NFC at index 4', () => {
-        expect(DevicePermission.enc('NFC')).toEqual(new Uint8Array([4]));
-        expect(DevicePermission.dec(new Uint8Array([4]))).toEqual('NFC');
-    });
-    it('encodes Location at index 5', () => {
-        expect(DevicePermission.enc('Location')).toEqual(new Uint8Array([5]));
-        expect(DevicePermission.dec(new Uint8Array([5]))).toEqual('Location');
-    });
-    it('encodes Clipboard at index 6', () => {
-        expect(DevicePermission.enc('Clipboard')).toEqual(new Uint8Array([6]));
-        expect(DevicePermission.dec(new Uint8Array([6]))).toEqual('Clipboard');
-    });
-    it('encodes OpenUrl at index 7', () => {
-        expect(DevicePermission.enc('OpenUrl')).toEqual(new Uint8Array([7]));
-        expect(DevicePermission.dec(new Uint8Array([7]))).toEqual('OpenUrl');
-    });
-    it('encodes Biometrics at index 8', () => {
-        expect(DevicePermission.enc('Biometrics')).toEqual(new Uint8Array([8]));
-        expect(DevicePermission.dec(new Uint8Array([8]))).toEqual('Biometrics');
-    });
-    it('DevicePermissionV1_request is DevicePermission', () => {
-        expect(DevicePermissionV1_request).toBe(DevicePermission);
-    });
-});
-describe('DevicePermissionV1_response codec', () => {
-    it('encodes and decodes ok(true)', () => {
-        const encoded = DevicePermissionV1_response.enc({ success: true, value: true });
-        expect(DevicePermissionV1_response.dec(encoded)).toEqual({ success: true, value: true });
-    });
-    it('encodes and decodes err with GenericError', () => {
-        const error = new GenericError({ reason: 'denied' });
-        const encoded = DevicePermissionV1_response.enc({ success: false, value: error });
-        const decoded = DevicePermissionV1_response.dec(encoded);
-        expect(decoded.success).toBe(false);
-        if (decoded.success === false) {
-            expect(decoded.value).toBeInstanceOf(GenericError);
-            expect(decoded.value.message).toContain('denied');
-        }
-    });
-});

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

@@ -1,7 +0,0 @@
-export declare const JsonRpcMessageSendV1_request: import("scale-ts").Codec<[`0x${string}`, string]>;
-export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("packages/scale/src/err.js").CodecError<{
-    reason: string;
-}, "GenericError">>>;
-export declare const JsonRpcMessageSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;
-export declare const JsonRpcMessageSubscribeV1_receive: import("scale-ts").Codec<string>;
-export declare const JsonRpcMessageSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;

package/dist/protocol/v1/jsonRpc.js

@@ -1,7 +0,0 @@
-import { Result, Tuple, _void, str } from 'scale-ts';
-import { GenericError, GenesisHash } from '../commonCodecs.js';
-export const JsonRpcMessageSendV1_request = Tuple(GenesisHash, str);
-export const JsonRpcMessageSendV1_response = Result(_void, GenericError);
-export const JsonRpcMessageSubscribeV1_start = GenesisHash;
-export const JsonRpcMessageSubscribeV1_receive = str;
-export const JsonRpcMessageSubscribeV1_interrupt = _void;

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

@@ -1,50 +0,0 @@
-export declare const PermissionErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
-    reason: string;
-}, "PermissionErr::Unknown">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
-    reason: string;
-}, "PermissionErr::Unknown">>] & {
-    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
-        reason: string;
-    }, "PermissionErr::Unknown">>;
-    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
-        reason: string;
-    }, "PermissionErr::Unknown">>;
-} & {
-    readonly Rejected: import("@novasamatech/scale").ErrCodec<undefined, "PermissionErr::Rejected">;
-    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
-        reason: string;
-    }, "PermissionErr::Unknown">;
-};
-export declare const ChainConnectPermission: import("scale-ts").Codec<{
-    genesisHash: `0x${string}`;
-    name: string;
-}>;
-export declare const Permission: import("scale-ts").Codec<{
-    tag: "ChainSubmit";
-    value: `0x${string}`;
-} | {
-    tag: "ChainConnect";
-    value: {
-        genesisHash: `0x${string}`;
-        name: string;
-    };
-} | {
-    tag: "NetworkRequest";
-    value: string[];
-}>;
-export declare const PermissionRequestV1_request: import("scale-ts").Codec<{
-    tag: "ChainSubmit";
-    value: `0x${string}`;
-} | {
-    tag: "ChainConnect";
-    value: {
-        genesisHash: `0x${string}`;
-        name: string;
-    };
-} | {
-    tag: "NetworkRequest";
-    value: string[];
-}>;
-export declare const PermissionRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<undefined, "PermissionErr::Rejected"> | import("@novasamatech/scale").CodecError<{
-    reason: string;
-}, "PermissionErr::Unknown">>>;

package/dist/protocol/v1/permission.js

@@ -1,19 +0,0 @@
-import { Enum, ErrEnum } from '@novasamatech/scale';
-import { Result, Struct, Vector, _void, str } from 'scale-ts';
-import { GenericErr, GenesisHash } from '../commonCodecs.js';
-export const PermissionErr = ErrEnum('PermissionErr', {
-    Rejected: [_void, 'Permission: rejected'],
-    Unknown: [GenericErr, 'Permission: unknown error'],
-});
-export const ChainConnectPermission = Struct({
-    genesisHash: GenesisHash,
-    name: str,
-});
-export const Permission = Enum({
-    ChainSubmit: GenesisHash,
-    ChainConnect: ChainConnectPermission,
-    NetworkRequest: Vector(str),
-    // TBD
-});
-export const PermissionRequestV1_request = Permission;
-export const PermissionRequestV1_response = Result(_void, PermissionErr);

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

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

package/dist/protocol/v1/remotePermission.spec.js

@@ -1,65 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { GenericError } from '../commonCodecs.js';
-import { RemotePermission, RemotePermissionV1_request, RemotePermissionV1_response } from './remotePermission.js';
-describe('RemotePermission codec', () => {
-    it('encodes and decodes Remote (index 0) with domain list', () => {
-        const value = { tag: 'Remote', value: ['api.coingecko.com', '*.example.com'] };
-        const encoded = RemotePermission.enc(value);
-        expect(encoded[0]).toBe(0);
-        expect(RemotePermission.dec(encoded)).toEqual(value);
-    });
-    it('encodes and decodes WebRTC at index 1', () => {
-        const value = { tag: 'WebRTC', value: undefined };
-        const encoded = RemotePermission.enc(value);
-        expect(encoded[0]).toBe(1);
-        expect(RemotePermission.dec(encoded)).toEqual(value);
-    });
-    it('encodes and decodes ChainSubmit at index 2', () => {
-        const value = { tag: 'ChainSubmit', value: undefined };
-        const encoded = RemotePermission.enc(value);
-        expect(encoded[0]).toBe(2);
-        expect(RemotePermission.dec(encoded)).toEqual(value);
-    });
-    it('encodes and decodes PreimageSubmit at index 3', () => {
-        const value = { tag: 'PreimageSubmit', value: undefined };
-        const encoded = RemotePermission.enc(value);
-        expect(encoded[0]).toBe(3);
-        expect(RemotePermission.dec(encoded)).toEqual(value);
-    });
-    it('encodes and decodes StatementSubmit at index 4', () => {
-        const value = { tag: 'StatementSubmit', value: undefined };
-        const encoded = RemotePermission.enc(value);
-        expect(encoded[0]).toBe(4);
-        expect(RemotePermission.dec(encoded)).toEqual(value);
-    });
-    it('RemotePermissionV1_request encodes a batch of multiple permissions', () => {
-        const batch = [
-            { tag: 'Remote', value: ['api.example.com'] },
-            { tag: 'ChainSubmit', value: undefined },
-            { tag: 'StatementSubmit', value: undefined },
-        ];
-        const encoded = RemotePermissionV1_request.enc(batch);
-        const decoded = RemotePermissionV1_request.dec(encoded);
-        expect(decoded).toEqual(batch);
-    });
-    it('RemotePermissionV1_request encodes an empty batch', () => {
-        RemotePermissionV1_request.enc([]);
-        expect(RemotePermissionV1_request.dec(RemotePermissionV1_request.enc([]))).toEqual([]);
-    });
-});
-describe('RemotePermissionV1_response codec', () => {
-    it('encodes and decodes ok(true)', () => {
-        const encoded = RemotePermissionV1_response.enc({ success: true, value: true });
-        expect(RemotePermissionV1_response.dec(encoded)).toEqual({ success: true, value: true });
-    });
-    it('encodes and decodes err with GenericError', () => {
-        const error = new GenericError({ reason: 'denied' });
-        const encoded = RemotePermissionV1_response.enc({ success: false, value: error });
-        const decoded = RemotePermissionV1_response.dec(encoded);
-        expect(decoded.success).toBe(false);
-        if (decoded.success === false) {
-            expect(decoded.value).toBeInstanceOf(GenericError);
-            expect(decoded.value.message).toContain('denied');
-        }
-    });
-});

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

@@ -1,31 +0,0 @@
-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/storage.js

@@ -1,17 +0,0 @@
-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);