@novasamatech/host-api 0.5.0-18 → 0.5.0-19

package/dist/protocol/messageCodec.js

@@ -0,0 +1,24 @@
+import { Struct, _void, str } from 'scale-ts';
+import { Enum } from './commonCodecs.js';
+import { hostApiProtocol } from './impl.js';
+const createPayload = (hostApi) => {
+    const fields = {};
+    for (const [method, payload] of Object.entries(hostApi)) {
+        if (payload.type === 'request') {
+            fields[`${method}_request`] = payload.request;
+            fields[`${method}_response`] = payload.response;
+        }
+        if (payload.type === 'subscription') {
+            fields[`${method}_start`] = payload.start;
+            fields[`${method}_stop`] = _void;
+            fields[`${method}_interrupt`] = _void;
+            fields[`${method}_receive`] = payload.receive;
+        }
+    }
+    return Enum(fields);
+};
+export const MessagePayload = createPayload(hostApiProtocol);
+export const Message = Struct({
+    requestId: str,
+    payload: MessagePayload,
+});

package/dist/protocol/types.js

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

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

@@ -0,0 +1,265 @@
+export declare const AccountId: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const PublicKey: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const DotNsIdentifier: import("scale-ts").Codec<string>;
+export declare const DerivationIndex: import("scale-ts").Codec<number>;
+export declare const ProductAccountId: import("scale-ts").Codec<[string, number]>;
+export declare const RingVrfProof: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const RingVrgAlias: import("scale-ts").Codec<Uint8Array<ArrayBufferLike>>;
+export declare const Account: import("scale-ts").Codec<{
+    publicKey: Uint8Array<ArrayBufferLike>;
+    name: string | undefined;
+}>;
+export declare const ContextualAlias: import("scale-ts").Codec<{
+    context: Uint8Array<ArrayBufferLike>;
+    alias: Uint8Array<ArrayBufferLike>;
+}>;
+export declare const RingLocationHint: import("scale-ts").Codec<{
+    palletInstance: number | undefined;
+}>;
+export declare const RingLocation: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    ringRootHash: `0x${string}`;
+    hints: {
+        palletInstance: number | undefined;
+    } | undefined;
+}>;
+export declare const RequestCredentialsErr: [import("scale-ts").Encoder<(Error & {
+    name: "RequestCredentialsErr::NotConnected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::DomainNotValid";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>, import("scale-ts").Decoder<(Error & {
+    name: "RequestCredentialsErr::NotConnected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::DomainNotValid";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "RequestCredentialsErr::NotConnected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::DomainNotValid";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "RequestCredentialsErr::NotConnected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::DomainNotValid";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "RequestCredentialsErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+} & {
+    readonly NotConnected: import("../commonCodecs.js").ErrCodec<undefined, "RequestCredentialsErr::NotConnected">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "RequestCredentialsErr::Rejected">;
+    readonly DomainNotValid: import("../commonCodecs.js").ErrCodec<undefined, "RequestCredentialsErr::DomainNotValid">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "RequestCredentialsErr::Unknown">;
+};
+export declare const CreateProofErr: [import("scale-ts").Encoder<(Error & {
+    name: "CreateProofErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateProofErr::RingNotFound";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "CreateProofErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateProofErr::RingNotFound";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "CreateProofErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateProofErr::RingNotFound";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "CreateProofErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateProofErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateProofErr::RingNotFound";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly RingNotFound: import("../commonCodecs.js").ErrCodec<undefined, "CreateProofErr::RingNotFound">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "CreateProofErr::Rejected">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "CreateProofErr::Unknown">;
+};
+export declare const AccountGetV1_request: import("scale-ts").Codec<[string, number]>;
+export declare const AccountGetV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    publicKey: Uint8Array<ArrayBufferLike>;
+    name: string | undefined;
+}, (Error & {
+    name: "RequestCredentialsErr::NotConnected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::DomainNotValid";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>>;
+export declare const AccountGetAliasV1_request: import("scale-ts").Codec<[string, number]>;
+export declare const AccountGetAliasV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    context: Uint8Array<ArrayBufferLike>;
+    alias: Uint8Array<ArrayBufferLike>;
+}, (Error & {
+    name: "RequestCredentialsErr::NotConnected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::DomainNotValid";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>>;
+export declare const AccountCreateProofV1_request: import("scale-ts").Codec<[[string, number], {
+    genesisHash: `0x${string}`;
+    ringRootHash: `0x${string}`;
+    hints: {
+        palletInstance: number | undefined;
+    } | undefined;
+}, Uint8Array<ArrayBufferLike>]>;
+export declare const AccountCreateProofV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, (Error & {
+    name: "CreateProofErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateProofErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateProofErr::RingNotFound";
+    className: string;
+    payload: undefined;
+})>>;
+export declare const GetNonProductAccountsV1_request: import("scale-ts").Codec<undefined>;
+export declare const GetNonProductAccountsV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
+    publicKey: Uint8Array<ArrayBufferLike>;
+    name: string | undefined;
+}[], (Error & {
+    name: "RequestCredentialsErr::NotConnected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::DomainNotValid";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "RequestCredentialsErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>>;

package/dist/{interactions → protocol}/v1/accounts.js

@@ -1,5 +1,5 @@
-import { Bytes, Enum, Option, Result, Struct, Tuple, Vector, _void, str, u32 } from 'scale-ts';
-import { GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
+import { Bytes, Option, Result, Struct, Tuple, Vector, _void, str, u32 } from 'scale-ts';
+import { ErrEnum, GenericErr, GenesisHash, Hex } from '../commonCodecs.js';
 // common types
 export const AccountId = Bytes(32);
 export const PublicKey = Bytes();
@@ -26,16 +26,16 @@ export const RingLocation = Struct({
     hints: Option(RingLocationHint),
 });
 // errors
-export const RequestCredentialsErr = Enum({
-    NotConnected: _void,
-    Rejected: _void,
-    DomainNotValid: _void,
-    Unknown: GenericErr,
+export const RequestCredentialsErr = ErrEnum('RequestCredentialsErr', {
+    NotConnected: [_void, 'RequestCredentials: not connected'],
+    Rejected: [_void, 'RequestCredentials: rejected'],
+    DomainNotValid: [_void, 'RequestCredentials: domain not valid'],
+    Unknown: [GenericErr, 'RequestCredentials: unknown error'],
 });
-export const CreateProofErr = Enum({
-    RingNotFound: _void,
-    Rejected: _void,
-    Unknown: GenericErr,
+export const CreateProofErr = ErrEnum('CreateProofErr', {
+    RingNotFound: [_void, 'CreateProof: ring not found'],
+    Rejected: [_void, 'CreateProof: rejected'],
+    Unknown: [GenericErr, 'CreateProof: unknown error'],
 });
 // account_get
 export const AccountGetV1_request = ProductAccountId;

package/dist/{interactions → protocol}/v1/chat.d.ts

@@ -1,9 +1,36 @@
-export declare const ChatContactRegistrationErr: import("scale-ts").Codec<{
-    tag: "Unknown";
-    value: {
+export declare const ChatContactRegistrationErr: [import("scale-ts").Encoder<Error & {
+    name: "ChatContactRegistrationErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-}>;
+}>, import("scale-ts").Decoder<Error & {
+    name: "ChatContactRegistrationErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}>] & {
+    enc: import("scale-ts").Encoder<Error & {
+        name: "ChatContactRegistrationErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }>;
+    dec: import("scale-ts").Decoder<Error & {
+        name: "ChatContactRegistrationErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }>;
+} & {
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "ChatContactRegistrationErr::Unknown">;
+};
+export declare const ChatContactRegistrationStatus: import("scale-ts").Codec<"New" | "Exists">;
 export declare const ChatContact: import("scale-ts").Codec<{
     name: string;
     icon: string;
@@ -12,9 +39,10 @@ export declare const ChatCreateContactV1_request: import("scale-ts").Codec<{
     name: string;
     icon: string;
 }>;
-export declare const ChatCreateContactV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, {
-    tag: "Unknown";
-    value: {
+export declare const ChatCreateContactV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<"New" | "Exists", Error & {
+    name: "ChatContactRegistrationErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
 }>>;
@@ -22,26 +50,14 @@ export declare const ChatAction: import("scale-ts").Codec<{
     actionId: string;
     title: string;
 }>;
-export declare const ChatActionLayout: import("scale-ts").Codec<{
-    tag: "Column";
-    value: undefined;
-} | {
-    tag: "Grid";
-    value: undefined;
-}>;
+export declare const ChatActionLayout: import("scale-ts").Codec<"Column" | "Grid">;
 export declare const ChatActions: import("scale-ts").Codec<{
     text: string | undefined;
     actions: {
         actionId: string;
         title: string;
     }[];
-    layout: {
-        tag: "Column";
-        value: undefined;
-    } | {
-        tag: "Grid";
-        value: undefined;
-    };
+    layout: "Column" | "Grid";
 }>;
 export declare const ChatMedia: import("scale-ts").Codec<{
     url: string;
@@ -66,6 +82,14 @@ export declare const ChatReaction: import("scale-ts").Codec<{
 export declare const ChatMessage: import("scale-ts").Codec<{
     tag: "Text";
     value: string;
+} | {
+    tag: "RichText";
+    value: {
+        text: string | undefined;
+        media: {
+            url: string;
+        }[];
+    };
 } | {
     tag: "Actions";
     value: {
@@ -74,18 +98,7 @@ export declare const ChatMessage: import("scale-ts").Codec<{
             actionId: string;
             title: string;
         }[];
-        layout: {
-            tag: "Column";
-            value: undefined;
-        } | {
-            tag: "Grid";
-            value: undefined;
-        };
-    };
-} | {
-    tag: "RichText";
-    value: {
-        url: string;
+        layout: "Column" | "Grid";
     };
 } | {
     tag: "File";
@@ -109,21 +122,69 @@ export declare const ChatMessage: import("scale-ts").Codec<{
         emoji: string;
     };
 }>;
-export declare const ChatMessagePostingErr: import("scale-ts").Codec<{
-    tag: "Unknown";
-    value: {
+export declare const ChatMessagePostingErr: [import("scale-ts").Encoder<(Error & {
+    name: "ChatMessagePostingErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "OverflowMessageSize";
-    value: undefined;
-}>;
+}) | (Error & {
+    name: "ChatMessagePostingErr::MessageTooLarge";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "ChatMessagePostingErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "ChatMessagePostingErr::MessageTooLarge";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "ChatMessagePostingErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "ChatMessagePostingErr::MessageTooLarge";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "ChatMessagePostingErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "ChatMessagePostingErr::MessageTooLarge";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly MessageTooLarge: import("../commonCodecs.js").ErrCodec<undefined, "ChatMessagePostingErr::MessageTooLarge">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "ChatMessagePostingErr::Unknown">;
+};
 export declare const ChatPostMessageResult: import("scale-ts").Codec<{
     messageId: string;
 }>;
 export declare const ChatPostMessageV1_request: import("scale-ts").Codec<{
     tag: "Text";
     value: string;
+} | {
+    tag: "RichText";
+    value: {
+        text: string | undefined;
+        media: {
+            url: string;
+        }[];
+    };
 } | {
     tag: "Actions";
     value: {
@@ -132,18 +193,7 @@ export declare const ChatPostMessageV1_request: import("scale-ts").Codec<{
             actionId: string;
             title: string;
         }[];
-        layout: {
-            tag: "Column";
-            value: undefined;
-        } | {
-            tag: "Grid";
-            value: undefined;
-        };
-    };
-} | {
-    tag: "RichText";
-    value: {
-        url: string;
+        layout: "Column" | "Grid";
     };
 } | {
     tag: "File";
@@ -169,15 +219,17 @@ export declare const ChatPostMessageV1_request: import("scale-ts").Codec<{
 }>;
 export declare const ChatPostMessageV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<{
     messageId: string;
-}, {
-    tag: "Unknown";
-    value: {
+}, (Error & {
+    name: "ChatMessagePostingErr::Unknown";
+    className: string;
+    payload: {
         reason: string;
     };
-} | {
-    tag: "OverflowMessageSize";
-    value: undefined;
-}>>;
+}) | (Error & {
+    name: "ChatMessagePostingErr::MessageTooLarge";
+    className: string;
+    payload: undefined;
+})>>;
 export declare const ActionTrigger: import("scale-ts").Codec<{
     messageId: string;
     actionId: string;
@@ -187,6 +239,14 @@ export declare const ReceivedChatAction: import("scale-ts").Codec<{
     value: {
         tag: "Text";
         value: string;
+    } | {
+        tag: "RichText";
+        value: {
+            text: string | undefined;
+            media: {
+                url: string;
+            }[];
+        };
     } | {
         tag: "Actions";
         value: {
@@ -195,18 +255,7 @@ export declare const ReceivedChatAction: import("scale-ts").Codec<{
                 actionId: string;
                 title: string;
             }[];
-            layout: {
-                tag: "Column";
-                value: undefined;
-            } | {
-                tag: "Grid";
-                value: undefined;
-            };
-        };
-    } | {
-        tag: "RichText";
-        value: {
-            url: string;
+            layout: "Column" | "Grid";
         };
     } | {
         tag: "File";
@@ -243,6 +292,14 @@ export declare const ChatActionSubscribeV1_receive: import("scale-ts").Codec<{
     value: {
         tag: "Text";
         value: string;
+    } | {
+        tag: "RichText";
+        value: {
+            text: string | undefined;
+            media: {
+                url: string;
+            }[];
+        };
     } | {
         tag: "Actions";
         value: {
@@ -251,18 +308,7 @@ export declare const ChatActionSubscribeV1_receive: import("scale-ts").Codec<{
                 actionId: string;
                 title: string;
             }[];
-            layout: {
-                tag: "Column";
-                value: undefined;
-            } | {
-                tag: "Grid";
-                value: undefined;
-            };
-        };
-    } | {
-        tag: "RichText";
-        value: {
-            url: string;
+            layout: "Column" | "Grid";
         };
     } | {
         tag: "File";

package/dist/{interactions → protocol}/v1/chat.js

@@ -1,24 +1,22 @@
-import { Enum, Option, Result, Struct, Vector, _void, str, u64 } from 'scale-ts';
-import { GenericErr } from '../commonCodecs.js';
+import { Option, Result, Struct, Vector, _void, str, u64 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, Status } from '../commonCodecs.js';
 // contact
-export const ChatContactRegistrationErr = Enum({
-    Unknown: GenericErr,
+export const ChatContactRegistrationErr = ErrEnum('ChatContactRegistrationErr', {
+    Unknown: [GenericErr, 'Unknown error while chat registration'],
 });
+export const ChatContactRegistrationStatus = Status('New', 'Exists');
 export const ChatContact = Struct({
     name: str,
     icon: str, // url or base64 encoded image for contact
 });
 export const ChatCreateContactV1_request = ChatContact;
-export const ChatCreateContactV1_response = Result(_void, ChatContactRegistrationErr);
+export const ChatCreateContactV1_response = Result(ChatContactRegistrationStatus, ChatContactRegistrationErr);
 // message format
 export const ChatAction = Struct({
     actionId: str,
     title: str,
 });
-export const ChatActionLayout = Enum({
-    Column: _void,
-    Grid: _void,
-});
+export const ChatActionLayout = Status('Column', 'Grid');
 export const ChatActions = Struct({
     text: Option(str),
     actions: Vector(ChatAction),
@@ -44,23 +42,23 @@ export const ChatReaction = Struct({
 });
 export const ChatMessage = Enum({
     Text: str,
+    RichText: ChatRichText,
     Actions: ChatActions,
-    RichText: ChatMedia,
     File: ChatFile,
     Reaction: ChatReaction,
     ReactionRemoved: ChatReaction,
 });
 // sending message
-export const ChatMessagePostingErr = Enum({
-    OverflowMessageSize: _void,
-    Unknown: GenericErr,
+export const ChatMessagePostingErr = ErrEnum('ChatMessagePostingErr', {
+    MessageTooLarge: [_void, 'ChatMessagePosting: message too large'],
+    Unknown: [GenericErr, 'ChatMessagePosting: unknown error'],
 });
 export const ChatPostMessageResult = Struct({
     messageId: str,
 });
 export const ChatPostMessageV1_request = ChatMessage;
 export const ChatPostMessageV1_response = Result(ChatPostMessageResult, ChatMessagePostingErr);
-// receiving message
+// receiving a message
 export const ActionTrigger = Struct({
     messageId: str,
     actionId: str,