@novasamatech/scale 0.5.3-0

package/README.md

@@ -0,0 +1,11 @@
+# @novasamatech/host-papp
+
+Polkadot app integration layer for host applications.
+
+## Overview
+
+## Installation
+
+```shell
+npm install @novasamatech/host-papp --save -E
+```

package/dist/enum.d.ts

@@ -0,0 +1,8 @@
+import type { Codec, 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: import("scale-ts").CodecType<T_1[K]>;
+}; } : never)[keyof FilterStringRecord<T>]>;
+export {};

package/dist/enum.js

@@ -0,0 +1,2 @@
+import { Enum as ScaleEnum } from 'scale-ts';
+export const Enum = (inner) => ScaleEnum(inner);

package/dist/enum.spec.d.ts

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

package/dist/enum.spec.js

@@ -0,0 +1,15 @@
+import { bool, u8 } from 'scale-ts';
+import { describe, expect, it } from 'vitest';
+import { Enum } from './enum.js';
+describe('Enum', () => {
+    it('should correctly encode/decode Enum', () => {
+        const codec = Enum({
+            a: u8,
+            b: bool,
+        });
+        expect(codec.enc({ tag: 'a', value: 1 })).toEqual(new Uint8Array([0, 1]));
+        expect(codec.enc({ tag: 'b', value: true })).toEqual(new Uint8Array([1, 1]));
+        expect(codec.dec(new Uint8Array([0, 1]))).toEqual({ tag: 'a', value: 1 });
+        expect(codec.dec(new Uint8Array([1, 1]))).toEqual({ tag: 'b', value: true });
+    });
+});

package/dist/err.d.ts

@@ -0,0 +1,11 @@
+import type { Codec } from 'scale-ts';
+export type CodecError<T, Name extends string> = Error & {
+    name: Name;
+    instance: string;
+    payload: T;
+};
+export type ErrCodec<T, Name extends string> = Codec<CodecError<T, Name>> & CodecErrorConstructor<T, Name>;
+type Constructor<A extends Array<any>, T> = new (...args: A) => T;
+type CodecErrorConstructor<T, Name extends string> = Constructor<T extends undefined ? [void] : [T], CodecError<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>;
+export {};

package/dist/err.js

@@ -0,0 +1,31 @@
+import { enhanceCodec } from 'scale-ts';
+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 {
+            instance = className;
+            name = name;
+            payload;
+            constructor(data) {
+                super(typeof message === 'function' ? message(data) : message);
+                this.payload = data;
+            }
+            // codec array destructuring workaround
+            static [Symbol.iterator]() {
+                return errorCodec[Symbol.iterator]();
+            }
+            // codec fields access workaround
+            get enc() {
+                return errorCodec.enc;
+            }
+            get dec() {
+                return errorCodec.dec;
+            }
+        },
+    }[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);
+}

package/dist/err.spec.d.ts

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

package/dist/err.spec.js

@@ -0,0 +1,19 @@
+import { Struct, _void, bool } from 'scale-ts';
+import { describe, expect, it } from 'vitest';
+import { Err } from './err.js';
+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 }));
+    });
+});

package/dist/errEnum.d.ts

@@ -0,0 +1,11 @@
+import type { Codec, CodecType } from 'scale-ts';
+import type { CodecError, ErrCodec } from './err.js';
+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>;
+export {};

package/dist/errEnum.js

@@ -0,0 +1,10 @@
+import { enhanceCodec } from 'scale-ts';
+import { Enum } from './enum.js';
+import { Err } from './err.js';
+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.instance, value: v }), v => v.value);
+    return Object.assign(codec, values);
+}

package/dist/errEnum.spec.d.ts

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

package/dist/errEnum.spec.js

@@ -0,0 +1,28 @@
+import { _void } from 'scale-ts';
+import { describe, expect, it } from 'vitest';
+import { ErrEnum } from './errEnum.js';
+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/helpers.d.ts

@@ -0,0 +1,29 @@
+import type { ResultPayload } from 'scale-ts';
+import type { HexString } from './hex.js';
+export declare function unwrapResultOrThrow<Ok, Err>(response: ResultPayload<Ok, Err>, toError: (e: Err) => Error): Ok;
+export declare function resultOk<const T>(value: T): {
+    success: true;
+    value: T;
+};
+export declare function resultErr<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 toHex(data: Uint8Array): HexString;
+export declare function fromHex(hex: string): Uint8Array<ArrayBufferLike>;

package/dist/helpers.js

@@ -0,0 +1,30 @@
+import { fromHex as papiFromHex, toHex as papiToHex } from '@polkadot-api/utils';
+export function unwrapResultOrThrow(response, toError) {
+    if (response.success) {
+        return response.value;
+    }
+    throw toError(response.value);
+}
+export function resultOk(value) {
+    return { success: true, value };
+}
+export function resultErr(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 toHex(data) {
+    return papiToHex(data);
+}
+export function fromHex(hex) {
+    return papiFromHex(hex);
+}

package/dist/hex.d.ts

@@ -0,0 +1,6 @@
+export type HexString = `0x${string}`;
+/**
+ * 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) => import("scale-ts").Codec<`0x${string}`>;

package/dist/hex.js

@@ -0,0 +1,7 @@
+import { fromHex, toHex } from '@polkadot-api/utils';
+import { Bytes, enhanceCodec } from 'scale-ts';
+/**
+ * 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, v => toHex(v));

package/dist/hex.spec.d.ts

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

package/dist/hex.spec.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { Hex } from './hex.js';
+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);
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { HexString } from './hex.js';
+export { Hex } from './hex.js';
+export { Nullable } from './nullable.js';
+export { Status } from './status.js';
+export type { EnumCodec } from './enum.js';
+export { Enum } from './enum.js';
+export type { CodecError, ErrCodec } from './err.js';
+export { Err } from './err.js';
+export { ErrEnum } from './errEnum.js';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from './helpers.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Hex } from './hex.js';
+export { Nullable } from './nullable.js';
+export { Status } from './status.js';
+export { Enum } from './enum.js';
+export { Err } from './err.js';
+export { ErrEnum } from './errEnum.js';
+export { assertEnumVariant, enumValue, fromHex, isEnumVariant, resultErr, resultOk, toHex, unwrapResultOrThrow, } from './helpers.js';

package/dist/nullable.d.ts

@@ -0,0 +1,2 @@
+import type { Codec } from 'scale-ts';
+export declare function Nullable<T>(inner: Codec<T>): Codec<T | null>;

package/dist/nullable.js

@@ -0,0 +1,4 @@
+import { Option, enhanceCodec } from 'scale-ts';
+export function Nullable(inner) {
+    return enhanceCodec(Option(inner), v => (v === null ? undefined : v), v => (v === undefined ? null : v));
+}

package/dist/status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Enum without values
+ */
+export declare function Status<const T>(...list: T[]): import("scale-ts").Codec<T>;

package/dist/status.js

@@ -0,0 +1,19 @@
+import { enhanceCodec, u8 } from 'scale-ts';
+/**
+ * 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;
+    });
+}

package/dist/status.spec.d.ts

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

package/dist/status.spec.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { Status } from './status.js';
+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]`);
+    });
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@novasamatech/scale",
+  "type": "module",
+  "version": "0.5.3-0",
+  "description": "additional scale-ts bindings",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/novasamatech/spektr-sdk.git"
+  },
+  "keywords": [
+    "polkadot"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@polkadot-api/utils": "^0.2.0",
+    "scale-ts": "1.6.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}