@novasamatech/host-api 0.5.0-9 → 0.5.0

package/dist/protocol/v1/chat.js

@@ -0,0 +1,71 @@
+import { Option, Result, Struct, Vector, _void, str, u64 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, Status } from '../commonCodecs.js';
+// contact
+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(ChatContactRegistrationStatus, ChatContactRegistrationErr);
+// message format
+export const ChatAction = Struct({
+    actionId: str,
+    title: str,
+});
+export const ChatActionLayout = Status('Column', 'Grid');
+export const ChatActions = Struct({
+    text: Option(str),
+    actions: Vector(ChatAction),
+    layout: ChatActionLayout,
+});
+export const ChatMedia = Struct({
+    url: str,
+});
+export const ChatRichText = Struct({
+    text: Option(str),
+    media: Vector(ChatMedia),
+});
+export const ChatFile = Struct({
+    url: str,
+    fileName: str,
+    mimeType: str,
+    sizeBytes: u64,
+    text: Option(str),
+});
+export const ChatReaction = Struct({
+    messageId: str,
+    emoji: str,
+});
+export const ChatMessage = Enum({
+    Text: str,
+    RichText: ChatRichText,
+    Actions: ChatActions,
+    File: ChatFile,
+    Reaction: ChatReaction,
+    ReactionRemoved: ChatReaction,
+});
+// sending message
+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 a message
+export const ActionTrigger = Struct({
+    messageId: str,
+    actionId: str,
+});
+export const ReceivedChatAction = Enum({
+    MessagePosted: ChatMessage,
+    ActionTriggered: ActionTrigger,
+});
+export const ChatActionSubscribeV1_start = _void;
+export const ChatActionSubscribeV1_receive = ReceivedChatAction;

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

@@ -0,0 +1,238 @@
+import type { HexString } from '../types.js';
+/**
+ * createTransaction implementation
+ * @see https://github.com/polkadot-js/api/issues/6213
+ */
+export declare const CreateTransactionErr: [import("scale-ts").Encoder<(Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "CreateTransactionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateTransactionErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::NotSupported";
+        className: string;
+        payload: string;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "CreateTransactionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "CreateTransactionErr::FailedToDecode";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "CreateTransactionErr::NotSupported";
+        className: string;
+        payload: string;
+    })>;
+} & {
+    readonly FailedToDecode: import("../commonCodecs.js").ErrCodec<undefined, "CreateTransactionErr::FailedToDecode">;
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "CreateTransactionErr::Rejected">;
+    readonly NotSupported: import("../commonCodecs.js").ErrCodec<string, "CreateTransactionErr::NotSupported">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "CreateTransactionErr::Unknown">;
+};
+export declare const TxPayloadExtensionV1: import("scale-ts").Codec<{
+    id: string;
+    extra: `0x${string}`;
+    additionalSigned: `0x${string}`;
+}>;
+export declare const TxPayloadContextV1: import("scale-ts").Codec<{
+    metadata: `0x${string}`;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    bestBlockHeight: number;
+}>;
+export declare const TxPayloadV1: import("scale-ts").Codec<{
+    signer: string | null;
+    callData: `0x${string}`;
+    extensions: {
+        id: string;
+        extra: `0x${string}`;
+        additionalSigned: `0x${string}`;
+    }[];
+    txExtVersion: number;
+    context: {
+        metadata: `0x${string}`;
+        tokenSymbol: string;
+        tokenDecimals: number;
+        bestBlockHeight: number;
+    };
+}>;
+export declare const VersionedTxPayload: import("scale-ts").Codec<{
+    tag: "v1";
+    value: {
+        signer: string | null;
+        callData: `0x${string}`;
+        extensions: {
+            id: string;
+            extra: `0x${string}`;
+            additionalSigned: `0x${string}`;
+        }[];
+        txExtVersion: number;
+        context: {
+            metadata: `0x${string}`;
+            tokenSymbol: string;
+            tokenDecimals: number;
+            bestBlockHeight: number;
+        };
+    };
+}>;
+export declare const VersionedPublicTxPayload: import("scale-ts").Codec<TxPayloadV1Public>;
+export declare const CreateTransactionV1_request: import("scale-ts").Codec<[[string, number], TxPayloadV1Public]>;
+export declare const CreateTransactionV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, (Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>>;
+export declare const CreateTransactionWithNonProductAccountV1_request: import("scale-ts").Codec<TxPayloadV1Public>;
+export declare const CreateTransactionWithNonProductAccountV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<Uint8Array<ArrayBufferLike>, (Error & {
+    name: "CreateTransactionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "CreateTransactionErr::FailedToDecode";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "CreateTransactionErr::NotSupported";
+    className: string;
+    payload: string;
+})>>;
+export interface TxPayloadV1Public {
+    /** Payload version. MUST be 1. */
+    version: 1;
+    /**
+     * Signer selection hint. Allows the implementer to identify which private-key / scheme to use.
+     * - Use a wallet-defined handle (e.g., address/SS58, account-name, etc). This identifier
+     * was previously made available to the consumer.
+     * - Set `null` to let the implementer pick the signer (or if the signer is implied).
+     */
+    signer: string | null;
+    /**
+     * SCALE-encoded Call (module indicator + function indicator + params).
+     */
+    callData: HexString;
+    /**
+     * Transaction extensions supplied by the caller (order irrelevant).
+     * The consumer SHOULD provide every extension that is relevant to them.
+     * The implementer MAY infer missing ones.
+     */
+    extensions: Array<{
+        /** Identifier as defined in metadata (e.g., "CheckSpecVersion", "ChargeAssetTxPayment"). */
+        id: string;
+        /**
+         * Explicit "extra" to sign (goes into the extrinsic body).
+         * SCALE-encoded per the extension's "extra" type as defined in the metadata.
+         */
+        extra: HexString;
+        /**
+         * "Implicit" data to sign (known by the chain, not included into the extrinsic body).
+         * SCALE-encoded per the extension's "additionalSigned" type as defined in the metadata.
+         */
+        additionalSigned: HexString;
+    }>;
+    /**
+     * Transaction Extension Version.
+     * - For Extrinsic V4 MUST be 0.
+     * - For Extrinsic V5, set to any version supported by the runtime.
+     * The implementer:
+     *  - MUST use this field to determine the required extensions for creating the extrinsic.
+     *  - MAY use this field to infer missing extensions that the implementer could know how to handle.
+     */
+    txExtVersion: number;
+    /**
+     * Context needed for decoding, display, and (optionally) inferring certain extensions.
+     */
+    context: {
+        /**
+         * RuntimeMetadataPrefixed blob (SCALE), starting with ASCII "meta" magic (`0x6d657461`),
+         * then a metadata version (V14+). For V5+ versioned extensions, MUST provide V16+.
+         */
+        metadata: HexString;
+        /**
+         * Native token display info (used by some implementers), also needed to compute
+         * the `CheckMetadataHash` value.
+         */
+        tokenSymbol: string;
+        tokenDecimals: number;
+        /**
+         * Highest known block number to aid mortality UX.
+         */
+        bestBlockHeight: number;
+    };
+}

package/dist/protocol/v1/createTransaction.js

@@ -0,0 +1,58 @@
+import { Bytes, Result, Struct, Tuple, Vector, _void, enhanceCodec, str, u32, u8 } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, Hex, Nullable } from '../commonCodecs.js';
+import { ProductAccountId } from './accounts.js';
+/**
+ * createTransaction implementation
+ * @see https://github.com/polkadot-js/api/issues/6213
+ */
+export const CreateTransactionErr = ErrEnum('CreateTransactionErr', {
+    FailedToDecode: [_void, 'CreateTransaction: failed to decode'],
+    Rejected: [_void, 'CreateTransaction: rejected'],
+    // Unsupported payload version
+    // Failed to infer missing extensions, some extension is unsupported, etc.
+    NotSupported: [str, 'CreateTransaction: not supported'],
+    Unknown: [GenericErr, 'CreateTransaction: unknown error'],
+});
+export const TxPayloadExtensionV1 = Struct({
+    id: str,
+    extra: Hex(),
+    additionalSigned: Hex(),
+});
+export const TxPayloadContextV1 = Struct({
+    metadata: Hex(),
+    tokenSymbol: str,
+    tokenDecimals: u32,
+    bestBlockHeight: u32,
+});
+export const TxPayloadV1 = Struct({
+    signer: Nullable(str),
+    callData: Hex(),
+    extensions: Vector(TxPayloadExtensionV1),
+    txExtVersion: u8,
+    context: TxPayloadContextV1,
+});
+export const VersionedTxPayload = Enum({
+    v1: TxPayloadV1,
+});
+export const VersionedPublicTxPayload = enhanceCodec(VersionedTxPayload, v => {
+    if (v.version !== 1) {
+        throw new Error(`Unsupported transaction version: ${v}`);
+    }
+    return {
+        tag: 'v1',
+        value: v,
+    };
+}, v => {
+    if (v.tag !== 'v1') {
+        throw new Error(`Unsupported transaction version: ${v}`);
+    }
+    return {
+        version: 1,
+        ...v.value,
+    };
+});
+// transaction in the context of a host api account model
+export const CreateTransactionV1_request = Tuple(ProductAccountId, VersionedPublicTxPayload);
+export const CreateTransactionV1_response = Result(Bytes(), CreateTransactionErr);
+export const CreateTransactionWithNonProductAccountV1_request = VersionedPublicTxPayload;
+export const CreateTransactionWithNonProductAccountV1_response = Result(Bytes(), CreateTransactionErr);

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

@@ -0,0 +1,15 @@
+export declare const Feature: import("scale-ts").Codec<{
+    tag: "Chain";
+    value: `0x${string}`;
+}>;
+export declare const FeatureV1_request: import("scale-ts").Codec<{
+    tag: "Chain";
+    value: `0x${string}`;
+}>;
+export declare const FeatureV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<boolean, Error & {
+    name: "GenericError";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}>>;

package/dist/protocol/v1/feature.js

@@ -0,0 +1,7 @@
+import { Result, bool } from 'scale-ts';
+import { Enum, GenericError, GenesisHash } from '../commonCodecs.js';
+export const Feature = Enum({
+    Chain: GenesisHash,
+});
+export const FeatureV1_request = Feature;
+export const FeatureV1_response = Result(bool, GenericError);

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

@@ -0,0 +1,85 @@
+export declare const HandshakeErr: [import("scale-ts").Encoder<(Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>, import("scale-ts").Decoder<(Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "HandshakeErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "HandshakeErr::Timeout";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "HandshakeErr::UnsupportedProtocolVersion";
+        className: string;
+        payload: undefined;
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "HandshakeErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    }) | (Error & {
+        name: "HandshakeErr::Timeout";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "HandshakeErr::UnsupportedProtocolVersion";
+        className: string;
+        payload: undefined;
+    })>;
+} & {
+    readonly Timeout: import("../commonCodecs.js").ErrCodec<undefined, "HandshakeErr::Timeout">;
+    readonly UnsupportedProtocolVersion: import("../commonCodecs.js").ErrCodec<undefined, "HandshakeErr::UnsupportedProtocolVersion">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "HandshakeErr::Unknown">;
+};
+/**
+ * HandshakeV1_request = 1 - JAM codec
+ */
+export declare const HandshakeV1_request: import("scale-ts").Codec<number>;
+export declare const HandshakeV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "HandshakeErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}) | (Error & {
+    name: "HandshakeErr::Timeout";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "HandshakeErr::UnsupportedProtocolVersion";
+    className: string;
+    payload: undefined;
+})>>;

package/dist/protocol/v1/handshake.js

@@ -0,0 +1,12 @@
+import { Result, _void, u8 } from 'scale-ts';
+import { ErrEnum, GenericErr } from '../commonCodecs.js';
+export const HandshakeErr = ErrEnum('HandshakeErr', {
+    Timeout: [_void, 'Handshake: timeout'],
+    UnsupportedProtocolVersion: [_void, 'Handshake: unsupported protocol version'],
+    Unknown: [GenericErr, 'Handshake: unknown error'],
+});
+/**
+ * HandshakeV1_request = 1 - JAM codec
+ */
+export const HandshakeV1_request = u8;
+export const HandshakeV1_response = Result(_void, HandshakeErr);

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

@@ -0,0 +1,10 @@
+export declare const JsonRpcMessageSendV1_request: import("scale-ts").Codec<[`0x${string}`, string]>;
+export declare const JsonRpcMessageSendV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, Error & {
+    name: "GenericError";
+    className: string;
+    payload: {
+        reason: string;
+    };
+}>>;
+export declare const JsonRpcMessageSubscribeV1_start: import("scale-ts").Codec<`0x${string}`>;
+export declare const JsonRpcMessageSubscribeV1_receive: import("scale-ts").Codec<string>;

package/dist/protocol/v1/jsonRpc.js

@@ -0,0 +1,6 @@
+import { Result, Tuple, _void, str } from 'scale-ts';
+import { GenericError, GenesisHash } from '../commonCodecs.js';
+export const JsonRpcMessageSendV1_request = Tuple(GenesisHash, str);
+export const JsonRpcMessageSendV1_response = Result(_void, GenericError);
+export const JsonRpcMessageSubscribeV1_start = GenesisHash;
+export const JsonRpcMessageSubscribeV1_receive = str;

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

@@ -0,0 +1,90 @@
+export declare const PermissionErr: [import("scale-ts").Encoder<(Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>, import("scale-ts").Decoder<(Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>] & {
+    enc: import("scale-ts").Encoder<(Error & {
+        name: "PermissionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "PermissionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+    dec: import("scale-ts").Decoder<(Error & {
+        name: "PermissionErr::Rejected";
+        className: string;
+        payload: undefined;
+    }) | (Error & {
+        name: "PermissionErr::Unknown";
+        className: string;
+        payload: {
+            reason: string;
+        };
+    })>;
+} & {
+    readonly Rejected: import("../commonCodecs.js").ErrCodec<undefined, "PermissionErr::Rejected">;
+    readonly Unknown: import("../commonCodecs.js").ErrCodec<{
+        reason: string;
+    }, "PermissionErr::Unknown">;
+};
+export declare const ChainConnectPermission: import("scale-ts").Codec<{
+    genesisHash: `0x${string}`;
+    name: string;
+}>;
+export declare const Permission: import("scale-ts").Codec<{
+    tag: "ChainSubmit";
+    value: `0x${string}`;
+} | {
+    tag: "ChainConnect";
+    value: {
+        genesisHash: `0x${string}`;
+        name: string;
+    };
+} | {
+    tag: "NetworkRequest";
+    value: string[];
+}>;
+export declare const PermissionRequestV1_request: import("scale-ts").Codec<{
+    tag: "ChainSubmit";
+    value: `0x${string}`;
+} | {
+    tag: "ChainConnect";
+    value: {
+        genesisHash: `0x${string}`;
+        name: string;
+    };
+} | {
+    tag: "NetworkRequest";
+    value: string[];
+}>;
+export declare const PermissionRequestV1_response: import("scale-ts").Codec<import("scale-ts").ResultPayload<undefined, (Error & {
+    name: "PermissionErr::Rejected";
+    className: string;
+    payload: undefined;
+}) | (Error & {
+    name: "PermissionErr::Unknown";
+    className: string;
+    payload: {
+        reason: string;
+    };
+})>>;

package/dist/protocol/v1/permission.js

@@ -0,0 +1,18 @@
+import { Result, Struct, Vector, _void, str } from 'scale-ts';
+import { Enum, ErrEnum, GenericErr, GenesisHash } from '../commonCodecs.js';
+export const PermissionErr = ErrEnum('PermissionErr', {
+    Rejected: [_void, 'Permission: rejected'],
+    Unknown: [GenericErr, 'Permission: unknown error'],
+});
+export const ChainConnectPermission = Struct({
+    genesisHash: GenesisHash,
+    name: str,
+});
+export const Permission = Enum({
+    ChainSubmit: GenesisHash,
+    ChainConnect: ChainConnectPermission,
+    NetworkRequest: Vector(str),
+    // TBD
+});
+export const PermissionRequestV1_request = Permission;
+export const PermissionRequestV1_response = Result(_void, PermissionErr);