@novasamatech/host-api 0.5.0-8 → 0.5.0

package/dist/protocol/commonCodecs.d.ts

@@ -0,0 +1,42 @@
+import type { Codec, CodecType, StringRecord } from 'scale-ts';
+type FilterStringRecord<T extends Record<string, Codec<any>>> = T extends StringRecord<Codec<any>> ? T : never;
+export type EnumCodec<T extends Record<string, Codec<any>>> = ReturnType<typeof Enum<T>>;
+export declare const Enum: <T extends Record<string, Codec<any>>>(inner: T) => Codec<(FilterStringRecord<T> extends infer T_1 extends StringRecord<Codec<any>> ? { [K in keyof T_1]: {
+    tag: K;
+    value: CodecType<T_1[K]>;
+}; } : never)[keyof FilterStringRecord<T>]>;
+/**
+ * Enum without values
+ */
+export declare function Status<T extends string>(...list: T[]): Codec<T>;
+export declare function Nullable<T>(inner: Codec<T>): Codec<T | null>;
+type Constructor<A extends Array<any>, T> = new (...args: A) => T;
+type CodecError<T, Name extends string> = Error & {
+    name: Name;
+    className: string;
+    payload: T;
+};
+type CodecErrorConstructor<T, Name extends string> = Constructor<T extends undefined ? [void] : [T], CodecError<T, Name>>;
+export type ErrCodec<T, Name extends string> = Codec<CodecError<T, Name>> & CodecErrorConstructor<T, Name>;
+export declare function Err<const T, const Name extends string>(name: Name, value: Codec<T>, message: string | ((value: NoInfer<T>) => string), className?: string): ErrCodec<T, Name>;
+type MapErrEnum<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
+    [K in keyof T]: ErrCodec<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
+};
+type ErrEnumInput<Name extends string, T extends Record<string, ErrEnumArguments<any>>> = {
+    [K in keyof T]: CodecError<CodecType<T[K][0]>, K extends string ? `${Name}::${K}` : Name>;
+}[keyof T];
+type ErrEnumArguments<T> = [value: Codec<T>, message: string | ((value: T) => string)];
+export declare function ErrEnum<const Name extends string, const T extends Record<string, ErrEnumArguments<any>>>(name: Name, inner: T): Codec<ErrEnumInput<Name, T>> & MapErrEnum<Name, T>;
+/**
+ * Wrapper around Bytes codec. Every usage of Hex codec should be threaded as raw Bytes with mapping to hex string.
+ * @param [length] Optional, corresponds to byte array size, not the length of hex string.
+ */
+export declare const Hex: (length?: number) => Codec<`0x${string}`>;
+export declare const GenesisHash: Codec<`0x${string}`>;
+export declare const GenericErr: Codec<{
+    reason: string;
+}>;
+export declare const GenericError: ErrCodec<{
+    reason: string;
+}, "GenericError">;
+export {};

package/dist/protocol/commonCodecs.js

@@ -0,0 +1,64 @@
+import { Bytes, Enum as ScaleEnum, Option, Struct, _void, enhanceCodec, str, u8 } from 'scale-ts';
+import { fromHex, toHex } from '../helpers.js';
+export const Enum = (inner) => ScaleEnum(inner);
+/**
+ * Enum without values
+ */
+export function Status(...list) {
+    return enhanceCodec(u8, v => {
+        const i = list.indexOf(v);
+        if (i === -1) {
+            throw new Error(`Unknown status value: ${v}`);
+        }
+        return i;
+    }, i => {
+        const v = list.at(i);
+        if (v === undefined) {
+            throw new Error(`Unknown status index: ${i}`);
+        }
+        return v;
+    });
+}
+export function Nullable(inner) {
+    return enhanceCodec(Option(inner), v => (v === null ? undefined : v), v => (v === undefined ? null : v));
+}
+export function Err(name, value, message, className = name) {
+    // Defining class with dynamic name
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const C = {
+        [className]: class extends Error {
+            className = className;
+            name = name;
+            payload;
+            constructor(data) {
+                super(typeof message === 'function' ? message(data) : message);
+                this.payload = data;
+            }
+            // workaround for codec array destructuring
+            static [Symbol.iterator]() {
+                return errorCodec[Symbol.iterator]();
+            }
+        },
+    }[className];
+    const errorCodec = enhanceCodec(value, v => v.payload, 
+    // @ts-expect-error don't want to fix it really
+    v => new C(v));
+    return Object.assign(C, errorCodec);
+}
+export function ErrEnum(name, inner) {
+    const values = Object.fromEntries(Object.entries(inner).map(([k, [value, message]]) => {
+        return [k, Err(`${name}::${k}`, value, message, k)];
+    }));
+    const codec = enhanceCodec(Enum(values), v => ({ tag: v.className, value: v }), v => v.value);
+    return Object.assign(codec, values);
+}
+/**
+ * Wrapper around Bytes codec. Every usage of Hex codec should be threaded as raw Bytes with mapping to hex string.
+ * @param [length] Optional, corresponds to byte array size, not the length of hex string.
+ */
+export const Hex = (length) => enhanceCodec(Bytes(length), fromHex, toHex);
+export const GenesisHash = Hex();
+export const GenericErr = Struct({
+    reason: str,
+});
+export const GenericError = Err('GenericError', GenericErr, ({ reason }) => `Unknown error: ${reason}`);

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

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

package/dist/protocol/commonCodecs.spec.js

@@ -0,0 +1,72 @@
+import { Struct, _void, bool } from 'scale-ts';
+import { describe, expect, it } from 'vitest';
+import { Err, ErrEnum, Hex, Status } from './commonCodecs.js';
+describe('Common codecs', () => {
+    describe('Hex', () => {
+        it('should correctly encode/decode Hex with arbitrary length', () => {
+            const hex = '0xffffff';
+            const codec = Hex();
+            expect(codec.enc(hex)).toEqual(new Uint8Array([12, 255, 255, 255]));
+            expect(codec.dec(codec.enc(hex))).toEqual(hex);
+        });
+        it('should correctly encode/decode Hex with fixed length', () => {
+            const hex = '0xffffff';
+            const codec = Hex(3);
+            expect(codec.enc(hex)).toEqual(new Uint8Array([255, 255, 255]));
+            expect(codec.dec(codec.enc(hex))).toEqual(hex);
+        });
+    });
+    describe('Status', () => {
+        it('should correctly encode/decode Status', () => {
+            const codec = Status('New', 'Used');
+            expect(codec.enc('New')).toEqual(new Uint8Array([0]));
+            expect(codec.enc('Used')).toEqual(new Uint8Array([1]));
+            expect(codec.dec('0x00')).toEqual('New');
+            expect(codec.dec('0x01')).toEqual('Used');
+            // @ts-expect-error for test
+            expect(() => codec.enc('Unknown')).toThrowErrorMatchingInlineSnapshot(`[Error: Unknown status value: Unknown]`);
+            expect(() => codec.dec('0x03')).toThrowErrorMatchingInlineSnapshot(`[Error: Unknown status index: 3]`);
+        });
+    });
+    describe('Err', () => {
+        it('should correctly construct Error', () => {
+            const ErrorCodec = Err('TestError', _void, 'Test message');
+            const error = new ErrorCodec(undefined);
+            expect(error).toBeInstanceOf(ErrorCodec);
+            expect(error.name).toBe('TestError');
+            expect(error.message).toBe('Test message');
+        });
+        it('should correctly encode/decode Err', () => {
+            const payload = Struct({ enable: bool });
+            const ErrorCodec = Err('TestError', payload, 'Test message');
+            const error = new ErrorCodec({ enable: true });
+            expect(ErrorCodec.enc(error)).toEqual(new Uint8Array([1]));
+            expect(ErrorCodec.dec(ErrorCodec.enc(error))).toEqual(new ErrorCodec({ enable: true }));
+        });
+    });
+    describe('ErrEnum', () => {
+        it('should correctly construct ErrorEnum field', () => {
+            const ErrorCodec = ErrEnum('ErrorCodec', {
+                TestError: [_void, 'Test message'],
+            });
+            const error = new ErrorCodec.TestError(undefined);
+            expect(error).toBeInstanceOf(ErrorCodec.TestError);
+            expect(error.name).toBe('ErrorCodec::TestError');
+            expect(error.message).toBe('Test message');
+        });
+        it('should correctly serialize/deserialize', () => {
+            const ErrorCodec = ErrEnum('ErrorCodec', {
+                First: [_void, 'First'],
+                Second: [_void, 'Second'],
+            });
+            const first = new ErrorCodec.First(undefined);
+            const second = new ErrorCodec.Second(undefined);
+            expect(ErrorCodec.enc(first)).toEqual(new Uint8Array([0]));
+            expect(ErrorCodec.enc(second)).toEqual(new Uint8Array([1]));
+            expect(ErrorCodec.dec(ErrorCodec.enc(first))).toEqual(first);
+            expect(ErrorCodec.dec(ErrorCodec.enc(second))).toEqual(second);
+            expect(ErrorCodec.dec(ErrorCodec.enc(first))).not.toEqual(second);
+            expect(ErrorCodec.dec(ErrorCodec.enc(second))).not.toEqual(first);
+        });
+    });
+});

package/dist/protocol/impl.d.ts

@@ -0,0 +1,93 @@
+import type { Codec } from 'scale-ts';
+import type { EnumCodec } from './commonCodecs.js';
+import { AccountCreateProofV1_request, AccountCreateProofV1_response, AccountGetAliasV1_request, AccountGetAliasV1_response, AccountGetV1_request, AccountGetV1_response, GetNonProductAccountsV1_request, GetNonProductAccountsV1_response } from './v1/accounts.js';
+import { ChatActionSubscribeV1_receive, ChatActionSubscribeV1_start, ChatCreateContactV1_request, ChatCreateContactV1_response, ChatPostMessageV1_request, ChatPostMessageV1_response } from './v1/chat.js';
+import { CreateTransactionV1_request, CreateTransactionV1_response, CreateTransactionWithNonProductAccountV1_request, CreateTransactionWithNonProductAccountV1_response } from './v1/createTransaction.js';
+import { FeatureV1_request, FeatureV1_response } from './v1/feature.js';
+import { HandshakeV1_request, HandshakeV1_response } from './v1/handshake.js';
+import { JsonRpcMessageSendV1_request, JsonRpcMessageSendV1_response, JsonRpcMessageSubscribeV1_receive, JsonRpcMessageSubscribeV1_start } from './v1/jsonRpc.js';
+import { PermissionRequestV1_request, PermissionRequestV1_response } from './v1/permission.js';
+import { SignPayloadV1_request, SignPayloadV1_response, SignRawV1_request, SignRawV1_response } from './v1/sign.js';
+import { StatementStoreCreateProofV1_request, StatementStoreCreateProofV1_response } from './v1/statementStore.js';
+import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request, StorageReadV1_response, StorageWriteV1_request, StorageWriteV1_response } from './v1/storage.js';
+export type VersionedArguments = Record<string, [Codec<any>, Codec<any>]>;
+type InferVersionedArgument<EnumValues extends VersionedArguments, N extends number> = {
+    [V in keyof EnumValues]: EnumValues[V][N];
+};
+export type VersionedProtocolRequest<T extends VersionedArguments = VersionedArguments> = {
+    type: 'request';
+    request: EnumCodec<InferVersionedArgument<T, 0>>;
+    response: EnumCodec<InferVersionedArgument<T, 1>>;
+};
+export type VersionedProtocolSubscription<T extends VersionedArguments = VersionedArguments> = {
+    type: 'subscription';
+    start: EnumCodec<InferVersionedArgument<T, 0>>;
+    receive: EnumCodec<InferVersionedArgument<T, 1>>;
+};
+export type HostApiProtocol = {
+    handshake: VersionedProtocolRequest<{
+        v1: [typeof HandshakeV1_request, typeof HandshakeV1_response];
+    }>;
+    feature: VersionedProtocolRequest<{
+        v1: [typeof FeatureV1_request, typeof FeatureV1_response];
+    }>;
+    permission_request: VersionedProtocolRequest<{
+        v1: [typeof PermissionRequestV1_request, typeof PermissionRequestV1_response];
+    }>;
+    storage_read: VersionedProtocolRequest<{
+        v1: [typeof StorageReadV1_request, typeof StorageReadV1_response];
+    }>;
+    storage_write: VersionedProtocolRequest<{
+        v1: [typeof StorageWriteV1_request, typeof StorageWriteV1_response];
+    }>;
+    storage_clear: VersionedProtocolRequest<{
+        v1: [typeof StorageClearV1_request, typeof StorageClearV1_response];
+    }>;
+    account_get: VersionedProtocolRequest<{
+        v1: [typeof AccountGetV1_request, typeof AccountGetV1_response];
+    }>;
+    account_get_alias: VersionedProtocolRequest<{
+        v1: [typeof AccountGetAliasV1_request, typeof AccountGetAliasV1_response];
+    }>;
+    account_create_proof: VersionedProtocolRequest<{
+        v1: [typeof AccountCreateProofV1_request, typeof AccountCreateProofV1_response];
+    }>;
+    get_non_product_accounts: VersionedProtocolRequest<{
+        v1: [typeof GetNonProductAccountsV1_request, typeof GetNonProductAccountsV1_response];
+    }>;
+    create_transaction: VersionedProtocolRequest<{
+        v1: [typeof CreateTransactionV1_request, typeof CreateTransactionV1_response];
+    }>;
+    create_transaction_with_non_product_account: VersionedProtocolRequest<{
+        v1: [
+            typeof CreateTransactionWithNonProductAccountV1_request,
+            typeof CreateTransactionWithNonProductAccountV1_response
+        ];
+    }>;
+    sign_raw: VersionedProtocolRequest<{
+        v1: [typeof SignRawV1_request, typeof SignRawV1_response];
+    }>;
+    sign_payload: VersionedProtocolRequest<{
+        v1: [typeof SignPayloadV1_request, typeof SignPayloadV1_response];
+    }>;
+    chat_create_contact: VersionedProtocolRequest<{
+        v1: [typeof ChatCreateContactV1_request, typeof ChatCreateContactV1_response];
+    }>;
+    chat_post_message: VersionedProtocolRequest<{
+        v1: [typeof ChatPostMessageV1_request, typeof ChatPostMessageV1_response];
+    }>;
+    chat_action_subscribe: VersionedProtocolSubscription<{
+        v1: [typeof ChatActionSubscribeV1_start, typeof ChatActionSubscribeV1_receive];
+    }>;
+    statement_store_create_proof: VersionedProtocolRequest<{
+        v1: [typeof StatementStoreCreateProofV1_request, typeof StatementStoreCreateProofV1_response];
+    }>;
+    jsonrpc_message_send: VersionedProtocolRequest<{
+        v1: [typeof JsonRpcMessageSendV1_request, typeof JsonRpcMessageSendV1_response];
+    }>;
+    jsonrpc_message_subscribe: VersionedProtocolSubscription<{
+        v1: [typeof JsonRpcMessageSubscribeV1_start, typeof JsonRpcMessageSubscribeV1_receive];
+    }>;
+};
+export declare const hostApiProtocol: HostApiProtocol;
+export {};

package/dist/protocol/impl.js

@@ -0,0 +1,97 @@
+import { Enum } from './commonCodecs.js';
+import { AccountCreateProofV1_request, AccountCreateProofV1_response, AccountGetAliasV1_request, AccountGetAliasV1_response, AccountGetV1_request, AccountGetV1_response, GetNonProductAccountsV1_request, GetNonProductAccountsV1_response, } from './v1/accounts.js';
+import { ChatActionSubscribeV1_receive, ChatActionSubscribeV1_start, ChatCreateContactV1_request, ChatCreateContactV1_response, ChatPostMessageV1_request, ChatPostMessageV1_response, } from './v1/chat.js';
+import { CreateTransactionV1_request, CreateTransactionV1_response, CreateTransactionWithNonProductAccountV1_request, CreateTransactionWithNonProductAccountV1_response, } from './v1/createTransaction.js';
+import { FeatureV1_request, FeatureV1_response } from './v1/feature.js';
+import { HandshakeV1_request, HandshakeV1_response } from './v1/handshake.js';
+import { JsonRpcMessageSendV1_request, JsonRpcMessageSendV1_response, JsonRpcMessageSubscribeV1_receive, JsonRpcMessageSubscribeV1_start, } from './v1/jsonRpc.js';
+import { PermissionRequestV1_request, PermissionRequestV1_response } from './v1/permission.js';
+import { SignPayloadV1_request, SignPayloadV1_response, SignRawV1_request, SignRawV1_response } from './v1/sign.js';
+import { StatementStoreCreateProofV1_request, StatementStoreCreateProofV1_response } from './v1/statementStore.js';
+import { StorageClearV1_request, StorageClearV1_response, StorageReadV1_request, StorageReadV1_response, StorageWriteV1_request, StorageWriteV1_response, } from './v1/storage.js';
+const enumFromArg = (enumValues, n) => {
+    return Enum(Object.fromEntries(Object.entries(enumValues).map(([key, value]) => [key, value[n]])));
+};
+const versionedRequest = (values) => {
+    return {
+        type: 'request',
+        request: enumFromArg(values, 0),
+        response: enumFromArg(values, 1),
+    };
+};
+const versionedSubscription = (values) => {
+    return {
+        type: 'subscription',
+        start: enumFromArg(values, 0),
+        receive: enumFromArg(values, 1),
+    };
+};
+export const hostApiProtocol = {
+    // host requests
+    handshake: versionedRequest({
+        v1: [HandshakeV1_request, HandshakeV1_response],
+    }),
+    feature: versionedRequest({
+        v1: [FeatureV1_request, FeatureV1_response],
+    }),
+    permission_request: versionedRequest({
+        v1: [PermissionRequestV1_request, PermissionRequestV1_response],
+    }),
+    // storage
+    storage_read: versionedRequest({
+        v1: [StorageReadV1_request, StorageReadV1_response],
+    }),
+    storage_write: versionedRequest({
+        v1: [StorageWriteV1_request, StorageWriteV1_response],
+    }),
+    storage_clear: versionedRequest({
+        v1: [StorageClearV1_request, StorageClearV1_response],
+    }),
+    // accounts
+    account_get: versionedRequest({
+        v1: [AccountGetV1_request, AccountGetV1_response],
+    }),
+    account_get_alias: versionedRequest({
+        v1: [AccountGetAliasV1_request, AccountGetAliasV1_response],
+    }),
+    account_create_proof: versionedRequest({
+        v1: [AccountCreateProofV1_request, AccountCreateProofV1_response],
+    }),
+    get_non_product_accounts: versionedRequest({
+        v1: [GetNonProductAccountsV1_request, GetNonProductAccountsV1_response],
+    }),
+    // signing
+    create_transaction: versionedRequest({
+        v1: [CreateTransactionV1_request, CreateTransactionV1_response],
+    }),
+    create_transaction_with_non_product_account: versionedRequest({
+        v1: [CreateTransactionWithNonProductAccountV1_request, CreateTransactionWithNonProductAccountV1_response],
+    }),
+    sign_raw: versionedRequest({
+        v1: [SignRawV1_request, SignRawV1_response],
+    }),
+    sign_payload: versionedRequest({
+        v1: [SignPayloadV1_request, SignPayloadV1_response],
+    }),
+    // chat
+    chat_create_contact: versionedRequest({
+        v1: [ChatCreateContactV1_request, ChatCreateContactV1_response],
+    }),
+    chat_post_message: versionedRequest({
+        v1: [ChatPostMessageV1_request, ChatPostMessageV1_response],
+    }),
+    chat_action_subscribe: versionedSubscription({
+        v1: [ChatActionSubscribeV1_start, ChatActionSubscribeV1_receive],
+    }),
+    // statement store
+    statement_store_create_proof: versionedRequest({
+        v1: [StatementStoreCreateProofV1_request, StatementStoreCreateProofV1_response],
+    }),
+    // json rpc
+    jsonrpc_message_send: versionedRequest({
+        v1: [JsonRpcMessageSendV1_request, JsonRpcMessageSendV1_response],
+    }),
+    jsonrpc_message_subscribe: versionedSubscription({
+        v1: [JsonRpcMessageSubscribeV1_start, JsonRpcMessageSubscribeV1_receive],
+    }),
+};