@novasamatech/host-api 0.5.2 → 0.5.4-0

package/dist/protocol/v1/statementStore.js

@@ -1,5 +1,6 @@
+import { Enum, ErrEnum } from '@novasamatech/scale';
 import { Bytes, Option, Result, Struct, Tuple, Vector, _void, u32, u64 } from 'scale-ts';
-import { Enum, ErrEnum, GenericErr } from '../commonCodecs.js';
+import { GenericErr, GenericError } from '../commonCodecs.js';
 import { ProductAccountId } from './accounts.js';
 // structs definition
 export const Topic = Bytes(32);
@@ -37,6 +38,19 @@ export const Statement = Struct({
     topics: Vector(Topic),
     data: Option(Bytes()),
 });
+export const SignedStatement = Struct({
+    proof: StatementProof,
+    decryptionKey: Option(DecryptionKey),
+    priority: Option(u32),
+    channel: Option(Channel),
+    topics: Vector(Topic),
+    data: Option(Bytes()),
+});
+// query
+export const StatementStoreQueryV1_request = Vector(Topic);
+export const StatementStoreQueryV1_response = Result(Vector(SignedStatement), GenericError);
+export const StatementStoreSubscribeV1_start = Vector(Topic);
+export const StatementStoreSubscribeV1_receive = Vector(SignedStatement);
 // creating proof
 export const StatementProofErr = ErrEnum('StatementProofErr', {
     UnableToSign: [_void, 'StatementProof: unable to sign'],
@@ -45,3 +59,6 @@ export const StatementProofErr = ErrEnum('StatementProofErr', {
 });
 export const StatementStoreCreateProofV1_request = Tuple(ProductAccountId, Statement);
 export const StatementStoreCreateProofV1_response = Result(StatementProof, StatementProofErr);
+// submit
+export const StatementStoreSubmitV1_request = SignedStatement;
+export const StatementStoreSubmitV1_response = Result(_void, GenericError);

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

@@ -1,87 +1,31 @@
-export declare const StorageErr: [import("scale-ts").Encoder<(Error & {
-    name: "StorageErr::Unknown";
-    className: string;
-    payload: {
+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;
-    };
-}) | (Error & {
-    name: "StorageErr::Full";
-    className: string;
-    payload: undefined;
-})>, import("scale-ts").Decoder<(Error & {
-    name: "StorageErr::Unknown";
-    className: string;
-    payload: {
+    }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
         reason: string;
-    };
-}) | (Error & {
-    name: "StorageErr::Full";
-    className: string;
-    payload: undefined;
-})>] & {
-    enc: import("scale-ts").Encoder<(Error & {
-        name: "StorageErr::Unknown";
-        className: string;
-        payload: {
-            reason: string;
-        };
-    }) | (Error & {
-        name: "StorageErr::Full";
-        className: string;
-        payload: undefined;
-    })>;
-    dec: import("scale-ts").Decoder<(Error & {
-        name: "StorageErr::Unknown";
-        className: string;
-        payload: {
-            reason: string;
-        };
-    }) | (Error & {
-        name: "StorageErr::Full";
-        className: string;
-        payload: undefined;
-    })>;
+    }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>;
 } & {
-    readonly Full: import("../commonCodecs.js").ErrCodec<undefined, "StorageErr::Full">;
-    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+    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<`0x${string}`>;
+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<`0x${string}`>;
-export declare const StorageReadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike> | undefined, (Error & {
-    name: "StorageErr::Unknown";
-    className: string;
-    payload: {
-        reason: string;
-    };
-}) | (Error & {
-    name: "StorageErr::Full";
-    className: string;
-    payload: undefined;
-})>>;
-export declare const StorageWriteV1_request: import("scale-ts").Codec<[`0x${string}`, Uint8Array<ArrayBufferLike>]>;
-export declare const StorageWriteV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
-    name: "StorageErr::Unknown";
-    className: string;
-    payload: {
-        reason: string;
-    };
-}) | (Error & {
-    name: "StorageErr::Full";
-    className: string;
-    payload: undefined;
-})>>;
-export declare const StorageClearV1_request: import("scale-ts").Codec<`0x${string}`>;
-export declare const StorageClearV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
-    name: "StorageErr::Unknown";
-    className: string;
-    payload: {
-        reason: string;
-    };
-}) | (Error & {
-    name: "StorageErr::Full";
-    className: string;
-    payload: undefined;
-})>>;
+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,11 +1,12 @@
-import { Bytes, Option, Result, Tuple, _void } from 'scale-ts';
-import { ErrEnum, GenericErr, Hex } from '../commonCodecs.js';
+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, 'Storage: unknown error'],
+    Unknown: [GenericErr, 'Unknown storage error'],
 });
-export const StorageKey = Hex();
+export const StorageKey = str;
 export const StorageValue = Bytes();
 // actions
 export const StorageReadV1_request = StorageKey;

package/dist/transport.js

@@ -1,6 +1,7 @@
+import { enumValue, isEnumVariant, resultErr, resultOk } from '@novasamatech/scale';
 import { createNanoEvents } from 'nanoevents';
 import { HANDSHAKE_INTERVAL, HANDSHAKE_TIMEOUT, JAM_CODEC_PROTOCOL_ID } from './constants.js';
-import { composeAction, createRequestId, delay, enumValue, errResult, isEnumVariant, okResult, promiseWithResolvers, } from './helpers.js';
+import { composeAction, createRequestId, delay, promiseWithResolvers } from './helpers.js';
 import { Message } from './protocol/messageCodec.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
 const isConnected = (status) => status === 'connected';
@@ -234,13 +235,13 @@ export function createTransport(provider) {
                     codecVersion = version.value;
                     switch (version.value) {
                         case JAM_CODEC_PROTOCOL_ID:
-                            return enumValue(version.tag, okResult(undefined));
+                            return enumValue(version.tag, resultOk(undefined));
                         default:
-                            return enumValue(version.tag, errResult(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
+                            return enumValue(version.tag, resultErr(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
                     }
                 }
                 default:
-                    return enumValue(version.tag, errResult(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
+                    return enumValue(version.tag, resultErr(new HandshakeErr.UnsupportedProtocolVersion(undefined)));
             }
         });
     }

package/dist/types.d.ts

@@ -1,5 +1,7 @@
+import type { HostApiProtocol } from './protocol/impl.js';
 import type { ComposeMessageAction, MessageAction, MessagePayloadSchema, PickMessagePayload, PickMessagePayloadValue } from './protocol/messageCodec.js';
 import type { Provider } from './provider.js';
+export type HostApiMethod = keyof HostApiProtocol;
 export type Logger = Record<'info' | 'warn' | 'error' | 'log', (...args: unknown[]) => void>;
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export type RequestHandler<Method extends string> = (message: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>) => PromiseLike<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
@@ -14,10 +16,10 @@ export type Transport = {
     isReady(): Promise<boolean>;
     onConnectionStatusChange(callback: (status: ConnectionStatus) => void): VoidFunction;
     dispose(): void;
-    request<const Method extends string>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>, signal?: AbortSignal): Promise<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
-    handleRequest<const Method extends string>(method: Method, handler: RequestHandler<Method>): VoidFunction;
-    subscribe<const Method extends string>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, callback: (payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void): Subscription;
-    handleSubscription<const Method extends string>(method: Method, handler: SubscriptionHandler<Method>): VoidFunction;
+    request<const Method extends HostApiMethod>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>, signal?: AbortSignal): Promise<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
+    handleRequest<const Method extends HostApiMethod>(method: Method, handler: RequestHandler<Method>): VoidFunction;
+    subscribe<const Method extends HostApiMethod>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, callback: (payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void): Subscription;
+    handleSubscription<const Method extends HostApiMethod>(method: Method, handler: SubscriptionHandler<Method>): VoidFunction;
     postMessage(requestId: string, payload: MessagePayloadSchema): void;
     listenMessages<const Action extends MessageAction>(action: Action, callback: (requestId: string, data: PickMessagePayload<Action>) => void, onError?: (error: unknown) => void): VoidFunction;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.5.2",
+  "version": "0.5.4-0",
   "description": "Host API: transport implementation for host - product integration.",
   "license": "Apache-2.0",
   "repository": {
@@ -21,6 +21,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@novasamatech/scale": "0.5.4-0",
     "@polkadot-api/utils": "^0.2.0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.6",