@chainlink/cre-sdk 0.0.2-alpha → 0.0.4-alpha

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

@@ -5,32 +5,73 @@ import { mainnetByName, mainnetByNameByFamily, mainnetBySelector, mainnetBySelec
  * @returns NetworkInfo if found, undefined otherwise
  */
 export const getNetwork = (options) => {
-    const { chainSelector, chainSelectorName, isTestnet = false, chainFamily } = options;
+    const { chainSelector, chainSelectorName, isTestnet, chainFamily } = options;
+    const getBySelector = (map) => {
+        if (chainSelector === undefined)
+            return undefined;
+        return map.get(chainSelector);
+    };
     // 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 && chainSelector !== undefined) {
+        if (isTestnet === false) {
+            return getBySelector(mainnetBySelectorByFamily[chainFamily]);
+        }
+        if (isTestnet === true) {
+            return getBySelector(testnetBySelectorByFamily[chainFamily]);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = getBySelector(testnetBySelectorByFamily[chainFamily]);
+        if (!network) {
+            network = getBySelector(mainnetBySelectorByFamily[chainFamily]);
+        }
+        return network;
     }
     if (chainFamily && chainSelectorName) {
-        const familyMap = isTestnet
-            ? testnetByNameByFamily[chainFamily]
-            : mainnetByNameByFamily[chainFamily];
-        return familyMap?.get(chainSelectorName);
+        if (isTestnet === false) {
+            return mainnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        if (isTestnet === true) {
+            return testnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = testnetByNameByFamily[chainFamily].get(chainSelectorName);
+        if (!network) {
+            network = mainnetByNameByFamily[chainFamily].get(chainSelectorName);
+        }
+        return network;
     }
     // If only network type is specified, use the general maps
-    if (chainSelector) {
-        const selectorMap = isTestnet ? testnetBySelector : mainnetBySelector;
-        return selectorMap.get(chainSelector);
+    if (chainSelector !== undefined) {
+        if (isTestnet === false) {
+            return getBySelector(mainnetBySelector);
+        }
+        if (isTestnet === true) {
+            return getBySelector(testnetBySelector);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = getBySelector(testnetBySelector);
+        if (!network) {
+            network = getBySelector(mainnetBySelector);
+        }
+        return network;
     }
     if (chainSelectorName) {
-        const nameMap = isTestnet ? testnetByName : mainnetByName;
-        return nameMap.get(chainSelectorName);
+        if (isTestnet === false) {
+            return mainnetByName.get(chainSelectorName);
+        }
+        if (isTestnet === true) {
+            return testnetByName.get(chainSelectorName);
+        }
+        // If user haven't defined if it's testnet or not we can try all networks, starting from testnet
+        let network = testnetByName.get(chainSelectorName);
+        if (!network) {
+            network = mainnetByName.get(chainSelectorName);
+        }
+        return network;
     }
     return undefined;
 };

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

@@ -2,7 +2,7 @@ export type ChainFamily = 'evm' | 'solana' | 'aptos' | 'sui' | 'ton' | 'tron';
 export type NetworkType = 'mainnet' | 'testnet';
 export interface ChainSelector {
     name: string;
-    selector: string;
+    selector: bigint;
 }
 export interface NetworkInfo {
     chainId: string;

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

@@ -1,3 +1,6 @@
+export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/http/http-helpers';
+export * from './chain-selectors';
 export * from './hex-utils';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';

package/dist/sdk/utils/index.js

@@ -1,3 +1,6 @@
+export * from './capabilities/blockchain/blockchain-helpers';
+export * from './capabilities/http/http-helpers';
+export * from './chain-selectors';
 export * from './hex-utils';
 export * from './values/consensus_aggregators';
 export * from './values/serializer_types';

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

@@ -17,5 +17,5 @@ export interface Trigger<TRawTriggerOutput extends Message<string>, TTriggerOutp
     /** 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>;
+    adapt(rawOutput: TRawTriggerOutput): TTriggerOutput;
 }

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

@@ -1,7 +1,7 @@
 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 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]>;
 } : never;

package/dist/sdk/wasm/runner.js

@@ -73,7 +73,7 @@ export class Runner {
              * @see https://github.com/smartcontractkit/cre-sdk-go/blob/5a41d81e3e072008484e85dc96d746401aafcba2/cre/wasm/runner.go#L81
              * */
             const decoded = fromBinary(schema, payloadAny.value);
-            const adapted = await entry.trigger.adapt(decoded);
+            const adapted = entry.trigger.adapt(decoded);
             try {
                 const result = await entry.fn(runtime, adapted);
                 const wrapped = Value.wrap(result);

package/dist/sdk/wasm/runtime.js

@@ -52,4 +52,7 @@ class WasmRuntimeHelpers {
     switchModes(mode) {
         hostBindings.switchModes(mode);
     }
+    log(message) {
+        hostBindings.log(message);
+    }
 }

package/dist/sdk/workflow.d.ts

@@ -12,6 +12,6 @@ export type Workflow<TConfig> = ReadonlyArray<HandlerEntry<TConfig, any, any, an
 export declare const handler: <TRawTriggerOutput extends Message<string>, TTriggerOutput, TConfig, TResult>(trigger: Trigger<TRawTriggerOutput, TTriggerOutput>, fn: HandlerFn<TConfig, TTriggerOutput, TResult>) => HandlerEntry<TConfig, TRawTriggerOutput, TTriggerOutput, TResult>;
 export type SecretsProvider = {
     getSecret(request: SecretRequest | SecretRequestJson): {
-        result: () => Promise<Secret>;
+        result: () => Secret;
     };
 };

package/dist/workflows/standard_tests/Makefile

@@ -0,0 +1,19 @@
+# Declare all matching test.wasm targets as phony
+.PHONY: FORCE
+FORCE:
+
+# Pattern rule to build test.wasm in any subdirectory
+%/test.wasm: FORCE
+	@echo "Building test: $*"
+	@case "$*" in \
+		*/*/*) \
+			echo "❌ Unsupported test path depth: $*"; \
+			exit 1; \
+			;; \
+		*/*) \
+			cd ../.. && bun compile:workflow src/standard_tests/$$(echo "$*" | cut -d'/' -f1)/$$(echo "$*" | cut -d'/' -f2)/test.ts .temp/standard_tests/$$(echo "$*" | cut -d'/' -f1)/$$(echo "$*" | cut -d'/' -f2)/test.wasm; \
+			;; \
+		*) \
+			cd ../.. && bun compile:workflow src/standard_tests/$*/test.ts .temp/standard_tests/$*/test.wasm; \
+			;; \
+	esac

package/dist/workflows/standard_tests/capability_calls_are_async/test.ts

@@ -0,0 +1,39 @@
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const asyncCalls = (runtime: Runtime<Uint8Array>) => {
+	const basicAction = new BasicActionCapability()
+
+	const input1 = { inputThing: true }
+	const input2 = { inputThing: false }
+
+	// Notice: we call perform action on input1 and then input 2.
+	const p1 = basicAction.performAction(runtime, input1)
+	const p2 = basicAction.performAction(runtime, input2)
+
+	// We get results in the reverse order.
+	const r2 = p2.result()
+	const r1 = p1.result()
+
+	return `${r1.adaptedThing}${r2.adaptedThing}`
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	return [cre.handler(basicTrigger.trigger({}), asyncCalls)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: capability calls are async [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/config/test.ts

@@ -0,0 +1,23 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const sendBackConfig = (runtime: Runtime<Uint8Array>) => {
+	return runtime.config
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	return [cre.handler(basicTrigger.trigger({}), sendBackConfig)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: config [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/errors/test.ts

@@ -0,0 +1,24 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const simulateWorkflowFailure = (_: Runtime<Uint8Array>) => {
+	throw new Error('workflow execution failure')
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), simulateWorkflowFailure)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: errors [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/logging/test.ts

@@ -0,0 +1,25 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const doLog = (runtime: Runtime<string>) => {
+	runtime.log('log from wasm!')
+	return runtime.config
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), doLog)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: logging [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<string>({
+		configParser: (c) => c.toString(),
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/mode_switch/don_runtime_in_node_mode/test.ts

@@ -0,0 +1,33 @@
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { consensusIdenticalAggregation } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+const handler = (runtime: Runtime<Uint8Array>) => {
+	return runtime
+		.runInNodeMode(() => {
+			const basicCap = new BasicActionCapability()
+			return basicCap.performAction(runtime, { inputThing: true }).result().adaptedThing
+		}, consensusIdenticalAggregation())()
+		.result()
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handler)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: mode_switch: successful_mode_switch [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/mode_switch/node_runtime_in_don_mode/test.ts

@@ -0,0 +1,41 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { BasicActionCapability as NodeActionCapability } from '@cre/generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen'
+import { cre, type NodeRuntime, type Runtime } from '@cre/sdk/cre'
+import { consensusIdenticalAggregation } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+const handler = (runtime: Runtime<Uint8Array>) => {
+	// First, run in node mode and do consensus - this makes the expected CallCapability call
+	var nrt: NodeRuntime<Uint8Array> | undefined
+	runtime
+		.runInNodeMode((nodeRuntime: NodeRuntime<Uint8Array>) => {
+			nrt = nodeRuntime
+			return 'hi'
+		}, consensusIdenticalAggregation())()
+		.result()
+
+	// Now we're back in DON mode, try to use a NODE mode capability
+	// This should trigger assertNodeSafe() and throw "cannot use NodeRuntime outside RunInNodeMode"
+	const nodeActionCapability = new NodeActionCapability()
+	nodeActionCapability.performAction(nrt as NodeRuntime<Uint8Array>, { inputThing: true }).result()
+	return 'hi'
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handler)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: mode_switch: node_runtime_in_don_mode [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/mode_switch/successful_mode_switch/test.ts

@@ -0,0 +1,58 @@
+import { BasicActionCapability } from '@cre/generated-sdk/capabilities/internal/basicaction/v1/basicaction_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { BasicActionCapability as NodeActionCapability } from '@cre/generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import type { NodeRuntime } from '@cre/sdk/runtime'
+import { ConsensusAggregationByFields, Int64, median } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+class Output {
+	constructor(public OutputThing: Int64) {}
+}
+
+const handler = (runtime: Runtime<Uint8Array>) => {
+	const donInput = { inputThing: true }
+	const basicActionCapability = new BasicActionCapability()
+	const donResponse = basicActionCapability.performAction(runtime, donInput).result()
+	runtime.now()
+
+	const consensusOutput = runtime.runInNodeMode(
+		(nodeRuntime: NodeRuntime<Uint8Array>): Output => {
+			nodeRuntime.now()
+			const nodeActionCapability = new NodeActionCapability()
+			const nodeResponse = nodeActionCapability
+				.performAction(nodeRuntime, {
+					inputThing: true,
+				})
+				.result()
+
+			return new Output(new Int64(nodeResponse.outputThing))
+		},
+		ConsensusAggregationByFields<Output>({ OutputThing: median }).withDefault(
+			new Output(new Int64(123)),
+		),
+	)()
+
+	runtime.now()
+
+	return `${donResponse.adaptedThing}${consensusOutput.result().OutputThing.value}`
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handler)]
+}
+
+export async function main() {
+	console.log(
+		`TS workflow: standard test: mode_switch: successful_mode_switch [${new Date().toISOString()}]`,
+	)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/multiple_triggers/test.ts

@@ -0,0 +1,40 @@
+import type { TriggerEvent } from '@cre/generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb'
+import type { Outputs } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
+import { BasicCapability as ActionAndTriggerCapability } from '@cre/generated-sdk/capabilities/internal/actionandtrigger/v1/basic_sdk_gen'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const doLog0 = (_: Runtime<Uint8Array>, output: Outputs) => {
+	return `called 0 with ${output.coolOutput}`
+}
+
+const doLog1 = (_runtime: Runtime<Uint8Array>, output: TriggerEvent) => {
+	return `called 1 with ${output.coolOutput}`
+}
+
+const doLog2 = (_runtime: Runtime<Uint8Array>, output: Outputs) => {
+	return `called 2 with ${output.coolOutput}`
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+	const actionTrigger = new ActionAndTriggerCapability()
+
+	return [
+		cre.handler(basicTrigger.trigger({ name: 'first-trigger', number: 100 }), doLog0),
+		cre.handler(actionTrigger.trigger({ name: 'second-trigger', number: 150 }), doLog1),
+		cre.handler(basicTrigger.trigger({ name: 'third-trigger', number: 200 }), doLog2),
+	]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: multiple_triggers [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/random/test.ts

@@ -0,0 +1,64 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { BasicActionCapability as NodeActionCapability } from '@cre/generated-sdk/capabilities/internal/nodeaction/v1/basicaction_sdk_gen'
+import { cre, type NodeRuntime, type Runtime } from '@cre/sdk/cre'
+import { ConsensusAggregationByFields, Int64, median } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+class Output {
+	constructor(public OutputThing: Int64) {}
+}
+
+const castRandomToUint64 = (randomFloat: number) =>
+	BigInt(Math.floor(randomFloat * Number.MAX_SAFE_INTEGER))
+
+const randHandler = (runtime: Runtime<Uint8Array>) => {
+	const donRandomNumber = castRandomToUint64(Math.random())
+
+	let total = donRandomNumber
+
+	runtime
+		.runInNodeMode(
+			(nodeRuntime: NodeRuntime<Uint8Array>) => {
+				const nodeRandomNumber = castRandomToUint64(Math.random())
+
+				const nodeActionCapability = new NodeActionCapability()
+				const nodeResponse = nodeActionCapability
+					.performAction(nodeRuntime, {
+						inputThing: true,
+					})
+					.result()
+
+				if (nodeResponse.outputThing < 100n) {
+					runtime.log(`***${nodeRandomNumber.toString()}`)
+				}
+
+				return new Output(new Int64(nodeResponse.outputThing))
+			},
+			ConsensusAggregationByFields<Output>({
+				OutputThing: median,
+			}).withDefault(new Output(new Int64(123n))),
+		)()
+		.result()
+
+	total += donRandomNumber
+
+	return total
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), randHandler)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: random [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/secrets/test.ts

@@ -0,0 +1,30 @@
+import { toJson } from '@bufbuild/protobuf'
+import type { Outputs } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
+import { SecretSchema } from '@cre/generated/sdk/v1alpha/sdk_pb'
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type Runtime } from '@cre/sdk/cre'
+import { Runner } from '@cre/sdk/wasm'
+
+const handleSecret = async (runtime: Runtime<Uint8Array>, _: Outputs) => {
+	const secret = runtime.getSecret({ id: 'Foo' }).result()
+	const secretJson = toJson(SecretSchema, secret)
+
+	return secretJson.value || ''
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), handleSecret)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: secrets [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()

package/dist/workflows/standard_tests/secrets_fail_in_node_mode/test.ts

@@ -0,0 +1,29 @@
+import { BasicCapability as BasicTriggerCapability } from '@cre/generated-sdk/capabilities/internal/basictrigger/v1/basic_sdk_gen'
+import { cre, type NodeRuntime, type Runtime } from '@cre/sdk/cre'
+import { consensusIdenticalAggregation } from '@cre/sdk/utils'
+import { Runner } from '@cre/sdk/wasm'
+
+const secretAccessInNodeMode = (runtime: Runtime<Uint8Array>) => {
+	return runtime
+		.runInNodeMode((_nodeRuntime: NodeRuntime<Uint8Array>) => {
+			return runtime.getSecret({ id: 'anything' }).result()
+		}, consensusIdenticalAggregation())()
+		.result()
+}
+
+const initWorkflow = () => {
+	const basicTrigger = new BasicTriggerCapability()
+
+	return [cre.handler(basicTrigger.trigger({}), secretAccessInNodeMode)]
+}
+
+export async function main() {
+	console.log(`TS workflow: standard test: secrets_fail_in_node_mode [${new Date().toISOString()}]`)
+
+	const runner = await Runner.newRunner<Uint8Array>({
+		configParser: (c) => c,
+	})
+	await runner.run(initWorkflow)
+}
+
+await main()