@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

package/dist/sdk/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { Message } from '@bufbuild/protobuf';
+import type { GenMessage } from '@bufbuild/protobuf/codegenv2';
+import type { ConsensusAggregation, PrimitiveTypes, UnwrapOptions } from './utils';
+import type { SecretsProvider } from '.';
+export type CallCapabilityParams<I extends Message, O extends Message> = {
+    capabilityId: string;
+    method: string;
+    payload: I;
+    inputSchema: GenMessage<I>;
+    outputSchema: GenMessage<O>;
+};
+export type BaseRuntime<C> = {
+    config: C;
+    callCapability<I extends Message, O extends Message>(params: CallCapabilityParams<I, O>): {
+        result: () => Promise<O>;
+    };
+    now(): Date;
+};
+export type Runtime<C> = BaseRuntime<C> & SecretsProvider & {
+    runInNodeMode<TArgs extends any[], TOutput>(fn: (nodeRuntime: NodeRuntime<C>, ...args: TArgs) => Promise<TOutput> | TOutput, consensusAggregation: ConsensusAggregation<TOutput, true>, unwrapOptions?: TOutput extends PrimitiveTypes ? never : UnwrapOptions<TOutput>): (...args: TArgs) => Promise<TOutput>;
+};
+export type NodeRuntime<C> = BaseRuntime<C> & {
+    readonly _isNodeRuntime: true;
+};

package/dist/sdk/runtime.js

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

package/dist/sdk/utils/capabilities/capability-error.d.ts

@@ -0,0 +1,11 @@
+export declare class CapabilityError extends Error {
+    name: string;
+    capabilityId?: string;
+    method?: string;
+    callbackId?: number;
+    constructor(message: string, options?: {
+        capabilityId?: string;
+        method?: string;
+        callbackId?: number;
+    });
+}

package/dist/sdk/utils/capabilities/capability-error.js

@@ -0,0 +1,15 @@
+export class CapabilityError extends Error {
+    name;
+    capabilityId;
+    method;
+    callbackId;
+    constructor(message, options) {
+        super(message);
+        this.name = 'CapabilityError';
+        if (options) {
+            this.capabilityId = options.capabilityId;
+            this.method = options.method;
+            this.callbackId = options.callbackId;
+        }
+    }
+}

package/dist/sdk/utils/chain-selectors/getAllNetworks.d.ts

@@ -0,0 +1,2 @@
+import type { NetworkInfo } from './types';
+export declare const getAllNetworks: () => NetworkInfo[];

package/dist/sdk/utils/chain-selectors/getAllNetworks.js

@@ -0,0 +1,2 @@
+import { allNetworks } from '../../../generated/networks';
+export const getAllNetworks = () => allNetworks;

package/dist/sdk/utils/chain-selectors/getNetwork.d.ts

@@ -0,0 +1,14 @@
+import type { ChainFamily, NetworkInfo } from './types';
+interface GetNetworkOptions {
+    chainSelector?: string;
+    chainSelectorName?: string;
+    isTestnet?: boolean;
+    chainFamily?: ChainFamily;
+}
+/**
+ * High-performance network lookup using Maps for O(1) performance
+ * @param options - Search criteria
+ * @returns NetworkInfo if found, undefined otherwise
+ */
+export declare const getNetwork: (options: GetNetworkOptions) => NetworkInfo | undefined;
+export {};

package/dist/sdk/utils/chain-selectors/getNetwork.js

@@ -0,0 +1,36 @@
+import { mainnetByName, mainnetByNameByFamily, mainnetBySelector, mainnetBySelectorByFamily, testnetByName, testnetByNameByFamily, testnetBySelector, testnetBySelectorByFamily, } from '../../../generated/networks';
+/**
+ * High-performance network lookup using Maps for O(1) performance
+ * @param options - Search criteria
+ * @returns NetworkInfo if found, undefined otherwise
+ */
+export const getNetwork = (options) => {
+    const { chainSelector, chainSelectorName, isTestnet = false, chainFamily } = options;
+    // Validate input - need either chainSelector or chainSelectorName
+    if (!chainSelector && !chainSelectorName) {
+        return undefined;
+    }
+    // If both chainFamily and network type are specified, use the most specific maps
+    if (chainFamily && chainSelector) {
+        const familyMap = isTestnet
+            ? testnetBySelectorByFamily[chainFamily]
+            : mainnetBySelectorByFamily[chainFamily];
+        return familyMap?.get(chainSelector);
+    }
+    if (chainFamily && chainSelectorName) {
+        const familyMap = isTestnet
+            ? testnetByNameByFamily[chainFamily]
+            : mainnetByNameByFamily[chainFamily];
+        return familyMap?.get(chainSelectorName);
+    }
+    // If only network type is specified, use the general maps
+    if (chainSelector) {
+        const selectorMap = isTestnet ? testnetBySelector : mainnetBySelector;
+        return selectorMap.get(chainSelector);
+    }
+    if (chainSelectorName) {
+        const nameMap = isTestnet ? testnetByName : mainnetByName;
+        return nameMap.get(chainSelectorName);
+    }
+    return undefined;
+};

package/dist/sdk/utils/chain-selectors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './getAllNetworks';
+export * from './getNetwork';
+export * from './types';

package/dist/sdk/utils/chain-selectors/index.js

@@ -0,0 +1,3 @@
+export * from './getAllNetworks';
+export * from './getNetwork';
+export * from './types';

package/dist/sdk/utils/chain-selectors/types.d.ts

@@ -0,0 +1,12 @@
+export type ChainFamily = 'evm' | 'solana' | 'aptos' | 'sui' | 'ton' | 'tron';
+export type NetworkType = 'mainnet' | 'testnet';
+export interface ChainSelector {
+    name: string;
+    selector: string;
+}
+export interface NetworkInfo {
+    chainId: string;
+    chainSelector: ChainSelector;
+    chainFamily: ChainFamily;
+    networkType: NetworkType;
+}

package/dist/sdk/utils/chain-selectors/types.js

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

package/dist/sdk/utils/config/configHandler.test.d.ts

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

package/dist/sdk/utils/config/configHandler.test.js

@@ -0,0 +1,193 @@
+import { describe, expect, it } from 'bun:test';
+import { z } from 'zod';
+import { configHandler } from './index';
+// Mock schema for testing
+const mockSchema = {
+    '~standard': {
+        version: 1,
+        vendor: 'test',
+        validate: (input) => {
+            if (typeof input !== 'object' || input === null) {
+                return { issues: [{ message: 'Expected object' }] };
+            }
+            return { value: input };
+        },
+    },
+};
+// Helper to create mock ExecuteRequest
+const createMockRequest = (configData) => ({
+    config: new TextEncoder().encode(configData),
+});
+describe('configHandler', () => {
+    it('should work with no params passed in - uses default JSON parser', async () => {
+        const configData = '{"name": "test", "value": 42}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({ name: 'test', value: 42 });
+    });
+    it('should work with only parser passed in - JSON parsing', async () => {
+        const configData = '{"schedule": "0 0 * * *", "enabled": true}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const json = JSON.parse(Buffer.from(config).toString());
+            return { ...json, parsed: true };
+        };
+        const result = await configHandler(request, { configParser: customParser });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            enabled: true,
+            parsed: true,
+        });
+    });
+    it('should work with only parser passed in - noop parser (keeps Uint8Array)', async () => {
+        const configData = 'raw binary data';
+        const request = createMockRequest(configData);
+        const noopParser = (config) => config;
+        const result = await configHandler(request, { configParser: noopParser });
+        expect(result).toBeInstanceOf(Uint8Array);
+        expect(new TextDecoder().decode(result)).toBe(configData);
+    });
+    it('should work with only schema passed in - uses default parser', async () => {
+        const configData = '{"valid": "json", "number": 123}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request, { configSchema: mockSchema });
+        expect(result).toEqual({ valid: 'json', number: 123 });
+    });
+    it('should work with both parser and schema', async () => {
+        const configData = '{"raw": "data", "needs": "processing"}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return { ...parsed, processed: true };
+        };
+        const result = await configHandler(request, {
+            configParser: customParser,
+            configSchema: mockSchema,
+        });
+        expect(result).toEqual({
+            raw: 'data',
+            needs: 'processing',
+            processed: true,
+        });
+    });
+    it('should throw error when schema validation fails', async () => {
+        const configData = 'invalid json';
+        const request = createMockRequest(configData);
+        expect(configHandler(request, { configSchema: mockSchema })).rejects.toThrow();
+    });
+    it('should handle empty JSON object', async () => {
+        const configData = '{}';
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({});
+    });
+    it('should handle complex nested JSON', async () => {
+        const configData = JSON.stringify({
+            nested: {
+                array: [1, 2, 3],
+                object: { key: 'value' },
+            },
+            boolean: true,
+            nullValue: null,
+        });
+        const request = createMockRequest(configData);
+        const result = await configHandler(request);
+        expect(result).toEqual({
+            nested: {
+                array: [1, 2, 3],
+                object: { key: 'value' },
+            },
+            boolean: true,
+            nullValue: null,
+        });
+    });
+    it('should work with custom parser that returns different type', async () => {
+        const configData = '{"count": 5}';
+        const request = createMockRequest(configData);
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return parsed.count * 2; // Return number instead of object
+        };
+        const result = await configHandler(request, { configParser: customParser });
+        expect(result).toBe(10);
+    });
+    it('should work with Zod schema validation', async () => {
+        const configData = JSON.stringify({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+        });
+        const request = createMockRequest(configData);
+        // Create Zod schema
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+        });
+        const result = await configHandler(request, { configSchema: zodSchema });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+        });
+    });
+    it('should throw error when Zod schema validation fails', async () => {
+        const configData = JSON.stringify({
+            schedule: 'invalid cron',
+            apiUrl: 'not-a-url', // Invalid URL
+            timeout: 100, // Too low
+            retries: 15, // Too high
+        });
+        const request = createMockRequest(configData);
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+        });
+        expect(configHandler(request, { configSchema: zodSchema })).rejects.toThrow();
+    });
+    it('should work with Zod schema and custom parser', async () => {
+        const configData = JSON.stringify({
+            rawData: 'base64encoded',
+            metadata: { version: '1.0', type: 'config' },
+        });
+        const request = createMockRequest(configData);
+        // Custom parser that processes the data
+        const customParser = (config) => {
+            const parsed = JSON.parse(Buffer.from(config).toString());
+            return {
+                schedule: '0 0 * * *', // Extract from rawData
+                apiUrl: 'https://api.example.com', // Extract from rawData
+                timeout: 5000,
+                retries: 3,
+                metadata: parsed.metadata,
+            };
+        };
+        // Zod schema for the processed data
+        const zodSchema = z.object({
+            schedule: z.string(),
+            apiUrl: z.string().url(),
+            timeout: z.number().min(1000).max(30000),
+            retries: z.number().min(0).max(10),
+            metadata: z.object({
+                version: z.string(),
+                type: z.string(),
+            }),
+        });
+        const result = await configHandler(request, {
+            configParser: customParser,
+            configSchema: zodSchema,
+        });
+        expect(result).toEqual({
+            schedule: '0 0 * * *',
+            apiUrl: 'https://api.example.com',
+            timeout: 5000,
+            retries: 3,
+            metadata: { version: '1.0', type: 'config' },
+        });
+    });
+});

package/dist/sdk/utils/config/index.d.ts

@@ -0,0 +1,7 @@
+import type { ExecuteRequest } from '../../../generated/sdk/v1alpha/sdk_pb';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type ConfigHandlerParams<TConfig, TIntermediateConfig = TConfig> = {
+    configParser?: (config: Uint8Array) => TIntermediateConfig;
+    configSchema?: StandardSchemaV1<TIntermediateConfig, TConfig>;
+};
+export declare const configHandler: <TConfig, TIntermediateConfig = TConfig>(request: ExecuteRequest, { configParser, configSchema }?: ConfigHandlerParams<TConfig, TIntermediateConfig>) => Promise<TConfig>;

package/dist/sdk/utils/config/index.js

@@ -0,0 +1,22 @@
+async function standardValidate(schema, input) {
+    let result = schema['~standard'].validate(input);
+    if (result instanceof Promise)
+        result = await result;
+    /**
+     * If the `issues` field exists, the validation failed
+     * @see https://github.com/standard-schema/standard-schema?tab=readme-ov-file#how-do-i-accept-standard-schemas-in-my-library
+     */
+    if (result.issues) {
+        throw new Error(JSON.stringify(result.issues, null, 2));
+    }
+    return result.value;
+}
+const defaultJsonParser = (config) => JSON.parse(Buffer.from(config).toString());
+export const configHandler = async (request, { configParser, configSchema } = {}) => {
+    const config = request.config;
+    const parser = configParser || defaultJsonParser;
+    const intermediateConfig = parser(config);
+    return configSchema
+        ? standardValidate(configSchema, intermediateConfig)
+        : intermediateConfig;
+};

package/dist/sdk/utils/hex-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Hex conversion utilities for blockchain data
+ *
+ * Note: BigInt utilities are available in ../utils
+ * Use val.bigint() or bigIntToProtoBigInt() for BigInt conversions
+ */
+import type { Hex } from 'viem';
+/**
+ * Convert hex string to Uint8Array
+ */
+export declare const hexToBytes: (hexStr: string) => Uint8Array;
+/**
+ * Convert Uint8Array to hex string with 0x prefix
+ */
+export declare const bytesToHex: (bytes: Uint8Array) => Hex;
+/**
+ * Encode hex as base64 string
+ * @param hex
+ * @returns
+ */
+export declare const hexToBase64: (hex: string) => string;

package/dist/sdk/utils/hex-utils.js

@@ -0,0 +1,31 @@
+/**
+ * Convert hex string to Uint8Array
+ */
+export const hexToBytes = (hexStr) => {
+    if (!hexStr.startsWith('0x')) {
+        throw new Error(`Invalid hex string: ${hexStr}`);
+    }
+    const hex = hexStr.slice(2);
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = Number.parseInt(hex.substr(i, 2), 16);
+    }
+    return bytes;
+};
+/**
+ * Convert Uint8Array to hex string with 0x prefix
+ */
+export const bytesToHex = (bytes) => {
+    return `0x${Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('')}`;
+};
+/**
+ * Encode hex as base64 string
+ * @param hex
+ * @returns
+ */
+export const hexToBase64 = (hex) => {
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    return Buffer.from(cleanHex, 'hex').toString('base64');
+};

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

@@ -0,0 +1,4 @@
+export * from './hex-utils';
+export * from './values/consensus_aggregators';
+export * from './values/serializer_types';
+export * from './values/value';

package/dist/sdk/utils/index.js

@@ -0,0 +1,4 @@
+export * from './hex-utils';
+export * from './values/consensus_aggregators';
+export * from './values/serializer_types';
+export * from './values/value';

package/dist/sdk/utils/prepare-runtime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This function is used to prepare the runtime for the SDK to work.
+ * It should be called as a part of SDK initialization.
+ * It exposes NodeJS Buffer in global namespace, so it can be bundled and used in workflow code.
+ */
+export declare const prepareRuntime: () => void;

package/dist/sdk/utils/prepare-runtime.js

@@ -0,0 +1,9 @@
+import { Buffer } from 'node:buffer';
+/**
+ * This function is used to prepare the runtime for the SDK to work.
+ * It should be called as a part of SDK initialization.
+ * It exposes NodeJS Buffer in global namespace, so it can be bundled and used in workflow code.
+ */
+export const prepareRuntime = () => {
+    globalThis.Buffer = Buffer;
+};

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

@@ -0,0 +1,6 @@
+/**
+ * Supports stringifying an object with bigints, treating bigints as strings.
+ * @param obj - The object to stringify
+ * @returns The stringified object
+ */
+export declare const safeJsonStringify: (obj: any) => string;

package/dist/sdk/utils/safeJsonStringify.js

@@ -0,0 +1,6 @@
+/**
+ * Supports stringifying an object with bigints, treating bigints as strings.
+ * @param obj - The object to stringify
+ * @returns The stringified object
+ */
+export const safeJsonStringify = (obj) => JSON.stringify(obj, (_, value) => (typeof value === 'bigint' ? value.toString() : value), 2);

package/dist/sdk/utils/secrets-error.d.ts

@@ -0,0 +1,3 @@
+export declare class SecretsError extends Error {
+    constructor(message: string);
+}

package/dist/sdk/utils/secrets-error.js

@@ -0,0 +1,6 @@
+export class SecretsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SecretsError';
+    }
+}

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 as K extends '$typeName' ? never : K]: () => 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 {};