@novasamatech/host-api 0.7.1-1 → 0.7.2-0

package/dist/protocol/messageCodec.js

@@ -11,7 +11,7 @@ const createPayload = (hostApi) => {
         if (payload.method === 'subscribe') {
             fields[`${method}_start`] = payload.start;
             fields[`${method}_stop`] = _void;
-            fields[`${method}_interrupt`] = _void;
+            fields[`${method}_interrupt`] = payload.interrupt;
             fields[`${method}_receive`] = payload.receive;
         }
     }

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

@@ -63,6 +63,7 @@ export declare const CreateProofErr: [import("scale-ts").Encoder<import("@novasa
 export declare const AccountConnectionStatus: import("scale-ts").Codec<"disconnected" | "connected">;
 export declare const AccountConnectionStatusV1_start: import("scale-ts").Codec<undefined>;
 export declare const AccountConnectionStatusV1_receive: import("scale-ts").Codec<"disconnected" | "connected">;
+export declare const AccountConnectionStatusV1_interrupt: import("scale-ts").Codec<undefined>;
 export declare const AccountGetRootV1_request: import("scale-ts").Codec<undefined>;
 export declare const AccountGetRootV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
     publicKey: Uint8Array<ArrayBufferLike>;

package/dist/protocol/v1/accounts.js

@@ -42,6 +42,7 @@ export const CreateProofErr = ErrEnum('CreateProofErr', {
 export const AccountConnectionStatus = Status('disconnected', 'connected');
 export const AccountConnectionStatusV1_start = _void;
 export const AccountConnectionStatusV1_receive = AccountConnectionStatus;
+export const AccountConnectionStatusV1_interrupt = _void;
 // account_get_root
 export const AccountGetRootV1_request = _void;
 export const AccountGetRootV1_response = Result(Account, RequestCredentialsErr);

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

@@ -242,6 +242,7 @@ export declare const ChainHeadFollowV1_receive: import("scale-ts").Codec<{
     tag: "Stop";
     value: undefined;
 }>;
+export declare const ChainHeadFollowV1_interrupt: import("scale-ts").Codec<undefined>;
 export declare const ChainHeadHeaderV1_request: import("scale-ts").Codec<{
     genesisHash: `0x${string}`;
     followSubscriptionId: string;

package/dist/protocol/v1/chainInteraction.js

@@ -85,6 +85,7 @@ export const ChainHeadEvent = Enum({
     Stop: _void,
 });
 export const ChainHeadFollowV1_receive = ChainHeadEvent;
+export const ChainHeadFollowV1_interrupt = _void;
 // === ChainHead Header ===
 export const ChainHeadHeaderV1_request = Struct({
     genesisHash: GenesisHash,

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

@@ -82,6 +82,7 @@ export declare const ChatListSubscribeV1_receive: Codec<{
     roomId: string;
     participatingAs: "RoomHost" | "Bot";
 }[]>;
+export declare const ChatListSubscribeV1_interrupt: Codec<undefined>;
 export declare const ChatAction: Codec<{
     actionId: string;
     title: string;
@@ -458,9 +459,11 @@ export declare const ChatActionSubscribeV1_receive: Codec<{
         };
     };
 }>;
+export declare const ChatActionSubscribeV1_interrupt: Codec<undefined>;
 export declare const ChatCustomMessageRenderingV1_start: Codec<{
     messageId: string;
     messageType: string;
     payload: Uint8Array<ArrayBufferLike>;
 }>;
 export declare const ChatCustomMessageRenderingV1_receive: Codec<CustomRendererNodeType>;
+export declare const ChatCustomMessageRenderingV1_interrupt: Codec<undefined>;

package/dist/protocol/v1/chat.js

@@ -42,6 +42,7 @@ export const ChatRoom = Struct({
 });
 export const ChatListSubscribeV1_start = _void;
 export const ChatListSubscribeV1_receive = Vector(ChatRoom);
+export const ChatListSubscribeV1_interrupt = _void;
 // message format
 export const ChatAction = Struct({
     actionId: str,
@@ -119,6 +120,8 @@ export const ReceivedChatAction = Struct({
 });
 export const ChatActionSubscribeV1_start = _void;
 export const ChatActionSubscribeV1_receive = ReceivedChatAction;
+export const ChatActionSubscribeV1_interrupt = _void;
 // custom message rendering
 export const ChatCustomMessageRenderingV1_start = Struct({ messageId: str, messageType: str, payload: Bytes() });
 export const ChatCustomMessageRenderingV1_receive = CustomRendererNode;
+export const ChatCustomMessageRenderingV1_interrupt = _void;

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

@@ -4,3 +4,4 @@ export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<imp
 }, "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

@@ -4,3 +4,4 @@ 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/payments.d.ts

@@ -2,7 +2,7 @@ export declare const Ed25519PrivateKey: import("scale-ts").Codec<Uint8Array<Arra
 export declare const PaymentId: import("scale-ts").Codec<string>;
 export declare const PaymentTopUpSource: import("scale-ts").Codec<{
     tag: "ProductAccount";
-    value: [string, number];
+    value: number;
 } | {
     tag: "PrivateKey";
     value: Uint8Array<ArrayBufferLike>;
@@ -97,11 +97,28 @@ export declare const PaymentBalanceSubscribeV1_start: import("scale-ts").Codec<u
 export declare const PaymentBalanceSubscribeV1_receive: import("scale-ts").Codec<{
     available: bigint;
 }>;
+export declare const PaymentBalanceSubscribeV1_interrupt: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentBalanceErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentBalanceErr::PermissionDenied">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentBalanceErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentBalanceErr::PermissionDenied">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentBalanceErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentBalanceErr::PermissionDenied">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentBalanceErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentBalanceErr::PermissionDenied">>;
+} & {
+    readonly PermissionDenied: import("@novasamatech/scale").ErrCodec<undefined, "PaymentBalanceErr::PermissionDenied">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PaymentBalanceErr::Unknown">;
+};
 export declare const PaymentTopUpV1_request: import("scale-ts").Codec<{
     amount: bigint;
     source: {
         tag: "ProductAccount";
-        value: [string, number];
+        value: number;
     } | {
         tag: "PrivateKey";
         value: Uint8Array<ArrayBufferLike>;
@@ -130,3 +147,20 @@ export declare const PaymentStatusSubscribeV1_receive: import("scale-ts").Codec<
     tag: "Failed";
     value: string;
 }>;
+export declare const PaymentStatusSubscribeV1_interrupt: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentStatusErr::PaymentNotFound">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentStatusErr::PaymentNotFound">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentStatusErr::PaymentNotFound">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentStatusErr::PaymentNotFound">>;
+} & {
+    readonly PaymentNotFound: import("@novasamatech/scale").ErrCodec<undefined, "PaymentStatusErr::PaymentNotFound">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PaymentStatusErr::Unknown">;
+};

package/dist/protocol/v1/payments.js

@@ -1,12 +1,12 @@
 import { Enum, ErrEnum } from '@novasamatech/scale';
 import { Bytes, Result, Struct, _void, str, u128 } from 'scale-ts';
 import { GenericErr } from '../commonCodecs.js';
-import { ProductAccountId } from './accounts.js';
+import { DerivationIndex } from './accounts.js';
 // common types
 export const Ed25519PrivateKey = Bytes(32);
 export const PaymentId = str;
 export const PaymentTopUpSource = Enum({
-    ProductAccount: ProductAccountId,
+    ProductAccount: DerivationIndex,
     PrivateKey: Ed25519PrivateKey,
 });
 export const PaymentBalance = Struct({
@@ -42,6 +42,7 @@ export const PaymentStatusErr = ErrEnum('PaymentStatusErr', {
 // host_payment_balance_subscribe
 export const PaymentBalanceSubscribeV1_start = _void;
 export const PaymentBalanceSubscribeV1_receive = PaymentBalance;
+export const PaymentBalanceSubscribeV1_interrupt = PaymentBalanceErr;
 // host_payment_top_up
 export const PaymentTopUpV1_request = Struct({
     amount: u128,
@@ -57,3 +58,4 @@ export const PaymentRequestV1_response = Result(PaymentReceipt, PaymentRequestEr
 // host_payment_status_subscribe
 export const PaymentStatusSubscribeV1_start = PaymentId;
 export const PaymentStatusSubscribeV1_receive = PaymentStatus;
+export const PaymentStatusSubscribeV1_interrupt = PaymentStatusErr;

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

@@ -2,6 +2,7 @@ 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 PreimageLookupSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;
 export declare const PreimageSubmitErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "PreimageSubmitErr::Unknown">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{

package/dist/protocol/v1/preimage.js

@@ -1,10 +1,11 @@
 import { ErrEnum, Hex, Nullable } from '@novasamatech/scale';
-import { Bytes, Result } from 'scale-ts';
+import { Bytes, Result, _void } 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 PreimageLookupSubscribeV1_interrupt = _void;
 export const PreimageSubmitErr = ErrEnum('PreimageSubmitErr', {
     Unknown: [GenericErr, 'Unknown error'],
 });

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

@@ -14,7 +14,7 @@ export declare const RemotePermission: import("scale-ts").Codec<{
     tag: "StatementSubmit";
     value: undefined;
 }>;
-export declare const RemotePermissionV1_request: import("scale-ts").Codec<({
+export declare const RemotePermissionV1_request: import("scale-ts").Codec<{
     tag: "Remote";
     value: string[];
 } | {
@@ -29,7 +29,7 @@ export declare const RemotePermissionV1_request: import("scale-ts").Codec<({
 } | {
     tag: "StatementSubmit";
     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

@@ -8,5 +8,5 @@ export const RemotePermission = Enum({
     PreimageSubmit: _void,
     StatementSubmit: _void,
 });
-export const RemotePermissionV1_request = Vector(RemotePermission);
+export const RemotePermissionV1_request = RemotePermission;
 export const RemotePermissionV1_response = Result(bool, GenericError);

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

@@ -153,6 +153,7 @@ export declare const StatementStoreSubscribeV1_receive: import("scale-ts").Codec
     }[];
     isComplete: boolean;
 }>;
+export declare const StatementStoreSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;
 export declare const StatementProofErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "StatementProofErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnableToSign"> | import("@novasamatech/scale").CodecError<undefined, "StatementProofErr::UnknownAccount">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{

package/dist/protocol/v1/statementStore.js

@@ -57,6 +57,7 @@ export const SignedStatementsPage = Struct({
 });
 export const StatementStoreSubscribeV1_start = TopicFilter;
 export const StatementStoreSubscribeV1_receive = SignedStatementsPage;
+export const StatementStoreSubscribeV1_interrupt = _void;
 // creating proof
 export const StatementProofErr = ErrEnum('StatementProofErr', {
     UnableToSign: [_void, 'StatementProof: unable to sign'],

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

@@ -1,3 +1,4 @@
 export declare const Theme: import("scale-ts").Codec<"light" | "dark">;
 export declare const ThemeSubscribeV1_start: import("scale-ts").Codec<undefined>;
 export declare const ThemeSubscribeV1_receive: import("scale-ts").Codec<"light" | "dark">;
+export declare const ThemeSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;

package/dist/protocol/v1/theme.js

@@ -3,3 +3,4 @@ import { _void } from 'scale-ts';
 export const Theme = Status('light', 'dark');
 export const ThemeSubscribeV1_start = _void;
 export const ThemeSubscribeV1_receive = Theme;
+export const ThemeSubscribeV1_interrupt = _void;

package/dist/transport.js

@@ -187,9 +187,9 @@ export function createTransport(provider) {
                         }
                     }
                 });
-                const unsubscribeInterrupt = transport.listenMessages(interruptAction, receivedId => {
+                const unsubscribeInterrupt = transport.listenMessages(interruptAction, (receivedId, data) => {
                     if (receivedId === requestId) {
-                        events.emit('interrupt');
+                        events.emit('interrupt', data.value);
                         stopSubscription();
                     }
                 });
@@ -230,10 +230,10 @@ export function createTransport(provider) {
                 const unsubscribe = handler(payload.value, value => {
                     const receivePayload = enumValue(receiveAction, value);
                     transport.postMessage(requestId, receivePayload);
-                }, () => {
+                }, value => {
                     interrupted = true;
                     subscriptions.delete(requestId);
-                    transport.postMessage(requestId, enumValue(interruptAction, undefined));
+                    transport.postMessage(requestId, enumValue(interruptAction, value));
                 });
                 if (interrupted) {
                     unsubscribe();

package/dist/types.d.ts

@@ -7,11 +7,12 @@ export type Logger = Record<'info' | 'warn' | 'error' | 'log', (...args: unknown
 };
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export type RequestHandler<Method extends string> = (message: PickMessagePayloadValue<ComposeMessageAction<Method, 'request'>>) => PromiseLike<PickMessagePayloadValue<ComposeMessageAction<Method, 'response'>>>;
-export type SubscriptionHandler<Method extends string> = (params: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, send: (value: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void, interrupt: () => void) => VoidFunction;
-export type Subscription = {
+export type SubscriptionHandler<Method extends string> = (params: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, send: (value: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void, interrupt: (value: PickMessagePayloadValue<ComposeMessageAction<Method, 'interrupt'>>) => void) => VoidFunction;
+export type Subscription<InterruptPayload = unknown> = {
     unsubscribe: VoidFunction;
-    onInterrupt(callback: VoidFunction): VoidFunction;
+    onInterrupt(callback: (payload: InterruptPayload) => void): VoidFunction;
 };
+export type SubscriptionFor<Method extends HostApiMethod> = Subscription<PickMessagePayloadValue<ComposeMessageAction<Method, 'interrupt'>>>;
 export type Transport = {
     readonly provider: Provider;
     isCorrectEnvironment(): boolean;
@@ -21,7 +22,7 @@ export type Transport = {
     onDestroy(callback: VoidFunction): 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;
+    subscribe<const Method extends HostApiMethod>(method: Method, payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'start'>>, callback: (payload: PickMessagePayloadValue<ComposeMessageAction<Method, 'receive'>>) => void): SubscriptionFor<Method>;
     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.7.1-1",
+  "version": "0.7.2-0",
   "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.1-1",
+    "@novasamatech/scale": "0.7.2-0",
     "nanoevents": "9.1.0",
     "nanoid": "5.1.9",
     "neverthrow": "^8.2.0",