@novasamatech/host-api 0.10.1 → 0.11.0

package/dist/hostApi.js

@@ -293,6 +293,9 @@ export function createHostApi(transport) {
         paymentStatusSubscribe(args, callback) {
             return transport.subscribe('host_payment_status_subscribe', args, callback);
         },
+        paymentTopUpStatusSubscribe(args, callback) {
+            return transport.subscribe('host_payment_top_up_status_subscribe', args, callback);
+        },
         requestResourceAllocation(payload) {
             return makeRequest(transport.request('host_request_resource_allocation', payload), reason => ({
                 tag: payload.tag,

package/dist/index.d.ts

@@ -31,7 +31,7 @@ export { NotificationId, PushNotification, PushNotificationError } from './proto
 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';
-export { PaymentBalance, PaymentBalanceErr, PaymentId, PaymentReceipt, PaymentRequestErr, PaymentStatus, PaymentStatusErr, PaymentTopUpErr, PaymentTopUpSource, } from './protocol/v1/payments.js';
+export { PaymentBalance, PaymentBalanceErr, PaymentId, PaymentReceipt, PaymentRequestErr, PaymentStatus, PaymentStatusErr, PaymentTopUpErr, PaymentTopUpId, PaymentTopUpSource, PaymentTopUpStatus, PaymentTopUpStatusErr, } from './protocol/v1/payments.js';
 export { Arrangement, BorderStyle, ButtonVariant, ColorToken, ContentAlignment, CustomRendererNode, Dimensions, HorizontalAlignment, Modifier, Shape, Size, TypographyStyle, VerticalAlignment, } from './protocol/v1/customRenderer.js';
 export { ChainHeadEvent, ChainHeadFollowV1_start, ChainIdentifier, ChainInfoErr, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';
 export { CoinPaymentBalance, CoinPaymentCheque, CoinPaymentErr, CoinPaymentListenForItem, CoinPaymentPurseId, CoinPaymentPurseInfo, CoinPaymentReceivable, CoinPaymentStatus, CoinPaymentTransmissionChannel, } from './protocol/v1/coinPayment.js';

package/dist/index.js

@@ -23,7 +23,7 @@ export { NotificationId, PushNotification, PushNotificationError } from './proto
 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';
-export { PaymentBalance, PaymentBalanceErr, PaymentId, PaymentReceipt, PaymentRequestErr, PaymentStatus, PaymentStatusErr, PaymentTopUpErr, PaymentTopUpSource, } from './protocol/v1/payments.js';
+export { PaymentBalance, PaymentBalanceErr, PaymentId, PaymentReceipt, PaymentRequestErr, PaymentStatus, PaymentStatusErr, PaymentTopUpErr, PaymentTopUpId, PaymentTopUpSource, PaymentTopUpStatus, PaymentTopUpStatusErr, } from './protocol/v1/payments.js';
 export { Arrangement, BorderStyle, ButtonVariant, ColorToken, ContentAlignment, CustomRendererNode, Dimensions, HorizontalAlignment, Modifier, Shape, Size, TypographyStyle, VerticalAlignment, } from './protocol/v1/customRenderer.js';
 export { ChainHeadEvent, ChainHeadFollowV1_start, ChainIdentifier, ChainInfoErr, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';
 export { CoinPaymentBalance, CoinPaymentCheque, CoinPaymentErr, CoinPaymentListenForItem, CoinPaymentPurseId, CoinPaymentPurseInfo, CoinPaymentReceivable, CoinPaymentStatus, CoinPaymentTransmissionChannel, } from './protocol/v1/coinPayment.js';

package/dist/protocol/impl.d.ts

@@ -942,11 +942,10 @@ export declare const hostApiProtocol: {
                 tag: "Coins";
                 value: Uint8Array<ArrayBufferLike>[];
             };
+            id: Uint8Array<ArrayBufferLike>;
         }>, 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;
-        }, "PaymentTopUpErr::PartialPayment">>>];
+        }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>>];
     }>;
     readonly host_payment_request: VersionedProtocolRequest<{
         readonly v1: [Codec<{
@@ -1482,5 +1481,47 @@ export declare const hostApiProtocol: {
             reason: string;
         }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>>];
     }>;
+    readonly host_payment_top_up_status_subscribe: VersionedProtocolSubscription<{
+        readonly v1: [import("@novasamatech/scale").BytesCodec<number>, Codec<{
+            tag: "Detecting";
+            value: undefined;
+        } | {
+            tag: "Claiming";
+            value: undefined;
+        } | {
+            tag: "Claimed";
+            value: {
+                finalized: boolean;
+            };
+        } | {
+            tag: "ClaimedPartially";
+            value: {
+                actualClaimed: bigint;
+            };
+        } | {
+            tag: "NotClaimed";
+            value: undefined;
+        }>, [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>] & {
+            enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+            dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+        } & {
+            readonly NotFound: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpStatusErr::NotFound">;
+            readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+                reason: string;
+            }, "PaymentTopUpStatusErr::Unknown">;
+        } & {
+            [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">;
+        }];
+    }>;
 };
 export {};

package/dist/protocol/impl.js

@@ -14,7 +14,7 @@ import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request,
 import { LocaleSubscribeV1_interrupt, LocaleSubscribeV1_receive, LocaleSubscribeV1_start } from './v1/locale.js';
 import { NavigateToV1_request, NavigateToV1_response } from './v1/navigation.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 { PaymentBalanceSubscribeV1_interrupt, PaymentBalanceSubscribeV1_receive, PaymentBalanceSubscribeV1_start, PaymentRequestV1_request, PaymentRequestV1_response, PaymentStatusSubscribeV1_interrupt, PaymentStatusSubscribeV1_receive, PaymentStatusSubscribeV1_start, PaymentTopUpStatusSubscribeV1_interrupt, PaymentTopUpStatusSubscribeV1_receive, PaymentTopUpStatusSubscribeV1_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';
 import { RequestResourceAllocationV1_request, RequestResourceAllocationV1_response } from './v1/resourceAllocation.js';
@@ -317,4 +317,14 @@ export const hostApiProtocol = {
     host_worker_end_operation: versionedRequest(indexer.request(), {
         v1: [WorkerEndOperationV1_request, WorkerEndOperationV1_response],
     }),
+    // Appended rather than placed next to `host_payment_top_up`: the index is a
+    // single running counter, so slotting it into the payment block would shift
+    // every id after it.
+    host_payment_top_up_status_subscribe: versionedSubscription(indexer.subscription(), {
+        v1: [
+            PaymentTopUpStatusSubscribeV1_start,
+            PaymentTopUpStatusSubscribeV1_receive,
+            PaymentTopUpStatusSubscribeV1_interrupt,
+        ],
+    }),
 };

package/dist/protocol/messageCodec.d.ts

@@ -995,13 +995,12 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
             tag: "Coins";
             value: Uint8Array<ArrayBufferLike>[];
         };
+        id: Uint8Array<ArrayBufferLike>;
     }>;
 }>> & Record<"host_payment_top_up_response", EnumCodec<{
     readonly v1: 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;
-    }, "PaymentTopUpErr::PartialPayment">>>;
+    }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>>;
 }>> & Record<"host_payment_request_request", EnumCodec<{
     readonly v1: Codec<{
         from: number | undefined;
@@ -1577,7 +1576,52 @@ export declare const MessagePayload: EnumCodec<Record<"host_handshake_request",
     readonly v1: Codec<import("./callError.js").CallResultValue<undefined, import("@novasamatech/scale").CodecError<{
         reason: string;
     }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>>;
-}>>>;
+}>> & Record<"host_payment_top_up_status_subscribe_start", EnumCodec<{
+    readonly v1: import("@novasamatech/scale").BytesCodec<number>;
+}>> & Record<"host_payment_top_up_status_subscribe_receive", EnumCodec<{
+    readonly v1: Codec<{
+        tag: "Detecting";
+        value: undefined;
+    } | {
+        tag: "Claiming";
+        value: undefined;
+    } | {
+        tag: "Claimed";
+        value: {
+            finalized: boolean;
+        };
+    } | {
+        tag: "ClaimedPartially";
+        value: {
+            actualClaimed: bigint;
+        };
+    } | {
+        tag: "NotClaimed";
+        value: undefined;
+    }>;
+}>> & Record<"host_payment_top_up_status_subscribe_interrupt", EnumCodec<{
+    readonly v1: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>] & {
+        enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+        dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+    } & {
+        readonly NotFound: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpStatusErr::NotFound">;
+        readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown">;
+    } & {
+        [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">;
+    };
+}>> & Record<"host_payment_top_up_status_subscribe_stop", Codec<undefined>>>;
 export declare const Message: Codec<{
     requestId: string;
     payload: {
@@ -3006,6 +3050,7 @@ export declare const Message: Codec<{
                     tag: "Coins";
                     value: Uint8Array<ArrayBufferLike>[];
                 };
+                id: Uint8Array<ArrayBufferLike>;
             };
         };
     } | {
@@ -3014,9 +3059,7 @@ export declare const Message: Codec<{
             tag: "v1";
             value: 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;
-            }, "PaymentTopUpErr::PartialPayment">>;
+            }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>;
         };
     } | {
         tag: "host_payment_request_request";
@@ -3756,6 +3799,48 @@ export declare const Message: Codec<{
                 reason: string;
             }, "WorkerErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "WorkerErr::TooManyOpen">>;
         };
+    } | {
+        tag: "host_payment_top_up_status_subscribe_start";
+        value: {
+            tag: "v1";
+            value: Uint8Array<ArrayBufferLike>;
+        };
+    } | {
+        tag: "host_payment_top_up_status_subscribe_receive";
+        value: {
+            tag: "v1";
+            value: {
+                tag: "Detecting";
+                value: undefined;
+            } | {
+                tag: "Claiming";
+                value: undefined;
+            } | {
+                tag: "Claimed";
+                value: {
+                    finalized: boolean;
+                };
+            } | {
+                tag: "ClaimedPartially";
+                value: {
+                    actualClaimed: bigint;
+                };
+            } | {
+                tag: "NotClaimed";
+                value: undefined;
+            };
+        };
+    } | {
+        tag: "host_payment_top_up_status_subscribe_interrupt";
+        value: {
+            tag: "v1";
+            value: import("@novasamatech/scale").CodecError<{
+                reason: string;
+            }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">;
+        };
+    } | {
+        tag: "host_payment_top_up_status_subscribe_stop";
+        value: undefined;
     };
 }>;
 export type MessageAction = MessagePayloadSchema['tag'];

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

@@ -1,5 +1,7 @@
 export declare const Sr25519SecretKey: import("@novasamatech/scale").BytesCodec<number>;
 export declare const PaymentId: import("scale-ts").Codec<string>;
+/** Product-supplied, opaque 32-byte idempotency key for a top up. */
+export declare const PaymentTopUpId: import("@novasamatech/scale").BytesCodec<number>;
 export declare const CoinPaymentPurseId: import("scale-ts").Codec<number>;
 export declare const PaymentTopUpSource: import("scale-ts").Codec<{
     tag: "ProductAccount";
@@ -33,6 +35,26 @@ export declare const PaymentStatus: import("scale-ts").Codec<{
     tag: "Completed";
     value: undefined;
 }>;
+export declare const PaymentTopUpStatus: import("scale-ts").Codec<{
+    tag: "Detecting";
+    value: undefined;
+} | {
+    tag: "Claiming";
+    value: undefined;
+} | {
+    tag: "Claimed";
+    value: {
+        finalized: boolean;
+    };
+} | {
+    tag: "ClaimedPartially";
+    value: {
+        actualClaimed: bigint;
+    };
+} | {
+    tag: "NotClaimed";
+    value: undefined;
+}>;
 export declare const PaymentBalanceErr: [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<{
@@ -54,43 +76,49 @@ export declare const PaymentBalanceErr: [import("scale-ts").Encoder<import("@nov
         reason: string;
     }, "PaymentBalanceErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentBalanceErr::PermissionDenied">;
 };
-export declare const PartialPaymentErr: import("scale-ts").Codec<{
-    credited: bigint;
-}>;
 export declare const PaymentTopUpErr: [import("scale-ts").Encoder<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;
-}, "PaymentTopUpErr::PartialPayment">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+}, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>, import("scale-ts").Decoder<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;
-}, "PaymentTopUpErr::PartialPayment">>] & {
+}, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>] & {
     enc: import("scale-ts").Encoder<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;
-    }, "PaymentTopUpErr::PartialPayment">>;
+    }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>;
     dec: import("scale-ts").Decoder<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;
-    }, "PaymentTopUpErr::PartialPayment">>;
+    }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>;
 } & {
-    readonly InsufficientFunds: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpErr::InsufficientFunds">;
     readonly InvalidSource: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpErr::InvalidSource">;
-    readonly PartialPayment: import("@novasamatech/scale").ErrCodec<{
-        credited: bigint;
-    }, "PaymentTopUpErr::PartialPayment">;
+    readonly AlreadyExists: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpErr::AlreadyExists">;
+    readonly SourceBusy: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpErr::SourceBusy">;
     readonly Unknown: import("@novasamatech/scale").ErrCodec<{
         reason: string;
     }, "PaymentTopUpErr::Unknown">;
 } & {
     [Symbol.hasInstance](v: unknown): v is 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;
-    }, "PaymentTopUpErr::PartialPayment">;
+    }, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">;
+};
+export declare const PaymentTopUpStatusErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+} & {
+    readonly NotFound: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpStatusErr::NotFound">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">;
 };
 export declare const PaymentRequestErr: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<undefined, "PaymentRequestErr::Rejected"> | import("@novasamatech/scale").CodecError<{
     reason: string;
@@ -181,12 +209,11 @@ export declare const PaymentTopUpV1_request: import("scale-ts").Codec<{
         tag: "Coins";
         value: Uint8Array<ArrayBufferLike>[];
     };
+    id: Uint8Array<ArrayBufferLike>;
 }>;
 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;
-}, "PaymentTopUpErr::PartialPayment">>>;
+}, "PaymentTopUpErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::InvalidSource"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::AlreadyExists"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpErr::SourceBusy">>>;
 export declare const PaymentRequestV1_request: import("scale-ts").Codec<{
     from: number | undefined;
     amount: bigint;
@@ -229,3 +256,45 @@ export declare const PaymentStatusSubscribeV1_interrupt: [import("scale-ts").Enc
         reason: string;
     }, "PaymentStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentStatusErr::PaymentNotFound">;
 };
+export declare const PaymentTopUpStatusSubscribeV1_start: import("@novasamatech/scale").BytesCodec<number>;
+export declare const PaymentTopUpStatusSubscribeV1_receive: import("scale-ts").Codec<{
+    tag: "Detecting";
+    value: undefined;
+} | {
+    tag: "Claiming";
+    value: undefined;
+} | {
+    tag: "Claimed";
+    value: {
+        finalized: boolean;
+    };
+} | {
+    tag: "ClaimedPartially";
+    value: {
+        actualClaimed: bigint;
+    };
+} | {
+    tag: "NotClaimed";
+    value: undefined;
+}>;
+export declare const PaymentTopUpStatusSubscribeV1_interrupt: [import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>, import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>] & {
+    enc: import("scale-ts").Encoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+    dec: import("scale-ts").Decoder<import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">>;
+} & {
+    readonly NotFound: import("@novasamatech/scale").ErrCodec<undefined, "PaymentTopUpStatusErr::NotFound">;
+    readonly Unknown: import("@novasamatech/scale").ErrCodec<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown">;
+} & {
+    [Symbol.hasInstance](v: unknown): v is import("@novasamatech/scale").CodecError<{
+        reason: string;
+    }, "PaymentTopUpStatusErr::Unknown"> | import("@novasamatech/scale").CodecError<undefined, "PaymentTopUpStatusErr::NotFound">;
+};

package/dist/protocol/v1/payments.js

@@ -1,11 +1,13 @@
 import { Bytes, Enum, ErrEnum } from '@novasamatech/scale';
-import { Option, Struct, Vector, _void, str, u128, u32 } from 'scale-ts';
+import { Option, Struct, Vector, _void, bool, str, u128, u32 } from 'scale-ts';
 import { CallResult } from '../callError.js';
 import { GenericErr } from '../commonCodecs.js';
 import { DerivationIndex } from './accounts.js';
 // common types
 export const Sr25519SecretKey = Bytes(64);
 export const PaymentId = str;
+/** Product-supplied, opaque 32-byte idempotency key for a top up. */
+export const PaymentTopUpId = Bytes(32);
 // Optional purse selector (RFC 0017). `undefined` (None) targets MAIN_PURSE.
 export const CoinPaymentPurseId = u32;
 export const PaymentTopUpSource = Enum({
@@ -25,19 +27,40 @@ export const PaymentStatus = Enum({
     Completed: _void,
     Failed: str,
 });
+// A status never advances once it reaches a terminal variant (`Claimed` with
+// `finalized`, `ClaimedPartially`, `NotClaimed`); the host takes no further
+// action and keeps the status readable indefinitely.
+export const PaymentTopUpStatus = Enum({
+    // Waiting for the requested amount to appear on the source.
+    Detecting: _void,
+    Claiming: _void,
+    // At least the requested amount was claimed. Terminal once `finalized`.
+    Claimed: Struct({ finalized: bool }),
+    // Terminal: the host could only claim `actualClaimed`, less than requested.
+    // Usually means the source never held enough balance to cover the request —
+    // e.g. a re-orged pre-funding transfer. Requesting an amount below the
+    // smallest coinage denomination lands here too: the host claims
+    // `amount - amount % 2^min_coinage_exponent`.
+    ClaimedPartially: Struct({ actualClaimed: u128 }),
+    // Terminal: nothing could be claimed, most likely because the host never
+    // observed any balance at the source.
+    NotClaimed: _void,
+});
 // errors
 export const PaymentBalanceErr = ErrEnum('PaymentBalanceErr', {
     PermissionDenied: [_void, 'permission denied'],
     Unknown: [GenericErr, 'unknown error'],
 });
-// Carries the amount that was credited when only some coins could be claimed.
-export const PartialPaymentErr = Struct({
-    credited: u128,
-});
 export const PaymentTopUpErr = ErrEnum('PaymentTopUpErr', {
-    InsufficientFunds: [_void, 'insufficient funds'],
     InvalidSource: [_void, 'invalid source'],
-    PartialPayment: [PartialPaymentErr, ({ credited }) => `partial payment: credited ${credited}`],
+    AlreadyExists: [_void, 'a top up with this id already exists'],
+    // Only one top up can be live per source; the source frees up once the
+    // previous top up reaches a terminal status.
+    SourceBusy: [_void, 'source already has a top up in progress'],
+    Unknown: [GenericErr, 'unknown error'],
+});
+export const PaymentTopUpStatusErr = ErrEnum('PaymentTopUpStatusErr', {
+    NotFound: [_void, 'top up not found'],
     Unknown: [GenericErr, 'unknown error'],
 });
 export const PaymentRequestErr = ErrEnum('PaymentRequestErr', {
@@ -60,6 +83,7 @@ export const PaymentTopUpV1_request = Struct({
     into: Option(CoinPaymentPurseId),
     amount: u128,
     source: PaymentTopUpSource,
+    id: PaymentTopUpId,
 });
 export const PaymentTopUpV1_response = CallResult(_void, PaymentTopUpErr);
 // host_payment_request
@@ -73,3 +97,7 @@ export const PaymentRequestV1_response = CallResult(PaymentReceipt, PaymentReque
 export const PaymentStatusSubscribeV1_start = PaymentId;
 export const PaymentStatusSubscribeV1_receive = PaymentStatus;
 export const PaymentStatusSubscribeV1_interrupt = PaymentStatusErr;
+// host_payment_top_up_status_subscribe
+export const PaymentTopUpStatusSubscribeV1_start = PaymentTopUpId;
+export const PaymentTopUpStatusSubscribeV1_receive = PaymentTopUpStatus;
+export const PaymentTopUpStatusSubscribeV1_interrupt = PaymentTopUpStatusErr;

package/dist/transport.js

@@ -80,6 +80,56 @@ export function createTransport(provider) {
     const messageProvider = createMessageProvider(provider);
     // subscriptions management (multiplexing)
     const activeSubscriptions = new Map();
+    // Wires a real subscription on the transport; later subscribers with the same
+    // start payload join it through `listeners` instead of opening another. The
+    // first listener is registered before `start` is posted: an in-process host
+    // may send its first value synchronously while handling it.
+    function openSubscription(method, subscriptionKey, startPayload, listener) {
+        const requestId = createRequestId();
+        const stopAction = composeAction(method, 'stop');
+        const interruptAction = composeAction(method, 'interrupt');
+        const receiveAction = composeAction(method, 'receive');
+        const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
+            if (receivedId === requestId) {
+                for (const listener of subscription.listeners) {
+                    try {
+                        listener.call(data.value);
+                    }
+                    catch (e) {
+                        provider.logger.error(`subscription "${method}" listener threw`, e);
+                    }
+                }
+            }
+        });
+        const unsubscribeInterrupt = transport.listenMessages(interruptAction, (receivedId, data) => {
+            if (receivedId === requestId) {
+                // The host has dropped this subscription. Tear it down first so a
+                // re-subscribe with the same payload, even from inside onInterrupt,
+                // opens a fresh one instead of joining this dead entry.
+                stopSubscription();
+                subscription.latchedInterrupt = { payload: data.value };
+                subscription.interruptEvents.emit('interrupt', data.value);
+            }
+        });
+        const stopSubscription = () => {
+            activeSubscriptions.delete(subscriptionKey);
+            unsubscribeReceive();
+            unsubscribeInterrupt();
+        };
+        const subscription = {
+            requestId,
+            listeners: [listener],
+            interruptEvents: createNanoEvents(),
+            kill: () => {
+                stopSubscription();
+                const stopPayload = enumValue(stopAction, undefined);
+                transport.postMessage(requestId, stopPayload);
+            },
+        };
+        activeSubscriptions.set(subscriptionKey, subscription);
+        transport.postMessage(requestId, startPayload);
+        return subscription;
+    }
     // Lazy provider subscription — zero per-message decode cost while no
     // debug listener is attached.
     let debugListenerCount = 0;
@@ -208,17 +258,14 @@ export function createTransport(provider) {
         },
         subscribe(method, payload, callback) {
             checks();
-            const events = createNanoEvents();
             const startAction = composeAction(method, 'start');
             const startPayload = enumValue(startAction, payload);
             const subscriptionKey = getSubscriptionKey(method, startPayload);
-            let subscription = activeSubscriptions.get(subscriptionKey);
             function unsubscribeListener() {
                 const subscription = activeSubscriptions.get(subscriptionKey);
                 if (subscription) {
                     const newListeners = subscription.listeners.filter(listener => listener.call !== callback);
                     if (newListeners.length === 0) {
-                        activeSubscriptions.delete(subscriptionKey);
                         subscription.kill();
                     }
                     else {
@@ -230,61 +277,21 @@ export function createTransport(provider) {
                 call: callback,
                 unsubscribe: unsubscribeListener,
             };
-            const publicSubscription = {
+            const existing = activeSubscriptions.get(subscriptionKey);
+            existing?.listeners.push(listener);
+            const subscription = existing ?? openSubscription(method, subscriptionKey, startPayload, listener);
+            return {
                 unsubscribe: unsubscribeListener,
                 onInterrupt(callback) {
-                    return events.on('interrupt', callback);
+                    if (subscription.latchedInterrupt) {
+                        callback(subscription.latchedInterrupt.payload);
+                        return () => {
+                            /* already delivered */
+                        };
+                    }
+                    return subscription.interruptEvents.on('interrupt', callback);
                 },
             };
-            // wiring up a real subscription
-            if (!subscription) {
-                const requestId = createRequestId();
-                const stopAction = composeAction(method, 'stop');
-                const interruptAction = composeAction(method, 'interrupt');
-                const receiveAction = composeAction(method, 'receive');
-                const unsubscribeReceive = transport.listenMessages(receiveAction, (receivedId, data) => {
-                    if (receivedId === requestId) {
-                        const subscription = activeSubscriptions.get(subscriptionKey);
-                        if (subscription) {
-                            for (const listener of subscription.listeners) {
-                                try {
-                                    listener.call(data.value);
-                                }
-                                catch (e) {
-                                    provider.logger.error(`subscription "${method}" listener threw`, e);
-                                }
-                            }
-                        }
-                    }
-                });
-                const unsubscribeInterrupt = transport.listenMessages(interruptAction, (receivedId, data) => {
-                    if (receivedId === requestId) {
-                        events.emit('interrupt', data.value);
-                        stopSubscription();
-                    }
-                });
-                const stopSubscription = () => {
-                    unsubscribeReceive();
-                    unsubscribeInterrupt();
-                    events.events = {};
-                };
-                // creating subscription
-                subscription = {
-                    requestId,
-                    kill: () => {
-                        stopSubscription();
-                        const stopPayload = enumValue(stopAction, undefined);
-                        transport.postMessage(requestId, stopPayload);
-                    },
-                    listeners: [listener],
-                };
-                activeSubscriptions.set(subscriptionKey, subscription);
-                transport.postMessage(requestId, startPayload);
-            }
-            else {
-                subscription.listeners.push(listener);
-            }
-            return publicSubscription;
         },
         handleSubscription(method, handler) {
             checks();
@@ -302,8 +309,12 @@ export function createTransport(provider) {
                     transport.postMessage(requestId, receivePayload);
                 }, value => {
                     interrupted = true;
+                    // Undefined while the handler is still running; then the handler's
+                    // own cleanup, which must run since no `stop` will ever arrive.
+                    const cleanup = subscriptions.get(requestId);
                     subscriptions.delete(requestId);
                     transport.postMessage(requestId, enumValue(interruptAction, value));
+                    cleanup?.();
                 });
                 if (interrupted) {
                     unsubscribe();

package/dist/transport.spec.js

@@ -57,6 +57,134 @@ describe('transport', () => {
             expect(s1Handler).toHaveBeenCalledTimes(1);
             expect(s2Handler).toHaveBeenCalledTimes(2);
         });
+        it('starts a fresh host subscription when re-subscribing with the same payload after an interrupt', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const containerHandler = vi.fn((_, send, interrupt) => {
+                const unsubPush = events.on('push', () => send({ tag: 'v1', value: 'connected' }));
+                const unsubInterrupt = events.on('interrupt', () => interrupt({ tag: 'v1', value: undefined }));
+                return () => {
+                    unsubPush();
+                    unsubInterrupt();
+                };
+            });
+            host.handleSubscription('host_account_connection_status_subscribe', containerHandler);
+            const first = vi.fn();
+            sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, first);
+            expect(containerHandler).toHaveBeenCalledTimes(1);
+            events.emit('interrupt');
+            const second = vi.fn();
+            sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, second);
+            // The interrupted subscription is gone: the second subscribe must open a
+            // new one on the host rather than joining the dead entry.
+            expect(containerHandler).toHaveBeenCalledTimes(2);
+            events.emit('push');
+            expect(first).not.toHaveBeenCalled();
+            expect(second).toHaveBeenCalledTimes(1);
+        });
+        it('delivers an interrupt raised synchronously from the host handler to a later onInterrupt listener', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            host.handleSubscription('host_account_connection_status_subscribe', (_, _send, interrupt) => {
+                interrupt({ tag: 'v1', value: undefined });
+                return vi.fn();
+            });
+            const subscription = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, vi.fn());
+            // With an in-process host the interrupt arrives before subscribe() has
+            // returned, so onInterrupt is necessarily attached afterwards.
+            const interrupted = vi.fn();
+            subscription.onInterrupt(interrupted);
+            expect(interrupted).toHaveBeenCalledExactlyOnceWith({ tag: 'v1', value: undefined });
+        });
+        it('delivers an interrupt to every subscriber sharing a multiplexed subscription', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            host.handleSubscription('host_account_connection_status_subscribe', (_, _send, interrupt) => events.on('interrupt', () => interrupt({ tag: 'v1', value: undefined })));
+            const first = vi.fn();
+            const second = vi.fn();
+            sdk
+                .subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, vi.fn())
+                .onInterrupt(first);
+            sdk
+                .subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, vi.fn())
+                .onInterrupt(second);
+            events.emit('interrupt');
+            expect(first).toHaveBeenCalledExactlyOnceWith({ tag: 'v1', value: undefined });
+            expect(second).toHaveBeenCalledExactlyOnceWith({ tag: 'v1', value: undefined });
+        });
+        it('delivers a later interrupt to a listener attached before it', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            host.handleSubscription('host_account_connection_status_subscribe', (_, _send, interrupt) => events.on('interrupt', () => interrupt({ tag: 'v1', value: undefined })));
+            const interrupted = vi.fn();
+            sdk
+                .subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, vi.fn())
+                .onInterrupt(interrupted);
+            events.emit('interrupt');
+            expect(interrupted).toHaveBeenCalledExactlyOnceWith({ tag: 'v1', value: undefined });
+        });
+        it('drops receive frames and makes unsubscribe a no-op once interrupted', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const hostCleanup = vi.fn();
+            host.handleSubscription('host_account_connection_status_subscribe', (_, send, interrupt) => {
+                events.on('interrupt', () => interrupt({ tag: 'v1', value: undefined }));
+                events.on('push', () => send({ tag: 'v1', value: 'connected' }));
+                return hostCleanup;
+            });
+            const callback = vi.fn();
+            const subscription = sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, callback);
+            events.emit('interrupt');
+            // The host-side handler is already torn down by the interrupt itself.
+            expect(hostCleanup).toHaveBeenCalledTimes(1);
+            events.emit('push');
+            expect(callback).not.toHaveBeenCalled();
+            // Nothing is left to stop on the host, so no second cleanup.
+            subscription.unsubscribe();
+            expect(hostCleanup).toHaveBeenCalledTimes(1);
+        });
+        it('opens a fresh host subscription when re-subscribing from inside onInterrupt', () => {
+            const providers = createProviders();
+            const events = createNanoEvents();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            const containerHandler = vi.fn((_, send, interrupt) => {
+                events.on('interrupt', () => interrupt({ tag: 'v1', value: undefined }));
+                return events.on('push', () => send({ tag: 'v1', value: 'connected' }));
+            });
+            host.handleSubscription('host_account_connection_status_subscribe', containerHandler);
+            const retried = vi.fn();
+            sdk
+                .subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, vi.fn())
+                .onInterrupt(() => {
+                sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, retried);
+            });
+            events.emit('interrupt');
+            expect(containerHandler).toHaveBeenCalledTimes(2);
+            events.emit('push');
+            expect(retried).toHaveBeenCalledTimes(1);
+        });
+        it('delivers a value the host sends synchronously while handling start', () => {
+            const providers = createProviders();
+            const host = createTransport(providers.host);
+            const sdk = createTransport(providers.sdk);
+            host.handleSubscription('host_account_connection_status_subscribe', (_, send) => {
+                send({ tag: 'v1', value: 'connected' });
+                return vi.fn();
+            });
+            const callback = vi.fn();
+            sdk.subscribe('host_account_connection_status_subscribe', { tag: 'v1', value: undefined }, callback);
+            expect(callback).toHaveBeenCalledExactlyOnceWith({ tag: 'v1', value: 'connected' });
+        });
         it('isolates a throwing subscriber so siblings on the same subscription still receive', () => {
             const providers = createProviders();
             const events = createNanoEvents();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novasamatech/host-api",
   "type": "module",
-  "version": "0.10.1",
+  "version": "0.11.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.10.1",
+    "@novasamatech/scale": "0.11.0",
     "nanoevents": "10.0.0",
     "nanoid": "6.0.1",
     "neverthrow": "^8.2.0",

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

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

package/dist/protocol/messageCodec.spec.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { hostApiProtocol } from './impl.js';
-import { MessagePayload } from './messageCodec.js';
-describe('MessagePayload ABI', () => {
-    it('declares an explicit base index per method matching contiguous serialization order', () => {
-        let next = 0;
-        for (const payload of Object.values(hostApiProtocol)) {
-            expect(payload.index).toBe(next);
-            // requests expand to 2 actions (request/response),
-            // subscriptions to 4 (start/stop/interrupt/receive)
-            next += payload.method === 'subscribe' ? 4 : 2;
-        }
-    });
-    it('encodes the first action with leading index byte 0', () => {
-        const bytes = MessagePayload.enc({ tag: 'host_handshake_request', value: { tag: 'v1', value: 1 } });
-        expect(bytes[0]).toBe(0);
-    });
-    it('encodes the last action with its explicit index byte', () => {
-        const bytes = MessagePayload.enc({
-            tag: 'host_push_notification_cancel_response',
-            value: { tag: 'v1', value: { success: true, value: undefined } },
-        });
-        expect(bytes[0]).toBe(129);
-    });
-    it('round-trips an action through its explicit index', () => {
-        const value = { tag: 'host_handshake_request', value: { tag: 'v1', value: 7 } };
-        expect(MessagePayload.dec(MessagePayload.enc(value))).toEqual(value);
-    });
-});

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

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

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

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Theme, ThemeName, ThemeVariant } from './theme.js';
-describe('ThemeName', () => {
-    it('encodes/decodes the Custom variant with its string payload', () => {
-        const value = { tag: 'Custom', value: 'midnight' };
-        expect(ThemeName.dec(ThemeName.enc(value))).toEqual(value);
-    });
-    it('encodes/decodes the Default variant', () => {
-        const value = { tag: 'Default', value: undefined };
-        expect(ThemeName.dec(ThemeName.enc(value))).toEqual(value);
-    });
-    it('pins the wire indexes: Custom=0, Default=1', () => {
-        // Custom('x'): tag byte 0, then SCALE compact-prefixed string "x"
-        expect(ThemeName.enc({ tag: 'Custom', value: 'x' })).toEqual(new Uint8Array([0, 4, 120]));
-        expect(ThemeName.enc({ tag: 'Default', value: undefined })).toEqual(new Uint8Array([1]));
-    });
-});
-describe('ThemeVariant', () => {
-    it('encodes/decodes Light and Dark', () => {
-        expect(ThemeVariant.enc('Light')).toEqual(new Uint8Array([0]));
-        expect(ThemeVariant.enc('Dark')).toEqual(new Uint8Array([1]));
-        expect(ThemeVariant.dec(new Uint8Array([0]))).toEqual('Light');
-        expect(ThemeVariant.dec(new Uint8Array([1]))).toEqual('Dark');
-    });
-});
-describe('Theme', () => {
-    it('round-trips a Default/Light theme', () => {
-        const value = { name: { tag: 'Default', value: undefined }, variant: 'Light' };
-        expect(Theme.dec(Theme.enc(value))).toEqual(value);
-    });
-    it('round-trips a Custom/Dark theme and pins its byte layout', () => {
-        const value = { name: { tag: 'Custom', value: 'dark' }, variant: 'Dark' };
-        // name: Custom(0) + compact(4)=0x10 + "dark"; variant: Dark(1)
-        expect(Theme.enc(value)).toEqual(new Uint8Array([0, 16, 100, 97, 114, 107, 1]));
-        expect(Theme.dec(Theme.enc(value))).toEqual(value);
-    });
-});