@chainlink/cre-sdk 1.17.0-alpha.3 → 1.17.0-alpha.4

package/dist/sdk/tee-constraints.d.ts

@@ -0,0 +1,68 @@
+import type { Requirements } from '../generated/sdk/v1alpha/sdk_pb';
+import { z } from 'zod';
+export declare const REGIONS: readonly ["us-west-2"];
+export declare const NITRO_REGIONS: readonly ["us-west-2"];
+declare const regionSchema: z.ZodEnum<["us-west-2"]>;
+declare const nitroRegionSchema: z.ZodEnum<["us-west-2"]>;
+declare const nitroBindingSchema: z.ZodObject<{
+    tee: z.ZodLiteral<"nitro">;
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>;
+declare const teeBindingSchema: z.ZodDiscriminatedUnion<"tee", [z.ZodObject<{
+    tee: z.ZodLiteral<"nitro">;
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>]>;
+declare const oneOfTeesSchema: z.ZodArray<z.ZodDiscriminatedUnion<"tee", [z.ZodObject<{
+    tee: z.ZodLiteral<"nitro">;
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>]>, "atleastone">;
+declare const anyTeeConstraintSchema: z.ZodObject<{
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>;
+export declare const teeConstraintSchema: z.ZodUnion<[z.ZodArray<z.ZodDiscriminatedUnion<"tee", [z.ZodObject<{
+    tee: z.ZodLiteral<"nitro">;
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    tee: "nitro";
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>]>, "atleastone">, z.ZodObject<{
+    regions: z.ZodOptional<z.ZodArray<z.ZodEnum<["us-west-2"]>, "atleastone">>;
+}, "strict", z.ZodTypeAny, {
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}, {
+    regions?: ["us-west-2", ..."us-west-2"[]] | undefined;
+}>]>;
+export type Region = z.infer<typeof regionSchema>;
+export type NitroRegion = z.infer<typeof nitroRegionSchema>;
+export type NitroBinding = z.infer<typeof nitroBindingSchema>;
+export type TeeBinding = z.infer<typeof teeBindingSchema>;
+export type OneOfTees = z.infer<typeof oneOfTeesSchema>;
+export type AnyTeeConstraint = z.infer<typeof anyTeeConstraintSchema>;
+export type TeeConstraint = z.infer<typeof teeConstraintSchema>;
+export declare function buildTeeRequirements(input: TeeConstraint): Requirements;
+export {};

package/dist/sdk/tee-constraints.js

@@ -0,0 +1,59 @@
+import { create } from '@bufbuild/protobuf';
+import { RegionsSchema, RequirementsSchema, TeeSchema, TeeType, TeeTypesAndRegionsSchema, } from '../generated/sdk/v1alpha/sdk_pb';
+import { z } from 'zod';
+// --- Region schemas (source of truth) ---
+export const REGIONS = ['us-west-2'];
+export const NITRO_REGIONS = ['us-west-2'];
+const regionSchema = z.enum(REGIONS, {
+    message: `unknown region; expected one of: ${REGIONS.join(', ')}`,
+});
+const nitroRegionSchema = z.enum(NITRO_REGIONS, {
+    message: `aws nitro does not support this region; expected one of: ${NITRO_REGIONS.join(', ')}`,
+});
+// --- TeeConstraint schemas (types inferred from these) ---
+const nitroBindingSchema = z
+    .object({
+    tee: z.literal('nitro'),
+    regions: z.array(nitroRegionSchema).nonempty().optional(),
+})
+    .strict();
+const teeBindingSchema = z.discriminatedUnion('tee', [nitroBindingSchema]);
+const oneOfTeesSchema = z.array(teeBindingSchema).nonempty();
+const anyTeeConstraintSchema = z
+    .object({
+    regions: z.array(regionSchema).nonempty().optional(),
+})
+    .strict();
+export const teeConstraintSchema = z.union([oneOfTeesSchema, anyTeeConstraintSchema]);
+// --- Conversion to protobuf Requirements ---
+export function buildTeeRequirements(input) {
+    const parsed = teeConstraintSchema.parse(input);
+    if (Array.isArray(parsed)) {
+        const teeTypes = parsed.map((binding) => ({
+            type: teeTypeFromBinding(binding),
+            regions: binding.regions ?? [],
+        }));
+        return create(RequirementsSchema, {
+            tee: create(TeeSchema, {
+                item: {
+                    case: 'teeTypesAndRegions',
+                    value: create(TeeTypesAndRegionsSchema, { teeTypeAndRegions: teeTypes }),
+                },
+            }),
+        });
+    }
+    return create(RequirementsSchema, {
+        tee: create(TeeSchema, {
+            item: {
+                case: 'anyRegions',
+                value: create(RegionsSchema, { regions: parsed.regions ?? [] }),
+            },
+        }),
+    });
+}
+function teeTypeFromBinding(binding) {
+    switch (binding.tee) {
+        case 'nitro':
+            return TeeType.AWS_NITRO;
+    }
+}

package/dist/sdk/test/generated/capabilities/blockchain/aptos/v1alpha/aptos_mock_gen.d.ts

@@ -0,0 +1,25 @@
+import { type AccountAPTBalanceReply, type AccountAPTBalanceReplyJson, type AccountAPTBalanceRequest, type AccountTransactionsReply, type AccountTransactionsReplyJson, type AccountTransactionsRequest, type TransactionByHashReply, type TransactionByHashReplyJson, type TransactionByHashRequest, type ViewReply, type ViewReplyJson, type ViewRequest, type WriteReportReply, type WriteReportReplyJson, type WriteReportRequest } from '../../../../../../../generated/capabilities/blockchain/aptos/v1alpha/client_pb';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export declare class AptosMock {
+    static readonly CAPABILITY_ID = "aptos@1.0.0";
+    /** Set to define the return value for AccountAPTBalance. May return a plain object (AccountAPTBalanceReplyJson) or the message type. */
+    accountAPTBalance?: (input: AccountAPTBalanceRequest) => AccountAPTBalanceReply | AccountAPTBalanceReplyJson;
+    /** Set to define the return value for View. May return a plain object (ViewReplyJson) or the message type. */
+    view?: (input: ViewRequest) => ViewReply | ViewReplyJson;
+    /** Set to define the return value for TransactionByHash. May return a plain object (TransactionByHashReplyJson) or the message type. */
+    transactionByHash?: (input: TransactionByHashRequest) => TransactionByHashReply | TransactionByHashReplyJson;
+    /** Set to define the return value for AccountTransactions. May return a plain object (AccountTransactionsReplyJson) or the message type. */
+    accountTransactions?: (input: AccountTransactionsRequest) => AccountTransactionsReply | AccountTransactionsReplyJson;
+    /** Set to define the return value for WriteReport. May return a plain object (WriteReportReplyJson) or the message type. */
+    writeReport?: (input: WriteReportRequest) => WriteReportReply | WriteReportReplyJson;
+    private constructor();
+    /**
+     * Returns the mock instance for this capability and the specified tags.
+     * Multiple calls with the same tag values return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(chainSelector: bigint): AptosMock;
+}

package/dist/sdk/test/generated/capabilities/blockchain/aptos/v1alpha/aptos_mock_gen.js

@@ -0,0 +1,111 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { AccountAPTBalanceReplySchema, AccountAPTBalanceRequestSchema, AccountTransactionsReplySchema, AccountTransactionsRequestSchema, TransactionByHashReplySchema, TransactionByHashRequestSchema, ViewReplySchema, ViewRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../../../generated/capabilities/blockchain/aptos/v1alpha/client_pb';
+import { __getTestMockInstance, __setTestMockInstance, registerTestCapability, } from '../../../../../../testutils/test-runtime';
+/**
+ * Mock for ClientCapability. Use testInstance() to obtain an instance; do not construct directly.
+ * Set per-method properties (e.g. performAction) to define return values. If a method is invoked without a handler set, an error is thrown.
+ */
+export class AptosMock {
+    static CAPABILITY_ID = 'aptos@1.0.0';
+    /** Set to define the return value for AccountAPTBalance. May return a plain object (AccountAPTBalanceReplyJson) or the message type. */
+    accountAPTBalance;
+    /** Set to define the return value for View. May return a plain object (ViewReplyJson) or the message type. */
+    view;
+    /** Set to define the return value for TransactionByHash. May return a plain object (TransactionByHashReplyJson) or the message type. */
+    transactionByHash;
+    /** Set to define the return value for AccountTransactions. May return a plain object (AccountTransactionsReplyJson) or the message type. */
+    accountTransactions;
+    /** Set to define the return value for WriteReport. May return a plain object (WriteReportReplyJson) or the message type. */
+    writeReport;
+    constructor(chainSelector) {
+        const self = this;
+        const qualifiedId = `aptos:ChainSelector:${chainSelector}@1.0.0`;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'AccountAPTBalance': {
+                        const input = anyUnpack(req.payload, AccountAPTBalanceRequestSchema);
+                        const handler = self.accountAPTBalance;
+                        if (typeof handler !== 'function')
+                            throw new Error("AccountAPTBalance: no implementation provided; set the mock's accountAPTBalance property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(AccountAPTBalanceReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(AccountAPTBalanceReplySchema, output) },
+                        };
+                    }
+                    case 'View': {
+                        const input = anyUnpack(req.payload, ViewRequestSchema);
+                        const handler = self.view;
+                        if (typeof handler !== 'function')
+                            throw new Error("View: no implementation provided; set the mock's view property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(ViewReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(ViewReplySchema, output) } };
+                    }
+                    case 'TransactionByHash': {
+                        const input = anyUnpack(req.payload, TransactionByHashRequestSchema);
+                        const handler = self.transactionByHash;
+                        if (typeof handler !== 'function')
+                            throw new Error("TransactionByHash: no implementation provided; set the mock's transactionByHash property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(TransactionByHashReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(TransactionByHashReplySchema, output) },
+                        };
+                    }
+                    case 'AccountTransactions': {
+                        const input = anyUnpack(req.payload, AccountTransactionsRequestSchema);
+                        const handler = self.accountTransactions;
+                        if (typeof handler !== 'function')
+                            throw new Error("AccountTransactions: no implementation provided; set the mock's accountTransactions property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(AccountTransactionsReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(AccountTransactionsReplySchema, output) },
+                        };
+                    }
+                    case 'WriteReport': {
+                        const input = anyUnpack(req.payload, WriteReportRequestSchema);
+                        const handler = self.writeReport;
+                        if (typeof handler !== 'function')
+                            throw new Error("WriteReport: no implementation provided; set the mock's writeReport property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(WriteReportReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(WriteReportReplySchema, output) } };
+                    }
+                    default:
+                        return { response: { case: 'error', value: `unknown method ${req.method}` } };
+                }
+            });
+        }
+        catch {
+            throw new Error("Capability mocks must be used within the CRE test framework's test() method.");
+        }
+    }
+    /**
+     * Returns the mock instance for this capability and the specified tags.
+     * Multiple calls with the same tag values return the same instance.
+     * Must be called within the test framework's test() method.
+     */
+    static testInstance(chainSelector) {
+        const qualifiedId = `aptos:ChainSelector:${chainSelector}@1.0.0`;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new AptosMock(chainSelector);
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

package/dist/sdk/test/generated/index.d.ts

@@ -1,4 +1,5 @@
 /** Auto-generated barrel of capability mocks. Do not edit. */
+export { AptosMock } from './capabilities/blockchain/aptos/v1alpha/aptos_mock_gen';
 export { EvmMock } from './capabilities/blockchain/evm/v1alpha/evm_mock_gen';
 export { SolanaMock } from './capabilities/blockchain/solana/v1alpha/solana_mock_gen';
 export { BasicTestActionTriggerMock } from './capabilities/internal/actionandtrigger/v1/basic_test_action_trigger_mock_gen';

package/dist/sdk/test/generated/index.js

@@ -1,4 +1,5 @@
 /** Auto-generated barrel of capability mocks. Do not edit. */
+export { AptosMock } from './capabilities/blockchain/aptos/v1alpha/aptos_mock_gen';
 export { EvmMock } from './capabilities/blockchain/evm/v1alpha/evm_mock_gen';
 export { SolanaMock } from './capabilities/blockchain/solana/v1alpha/solana_mock_gen';
 export { BasicTestActionTriggerMock } from './capabilities/internal/actionandtrigger/v1/basic_test_action_trigger_mock_gen';

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

@@ -2,5 +2,5 @@
  * Test-only utilities for the CRE SDK runtime. Not part of the public API.
  * Use for unit testing runtime logic without the WASM execution environment.
  */
-export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, type NewTestRuntimeOptions, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, type Secrets, TestRuntime, type TestRuntimeState, test, } from './test-runtime';
+export { type CapabilityHandler, DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, type NewTestRuntimeOptions, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, type Secrets, TestRuntime, type TestRuntimeState, TestTeeRuntime, test, } from './test-runtime';
 export { TestWriter } from './test-writer';

package/dist/sdk/testutils/index.js

@@ -2,5 +2,5 @@
  * Test-only utilities for the CRE SDK runtime. Not part of the public API.
  * Use for unit testing runtime logic without the WASM execution environment.
  */
-export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, TestRuntime, test, } from './test-runtime';
+export { DEFAULT_MAX_RESPONSE_SIZE_BYTES, getTestCapabilityHandler, newTestRuntime, REPORT_METADATA_HEADER_LENGTH, RESPONSE_BUFFER_TOO_SMALL, registerTestCapability, TestRuntime, TestTeeRuntime, test, } from './test-runtime';
 export { TestWriter } from './test-writer';

package/dist/sdk/testutils/test-runtime.d.ts

@@ -3,8 +3,9 @@
  * Registry is scoped per test via AsyncLocalStorage; use testWithRuntime to run tests with a registry.
  */
 import type { Any } from '@bufbuild/protobuf/wkt';
+import type { WorkflowUserMetric } from '../../generated/workflows/v2/workflow_user_metric_pb';
 import type { RuntimeHelpers } from '../impl/runtime-impl';
-import { RuntimeImpl } from '../impl/runtime-impl';
+import { RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
 import { TestWriter } from './test-writer';
 /** Error message when response exceeds max size. Used by the harness when its await implements the size check. */
 export declare const RESPONSE_BUFFER_TOO_SMALL = "response buffer too small";
@@ -70,15 +71,27 @@ export declare function test(title: string, fn: () => void | Promise<void>): voi
 /**
  * Creates a test runtime. This must be called from within a test in this package.
  */
-export declare function newTestRuntime(secrets?: Secrets | null, options?: NewTestRuntimeOptions): TestRuntime;
+export declare function newTestRuntime<T = unknown>(secrets?: Secrets | null, options?: NewTestRuntimeOptions, config?: T | undefined): TestRuntime<T>;
 /**
  * TestRuntime is a Runtime implementation for unit tests. Extends RuntimeImpl; construct via newTestRuntime.
  * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
  */
-export declare class TestRuntime extends RuntimeImpl<unknown> {
+export declare class TestRuntime<T> extends RuntimeImpl<T> {
     private readonly testWriter;
     private readonly state;
-    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState);
+    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState, config?: T | undefined);
     getLogs(): string[];
     setTimeProvider(timeProvider: () => number): void;
 }
+/**
+ * TestTeeRuntime is a TeeRuntime implementation for unit tests. Extends TeeRuntimeImpl; construct via newTestTEERuntime.
+ * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
+ */
+export declare class TestTeeRuntime<T> extends TeeRuntimeImpl<T> {
+    private readonly testWriter;
+    private readonly state;
+    constructor(helpers: RuntimeHelpers, maxResponseSize: bigint, testWriter: TestWriter, state: TestRuntimeState, config: T);
+    getLogs(): string[];
+    getMetrics(): WorkflowUserMetric[];
+    setTimeProvider(timeProvider: () => number): void;
+}

package/dist/sdk/testutils/test-runtime.js

@@ -8,7 +8,7 @@ import { create, toBinary } from '@bufbuild/protobuf';
 import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
 import { AttributedSignatureSchema, AwaitCapabilitiesResponseSchema, AwaitSecretsResponseSchema, CapabilityResponseSchema, ReportRequestSchema, ReportResponseSchema, SecretErrorSchema, SecretResponseSchema, SecretResponsesSchema, SecretSchema, SimpleConsensusInputsSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
 import { ValueSchema } from '../../generated/values/v1/values_pb';
-import { RuntimeImpl } from '../impl/runtime-impl';
+import { RuntimeImpl, TeeRuntimeImpl } from '../impl/runtime-impl';
 import { TestWriter } from './test-writer';
 /** Error message when response exceeds max size. Used by the harness when its await implements the size check. */
 export const RESPONSE_BUFFER_TOO_SMALL = 'response buffer too small';
@@ -239,6 +239,10 @@ function createTestRuntimeHelpers(registry, secrets, testWriter, state, _maxResp
         log(message) {
             testWriter.log(message);
         },
+        emitMetric(payload) {
+            testWriter.emitMetric(payload);
+            return true;
+        },
     };
 }
 /**
@@ -258,7 +262,7 @@ export function test(title, fn) {
 /**
  * Creates a test runtime. This must be called from within a test in this package.
  */
-export function newTestRuntime(secrets, options = {}) {
+export function newTestRuntime(secrets, options = {}, config = undefined) {
     const secretsMap = secrets ?? new Map();
     const testWriter = new TestWriter();
     const registry = registryStorage.getStore() ?? new Registry();
@@ -297,7 +301,7 @@ export function newTestRuntime(secrets, options = {}) {
     }
     const maxResponseSize = BigInt(configuredMaxResponseSize);
     const helpers = createTestRuntimeHelpers(registry, secretsMap, testWriter, state, maxResponseSize);
-    return new TestRuntime(helpers, maxResponseSize, testWriter, state);
+    return new TestRuntime(helpers, maxResponseSize, testWriter, state, config);
 }
 /**
  * TestRuntime is a Runtime implementation for unit tests. Extends RuntimeImpl; construct via newTestRuntime.
@@ -306,14 +310,36 @@ export function newTestRuntime(secrets, options = {}) {
 export class TestRuntime extends RuntimeImpl {
     testWriter;
     state;
-    constructor(helpers, maxResponseSize, testWriter, state) {
-        super({}, 0, helpers, maxResponseSize);
+    constructor(helpers, maxResponseSize, testWriter, state, config = undefined) {
+        super(config ?? {}, 0, helpers, maxResponseSize);
+        this.testWriter = testWriter;
+        this.state = state;
+    }
+    getLogs() {
+        return this.testWriter.getLogs();
+    }
+    setTimeProvider(timeProvider) {
+        this.state.timeProvider = timeProvider;
+    }
+}
+/**
+ * TestTeeRuntime is a TeeRuntime implementation for unit tests. Extends TeeRuntimeImpl; construct via newTestTEERuntime.
+ * Adds getLogs() and setTimeProvider(). Registry is accessed via getTestCapabilityHandler when inside testWithRuntime.
+ */
+export class TestTeeRuntime extends TeeRuntimeImpl {
+    testWriter;
+    state;
+    constructor(helpers, maxResponseSize, testWriter, state, config) {
+        super(config, 0, helpers, maxResponseSize);
         this.testWriter = testWriter;
         this.state = state;
     }
     getLogs() {
         return this.testWriter.getLogs();
     }
+    getMetrics() {
+        return this.testWriter.getMetrics();
+    }
     setTimeProvider(timeProvider) {
         this.state.timeProvider = timeProvider;
     }

package/dist/sdk/testutils/test-writer.d.ts

@@ -1,13 +1,19 @@
+import { type WorkflowUserMetric } from '../../generated/workflows/v2/workflow_user_metric_pb';
 /**
  * In-memory log sink for tests. Captures messages so tests can assert on log output.
  * Equivalent to Go's cre/testutils/test_writer.go.
  */
 export declare class TestWriter {
     private logs;
+    private metrics;
     /** Appends a message to the captured log buffer. */
     log(message: string): void;
     /** Returns a copy of all captured log messages in order. */
     getLogs(): string[];
-    /** Clears the captured log buffer. */
+    /** Captures a serialized WorkflowUserMetric payload. */
+    emitMetric(payload: Uint8Array): void;
+    /** Returns captured metric payloads decoded as `WorkflowUserMetric` protos. */
+    getMetrics(): WorkflowUserMetric[];
+    /** Clears captured logs and metrics. */
     clear(): void;
 }

package/dist/sdk/testutils/test-writer.js

@@ -1,9 +1,12 @@
+import { fromBinary } from '@bufbuild/protobuf';
+import { WorkflowUserMetricSchema, } from '../../generated/workflows/v2/workflow_user_metric_pb';
 /**
  * In-memory log sink for tests. Captures messages so tests can assert on log output.
  * Equivalent to Go's cre/testutils/test_writer.go.
  */
 export class TestWriter {
     logs = [];
+    metrics = [];
     /** Appends a message to the captured log buffer. */
     log(message) {
         this.logs.push(message);
@@ -12,8 +15,17 @@ export class TestWriter {
     getLogs() {
         return [...this.logs];
     }
-    /** Clears the captured log buffer. */
+    /** Captures a serialized WorkflowUserMetric payload. */
+    emitMetric(payload) {
+        this.metrics.push(payload);
+    }
+    /** Returns captured metric payloads decoded as `WorkflowUserMetric` protos. */
+    getMetrics() {
+        return this.metrics.map((bytes) => fromBinary(WorkflowUserMetricSchema, bytes));
+    }
+    /** Clears captured logs and metrics. */
     clear() {
         this.logs = [];
+        this.metrics = [];
     }
 }

package/dist/sdk/types/global.d.ts

@@ -45,6 +45,14 @@ declare global {
 	 */
 	function log(message: string): void
 
+	/**
+	 * Emits a user metric to the host. The payload is a protobuf-encoded
+	 * `workflows.v2.WorkflowUserMetric` message.
+	 * @param payload - protobuf-encoded WorkflowUserMetric bytes
+	 * @returns 0 on success, negative on error (rate-limited, oversized, invalid name, etc.)
+	 */
+	function emitMetric(payload: Uint8Array): number
+
 	/**
 	 * Sends a response back to the host
 	 * @param response - bytes response

package/dist/sdk/utils/capabilities/blockchain/solana/solana-helpers.js

@@ -133,7 +133,7 @@ export const prepareSubkeyValue = (value) => {
         return u64BE(value);
     }
     if (typeof value === 'number') {
-        if (!Number.isInteger(value)) {
+        if (!Number.isSafeInteger(value)) {
             throw new Error('prepareSubkeyValue: non-integer number; use prepareSubkeyFloatValue for f32/f64 values');
         }
         return u64BE(BigInt(value));

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

@@ -1,19 +1,27 @@
 import { type ConsensusDescriptor } from '../../../generated/sdk/v1alpha/sdk_pb';
 import type { CreSerializable, NumericType, TypeVerifier } from './serializer_types';
-export type ConsensusAggregation<T, U> = {
+import { Int64 } from './value';
+export type ConsensusAggregation<TInput, TOutput, U> = {
     readonly descriptor: ConsensusDescriptor;
-    readonly defaultValue?: T;
-    withDefault(t: T): ConsensusAggregation<T, U>;
+    readonly defaultValue?: TInput;
+    withDefault(t: TInput): ConsensusAggregation<TInput, TOutput, 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 consensusMedianAggregation<T extends NumericType>(): ConsensusAggregation<T, T, TypeVerifier<T, CreSerializable<T>>>;
+export declare function consensusIdenticalAggregation<T>(): ConsensusAggregation<T, T, TypeVerifier<T, CreSerializable<T>>>;
+export declare function consensusCommonPrefixAggregation<T>(): ConsensusAggregation<T[], T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare function consensusCommonSuffixAggregation<T>(): ConsensusAggregation<T[], T[], TypeVerifier<T[], CreSerializable<T[]>>>;
+export declare class FrequencyListEntry<T> {
+    value: T;
+    count: Int64;
+    constructor(value: T, count: Int64);
+}
+export declare function consensusFrequencyListAggregation<T>(): ConsensusAggregation<T[], FrequencyListEntry<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 frequencyList<T>(): ConsensusFieldAggregation<T, TypeVerifier<T, CreSerializable<T>>>;
 export declare function ignore<T>(): ConsensusFieldAggregation<T, true>;
 export declare class ConsensusFieldAggregation<T, U> {
     fieldDescriptor?: ConsensusDescriptor | undefined;
@@ -24,4 +32,4 @@ export declare class ConsensusFieldAggregation<T, U> {
 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>;
+export declare function ConsensusAggregationByFields<T extends object, TOutput = T>(aggregation: ConsensusAggregationFields<T>): ConsensusAggregation<T, TOutput, true>;

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

@@ -1,8 +1,6 @@
 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
+import { Int64 } from './value';
 export function consensusMedianAggregation() {
     return simpleConsensus(AggregationType.MEDIAN);
 }
@@ -15,6 +13,17 @@ export function consensusCommonPrefixAggregation() {
 export function consensusCommonSuffixAggregation() {
     return simpleConsensus(AggregationType.COMMON_SUFFIX);
 }
+export class FrequencyListEntry {
+    value;
+    count;
+    constructor(value, count) {
+        this.value = value;
+        this.count = count;
+    }
+}
+export function consensusFrequencyListAggregation() {
+    return simpleConsensus(AggregationType.FREQUENCY_LIST);
+}
 class ConsensusImpl {
     descriptor;
     defaultValue;
@@ -51,6 +60,9 @@ export function commonPrefix() {
 export function commonSuffix() {
     return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.COMMON_SUFFIX));
 }
+export function frequencyList() {
+    return new ConsensusFieldAggregation(simpleDescriptor(AggregationType.FREQUENCY_LIST));
+}
 export function ignore() {
     return new ConsensusFieldAggregation();
 }
@@ -66,6 +78,11 @@ export class ConsensusFieldAggregation {
         this.u = u;
     }
 }
+// TOutput lets the consensus result type differ from the observed input type. It defaults to T
+// (most field aggregators return the same shape they consume), but aggregators that reshape a
+// field — e.g. `frequencyList`, which turns a field of type F into FrequencyListEntry<F>[] —
+// change the result. Pass TOutput explicitly in that case so `.result()` is typed correctly
+// instead of forcing callers to cast (`.result() as unknown as ...`).
 export function ConsensusAggregationByFields(aggregation) {
     const fieldMap = create(FieldsMapSchema);
     Object.keys(aggregation).forEach((key) => {

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

@@ -1,6 +1,6 @@
 import type { Decimal, Int64, UInt64 } from './value';
 export type NumericType = number | bigint | Date | Decimal | Int64 | UInt64;
-export type PrimitiveTypes = NumericType | boolean | string;
+export type PrimitiveTypes = NumericType | boolean | string | Uint8Array;
 export type NonSerializable = null | Map<unknown, unknown> | Set<unknown> | RegExp | Int8Array | Promise<unknown>;
 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]>;

package/dist/sdk/wasm/host-bindings.d.ts

@@ -11,6 +11,7 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     awaitSecrets: z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>, z.ZodNumber], z.ZodUnknown>, z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>>;
     getWasiArgs: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
     now: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodNumber>;
+    emitMetric: z.ZodFunction<z.ZodTuple<[z.ZodUnion<[z.ZodType<Uint8Array<ArrayBuffer>, z.ZodTypeDef, Uint8Array<ArrayBuffer>>, z.ZodType<Uint8Array<ArrayBufferLike>, z.ZodTypeDef, Uint8Array<ArrayBufferLike>>]>], z.ZodUnknown>, z.ZodNumber>;
     sleep: z.ZodFunction<z.ZodTuple<[z.ZodNumber], z.ZodUnknown>, z.ZodVoid>;
 }, "strip", z.ZodTypeAny, {
     callCapability: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
@@ -18,6 +19,7 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
+    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;
@@ -30,6 +32,7 @@ export declare const globalHostBindingsSchema: z.ZodObject<{
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
+    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;
@@ -43,6 +46,7 @@ export declare const hostBindings: {
     getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
     awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
     log: (args_0: string, ...args: unknown[]) => void;
+    emitMetric: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
     switchModes: (args_0: Mode, ...args: unknown[]) => void;
     versionV2: (...args: unknown[]) => void;