@novasamatech/host-api 0.9.4 → 0.10.1

package/dist/protocol/v1/devicePermission.js

@@ -1,6 +1,7 @@
 import { Status } from '@novasamatech/scale';
-import { Result, bool } from 'scale-ts';
+import { bool } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericError } from '../commonCodecs.js';
 export const DevicePermission = Status('Notifications', 'Camera', 'Microphone', 'Bluetooth', 'NFC', 'Location', 'Clipboard', 'OpenUrl', 'Biometrics');
 export const DevicePermissionV1_request = DevicePermission;
-export const DevicePermissionV1_response = Result(bool, GenericError);
+export const DevicePermissionV1_response = CallResult(bool, GenericError);

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

@@ -6,6 +6,6 @@ export declare const FeatureV1_request: import("scale-ts").Codec<{
     tag: "Chain";
     value: `0x${string}`;
 }>;
-export declare const FeatureV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, import("@novasamatech/scale").CodecError<{
+export declare const FeatureV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<boolean, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/feature.js

@@ -1,8 +1,9 @@
 import { Enum, Hex } from '@novasamatech/scale';
-import { Result, bool } from 'scale-ts';
+import { bool } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericError } from '../commonCodecs.js';
 export const Feature = Enum({
     Chain: Hex(),
 });
 export const FeatureV1_request = Feature;
-export const FeatureV1_response = Result(bool, GenericError);
+export const FeatureV1_response = CallResult(bool, GenericError);

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

@@ -24,6 +24,6 @@ export declare const HandshakeErr: [import("scale-ts").Encoder<import("@novasama
  * HandshakeV1_request = 1 - SCALE codec
  */
 export declare const HandshakeV1_request: import("scale-ts").Codec<number>;
-export declare const HandshakeV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+export declare const HandshakeV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "HandshakeErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "HandshakeErr::Timeout"> | import("@novasamatech/scale").CodecError<undefined, "HandshakeErr::UnsupportedProtocolVersion">>>;

package/dist/protocol/v1/handshake.js

@@ -1,5 +1,6 @@
 import { ErrEnum } from '@novasamatech/scale';
-import { Result, _void, u8 } from 'scale-ts';
+import { _void, u8 } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 export const HandshakeErr = ErrEnum('HandshakeErr', {
     Timeout: [_void, 'Handshake: timeout'],
@@ -10,4 +11,4 @@ export const HandshakeErr = ErrEnum('HandshakeErr', {
  * HandshakeV1_request = 1 - SCALE codec
  */
 export const HandshakeV1_request = u8;
-export const HandshakeV1_response = Result(_void, HandshakeErr);
+export const HandshakeV1_response = CallResult(_void, HandshakeErr);

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

@@ -22,14 +22,21 @@ export declare const StorageErr: [import("scale-ts").Encoder<import("@novasamate
 export declare const StorageKey: import("scale-ts").Codec<string>;
 export declare const StorageValue: import("@novasamatech/scale").BytesCodec<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<{
+export declare const StorageReadV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<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<{
+export declare const StorageWriteV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<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<{
+export declare const StorageClearV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "StorageErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "StorageErr::Full">>>;
+export declare const StorageSubscribeV1_start: import("scale-ts").Codec<{
+    key: string;
+}>;
+export declare const StorageSubscribeV1_receive: import("scale-ts").Codec<{
+    value: Uint8Array<ArrayBufferLike> | undefined;
+}>;
+export declare const StorageSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;

package/dist/protocol/v1/localStorage.js

@@ -1,5 +1,6 @@
 import { Bytes, ErrEnum } from '@novasamatech/scale';
-import { Option, Result, Tuple, _void, str } from 'scale-ts';
+import { Option, Struct, Tuple, _void, str } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 // common structures
 export const StorageErr = ErrEnum('StorageErr', {
@@ -10,8 +11,13 @@ export const StorageKey = str;
 export const StorageValue = Bytes();
 // actions
 export const StorageReadV1_request = StorageKey;
-export const StorageReadV1_response = Result(Option(StorageValue), StorageErr);
+export const StorageReadV1_response = CallResult(Option(StorageValue), StorageErr);
 export const StorageWriteV1_request = Tuple(StorageKey, StorageValue);
-export const StorageWriteV1_response = Result(_void, StorageErr);
+export const StorageWriteV1_response = CallResult(_void, StorageErr);
 export const StorageClearV1_request = StorageKey;
-export const StorageClearV1_response = Result(_void, StorageErr);
+export const StorageClearV1_response = CallResult(_void, StorageErr);
+// Emits the current value first, then one item per later write or clear of the
+// key. `None` represents a cleared or absent key.
+export const StorageSubscribeV1_start = Struct({ key: StorageKey });
+export const StorageSubscribeV1_receive = Struct({ value: Option(StorageValue) });
+export const StorageSubscribeV1_interrupt = _void;

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

@@ -0,0 +1,8 @@
+export declare const HostLocale: import("scale-ts").Codec<{
+    languageTag: string;
+}>;
+export declare const LocaleSubscribeV1_start: import("scale-ts").Codec<undefined>;
+export declare const LocaleSubscribeV1_receive: import("scale-ts").Codec<{
+    languageTag: string;
+}>;
+export declare const LocaleSubscribeV1_interrupt: import("scale-ts").Codec<undefined>;

package/dist/protocol/v1/locale.js

@@ -0,0 +1,7 @@
+import { Struct, _void, str } from 'scale-ts';
+export const HostLocale = Struct({
+    languageTag: str,
+});
+export const LocaleSubscribeV1_start = _void;
+export const LocaleSubscribeV1_receive = HostLocale;
+export const LocaleSubscribeV1_interrupt = _void;

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

@@ -20,6 +20,6 @@ export declare const NavigateToErr: [import("scale-ts").Encoder<import("@novasam
     }, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">;
 };
 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<{
+export declare const NavigateToV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "NavigateToErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "NavigateToErr::PermissionDenied">>>;

package/dist/protocol/v1/navigation.js

@@ -1,9 +1,10 @@
 import { ErrEnum } from '@novasamatech/scale';
-import { Result, _void, str } from 'scale-ts';
+import { _void, str } from 'scale-ts';
+import { CallResult } from '../callError.js';
 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);
+export const NavigateToV1_response = CallResult(_void, NavigateToErr);

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

@@ -30,10 +30,10 @@ export declare const PushNotificationV1_request: import("scale-ts").Codec<{
     deeplink: string | undefined;
     scheduledAt: bigint | undefined;
 }>;
-export declare const PushNotificationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<number, import("@novasamatech/scale").CodecError<{
+export declare const PushNotificationV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<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<{
+export declare const PushNotificationCancelV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/notification.js

@@ -1,5 +1,6 @@
 import { ErrEnum } from '@novasamatech/scale';
-import { Option, Result, Struct, _void, str, u32, u64 } from 'scale-ts';
+import { Option, Struct, _void, str, u32, u64 } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr, GenericError } from '../commonCodecs.js';
 export const NotificationId = u32;
 export const PushNotification = Struct({
@@ -12,6 +13,6 @@ export const PushNotificationError = ErrEnum('PushNotificationError', {
     Unknown: [GenericErr, 'Unknown error'],
 });
 export const PushNotificationV1_request = PushNotification;
-export const PushNotificationV1_response = Result(NotificationId, PushNotificationError);
+export const PushNotificationV1_response = CallResult(NotificationId, PushNotificationError);
 export const PushNotificationCancelV1_request = NotificationId;
-export const PushNotificationCancelV1_response = Result(_void, GenericError);
+export const PushNotificationCancelV1_response = CallResult(_void, GenericError);

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

@@ -24,14 +24,14 @@ export declare const PaymentReceipt: import("scale-ts").Codec<{
     id: string;
 }>;
 export declare const PaymentStatus: import("scale-ts").Codec<{
+    tag: "Failed";
+    value: string;
+} | {
     tag: "Processing";
     value: undefined;
 } | {
     tag: "Completed";
     value: undefined;
-} | {
-    tag: "Failed";
-    value: string;
 }>;
 export declare const PaymentBalanceErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
     reason: string;
@@ -182,7 +182,7 @@ export declare const PaymentTopUpV1_request: import("scale-ts").Codec<{
         value: Uint8Array<ArrayBufferLike>[];
     };
 }>;
-export declare const PaymentTopUpV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+export declare const PaymentTopUpV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InsufficientFunds"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<{
     credited: bigint;
@@ -192,21 +192,21 @@ export declare const PaymentRequestV1_request: import("scale-ts").Codec<{
     amount: bigint;
     destination: Uint8Array<ArrayBufferLike>;
 }>;
-export declare const PaymentRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const PaymentRequestV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     id: string;
 }, import("@novasamatech/scale").CodecError<undefined, "PaymentRequestErr::Rejected"> | import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "PaymentRequestErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentRequestErr::InsufficientBalance">>>;
 export declare const PaymentStatusSubscribeV1_start: import("scale-ts").Codec<string>;
 export declare const PaymentStatusSubscribeV1_receive: import("scale-ts").Codec<{
+    tag: "Failed";
+    value: string;
+} | {
     tag: "Processing";
     value: undefined;
 } | {
     tag: "Completed";
     value: undefined;
-} | {
-    tag: "Failed";
-    value: string;
 }>;
 export declare const PaymentStatusSubscribeV1_interrupt: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
     reason: string;

package/dist/protocol/v1/payments.js

@@ -1,5 +1,6 @@
 import { Bytes, Enum, ErrEnum } from '@novasamatech/scale';
-import { Option, Result, Struct, Vector, _void, str, u128, u32 } from 'scale-ts';
+import { Option, Struct, Vector, _void, str, u128, u32 } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 import { DerivationIndex } from './accounts.js';
 // common types
@@ -60,14 +61,14 @@ export const PaymentTopUpV1_request = Struct({
     amount: u128,
     source: PaymentTopUpSource,
 });
-export const PaymentTopUpV1_response = Result(_void, PaymentTopUpErr);
+export const PaymentTopUpV1_response = CallResult(_void, PaymentTopUpErr);
 // host_payment_request
 export const PaymentRequestV1_request = Struct({
     from: Option(CoinPaymentPurseId),
     amount: u128,
     destination: Bytes(32),
 });
-export const PaymentRequestV1_response = Result(PaymentReceipt, PaymentRequestErr);
+export const PaymentRequestV1_response = CallResult(PaymentReceipt, PaymentRequestErr);
 // host_payment_status_subscribe
 export const PaymentStatusSubscribeV1_start = PaymentId;
 export const PaymentStatusSubscribeV1_receive = PaymentStatus;

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

@@ -24,6 +24,6 @@ export declare const PreimageSubmitErr: [import("scale-ts").Encoder<import("@nov
     }, "PreimageSubmitErr::Unknown">;
 };
 export declare const PreimageSubmitV1_request: import("@novasamatech/scale").BytesCodec<undefined>;
-export declare const PreimageSubmitV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<`0x${string}`, import("@novasamatech/scale").CodecError<{
+export declare const PreimageSubmitV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<`0x${string}`, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "PreimageSubmitErr::Unknown">>>;

package/dist/protocol/v1/preimage.js

@@ -1,5 +1,6 @@
 import { Bytes, ErrEnum, Hex, Nullable } from '@novasamatech/scale';
-import { Result, _void } from 'scale-ts';
+import { _void } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 export const PreimageKey = Hex();
 export const PreimageValue = Bytes();
@@ -10,4 +11,4 @@ export const PreimageSubmitErr = ErrEnum('PreimageSubmitErr', {
     Unknown: [GenericErr, 'Unknown error'],
 });
 export const PreimageSubmitV1_request = PreimageValue;
-export const PreimageSubmitV1_response = Result(PreimageKey, PreimageSubmitErr);
+export const PreimageSubmitV1_response = CallResult(PreimageKey, PreimageSubmitErr);

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

@@ -30,6 +30,6 @@ 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<{
+export declare const RemotePermissionV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<boolean, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/remotePermission.js

@@ -1,5 +1,6 @@
 import { Enum } from '@novasamatech/scale';
-import { Result, Vector, _void, bool, str } from 'scale-ts';
+import { Vector, _void, bool, str } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericError } from '../commonCodecs.js';
 export const RemotePermission = Enum({
     Remote: Vector(str),
@@ -9,4 +10,4 @@ export const RemotePermission = Enum({
     StatementSubmit: _void,
 });
 export const RemotePermissionV1_request = RemotePermission;
-export const RemotePermissionV1_response = Result(bool, GenericError);
+export const RemotePermissionV1_response = CallResult(bool, GenericError);

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

@@ -66,7 +66,7 @@ export declare const RequestResourceAllocationV1_request: import("scale-ts").Cod
     tag: "AutoSigning";
     value: undefined;
 })[]>;
-export declare const RequestResourceAllocationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<({
+export declare const RequestResourceAllocationV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<({
     tag: "Rejected";
     value: undefined;
 } | {

package/dist/protocol/v1/resourceAllocation.js

@@ -1,5 +1,6 @@
 import { Enum, ErrEnum } from '@novasamatech/scale';
-import { Result, Vector, _void } from 'scale-ts';
+import { Vector, _void } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 import { DerivationIndex } from './accounts.js';
 // resources requested by a product
@@ -22,4 +23,4 @@ export const ResourceAllocationErr = ErrEnum('ResourceAllocationErr', {
 });
 // host_request_resource_allocation
 export const RequestResourceAllocationV1_request = Vector(AllocatableResource);
-export const RequestResourceAllocationV1_response = Result(Vector(AllocationOutcome), ResourceAllocationErr);
+export const RequestResourceAllocationV1_response = CallResult(Vector(AllocationOutcome), ResourceAllocationErr);

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

@@ -74,7 +74,7 @@ export declare const SignRawV1_request: import("scale-ts").Codec<{
         value: string;
     };
 }>;
-export declare const SignRawV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const SignRawV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     signature: `0x${string}`;
     signedTransaction: `0x${string}` | undefined;
 }, import("@novasamatech/scale").CodecError<undefined, "SigningErr::Rejected"> | import("@novasamatech/scale").CodecError<{
@@ -90,7 +90,7 @@ export declare const SignRawWithLegacyAccountV1_request: import("scale-ts").Code
         value: string;
     };
 }>;
-export declare const SignRawWithLegacyAccountV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const SignRawWithLegacyAccountV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     signature: `0x${string}`;
     signedTransaction: `0x${string}` | undefined;
 }, import("@novasamatech/scale").CodecError<undefined, "SigningErr::Rejected"> | import("@novasamatech/scale").CodecError<{
@@ -168,7 +168,7 @@ export declare const SignPayloadV1_request: import("scale-ts").Codec<{
         withSignedTransaction: boolean | undefined;
     };
 }>;
-export declare const SignPayloadV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const SignPayloadV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     signature: `0x${string}`;
     signedTransaction: `0x${string}` | undefined;
 }, import("@novasamatech/scale").CodecError<undefined, "SigningErr::Rejected"> | import("@novasamatech/scale").CodecError<{
@@ -194,7 +194,7 @@ export declare const SignPayloadWithLegacyAccountV1_request: import("scale-ts").
         withSignedTransaction: boolean | undefined;
     };
 }>;
-export declare const SignPayloadWithLegacyAccountV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const SignPayloadWithLegacyAccountV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     signature: `0x${string}`;
     signedTransaction: `0x${string}` | undefined;
 }, import("@novasamatech/scale").CodecError<undefined, "SigningErr::Rejected"> | import("@novasamatech/scale").CodecError<{

package/dist/protocol/v1/sign.js

@@ -1,5 +1,6 @@
 import { Bytes, Enum, ErrEnum, Hex } from '@novasamatech/scale';
-import { Option, Result, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { Option, Struct, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 import { ProductAccountId } from './accounts.js';
 // common structures
@@ -27,9 +28,9 @@ export const SigningRawPayloadWithoutAccount = Struct({
     payload: RawPayload,
 });
 export const SignRawV1_request = SigningRawPayload;
-export const SignRawV1_response = Result(SigningResult, SigningErr);
+export const SignRawV1_response = CallResult(SigningResult, SigningErr);
 export const SignRawWithLegacyAccountV1_request = SigningRawPayloadWithoutAccount;
-export const SignRawWithLegacyAccountV1_response = Result(SigningResult, SigningErr);
+export const SignRawWithLegacyAccountV1_response = CallResult(SigningResult, SigningErr);
 // sign payload
 const SigningPayloadPayload = Struct({
     blockHash: Hex(),
@@ -57,6 +58,6 @@ export const SigningPayloadWithoutAccount = Struct({
     payload: SigningPayloadPayload,
 });
 export const SignPayloadV1_request = SigningPayload;
-export const SignPayloadV1_response = Result(SigningResult, SigningErr);
+export const SignPayloadV1_response = CallResult(SigningResult, SigningErr);
 export const SignPayloadWithLegacyAccountV1_request = SigningPayloadWithoutAccount;
-export const SignPayloadWithLegacyAccountV1_response = Result(SigningResult, SigningErr);
+export const SignPayloadWithLegacyAccountV1_response = CallResult(SigningResult, SigningErr);

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

@@ -215,7 +215,7 @@ export declare const StatementStoreCreateProofV1_request: import("scale-ts").Cod
     topics: Uint8Array<ArrayBufferLike>[];
     data: Uint8Array<ArrayBufferLike> | undefined;
 }]>;
-export declare const StatementStoreCreateProofV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const StatementStoreCreateProofV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     tag: "Sr25519";
     value: {
         signature: Uint8Array<ArrayBufferLike>;
@@ -276,7 +276,7 @@ export declare const StatementStoreCreateProofAuthorizedV1_request: import("scal
     topics: Uint8Array<ArrayBufferLike>[];
     data: Uint8Array<ArrayBufferLike> | undefined;
 }>;
-export declare const StatementStoreCreateProofAuthorizedV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+export declare const StatementStoreCreateProofAuthorizedV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
     tag: "Sr25519";
     value: {
         signature: Uint8Array<ArrayBufferLike>;
@@ -337,6 +337,6 @@ export declare const StatementStoreSubmitV1_request: import("scale-ts").Codec<{
     topics: Uint8Array<ArrayBufferLike>[];
     data: Uint8Array<ArrayBufferLike> | undefined;
 }>;
-export declare const StatementStoreSubmitV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+export declare const StatementStoreSubmitV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
     reason: string;
 }, "GenericError">>>;

package/dist/protocol/v1/statementStore.js

@@ -1,5 +1,6 @@
 import { Bytes, Enum, ErrEnum } from '@novasamatech/scale';
-import { Option, Result, Struct, Tuple, Vector, _void, bool, u64 } from 'scale-ts';
+import { Option, Struct, Tuple, Vector, _void, bool, u64 } from 'scale-ts';
+import { CallResult } from '../callError.js';
 import { GenericErr, GenericError } from '../commonCodecs.js';
 import { ProductAccountId } from './accounts.js';
 // structs definition
@@ -65,10 +66,10 @@ export const StatementProofErr = ErrEnum('StatementProofErr', {
     Unknown: [GenericErr, 'StatementProof: unknown error'],
 });
 export const StatementStoreCreateProofV1_request = Tuple(ProductAccountId, Statement);
-export const StatementStoreCreateProofV1_response = Result(StatementProof, StatementProofErr);
+export const StatementStoreCreateProofV1_response = CallResult(StatementProof, StatementProofErr);
 // creating proof using a host-internal allowance account (no product account required)
 export const StatementStoreCreateProofAuthorizedV1_request = Statement;
-export const StatementStoreCreateProofAuthorizedV1_response = Result(StatementProof, StatementProofErr);
+export const StatementStoreCreateProofAuthorizedV1_response = CallResult(StatementProof, StatementProofErr);
 // submit
 export const StatementStoreSubmitV1_request = SignedStatement;
-export const StatementStoreSubmitV1_response = Result(_void, GenericError);
+export const StatementStoreSubmitV1_response = CallResult(_void, GenericError);

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

@@ -0,0 +1,23 @@
+export declare const HostPlatform: import("scale-ts").Codec<"Unknown" | "Web" | "Android" | "Ios" | "Desktop" | "Cli">;
+export declare const HostInfo: import("scale-ts").Codec<{
+    platform: "Unknown" | "Web" | "Android" | "Ios" | "Desktop" | "Cli";
+    name: string;
+    version: string;
+}>;
+export declare const HostInfoV1_request: import("scale-ts").Codec<undefined>;
+export declare const HostInfoV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
+    platform: "Unknown" | "Web" | "Android" | "Ios" | "Desktop" | "Cli";
+    name: string;
+    version: string;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ProductContext: import("scale-ts").Codec<{
+    productId: string;
+}>;
+export declare const GetProductContextV1_request: import("scale-ts").Codec<undefined>;
+export declare const GetProductContextV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
+    productId: string;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;

package/dist/protocol/v1/system.js

@@ -0,0 +1,21 @@
+import { Status } from '@novasamatech/scale';
+import { Struct, _void, str } from 'scale-ts';
+import { CallResult } from '../callError.js';
+import { GenericError } from '../commonCodecs.js';
+// Platform category a host runs on. Variant order is the wire encoding — keep
+// it aligned with truapi `HostPlatform`.
+export const HostPlatform = Status('Web', 'Android', 'Ios', 'Desktop', 'Cli', 'Unknown');
+// Identity and version of the host currently running the product.
+export const HostInfo = Struct({
+    platform: HostPlatform,
+    name: str,
+    version: str,
+});
+export const HostInfoV1_request = _void;
+export const HostInfoV1_response = CallResult(HostInfo, GenericError);
+// Product context bound to the current host runtime.
+export const ProductContext = Struct({
+    productId: str,
+});
+export const GetProductContextV1_request = _void;
+export const GetProductContextV1_response = CallResult(ProductContext, GenericError);

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

@@ -0,0 +1,37 @@
+export declare const WorkerErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>;
+} & {
+    readonly TooManyOpen: import("@novasamatech/scale").ErrCodec<undefined, "WorkerErr::TooManyOpen">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "WorkerErr::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">;
+};
+/** Host-assigned pending-operation id, unique per product. */
+export declare const OperationId: import("scale-ts").Codec<number>;
+export declare const WorkerBeginOperationV1_request: import("scale-ts").Codec<{
+    label: string | undefined;
+}>;
+export declare const WorkerBeginOperationV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<{
+    id: number;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>>;
+export declare const WorkerEndOperationV1_request: import("scale-ts").Codec<{
+    id: number;
+}>;
+export declare const WorkerEndOperationV1_response: import("scale-ts").Codec<import("../callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>>;

package/dist/protocol/v1/worker.js

@@ -0,0 +1,20 @@
+import { ErrEnum } from '@novasamatech/scale';
+import { Option, Struct, _void, str, u32 } from 'scale-ts';
+import { CallResult } from '../callError.js';
+import { GenericErr } from '../commonCodecs.js';
+// common structures
+export const WorkerErr = ErrEnum('WorkerErr', {
+    TooManyOpen: [_void, 'Too many open operations'],
+    Unknown: [GenericErr, 'Unknown worker operation error'],
+});
+/** Host-assigned pending-operation id, unique per product. */
+export const OperationId = u32;
+// actions
+// The worker keeps itself alive by holding an open operation; the host keeps
+// the product's worker running while it has at least one open operation. The
+// request carries an optional label for host logs and UI.
+export const WorkerBeginOperationV1_request = Struct({ label: Option(str) });
+export const WorkerBeginOperationV1_response = CallResult(Struct({ id: OperationId }), WorkerErr);
+// Idempotent: ending an unknown or already-ended id still succeeds.
+export const WorkerEndOperationV1_request = Struct({ id: OperationId });
+export const WorkerEndOperationV1_response = CallResult(_void, WorkerErr);

package/dist/transport.js

@@ -1,7 +1,8 @@
 import { enumValue, isEnumVariant, resultErr, resultOk, toHex } from '@novasamatech/scale';
 import { createNanoEvents } from 'nanoevents';
 import { HANDSHAKE_INTERVAL, HANDSHAKE_TIMEOUT, SCALE_CODEC_PROTOCOL_ID } from './constants.js';
-import { composeAction, createRequestId, delay, promiseWithResolvers } from './helpers.js';
+import { composeAction, createRequestId, delay, extractErrorMessage, promiseWithResolvers } from './helpers.js';
+import { CALL_ERROR_FAILURE } from './protocol/callError.js';
 import { Message, MessagePayload } from './protocol/messageCodec.js';
 import { HandshakeErr } from './protocol/v1/handshake.js';
 function isConnected(status) {
@@ -194,6 +195,14 @@ export function createTransport(provider) {
                     transport.postMessage(requestId, responseMessage);
                 }, (error) => {
                     provider.logger.error(`handleRequest: handler for "${method}" rejected`, error);
+                    // Answer a transport-level CallError so the caller sees a failed
+                    // request rather than a hung promise. Domain errors are the
+                    // handler's job; this is the fallback when the handler itself threw.
+                    const failure = enumValue('v1', {
+                        [CALL_ERROR_FAILURE]: { tag: 'HostFailure', value: { reason: extractErrorMessage(error) } },
+                    });
+                    const responseMessage = enumValue(responseAction, failure);
+                    transport.postMessage(requestId, responseMessage);
                 });
             });
         },
@@ -238,7 +247,12 @@ export function createTransport(provider) {
                         const subscription = activeSubscriptions.get(subscriptionKey);
                         if (subscription) {
                             for (const listener of subscription.listeners) {
-                                listener.call(data.value);
+                                try {
+                                    listener.call(data.value);
+                                }
+                                catch (e) {
+                                    provider.logger.error(`subscription "${method}" listener threw`, e);
+                                }
                             }
                         }
                     }