@novasamatech/host-api 0.6.0 → 0.6.2-0

package/dist/hostApi.js

@@ -465,5 +465,225 @@ export function createHostApi(transport) {
         jsonrpcMessageSubscribe(args, callback) {
             return transport.subscribe('host_jsonrpc_message_subscribe', args, callback);
         },
+        // chain interaction
+        chainHeadFollow(args, callback) {
+            return transport.subscribe('remote_chain_head_follow', args, callback);
+        },
+        chainHeadHeader(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_header', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadBody(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_body', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadStorage(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_storage', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadCall(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_call', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadUnpin(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_unpin', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadContinue(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_continue', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainHeadStopOperation(payload) {
+            const response = fromPromise(transport.request('remote_chain_head_stop_operation', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainSpecGenesisHash(payload) {
+            const response = fromPromise(transport.request('remote_chain_spec_genesis_hash', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainSpecChainName(payload) {
+            const response = fromPromise(transport.request('remote_chain_spec_chain_name', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainSpecProperties(payload) {
+            const response = fromPromise(transport.request('remote_chain_spec_properties', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainTransactionBroadcast(payload) {
+            const response = fromPromise(transport.request('remote_chain_transaction_broadcast', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
+        chainTransactionStop(payload) {
+            const response = fromPromise(transport.request('remote_chain_transaction_stop', payload), e => ({
+                tag: payload.tag,
+                value: new GenericError({ reason: extractErrorMessage(e) }),
+            }));
+            return response.andThen(response => {
+                if (response.value.success) {
+                    return okAsync({
+                        tag: response.tag,
+                        value: response.value.value,
+                    });
+                }
+                return errAsync({
+                    tag: response.tag,
+                    value: response.value.value,
+                });
+            });
+        },
     };
 }

package/dist/index.d.ts

@@ -24,3 +24,4 @@ export { PushNotification } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { CustomRendererNode } from './protocol/v1/customRenderer.js';
+export { ChainHeadEvent, ChainHeadFollowV1_start, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';

package/dist/index.js

@@ -19,3 +19,4 @@ export { PushNotification } from './protocol/v1/notification.js';
 export { NavigateToErr } from './protocol/v1/navigation.js';
 export { PreimageKey, PreimageSubmitErr, PreimageValue } from './protocol/v1/preimage.js';
 export { CustomRendererNode } from './protocol/v1/customRenderer.js';
+export { ChainHeadEvent, ChainHeadFollowV1_start, OperationStartedResult, RuntimeType, StorageQueryItem, StorageQueryType, StorageResultItem, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './protocol/v1/chainInteraction.js';

package/dist/protocol/impl.d.ts

@@ -476,5 +476,237 @@ export declare const hostApiProtocol: {
     readonly host_jsonrpc_message_subscribe: VersionedProtocolSubscription<{
         readonly v1: [Codec<`0x${string}`>, Codec<string>];
     }>;
+    readonly remote_chain_head_follow: VersionedProtocolSubscription<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            withRuntime: boolean;
+        }>, 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;
+        }>];
+    }>;
+    readonly remote_chain_head_header: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            hash: `0x${string}`;
+        }>, Codec<import("scale-ts").ResultPayload<`0x${string}` | null, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_body: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            hash: `0x${string}`;
+        }>, Codec<import("scale-ts").ResultPayload<{
+            tag: "Started";
+            value: {
+                operationId: string;
+            };
+        } | {
+            tag: "LimitReached";
+            value: undefined;
+        }, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_storage: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            hash: `0x${string}`;
+            items: {
+                key: `0x${string}`;
+                type: "Value" | "Hash" | "ClosestDescendantMerkleValue" | "DescendantsValues" | "DescendantsHashes";
+            }[];
+            childTrie: `0x${string}` | null;
+        }>, Codec<import("scale-ts").ResultPayload<{
+            tag: "Started";
+            value: {
+                operationId: string;
+            };
+        } | {
+            tag: "LimitReached";
+            value: undefined;
+        }, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_call: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            hash: `0x${string}`;
+            function: string;
+            callParameters: `0x${string}`;
+        }>, Codec<import("scale-ts").ResultPayload<{
+            tag: "Started";
+            value: {
+                operationId: string;
+            };
+        } | {
+            tag: "LimitReached";
+            value: undefined;
+        }, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_unpin: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            hashes: `0x${string}`[];
+        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_continue: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            operationId: string;
+        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_head_stop_operation: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            followSubscriptionId: string;
+            operationId: string;
+        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_spec_genesis_hash: VersionedProtocolRequest<{
+        readonly v1: [Codec<`0x${string}`>, Codec<import("scale-ts").ResultPayload<`0x${string}`, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_spec_chain_name: VersionedProtocolRequest<{
+        readonly v1: [Codec<`0x${string}`>, Codec<import("scale-ts").ResultPayload<string, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_spec_properties: VersionedProtocolRequest<{
+        readonly v1: [Codec<`0x${string}`>, Codec<import("scale-ts").ResultPayload<string, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_transaction_broadcast: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            transaction: `0x${string}`;
+        }>, Codec<import("scale-ts").ResultPayload<string | null, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
+    readonly remote_chain_transaction_stop: VersionedProtocolRequest<{
+        readonly v1: [Codec<{
+            genesisHash: `0x${string}`;
+            operationId: string;
+        }>, Codec<import("scale-ts").ResultPayload<undefined, import("@novasamatech/scale").CodecError<{
+            reason: string;
+        }, "GenericError">>>];
+    }>;
 };
 export {};

package/dist/protocol/impl.js

@@ -1,5 +1,6 @@
 import { Enum } from '@novasamatech/scale';
 import { AccountConnectionStatusV1_receive, AccountConnectionStatusV1_start, AccountCreateProofV1_request, AccountCreateProofV1_response, AccountGetAliasV1_request, AccountGetAliasV1_response, AccountGetV1_request, AccountGetV1_response, GetNonProductAccountsV1_request, GetNonProductAccountsV1_response, } from './v1/accounts.js';
+import { ChainHeadBodyV1_request, ChainHeadBodyV1_response, ChainHeadCallV1_request, ChainHeadCallV1_response, ChainHeadContinueV1_request, ChainHeadContinueV1_response, ChainHeadFollowV1_receive, ChainHeadFollowV1_start, ChainHeadHeaderV1_request, ChainHeadHeaderV1_response, ChainHeadStopOperationV1_request, ChainHeadStopOperationV1_response, ChainHeadStorageV1_request, ChainHeadStorageV1_response, ChainHeadUnpinV1_request, ChainHeadUnpinV1_response, ChainSpecChainNameV1_request, ChainSpecChainNameV1_response, ChainSpecGenesisHashV1_request, ChainSpecGenesisHashV1_response, ChainSpecPropertiesV1_request, ChainSpecPropertiesV1_response, TransactionBroadcastV1_request, TransactionBroadcastV1_response, TransactionStopV1_request, TransactionStopV1_response, } from './v1/chainInteraction.js';
 import { ChatActionSubscribeV1_receive, ChatActionSubscribeV1_start, ChatCreateRoomV1_request, ChatCreateRoomV1_response, ChatCustomMessageRenderingV1_receive, ChatCustomMessageRenderingV1_start, ChatListSubscribeV1_receive, ChatListSubscribeV1_start, ChatPostMessageV1_request, ChatPostMessageV1_response, ChatRegisterBotV1_request, ChatRegisterBotV1_response, } from './v1/chat.js';
 import { CreateTransactionV1_request, CreateTransactionV1_response, CreateTransactionWithNonProductAccountV1_request, CreateTransactionWithNonProductAccountV1_response, } from './v1/createTransaction.js';
 import { DevicePermissionV1_request, DevicePermissionV1_response } from './v1/devicePermission.js';
@@ -126,11 +127,51 @@ export const hostApiProtocol = {
     remote_preimage_submit: versionedRequest({
         v1: [PreimageSubmitV1_request, PreimageSubmitV1_response],
     }),
-    // json rpc (temporary, kept until chain methods are added)
+    // json rpc (deprecated: use remote_chain_* methods instead)
     host_jsonrpc_message_send: versionedRequest({
         v1: [JsonRpcMessageSendV1_request, JsonRpcMessageSendV1_response],
     }),
     host_jsonrpc_message_subscribe: versionedSubscription({
         v1: [JsonRpcMessageSubscribeV1_start, JsonRpcMessageSubscribeV1_receive],
     }),
+    // chain interaction (remote namespace)
+    remote_chain_head_follow: versionedSubscription({
+        v1: [ChainHeadFollowV1_start, ChainHeadFollowV1_receive],
+    }),
+    remote_chain_head_header: versionedRequest({
+        v1: [ChainHeadHeaderV1_request, ChainHeadHeaderV1_response],
+    }),
+    remote_chain_head_body: versionedRequest({
+        v1: [ChainHeadBodyV1_request, ChainHeadBodyV1_response],
+    }),
+    remote_chain_head_storage: versionedRequest({
+        v1: [ChainHeadStorageV1_request, ChainHeadStorageV1_response],
+    }),
+    remote_chain_head_call: versionedRequest({
+        v1: [ChainHeadCallV1_request, ChainHeadCallV1_response],
+    }),
+    remote_chain_head_unpin: versionedRequest({
+        v1: [ChainHeadUnpinV1_request, ChainHeadUnpinV1_response],
+    }),
+    remote_chain_head_continue: versionedRequest({
+        v1: [ChainHeadContinueV1_request, ChainHeadContinueV1_response],
+    }),
+    remote_chain_head_stop_operation: versionedRequest({
+        v1: [ChainHeadStopOperationV1_request, ChainHeadStopOperationV1_response],
+    }),
+    remote_chain_spec_genesis_hash: versionedRequest({
+        v1: [ChainSpecGenesisHashV1_request, ChainSpecGenesisHashV1_response],
+    }),
+    remote_chain_spec_chain_name: versionedRequest({
+        v1: [ChainSpecChainNameV1_request, ChainSpecChainNameV1_response],
+    }),
+    remote_chain_spec_properties: versionedRequest({
+        v1: [ChainSpecPropertiesV1_request, ChainSpecPropertiesV1_response],
+    }),
+    remote_chain_transaction_broadcast: versionedRequest({
+        v1: [TransactionBroadcastV1_request, TransactionBroadcastV1_response],
+    }),
+    remote_chain_transaction_stop: versionedRequest({
+        v1: [TransactionStopV1_request, TransactionStopV1_response],
+    }),
 };