@chainlink/cre-sdk 0.0.0 → 0.0.1-alpha

package/dist/sdk/utils/send-response-value.js

@@ -0,0 +1,15 @@
+import { create, toBinary } from '@bufbuild/protobuf';
+import { ExecutionResultSchema } from '../../generated/sdk/v1alpha/sdk_pb';
+export const sendResponseValue = (value) => {
+    // Insert into the correct oneof field: 'payload'
+    const execResult = create(ExecutionResultSchema, {
+        result: {
+            case: 'value',
+            value: value.proto(),
+        },
+    });
+    // Marshal to protobuf bytes
+    const encoded = toBinary(ExecutionResultSchema, execResult);
+    // Send the result
+    sendResponse(encoded);
+};

package/dist/sdk/utils/time/get-time.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Gets the current time from the host runtime
+ * This function calls the host's `now` function which respects the current mode
+ * (DON or NODE) and calls the appropriate time function on the host.
+ *
+ * The Rust plugin handles all the low-level WASM memory management internally,
+ * so we just get a clean Unix timestamp in milliseconds.
+ *
+ * @returns The current time as a Unix timestamp in milliseconds
+ */
+export declare const getTime: () => number;
+/**
+ * Gets the current time as a Date object
+ * @returns The current time as a Date object
+ */
+export declare const getTimeAsDate: () => Date;

package/dist/sdk/utils/time/get-time.js

@@ -0,0 +1,21 @@
+import { hostBindings } from '../../runtime/host-bindings';
+/**
+ * Gets the current time from the host runtime
+ * This function calls the host's `now` function which respects the current mode
+ * (DON or NODE) and calls the appropriate time function on the host.
+ *
+ * The Rust plugin handles all the low-level WASM memory management internally,
+ * so we just get a clean Unix timestamp in milliseconds.
+ *
+ * @returns The current time as a Unix timestamp in milliseconds
+ */
+export const getTime = () => {
+    return hostBindings.now();
+};
+/**
+ * Gets the current time as a Date object
+ * @returns The current time as a Date object
+ */
+export const getTimeAsDate = () => {
+    return new Date(getTime());
+};

package/dist/sdk/utils/triggers/trigger-interface.d.ts

@@ -0,0 +1,21 @@
+import type { Message } from '@bufbuild/protobuf';
+import type { GenMessage } from '@bufbuild/protobuf/codegenv2';
+import type { Any } from '@bufbuild/protobuf/wkt';
+/**
+ * Full trigger interface with adapt method
+ *
+ * The adapt method allows transformation of the raw protobuf output
+ * to a more convenient type for the workflow.
+ */
+export interface Trigger<TRawTriggerOutput extends Message<string>, TTriggerOutput = TRawTriggerOutput> {
+    /** The capability ID for this trigger */
+    capabilityId(): string;
+    /** The method name for this trigger */
+    method(): string;
+    /** Access the raw output schema for decoding */
+    outputSchema(): GenMessage<TRawTriggerOutput>;
+    /** Get the configuration as an Any type for protobuf serialization */
+    configAsAny(): Any;
+    /** Transform the raw trigger output to the adapted type */
+    adapt(rawOutput: TRawTriggerOutput): TTriggerOutput | Promise<TTriggerOutput>;
+}

package/dist/sdk/utils/triggers/trigger-interface.js

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

package/dist/sdk/utils/typeurl.d.ts

@@ -0,0 +1,3 @@
+export declare const getTypeUrl: (schema: {
+    typeName: string;
+}) => string;

package/dist/sdk/utils/typeurl.js

@@ -0,0 +1 @@
+export const getTypeUrl = (schema) => `type.googleapis.com/${schema.typeName}`;

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

@@ -0,0 +1,27 @@
+import { type ConsensusDescriptor } from '../../../generated/sdk/v1alpha/sdk_pb';
+import type { CreSerializable, NumericType, TypeVerifier } from './serializer_types';
+export type ConsensusAggregation<T, U> = {
+    readonly descriptor: ConsensusDescriptor;
+    readonly defaultValue?: T;
+    withDefault(t: T): ConsensusAggregation<T, U>;
+    _usesUToForceShape(u: U): void;
+};
+export declare function consensusMedianAggregation<T extends NumericType>(): ConsensusAggregation<T, TypeVerifier<T, CreSerializable<T>>>;
+export declare function consensusIdenticalAggregation<T>(): ConsensusAggregation<T, TypeVerifier<T, CreSerializable<T>>>;
+export declare function consensusCommonPrefixAggregation<T>(): ConsensusAggregation<T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare function consensusCommonSuffixAggregation<T>(): ConsensusAggregation<T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare function median<T extends NumericType>(): ConsensusFieldAggregation<T, true>;
+export declare function identical<T>(): ConsensusFieldAggregation<T, TypeVerifier<T, CreSerializable<T>>>;
+export declare function commonPrefix<T>(): ConsensusFieldAggregation<T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare function commonSuffix<T>(): ConsensusFieldAggregation<T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare function ignore<T>(): ConsensusFieldAggregation<T, true>;
+export declare class ConsensusFieldAggregation<T, U> {
+    fieldDescriptor?: ConsensusDescriptor | undefined;
+    protected readonly t?: T | undefined;
+    protected readonly u?: U | undefined;
+    constructor(fieldDescriptor?: ConsensusDescriptor | undefined, t?: T | undefined, u?: U | undefined);
+}
+export type ConsensusAggregationFields<T extends object> = {
+    [K in keyof T]: () => ConsensusFieldAggregation<T[K], true>;
+};
+export declare function ConsensusAggregationByFields<T extends object>(aggregation: ConsensusAggregationFields<T>): ConsensusAggregation<T, true>;

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

@@ -0,0 +1,84 @@
+import { create } from '@bufbuild/protobuf';
+import { AggregationType, ConsensusDescriptorSchema, FieldsMapSchema, } from '../../../generated/sdk/v1alpha/sdk_pb';
+// Maybe make ConsensusAggregation take a second parameter, and it'll be true or false, then make anything using it require true
+// Only take one type, but make the return type ConsensusAggregation<T, TypeVerifier<T, CreSerializable<T>>
+// Similar for fields, but ignore would always return ConsensusAggregationFields<T, true> instead of ConsensusAggregationFields<T, CreSerializable<T>>, and so would ConsensusAggregationByFields :D
+export function consensusMedianAggregation() {
+    return simpleConsensus(AggregationType.MEDIAN);
+}
+export function consensusIdenticalAggregation() {
+    return simpleConsensus(AggregationType.IDENTICAL);
+}
+export function consensusCommonPrefixAggregation() {
+    return simpleConsensus(AggregationType.COMMON_PREFIX);
+}
+export function consensusCommonSuffixAggregation() {
+    return simpleConsensus(AggregationType.COMMON_SUFFIX);
+}
+class ConsensusImpl {
+    descriptor;
+    defaultValue;
+    constructor(descriptor, defaultValue) {
+        this.descriptor = descriptor;
+        this.defaultValue = defaultValue;
+    }
+    withDefault(t) {
+        return new ConsensusImpl(this.descriptor, t);
+    }
+    _usesUToForceShape(_) { }
+}
+function simpleConsensus(agg) {
+    return new ConsensusImpl(simpleDescriptor(agg));
+}
+function simpleDescriptor(agg) {
+    return create(ConsensusDescriptorSchema, {
+        descriptor: {
+            case: 'aggregation',
+            value: agg,
+        },
+    });
+}
+export function median() {
+    return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.MEDIAN));
+}
+// identical requires the type twice due to limitations in circular references in TypeScripts validation system.
+export function identical() {
+    return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.IDENTICAL));
+}
+export function commonPrefix() {
+    return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.COMMON_PREFIX));
+}
+export function commonSuffix() {
+    return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.COMMON_SUFFIX));
+}
+export function ignore() {
+    return new ConsensusFieldAggregation();
+}
+export class ConsensusFieldAggregation {
+    fieldDescriptor;
+    t;
+    u;
+    // t and u are included in the constructor to force the shape of ConsensusFieldAggregation to include them.
+    // This disallows automatic casting from other ConsensusFieldAggregation types.
+    constructor(fieldDescriptor, t, u) {
+        this.fieldDescriptor = fieldDescriptor;
+        this.t = t;
+        this.u = u;
+    }
+}
+export function ConsensusAggregationByFields(aggregation) {
+    const fieldMap = create(FieldsMapSchema);
+    Object.keys(aggregation).forEach((key) => {
+        const fieldFn = aggregation[key];
+        const fieldAggregation = fieldFn();
+        if (fieldAggregation.fieldDescriptor) {
+            fieldMap.fields[key] = fieldAggregation.fieldDescriptor;
+        }
+    });
+    return new ConsensusImpl(create(ConsensusDescriptorSchema, {
+        descriptor: {
+            case: 'fieldsMap',
+            value: fieldMap,
+        },
+    }));
+}

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

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

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;
+}