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

package/dist/hostApi.js

@@ -8,6 +8,7 @@ import { DeriveEntropyErr } from './protocol/v1/deriveEntropy.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
 import { StorageErr } from './protocol/v1/localStorage.js';
 import { NavigateToErr } from './protocol/v1/navigation.js';
+import { PushNotificationError } from './protocol/v1/notification.js';
 import { PaymentRequestErr, PaymentTopUpErr } from './protocol/v1/payments.js';
 import { PreimageSubmitErr } from './protocol/v1/preimage.js';
 import { ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';
@@ -44,6 +45,12 @@ export function createHostApi(transport) {
         },
         pushNotification(payload) {
             return makeRequest(transport.request('host_push_notification', payload), reason => ({
+                tag: payload.tag,
+                value: new PushNotificationError.Unknown({ reason }),
+            }));
+        },
+        pushNotificationCancel(payload) {
+            return makeRequest(transport.request('host_push_notification_cancel', payload), reason => ({
                 tag: payload.tag,
                 value: new GenericError({ reason }),
             }));

package/dist/index.d.ts

@@ -21,7 +21,7 @@ export { SignedStatement, SignedStatementsPage, Statement, StatementProofErr, To
 export { StorageErr } from './protocol/v1/localStorage.js';
 export { DevicePermission } from './protocol/v1/devicePermission.js';
 export { RemotePermission } from './protocol/v1/remotePermission.js';
-export { PushNotification } from './protocol/v1/notification.js';
+export { NotificationId, PushNotification, PushNotificationError } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { AllocatableResource, AllocationOutcome, ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';

package/dist/index.js

@@ -16,7 +16,7 @@ export { SignedStatement, SignedStatementsPage, Statement, StatementProofErr, To
 export { StorageErr } from './protocol/v1/localStorage.js';
 export { DevicePermission } from './protocol/v1/devicePermission.js';
 export { RemotePermission } from './protocol/v1/remotePermission.js';
-export { PushNotification } from './protocol/v1/notification.js';
+export { NotificationId, PushNotification, PushNotificationError } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { AllocatableResource, AllocationOutcome, ResourceAllocationErr } from './protocol/v1/resourceAllocation.js';

package/dist/protocol/impl.d.ts

@@ -36,9 +36,10 @@ export declare const hostApiProtocol: {
         readonly v1: [Codec<{
             text: string;
             deeplink: string | undefined;
-        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            scheduledAt: bigint | undefined;
+        }>, Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
             reason: string;
-        }, "GenericError">>>];
+        }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>];
     }>;
     readonly host_navigate_to: VersionedProtocolRequest<{
         readonly v1: [Codec<string>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
@@ -982,5 +983,10 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>>];
     }>;
+    readonly host_push_notification_cancel: VersionedProtocolRequest<{
+        readonly v1: [Codec<number>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
 };
 export {};

package/dist/protocol/impl.js

@@ -10,7 +10,7 @@ import { FeatureV1_request, FeatureV1_response } from './v1/feature.js';
 import { HandshakeV1_request, HandshakeV1_response } from './v1/handshake.js';
 import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request, StorageReadV1_response, StorageWriteV1_request, StorageWriteV1_response, } from './v1/localStorage.js';
 import { NavigateToV1_request, NavigateToV1_response } from './v1/navigation.js';
-import { PushNotificationV1_request, PushNotificationV1_response } from './v1/notification.js';
+import { PushNotificationCancelV1_request, PushNotificationCancelV1_response, PushNotificationV1_request, PushNotificationV1_response, } from './v1/notification.js';
 import { PaymentBalanceSubscribeV1_interrupt, PaymentBalanceSubscribeV1_receive, PaymentBalanceSubscribeV1_start, PaymentRequestV1_request, PaymentRequestV1_response, PaymentStatusSubscribeV1_interrupt, PaymentStatusSubscribeV1_receive, PaymentStatusSubscribeV1_start, PaymentTopUpV1_request, PaymentTopUpV1_response, } from './v1/payments.js';
 import { PreimageLookupSubscribeV1_interrupt, PreimageLookupSubscribeV1_receive, PreimageLookupSubscribeV1_start, PreimageSubmitV1_request, PreimageSubmitV1_response, } from './v1/preimage.js';
 import { RemotePermissionV1_request, RemotePermissionV1_response } from './v1/remotePermission.js';
@@ -211,4 +211,7 @@ export const hostApiProtocol = {
     remote_statement_store_create_proof_authorized: versionedRequest({
         v1: [StatementStoreCreateProofAuthorizedV1_request, StatementStoreCreateProofAuthorizedV1_response],
     }),
+    host_push_notification_cancel: versionedRequest({
+        v1: [PushNotificationCancelV1_request, PushNotificationCancelV1_response],
+    }),
 };

package/dist/protocol/messageCodec.d.ts

@@ -28,11 +28,12 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
     readonly v1: Codec<{
         text: string;
         deeplink: string | undefined;
+        scheduledAt: bigint | undefined;
     }>;
 }>> & Record<"host_push_notification_response", EnumCodec<{
-    readonly v1: Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    readonly v1: Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
         reason: string;
-    }, "GenericError">>>;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>;
 }>> & Record<"host_navigate_to_request", EnumCodec<{
     readonly v1: Codec<string>;
 }>> & Record<"host_navigate_to_response", EnumCodec<{
@@ -1050,6 +1051,12 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
     }, import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>>;
+}>> & Record<"host_push_notification_cancel_request", EnumCodec<{
+    readonly v1: Codec<number>;
+}>> & Record<"host_push_notification_cancel_response", EnumCodec<{
+    readonly v1: Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "GenericError">>>;
 }>>>;
 export declare const Message: Codec<{
     requestId: string;
@@ -1091,15 +1098,16 @@ export declare const Message: Codec<{
             value: {
                 text: string;
                 deeplink: string | undefined;
+                scheduledAt: bigint | undefined;
             };
         };
     } | {
         tag: "host_push_notification_response";
         value: {
             tag: "v1";
-            value: import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            value: import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
                 reason: string;
-            }, "GenericError">>;
+            }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
         };
     } | {
         tag: "host_navigate_to_request";
@@ -2583,6 +2591,20 @@ export declare const Message: Codec<{
                 reason: string;
             }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>;
         };
+    } | {
+        tag: "host_push_notification_cancel_request";
+        value: {
+            tag: "v1";
+            value: number;
+        };
+    } | {
+        tag: "host_push_notification_cancel_response";
+        value: {
+            tag: "v1";
+            value: import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "GenericError">>;
+        };
     };
 }>;
 export type MessageAction = MessagePayloadSchema['tag'];

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

@@ -1,11 +1,39 @@
+export declare const NotificationId: import("scale-ts").Codec<number>;
 export declare const PushNotification: import("scale-ts").Codec<{
     text: string;
     deeplink: string | undefined;
+    scheduledAt: bigint | undefined;
 }>;
+export declare const PushNotificationError: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>;
+} & {
+    readonly ScheduleLimitReached: import("@novasamatech/scale").ErrCodec<undefined, "PushNotificationError::ScheduleLimitReached">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PushNotificationError::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">;
+};
 export declare const PushNotificationV1_request: import("scale-ts").Codec<{
     text: string;
     deeplink: string | undefined;
+    scheduledAt: bigint | undefined;
 }>;
-export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PushNotificationError::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PushNotificationError::ScheduleLimitReached">>>;
+export declare const PushNotificationCancelV1_request: import("scale-ts").Codec<number>;
+export declare const PushNotificationCancelV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/notification.js

@@ -1,8 +1,17 @@
-import { Option, Result, Struct, _void, str } from 'scale-ts';
-import { GenericError } from '../commonCodecs.js';
+import { ErrEnum } from '@novasamatech/scale';
+import { Option, Result, Struct, _void, str, u32, u64 } from 'scale-ts';
+import { GenericErr, GenericError } from '../commonCodecs.js';
+export const NotificationId = u32;
 export const PushNotification = Struct({
     text: str,
     deeplink: Option(str),
+    scheduledAt: Option(u64),
+});
+export const PushNotificationError = ErrEnum('PushNotificationError', {
+    ScheduleLimitReached: [_void, 'Schedule limit reached'],
+    Unknown: [GenericErr, 'Unknown error'],
 });
 export const PushNotificationV1_request = PushNotification;
-export const PushNotificationV1_response = Result(_void, GenericError);
+export const PushNotificationV1_response = Result(NotificationId, PushNotificationError);
+export const PushNotificationCancelV1_request = NotificationId;
+export const PushNotificationCancelV1_response = Result(_void, GenericError);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.7.9-3",
+  "version": "0.7.9-5",
   "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-5",
     "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);