@novasamatech/host-api 0.5.1 → 0.5.3-0

package/README.md

@@ -29,7 +29,7 @@ Transport is a low-level wrapper around protocol and provider.
 It encapsulates serialization/deserialization and request/subscription logic.
 
 ```typescript
-import { createTransport, okResult } from '@novasamatech/host-api';
+import { createTransport, resultOk } from '@novasamatech/host-api';
 import { provider } from './custom-provider.js';
 
 const transport = createTransport(provider);
@@ -43,9 +43,9 @@ const response = await transport.request('storage_read', payload);
 const stop = transport.handleRequest('storage_read', async (payload) => {
   try {
     const result = await readFromStorage(payload);
-    return okResult(result);
+    return resultOk(result);
   } catch (e) {
-    return errResult(e);
+    return resultErr(e);
   }
 });
 

package/dist/helpers.d.ts

@@ -1,6 +1,4 @@
-import type { ResultPayload } from 'scale-ts';
 import type { ComposeMessageAction } from './protocol/messageCodec.js';
-import type { HexString } from './protocol/types.js';
 export declare function delay(ttl: number): Promise<void>;
 type PromiseWithResolvers<T> = {
     promise: Promise<T>;
@@ -8,34 +6,7 @@ type PromiseWithResolvers<T> = {
     reject: (reason: unknown) => void;
 };
 export declare const promiseWithResolvers: <const T>() => PromiseWithResolvers<T>;
-export declare function unwrapResultOrThrow<Ok, Err>(response: ResultPayload<Ok, Err>, toError: (e: Err) => Error): Ok;
-export declare function okResult<const T>(value: T): {
-    success: true;
-    value: T;
-};
-export declare function errResult<const T>(e: T): {
-    success: false;
-    value: T;
-};
-export declare function enumValue<const Tag extends string, const Value>(tag: Tag, value: Value): {
-    tag: Tag;
-    value: Value;
-};
-export declare function isEnumVariant<const Enum extends {
-    tag: string;
-    value: unknown;
-}, const Tag extends Enum['tag']>(v: Enum, tag: Tag): v is Extract<Enum, {
-    tag: Tag;
-}>;
-export declare function assertEnumVariant<const Enum extends {
-    tag: string;
-    value: unknown;
-}, const Tag extends Enum['tag']>(v: Enum, tag: Tag, message: string): asserts v is Extract<Enum, {
-    tag: Tag;
-}>;
 export declare function composeAction<const Method extends string, const Suffix extends string>(method: Method, suffix: Suffix): ComposeMessageAction<Method, Suffix>;
 export declare function createRequestId(): string;
 export declare function extractErrorMessage(err: unknown): string;
-export declare function toHex(value: Uint8Array): HexString;
-export declare function fromHex(value: string): Uint8Array;
 export {};

package/dist/helpers.js

@@ -1,4 +1,3 @@
-import { fromHex as papiFromHex, toHex as papiToHex } from '@polkadot-api/utils';
 import { nanoid } from 'nanoid';
 export function delay(ttl) {
     return new Promise(resolve => setTimeout(resolve, ttl));
@@ -13,29 +12,6 @@ export const promiseWithResolvers = () => {
     // @ts-expect-error before assign
     return { promise, resolve, reject };
 };
-export function unwrapResultOrThrow(response, toError) {
-    if (response.success) {
-        return response.value;
-    }
-    throw toError(response.value);
-}
-export function okResult(value) {
-    return { success: true, value };
-}
-export function errResult(e) {
-    return { success: false, value: e };
-}
-export function enumValue(tag, value) {
-    return { tag, value };
-}
-export function isEnumVariant(v, tag) {
-    return v.tag === tag;
-}
-export function assertEnumVariant(v, tag, message) {
-    if (!isEnumVariant(v, tag)) {
-        throw new Error(message);
-    }
-}
 export function composeAction(method, suffix) {
     return `${method}_${suffix}`;
 }
@@ -51,9 +27,3 @@ export function extractErrorMessage(err) {
     }
     return 'Unknown error occurred.';
 }
-export function toHex(value) {
-    return papiToHex(value);
-}
-export function fromHex(value) {
-    return papiFromHex(value);
-}

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 export type { ConnectionStatus, Logger, Transport } from './types.js';
 export type { Provider } from './provider.js';
-export { assertEnumVariant, createRequestId, enumValue, errResult, fromHex, isEnumVariant, okResult, toHex, unwrapResultOrThrow, } from './helpers.js';
-export type { HexString } from './protocol/types.js';
+export { createRequestId } from './helpers.js';
 export { createHostApi } from './hostApi.js';
 export { createTransport } from './transport.js';
 export { createDefaultLogger } from './logger.js';
 export type { HostApiProtocol, VersionedProtocolRequest, VersionedProtocolSubscription } from './protocol/impl.js';
 export { hostApiProtocol } from './protocol/impl.js';
 export type { Codec, CodecType } from 'scale-ts';
+export type { HexString } from '@novasamatech/scale';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from '@novasamatech/scale';
 export { GenericError } from './protocol/commonCodecs.js';
 export { CreateTransactionErr, VersionedPublicTxPayload } from './protocol/v1/createTransaction.js';
 export { Account, AccountId, CreateProofErr, ProductAccountId, RequestCredentialsErr } from './protocol/v1/accounts.js';

package/dist/index.js

@@ -1,8 +1,9 @@
-export { assertEnumVariant, createRequestId, enumValue, errResult, fromHex, isEnumVariant, okResult, toHex, unwrapResultOrThrow, } from './helpers.js';
+export { createRequestId } from './helpers.js';
 export { createHostApi } from './hostApi.js';
 export { createTransport } from './transport.js';
 export { createDefaultLogger } from './logger.js';
 export { hostApiProtocol } from './protocol/impl.js';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from '@novasamatech/scale';
 // Codecs
 export { GenericError } from './protocol/commonCodecs.js';
 export { CreateTransactionErr, VersionedPublicTxPayload } from './protocol/v1/createTransaction.js';

package/dist/protocol/commonCodecs.d.ts

@@ -1,42 +1,7 @@
-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<{
+export declare const GenesisHash: import("scale-ts").Codec<`0x${string}`>;
+export declare const GenericErr: import("scale-ts").Codec<{
     reason: string;
 }>;
-export declare const GenericError: ErrCodec<{
+export declare const GenericError: import("@novasamatech/scale").ErrCodec<{
     reason: string;
 }, "GenericError">;
-export {};

package/dist/protocol/commonCodecs.js

@@ -1,62 +1,5 @@
-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);
+import { Err, Hex } from '@novasamatech/scale';
+import { Struct, str } from 'scale-ts';
 export const GenesisHash = Hex();
 export const GenericErr = Struct({
     reason: str,

package/dist/protocol/impl.d.ts

@@ -1,5 +1,5 @@
+import type { EnumCodec } from '@novasamatech/scale';
 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';
@@ -15,12 +15,12 @@ type InferVersionedArgument<EnumValues extends VersionedArguments, N extends num
     [V in keyof EnumValues]: EnumValues[V][N];
 };
 export type VersionedProtocolRequest<T extends VersionedArguments = VersionedArguments> = {
-    type: 'request';
+    method: 'request';
     request: EnumCodec<InferVersionedArgument<T, 0>>;
     response: EnumCodec<InferVersionedArgument<T, 1>>;
 };
 export type VersionedProtocolSubscription<T extends VersionedArguments = VersionedArguments> = {
-    type: 'subscription';
+    method: 'subscribe';
     start: EnumCodec<InferVersionedArgument<T, 0>>;
     receive: EnumCodec<InferVersionedArgument<T, 1>>;
 };

package/dist/protocol/impl.js

@@ -1,4 +1,4 @@
-import { Enum } from './commonCodecs.js';
+import { Enum } from '@novasamatech/scale';
 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';
@@ -14,14 +14,14 @@ const enumFromArg = (enumValues, n) => {
 };
 const versionedRequest = (values) => {
     return {
-        type: 'request',
+        method: 'request',
         request: enumFromArg(values, 0),
         response: enumFromArg(values, 1),
     };
 };
 const versionedSubscription = (values) => {
     return {
-        type: 'subscription',
+        method: 'subscribe',
         start: enumFromArg(values, 0),
         receive: enumFromArg(values, 1),
     };