@novasamatech/host-api 0.6.1 → 0.6.3

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

@@ -0,0 +1,357 @@
+export declare const RuntimeType: import("scale-ts").Codec<{
+    tag: "Valid";
+    value: {
+        specName: string;
+        implName: string;
+        specVersion: number;
+        implVersion: number;
+        transactionVersion: number | undefined;
+        apis: [string, number][];
+    };
+} | {
+    tag: "Invalid";
+    value: {
+        error: string;
+    };
+}>;
+export declare const StorageQueryType: import("scale-ts").Codec<"Value" | "Hash" | "ClosestDescendantMerkleValue" | "DescendantsValues" | "DescendantsHashes">;
+export declare const StorageQueryItem: import("scale-ts").Codec<{
+    key: `0x${string}`;
+    type: "Value" | "Hash" | "ClosestDescendantMerkleValue" | "DescendantsValues" | "DescendantsHashes";
+}>;
+export declare const StorageResultItem: import("scale-ts").Codec<{
+    key: `0x${string}`;
+    value: `0x${string}` | null;
+    hash: `0x${string}` | null;
+    closestDescendantMerkleValue: `0x${string}` | null;
+}>;
+export declare const OperationStartedResult: import("scale-ts").Codec<{
+    tag: "Started";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "LimitReached";
+    value: undefined;
+}>;
+export declare const ChainHeadFollowV1_start: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    withRuntime: boolean;
+}>;
+export declare const ChainHeadEvent: import("scale-ts").Codec<{
+    tag: "Initialized";
+    value: {
+        finalizedBlockHashes: `0x${string}`[];
+        finalizedBlockRuntime: {
+            tag: "Valid";
+            value: {
+                specName: string;
+                implName: string;
+                specVersion: number;
+                implVersion: number;
+                transactionVersion: number | undefined;
+                apis: [string, number][];
+            };
+        } | {
+            tag: "Invalid";
+            value: {
+                error: string;
+            };
+        } | undefined;
+    };
+} | {
+    tag: "NewBlock";
+    value: {
+        blockHash: `0x${string}`;
+        parentBlockHash: `0x${string}`;
+        newRuntime: {
+            tag: "Valid";
+            value: {
+                specName: string;
+                implName: string;
+                specVersion: number;
+                implVersion: number;
+                transactionVersion: number | undefined;
+                apis: [string, number][];
+            };
+        } | {
+            tag: "Invalid";
+            value: {
+                error: string;
+            };
+        } | undefined;
+    };
+} | {
+    tag: "BestBlockChanged";
+    value: {
+        bestBlockHash: `0x${string}`;
+    };
+} | {
+    tag: "Finalized";
+    value: {
+        finalizedBlockHashes: `0x${string}`[];
+        prunedBlockHashes: `0x${string}`[];
+    };
+} | {
+    tag: "OperationBodyDone";
+    value: {
+        operationId: string;
+        value: `0x${string}`[];
+    };
+} | {
+    tag: "OperationCallDone";
+    value: {
+        operationId: string;
+        output: `0x${string}`;
+    };
+} | {
+    tag: "OperationStorageItems";
+    value: {
+        operationId: string;
+        items: {
+            key: `0x${string}`;
+            value: `0x${string}` | null;
+            hash: `0x${string}` | null;
+            closestDescendantMerkleValue: `0x${string}` | null;
+        }[];
+    };
+} | {
+    tag: "OperationStorageDone";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationWaitingForContinue";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationInaccessible";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationError";
+    value: {
+        operationId: string;
+        error: string;
+    };
+} | {
+    tag: "Stop";
+    value: undefined;
+}>;
+export declare const ChainHeadFollowV1_receive: import("scale-ts").Codec<{
+    tag: "Initialized";
+    value: {
+        finalizedBlockHashes: `0x${string}`[];
+        finalizedBlockRuntime: {
+            tag: "Valid";
+            value: {
+                specName: string;
+                implName: string;
+                specVersion: number;
+                implVersion: number;
+                transactionVersion: number | undefined;
+                apis: [string, number][];
+            };
+        } | {
+            tag: "Invalid";
+            value: {
+                error: string;
+            };
+        } | undefined;
+    };
+} | {
+    tag: "NewBlock";
+    value: {
+        blockHash: `0x${string}`;
+        parentBlockHash: `0x${string}`;
+        newRuntime: {
+            tag: "Valid";
+            value: {
+                specName: string;
+                implName: string;
+                specVersion: number;
+                implVersion: number;
+                transactionVersion: number | undefined;
+                apis: [string, number][];
+            };
+        } | {
+            tag: "Invalid";
+            value: {
+                error: string;
+            };
+        } | undefined;
+    };
+} | {
+    tag: "BestBlockChanged";
+    value: {
+        bestBlockHash: `0x${string}`;
+    };
+} | {
+    tag: "Finalized";
+    value: {
+        finalizedBlockHashes: `0x${string}`[];
+        prunedBlockHashes: `0x${string}`[];
+    };
+} | {
+    tag: "OperationBodyDone";
+    value: {
+        operationId: string;
+        value: `0x${string}`[];
+    };
+} | {
+    tag: "OperationCallDone";
+    value: {
+        operationId: string;
+        output: `0x${string}`;
+    };
+} | {
+    tag: "OperationStorageItems";
+    value: {
+        operationId: string;
+        items: {
+            key: `0x${string}`;
+            value: `0x${string}` | null;
+            hash: `0x${string}` | null;
+            closestDescendantMerkleValue: `0x${string}` | null;
+        }[];
+    };
+} | {
+    tag: "OperationStorageDone";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationWaitingForContinue";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationInaccessible";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "OperationError";
+    value: {
+        operationId: string;
+        error: string;
+    };
+} | {
+    tag: "Stop";
+    value: undefined;
+}>;
+export declare const ChainHeadHeaderV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    hash: `0x${string}`;
+}>;
+export declare const ChainHeadHeaderV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<`0x${string}` | null, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadBodyV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    hash: `0x${string}`;
+}>;
+export declare const ChainHeadBodyV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    tag: "Started";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "LimitReached";
+    value: undefined;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadStorageV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    hash: `0x${string}`;
+    items: {
+        key: `0x${string}`;
+        type: "Value" | "Hash" | "ClosestDescendantMerkleValue" | "DescendantsValues" | "DescendantsHashes";
+    }[];
+    childTrie: `0x${string}` | null;
+}>;
+export declare const ChainHeadStorageV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    tag: "Started";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "LimitReached";
+    value: undefined;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadCallV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    hash: `0x${string}`;
+    function: string;
+    callParameters: `0x${string}`;
+}>;
+export declare const ChainHeadCallV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    tag: "Started";
+    value: {
+        operationId: string;
+    };
+} | {
+    tag: "LimitReached";
+    value: undefined;
+}, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadUnpinV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    hashes: `0x${string}`[];
+}>;
+export declare const ChainHeadUnpinV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadContinueV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    operationId: string;
+}>;
+export declare const ChainHeadContinueV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainHeadStopOperationV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    followSubscriptionId: string;
+    operationId: string;
+}>;
+export declare const ChainHeadStopOperationV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainSpecGenesisHashV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const ChainSpecGenesisHashV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<`0x${string}`, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainSpecChainNameV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const ChainSpecChainNameV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<string, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const ChainSpecPropertiesV1_request: import("scale-ts").Codec<`0x${string}`>;
+export declare const ChainSpecPropertiesV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<string, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const TransactionBroadcastV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    transaction: `0x${string}`;
+}>;
+export declare const TransactionBroadcastV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<string | null, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;
+export declare const TransactionStopV1_request: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    operationId: string;
+}>;
+export declare const TransactionStopV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+    reason: string;
+}, "GenericError">>>;

package/dist/protocol/v1/chainInteraction.js

@@ -0,0 +1,159 @@
+import { Enum, Hex, Nullable, Status } from '@novasamatech/scale';
+import { Option, Result, Struct, Tuple, Vector, _void, bool, str, u32 } from 'scale-ts';
+import { GenericError, GenesisHash } from '../commonCodecs.js';
+// === Shared types ===
+const BlockHash = Hex();
+const OperationId = str;
+// === Runtime spec (for follow events with withRuntime=true) ===
+const RuntimeApi = Tuple(str, u32);
+const RuntimeSpec = Struct({
+    specName: str,
+    implName: str,
+    specVersion: u32,
+    implVersion: u32,
+    transactionVersion: Option(u32),
+    apis: Vector(RuntimeApi),
+});
+export const RuntimeType = Enum({
+    Valid: RuntimeSpec,
+    Invalid: Struct({ error: str }),
+});
+// === Storage types ===
+export const StorageQueryType = Status('Value', 'Hash', 'ClosestDescendantMerkleValue', 'DescendantsValues', 'DescendantsHashes');
+export const StorageQueryItem = Struct({
+    key: Hex(),
+    type: StorageQueryType,
+});
+export const StorageResultItem = Struct({
+    key: Hex(),
+    value: Nullable(Hex()),
+    hash: Nullable(Hex()),
+    closestDescendantMerkleValue: Nullable(Hex()),
+});
+// === Operation result (shared by body/storage/call responses) ===
+export const OperationStartedResult = Enum({
+    Started: Struct({ operationId: OperationId }),
+    LimitReached: _void,
+});
+// === ChainHead Follow ===
+export const ChainHeadFollowV1_start = Struct({
+    genesisHash: GenesisHash,
+    withRuntime: bool,
+});
+export const ChainHeadEvent = Enum({
+    Initialized: Struct({
+        finalizedBlockHashes: Vector(BlockHash),
+        finalizedBlockRuntime: Option(RuntimeType),
+    }),
+    NewBlock: Struct({
+        blockHash: BlockHash,
+        parentBlockHash: BlockHash,
+        newRuntime: Option(RuntimeType),
+    }),
+    BestBlockChanged: Struct({
+        bestBlockHash: BlockHash,
+    }),
+    Finalized: Struct({
+        finalizedBlockHashes: Vector(BlockHash),
+        prunedBlockHashes: Vector(BlockHash),
+    }),
+    OperationBodyDone: Struct({
+        operationId: OperationId,
+        value: Vector(Hex()),
+    }),
+    OperationCallDone: Struct({
+        operationId: OperationId,
+        output: Hex(),
+    }),
+    OperationStorageItems: Struct({
+        operationId: OperationId,
+        items: Vector(StorageResultItem),
+    }),
+    OperationStorageDone: Struct({
+        operationId: OperationId,
+    }),
+    OperationWaitingForContinue: Struct({
+        operationId: OperationId,
+    }),
+    OperationInaccessible: Struct({
+        operationId: OperationId,
+    }),
+    OperationError: Struct({
+        operationId: OperationId,
+        error: str,
+    }),
+    Stop: _void,
+});
+export const ChainHeadFollowV1_receive = ChainHeadEvent;
+// === ChainHead Header ===
+export const ChainHeadHeaderV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    hash: BlockHash,
+});
+export const ChainHeadHeaderV1_response = Result(Nullable(Hex()), GenericError);
+// === ChainHead Body ===
+export const ChainHeadBodyV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    hash: BlockHash,
+});
+export const ChainHeadBodyV1_response = Result(OperationStartedResult, GenericError);
+// === ChainHead Storage ===
+export const ChainHeadStorageV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    hash: BlockHash,
+    items: Vector(StorageQueryItem),
+    childTrie: Nullable(Hex()),
+});
+export const ChainHeadStorageV1_response = Result(OperationStartedResult, GenericError);
+// === ChainHead Call ===
+export const ChainHeadCallV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    hash: BlockHash,
+    function: str,
+    callParameters: Hex(),
+});
+export const ChainHeadCallV1_response = Result(OperationStartedResult, GenericError);
+// === ChainHead Unpin ===
+export const ChainHeadUnpinV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    hashes: Vector(BlockHash),
+});
+export const ChainHeadUnpinV1_response = Result(_void, GenericError);
+// === ChainHead Continue ===
+export const ChainHeadContinueV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    operationId: OperationId,
+});
+export const ChainHeadContinueV1_response = Result(_void, GenericError);
+// === ChainHead StopOperation ===
+export const ChainHeadStopOperationV1_request = Struct({
+    genesisHash: GenesisHash,
+    followSubscriptionId: str,
+    operationId: OperationId,
+});
+export const ChainHeadStopOperationV1_response = Result(_void, GenericError);
+// === ChainSpec ===
+export const ChainSpecGenesisHashV1_request = GenesisHash;
+export const ChainSpecGenesisHashV1_response = Result(Hex(), GenericError);
+export const ChainSpecChainNameV1_request = GenesisHash;
+export const ChainSpecChainNameV1_response = Result(str, GenericError);
+export const ChainSpecPropertiesV1_request = GenesisHash;
+export const ChainSpecPropertiesV1_response = Result(str, GenericError);
+// === Transaction Broadcast ===
+export const TransactionBroadcastV1_request = Struct({
+    genesisHash: GenesisHash,
+    transaction: Hex(),
+});
+export const TransactionBroadcastV1_response = Result(Nullable(str), GenericError);
+// === Transaction Stop ===
+export const TransactionStopV1_request = Struct({
+    genesisHash: GenesisHash,
+    operationId: str,
+});
+export const TransactionStopV1_response = Result(_void, GenericError);

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

@@ -459,6 +459,7 @@ export declare const ChatActionSubscribeV1_receive: Codec<{
     };
 }>;
 export declare const ChatCustomMessageRenderingV1_start: Codec<{
+    messageId: string;
     messageType: string;
     payload: Uint8Array<ArrayBufferLike>;
 }>;

package/dist/protocol/v1/chat.js

@@ -120,5 +120,5 @@ export const ReceivedChatAction = Struct({
 export const ChatActionSubscribeV1_start = _void;
 export const ChatActionSubscribeV1_receive = ReceivedChatAction;
 // custom message rendering
-export const ChatCustomMessageRenderingV1_start = Struct({ messageType: str, payload: Bytes() });
+export const ChatCustomMessageRenderingV1_start = Struct({ messageId: str, messageType: str, payload: Bytes() });
 export const ChatCustomMessageRenderingV1_receive = CustomRendererNode;