@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

package/dist/sdk/utils/values/consensus_aggregators.test.js

@@ -0,0 +1,172 @@
+import { describe, expect, test } from 'bun:test';
+import { AggregationType } from '../../../generated/sdk/v1alpha/sdk_pb';
+import { ConsensusAggregationByFields, commonPrefix, commonSuffix, consensusCommonPrefixAggregation, consensusCommonSuffixAggregation, consensusIdenticalAggregation, consensusMedianAggregation, identical, ignore, median, } from './consensus_aggregators';
+// Similar to the tests for serialization, there are portions of the tests to verify that the retuned type is correct.
+// The compilation itself is enough to validate it is correct, but it's broken into tests to make it easier to see what is tested.
+// Since CreSerializable is tested in depth in the serializer tests, tests in this file only verify one invalid type.
+describe('test consensus', () => {
+    test('median', () => {
+        assertSimpleConsensus(consensusMedianAggregation(), AggregationType.MEDIAN);
+        usableForConsensus(consensusMedianAggregation());
+        usableForConsensus(consensusMedianAggregation());
+        usableForConsensus(consensusMedianAggregation());
+        // Restrictions on consensusMedianAggregation won't allow other types
+    });
+    test('identical', () => {
+        assertSimpleConsensus(consensusIdenticalAggregation(), AggregationType.IDENTICAL);
+        usableForConsensus(consensusIdenticalAggregation());
+        usableForConsensus(consensusIdenticalAggregation());
+        usableForConsensus(consensusIdenticalAggregation());
+        usableForConsensus(consensusIdenticalAggregation());
+        usableForConsensus(consensusIdenticalAggregation());
+        usableForConsensus(consensusIdenticalAggregation());
+    });
+    test('common prefix', () => {
+        assertSimpleConsensus(consensusCommonPrefixAggregation(), AggregationType.COMMON_PREFIX);
+        usableForConsensus(consensusCommonPrefixAggregation());
+        usableForConsensus(consensusCommonPrefixAggregation());
+        usableForConsensus(consensusCommonPrefixAggregation());
+        usableForConsensus(consensusCommonPrefixAggregation());
+        usableForConsensus(consensusCommonPrefixAggregation());
+        usableForConsensus(consensusCommonPrefixAggregation());
+    });
+    test('common prefix', () => {
+        assertSimpleConsensus(consensusCommonSuffixAggregation(), AggregationType.COMMON_SUFFIX);
+        usableForConsensus(consensusCommonSuffixAggregation());
+        usableForConsensus(consensusCommonSuffixAggregation());
+        usableForConsensus(consensusCommonSuffixAggregation());
+        usableForConsensus(consensusCommonSuffixAggregation());
+        usableForConsensus(consensusCommonSuffixAggregation());
+        usableForConsensus(consensusCommonSuffixAggregation());
+    });
+    test('with default adds default', () => {
+        const original = consensusMedianAggregation();
+        const anyDefaultValue = 10;
+        const withDefault = original.withDefault(anyDefaultValue);
+        expect(original.defaultValue).toBeUndefined();
+        expect(withDefault.descriptor).toEqual(original.descriptor);
+        expect(withDefault.defaultValue).toEqual(anyDefaultValue);
+    });
+    test('with default overrides default', () => {
+        const anyDefaultValue = 10;
+        const original = consensusMedianAggregation().withDefault(anyDefaultValue);
+        const anyDifferentDefaultValue = anyDefaultValue + 20;
+        const withDefault = original.withDefault(anyDifferentDefaultValue);
+        expect(original.defaultValue).toEqual(anyDefaultValue);
+        expect(withDefault.descriptor).toEqual(original.descriptor);
+        expect(withDefault.defaultValue).toEqual(anyDifferentDefaultValue);
+    });
+    describe('test fields', () => {
+        test('median', () => {
+            const consensusAggregation = ConsensusAggregationByFields({
+                f1: median,
+                f2: median,
+            });
+            assertFieldConsensus(consensusAggregation, AggregationType.MEDIAN);
+            usableForFieldConsensus(median);
+            usableForFieldConsensus(median);
+            usableForFieldConsensus(median);
+            // Restrictions on median won't allow other types
+        });
+        test('identical', () => {
+            const consensusAggregation = ConsensusAggregationByFields({
+                f1: identical,
+                f2: identical,
+            });
+            assertFieldConsensus(consensusAggregation, AggregationType.IDENTICAL);
+            usableForFieldConsensus(identical);
+            usableForFieldConsensus(identical);
+            usableForFieldConsensus(identical);
+            usableForFieldConsensus(identical);
+            usableForFieldConsensus(identical);
+            usableForFieldConsensus(identical);
+        });
+        test('common prefix', () => {
+            const consensusAggregation = ConsensusAggregationByFields({
+                f1: commonPrefix,
+                f2: commonPrefix,
+            });
+            assertFieldConsensus(consensusAggregation, AggregationType.COMMON_PREFIX);
+            usableForFieldConsensus(commonPrefix);
+            usableForFieldConsensus(commonPrefix);
+            usableForFieldConsensus(commonPrefix);
+            usableForFieldConsensus(commonPrefix);
+            usableForFieldConsensus(commonPrefix);
+            usableForFieldConsensus(commonPrefix);
+        });
+        test('common suffix', () => {
+            const consensusAggregation = ConsensusAggregationByFields({
+                f1: commonSuffix,
+                f2: commonSuffix,
+            });
+            assertFieldConsensus(consensusAggregation, AggregationType.COMMON_SUFFIX);
+            usableForFieldConsensus(commonSuffix);
+            usableForFieldConsensus(commonSuffix);
+            usableForFieldConsensus(commonSuffix);
+            usableForFieldConsensus(commonSuffix);
+            usableForFieldConsensus(commonSuffix);
+            usableForFieldConsensus(commonSuffix);
+        });
+        test('ignore', () => {
+            const consensusAggregation = ConsensusAggregationByFields({
+                f1: identical,
+                f2: identical,
+                ignoreString: ignore,
+                ignoreRegExp: ignore,
+            });
+            assertFieldConsensus(consensusAggregation, AggregationType.IDENTICAL);
+        });
+    });
+});
+function assertSimpleConsensus(c, expected) {
+    expect(c.defaultValue).toBeUndefined();
+    const actual = expectCase(c.descriptor, 'aggregation');
+    expect(actual).toEqual(expected);
+}
+function assertFieldConsensus(c, expected) {
+    expect(c.defaultValue).toBeUndefined();
+    const actual = expectCase(c.descriptor, 'fieldsMap').fields;
+    const entries = Object.entries(actual);
+    expect(entries).toHaveLength(2);
+    expect(actual).toHaveProperty('f1');
+    expect(actual).toHaveProperty('f2');
+    const f1Descriptor = actual['f1'];
+    const f2Descriptor = actual['f2'];
+    expect(f1Descriptor.descriptor).toBeDefined();
+    expect(f1Descriptor.descriptor.case).toBe('aggregation');
+    expect(f1Descriptor.descriptor.value).toEqual(expected);
+    expect(f2Descriptor.descriptor).toBeDefined();
+    expect(f2Descriptor.descriptor.case).toBe('aggregation');
+    expect(f2Descriptor.descriptor.value).toEqual(expected);
+}
+function expectCase(actual, expectedCase) {
+    expect(actual.descriptor).toBeDefined();
+    expect(actual.descriptor.case).toBe(expectedCase);
+    return actual.descriptor.value;
+}
+class SimpleFieldType {
+    f1;
+    f2;
+    constructor(f1, f2) {
+        this.f1 = f1;
+        this.f2 = f2;
+    }
+}
+class InvalidFieldType {
+    f1;
+    f2;
+    ignoreString;
+    ignoreRegExp;
+    constructor(f1, f2, ignoreString, ignoreRegExp) {
+        this.f1 = f1;
+        this.f2 = f2;
+        this.ignoreString = ignoreString;
+        this.ignoreRegExp = ignoreRegExp;
+    }
+}
+function usableForConsensus(a) {
+    return a;
+}
+function usableForFieldConsensus(a) {
+    return a;
+}

package/dist/sdk/utils/values/serializer_types.d.ts

@@ -0,0 +1,11 @@
+import type { Decimal, Int64, UInt64 } from './value';
+export type NumericType = number | bigint | Date | Decimal | Int64 | UInt64;
+export type PrimitiveTypes = NumericType | boolean | string;
+export type NonSerializable = null | Map<any, any> | Set<any> | RegExp | Int8Array;
+export type CreSerializableNested<T> = T extends PrimitiveTypes ? T : T extends Function ? T : T extends NonSerializable ? never : T extends any[] ? CreSerializableNested<T[number]>[] : T extends object ? {
+    [K in keyof T]: CreSerializableNested<T[K]>;
+} : never;
+export type CreSerializable<T> = T extends PrimitiveTypes ? T : T extends Function ? never : T extends NonSerializable ? never : T extends any[] ? CreSerializableNested<T[number]>[] : T extends object ? {
+    [K in keyof T]: CreSerializableNested<T[K]>;
+} : never;
+export type TypeVerifier<T, U> = T extends U ? true : false;

package/dist/sdk/utils/values/serializer_types.js

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

package/dist/sdk/utils/values/serializer_types.test.d.ts

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

package/dist/sdk/utils/values/serializer_types.test.js

@@ -0,0 +1,104 @@
+import { describe, test } from 'bun:test';
+// These tests verify types are set up correctly.
+// The compilation itself is enough to validate it is correct, but it's broken into tests to make it easier to see what is tested.
+// Each path in a type is tested at laest once, in order of their occurence
+// False values are meant to demonstrate the constraints, but cannot be exaustive, for each type check, there's one false to capture it.
+describe('test types', () => {
+    test('NumericType', () => {
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+    });
+    test('PrimitiveTypes', () => {
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+    });
+    test('NonSerializable', () => {
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+    });
+    test('CreSerializableNested', () => {
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+        verifyType(false);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+    });
+    test('CreSerializable', () => {
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(true);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+        verifyType(false);
+    });
+});
+class Empty {
+}
+class TestSerializableClass {
+    a;
+    b;
+    constructor(a, b) {
+        this.a = a;
+        this.b = b;
+    }
+    foo() {
+        return false;
+    }
+}
+class TestSerializableClassPrivateNonSerializableMembers {
+    a;
+    b;
+    c;
+    constructor(a, b, c) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+}
+class TestNonSerializableClass {
+    a;
+    constructor(a) {
+        this.a = a;
+    }
+}
+function verifyType(isType) {
+    return isType;
+}

package/dist/sdk/utils/values/value.d.ts

@@ -0,0 +1,82 @@
+import type { Value as ProtoValue } from '../../../generated/values/v1/values_pb';
+import type { CreSerializable, PrimitiveTypes } from './serializer_types';
+/**
+ * Type that can validate a value and return a typed result.
+ * Compatible with Zod schemas, Yup validators, and other similar libraries.
+ */
+export interface SchemaValidator<T> {
+    parse(value: unknown): T;
+}
+/**
+ * Options for the unwrapToType function -
+ * - for primitive types, use the instance option to verify the type matches, the value is ignored.
+ * - for non-primitive types, either use a schema validator OR a factory function, not both.
+ */
+export type UnwrapOptions<T> = T extends PrimitiveTypes ? {
+    instance: T;
+} : {
+    schema: SchemaValidator<T>;
+    factory?: never;
+} | {
+    schema?: never;
+    factory: () => T;
+};
+export declare class Int64 {
+    static readonly INT64_MIN: bigint;
+    static readonly INT64_MAX: bigint;
+    readonly value: bigint;
+    static toInt64Bigint(v: number | bigint | string): bigint;
+    constructor(v: number | bigint | string);
+    add(i: Int64, safe?: boolean): Int64;
+    sub(i: Int64, safe?: boolean): Int64;
+    mul(i: Int64, safe?: boolean): Int64;
+    div(i: Int64, safe?: boolean): Int64;
+}
+export declare class UInt64 {
+    static readonly UINT64_MAX: bigint;
+    readonly value: bigint;
+    static toUint64Bigint(v: number | bigint | string): bigint;
+    constructor(v: number | bigint | string);
+    add(i: UInt64, safe?: boolean): UInt64;
+    sub(i: UInt64, safe?: boolean): UInt64;
+    mul(i: UInt64, safe?: boolean): UInt64;
+    div(i: UInt64, safe?: boolean): UInt64;
+}
+export declare class Decimal {
+    readonly coeffecient: bigint;
+    readonly exponent: number;
+    static parse(s: string): Decimal;
+    constructor(coeffecient: bigint, exponent: number);
+}
+export declare class Value {
+    private readonly value;
+    static from<T>(value: CreSerializable<T>): Value;
+    static wrap(value: ProtoValue): Value;
+    private constructor();
+    proto(): ProtoValue;
+    private static toUint8Array;
+    /**
+     * Converts a bigint to a byte array using big-endian byte order.
+     * Big-endian means the most significant byte comes first in the array.
+     */
+    private static bigintToBytesBE;
+    /**
+     * Converts a JavaScript Native bigint to a protobuf BigInt message.
+     */
+    private static bigIntToProtoBigInt;
+    private static toTimestamp;
+    private static isPlainObject;
+    private static isObject;
+    private static wrapInternal;
+    unwrap(): unknown;
+    /**
+     * Unwraps a Value object into its native JavaScript equivalent and casts it to type T.
+     * If the value is null or undefined, throws an exception.
+     
+     *
+     * @param options - Either a schema validator or a factory function (but not both), used for non-primitive types
+     * @returns The unwrapped JavaScript value cast to type T
+     * @throws Error if value is null, undefined, contains an invalid case, or fails schema validation
+     */
+    unwrapToType<T>(options: UnwrapOptions<T>): T;
+}