@chainlink/cre-sdk 1.6.0-alpha.1 → 1.6.0-alpha.3

package/dist/sdk/test/generated/capabilities/blockchain/solana/v1alpha/solana_mock_gen.js

@@ -0,0 +1,178 @@
+import { fromJson } from '@bufbuild/protobuf';
+import { anyPack, anyUnpack } from '@bufbuild/protobuf/wkt';
+import { GetAccountInfoWithOptsReplySchema, GetAccountInfoWithOptsRequestSchema, GetBalanceReplySchema, GetBalanceRequestSchema, GetBlockReplySchema, GetBlockRequestSchema, GetFeeForMessageReplySchema, GetFeeForMessageRequestSchema, GetMultipleAccountsWithOptsReplySchema, GetMultipleAccountsWithOptsRequestSchema, GetSignatureStatusesReplySchema, GetSignatureStatusesRequestSchema, GetSlotHeightReplySchema, GetSlotHeightRequestSchema, GetTransactionReplySchema, GetTransactionRequestSchema, WriteReportReplySchema, WriteReportRequestSchema, } from '../../../../../../../generated/capabilities/blockchain/solana/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 SolanaMock {
+    static CAPABILITY_ID = 'solana@1.0.0';
+    /** Set to define the return value for GetAccountInfoWithOpts. May return a plain object (GetAccountInfoWithOptsReplyJson) or the message type. */
+    getAccountInfoWithOpts;
+    /** Set to define the return value for GetBalance. May return a plain object (GetBalanceReplyJson) or the message type. */
+    getBalance;
+    /** Set to define the return value for GetBlock. May return a plain object (GetBlockReplyJson) or the message type. */
+    getBlock;
+    /** Set to define the return value for GetFeeForMessage. May return a plain object (GetFeeForMessageReplyJson) or the message type. */
+    getFeeForMessage;
+    /** Set to define the return value for GetMultipleAccountsWithOpts. May return a plain object (GetMultipleAccountsWithOptsReplyJson) or the message type. */
+    getMultipleAccountsWithOpts;
+    /** Set to define the return value for GetSignatureStatuses. May return a plain object (GetSignatureStatusesReplyJson) or the message type. */
+    getSignatureStatuses;
+    /** Set to define the return value for GetSlotHeight. May return a plain object (GetSlotHeightReplyJson) or the message type. */
+    getSlotHeight;
+    /** Set to define the return value for GetTransaction. May return a plain object (GetTransactionReplyJson) or the message type. */
+    getTransaction;
+    /** 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 = `solana:ChainSelector:${chainSelector}@1.0.0`;
+        try {
+            registerTestCapability(qualifiedId, (req) => {
+                switch (req.method) {
+                    case 'GetAccountInfoWithOpts': {
+                        const input = anyUnpack(req.payload, GetAccountInfoWithOptsRequestSchema);
+                        const handler = self.getAccountInfoWithOpts;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetAccountInfoWithOpts: no implementation provided; set the mock's getAccountInfoWithOpts property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetAccountInfoWithOptsReplySchema, raw);
+                        return {
+                            response: {
+                                case: 'payload',
+                                value: anyPack(GetAccountInfoWithOptsReplySchema, output),
+                            },
+                        };
+                    }
+                    case 'GetBalance': {
+                        const input = anyUnpack(req.payload, GetBalanceRequestSchema);
+                        const handler = self.getBalance;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetBalance: no implementation provided; set the mock's getBalance property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetBalanceReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(GetBalanceReplySchema, output) } };
+                    }
+                    case 'GetBlock': {
+                        const input = anyUnpack(req.payload, GetBlockRequestSchema);
+                        const handler = self.getBlock;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetBlock: no implementation provided; set the mock's getBlock property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetBlockReplySchema, raw);
+                        return { response: { case: 'payload', value: anyPack(GetBlockReplySchema, output) } };
+                    }
+                    case 'GetFeeForMessage': {
+                        const input = anyUnpack(req.payload, GetFeeForMessageRequestSchema);
+                        const handler = self.getFeeForMessage;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetFeeForMessage: no implementation provided; set the mock's getFeeForMessage property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetFeeForMessageReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(GetFeeForMessageReplySchema, output) },
+                        };
+                    }
+                    case 'GetMultipleAccountsWithOpts': {
+                        const input = anyUnpack(req.payload, GetMultipleAccountsWithOptsRequestSchema);
+                        const handler = self.getMultipleAccountsWithOpts;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetMultipleAccountsWithOpts: no implementation provided; set the mock's getMultipleAccountsWithOpts property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetMultipleAccountsWithOptsReplySchema, raw);
+                        return {
+                            response: {
+                                case: 'payload',
+                                value: anyPack(GetMultipleAccountsWithOptsReplySchema, output),
+                            },
+                        };
+                    }
+                    case 'GetSignatureStatuses': {
+                        const input = anyUnpack(req.payload, GetSignatureStatusesRequestSchema);
+                        const handler = self.getSignatureStatuses;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetSignatureStatuses: no implementation provided; set the mock's getSignatureStatuses property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetSignatureStatusesReplySchema, raw);
+                        return {
+                            response: {
+                                case: 'payload',
+                                value: anyPack(GetSignatureStatusesReplySchema, output),
+                            },
+                        };
+                    }
+                    case 'GetSlotHeight': {
+                        const input = anyUnpack(req.payload, GetSlotHeightRequestSchema);
+                        const handler = self.getSlotHeight;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetSlotHeight: no implementation provided; set the mock's getSlotHeight property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetSlotHeightReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(GetSlotHeightReplySchema, output) },
+                        };
+                    }
+                    case 'GetTransaction': {
+                        const input = anyUnpack(req.payload, GetTransactionRequestSchema);
+                        const handler = self.getTransaction;
+                        if (typeof handler !== 'function')
+                            throw new Error("GetTransaction: no implementation provided; set the mock's getTransaction property to define the return value.");
+                        const raw = handler(input);
+                        const output = raw && typeof raw.$typeName === 'string'
+                            ? raw
+                            : fromJson(GetTransactionReplySchema, raw);
+                        return {
+                            response: { case: 'payload', value: anyPack(GetTransactionReplySchema, 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 = `solana:ChainSelector:${chainSelector}@1.0.0`;
+        let instance = __getTestMockInstance(qualifiedId);
+        if (!instance) {
+            instance = new SolanaMock(chainSelector);
+            __setTestMockInstance(qualifiedId, instance);
+        }
+        return instance;
+    }
+}

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

@@ -1,5 +1,7 @@
 /** 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';
 export { BasicTestActionMock } from './capabilities/internal/basicaction/v1/basic_test_action_mock_gen';
 export { ConsensusMock } from './capabilities/internal/consensus/v1alpha/consensus_mock_gen';

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

@@ -1,5 +1,7 @@
 /** 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';
 export { BasicTestActionMock } from './capabilities/internal/basicaction/v1/basic_test_action_mock_gen';
 export { ConsensusMock } from './capabilities/internal/consensus/v1alpha/consensus_mock_gen';

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

@@ -166,6 +166,10 @@ function createTestRuntimeHelpers(registry, secrets, testWriter, state, _maxResp
             return true;
         },
         await(request, maxResponseSizeBytes) {
+            if (request.$typeName !==
+                'sdk.v1alpha.AwaitCapabilitiesRequest') {
+                throw new Error('await: expected a typed AwaitCapabilitiesRequest (created via create(AwaitCapabilitiesRequestSchema, ...)); got a plain object. The real WASM bridge serializes this to binary and will fail with a plain object.');
+            }
             const responses = {};
             for (const id of request.ids) {
                 const resp = pendingCalls.get(id);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainlink/cre-sdk",
-	"version": "1.6.0-alpha.1",
+	"version": "1.6.0-alpha.3",
 	"type": "module",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -49,7 +49,7 @@
 		"format": "biome format --write ${BIOME_PATHS:-.}",
 		"full-checks": "bun generate:sdk && bun run build && bun typecheck && bun check && bun test && bun test:standard",
 		"generate:chain-selectors": "bun scripts/run.ts generate-chain-selectors && BIOME_PATHS=\"src/generated\" bun check",
-		"generate:proto": "bunx @bufbuild/buf generate && BIOME_PATHS=\"src/generated\" bun check",
+		"generate:proto": "bun x @bufbuild/buf generate && BIOME_PATHS=\"src/generated\" bun check",
 		"generate:sdk": "bun generate:proto && bun generate:chain-selectors && bun scripts/run generate-sdks && BIOME_PATHS=\"src/generated src/generated-sdk src/sdk/test/generated\" bun check",
 		"lint": "biome lint --write",
 		"prepublishOnly": "bun typecheck && bun check && bun test && bun test:standard",
@@ -60,7 +60,7 @@
 	"dependencies": {
 		"@bufbuild/protobuf": "2.6.3",
 		"@bufbuild/protoc-gen-es": "2.6.3",
-		"@chainlink/cre-sdk-javy-plugin": "1.5.0-alpha.1",
+		"@chainlink/cre-sdk-javy-plugin": "1.5.0",
 		"@standard-schema/spec": "1.0.0",
 		"viem": "2.34.0",
 		"zod": "3.25.76"

package/scripts/run.ts

@@ -5,6 +5,7 @@ import { WorkflowRuntimeCompatibilityError } from './src/validate-workflow-runti
 
 const availableScripts = [
 	'build-types',
+	'check-determinism', // Check for non-deterministic patterns in workflow source
 	'compile-to-js',
 	'compile-to-wasm',
 	'compile-workflow', // TS -> JS -> WASM compilation in single script

package/scripts/src/check-determinism.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+let tempDir: string
+
+const scriptsDir = path.resolve(import.meta.dir, '..')
+const runScript = path.join(scriptsDir, 'run.ts')
+
+beforeEach(() => {
+	tempDir = mkdtempSync(path.join(tmpdir(), 'cre-check-determinism-test-'))
+})
+
+afterEach(() => {
+	rmSync(tempDir, { recursive: true, force: true })
+})
+
+const runCheckDeterminism = (filePath: string) =>
+	spawnSync(process.execPath, [runScript, 'check-determinism', filePath], {
+		cwd: scriptsDir,
+		encoding: 'utf-8',
+	})
+
+describe('check-determinism CLI', () => {
+	test('fails when the input file does not exist', () => {
+		const missingFile = path.join(tempDir, 'does-not-exist.ts')
+		const result = runCheckDeterminism(missingFile)
+
+		expect(result.status).toBe(1)
+		expect(result.stdout).not.toContain('No non-determinism warnings found.')
+		expect(result.stderr).toContain(`❌ File not found: ${missingFile}`)
+	})
+
+	test('prints warnings for non-deterministic patterns and exits 0', () => {
+		const filePath = path.join(tempDir, 'workflow.ts')
+		writeFileSync(filePath, `const result = await Promise.race([]);\n`, 'utf-8')
+		const result = runCheckDeterminism(filePath)
+
+		expect(result.status).toBe(0)
+		expect(result.stderr).toContain('Non-determinism warnings')
+		expect(result.stderr).toContain('Promise.race()')
+	})
+
+	test('prints success message for clean workflow and exits 0', () => {
+		const filePath = path.join(tempDir, 'workflow.ts')
+		writeFileSync(filePath, `const x = 1;\n`, 'utf-8')
+		const result = runCheckDeterminism(filePath)
+
+		expect(result.status).toBe(0)
+		expect(result.stdout).toContain('No non-determinism warnings found.')
+	})
+
+	test('fails when no input file is provided', () => {
+		const result = spawnSync(process.execPath, [runScript, 'check-determinism'], {
+			cwd: scriptsDir,
+			encoding: 'utf-8',
+		})
+
+		expect(result.status).toBe(1)
+		expect(result.stderr).toContain('Usage:')
+	})
+})

package/scripts/src/check-determinism.ts

@@ -0,0 +1,32 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { checkWorkflowDeterminism, printDeterminismWarnings } from './validate-workflow-determinism'
+
+const printUsage = () => {
+	console.error('Usage: bun scripts/run.ts check-determinism <path/to/workflow.ts>')
+	console.error('Example:')
+	console.error('  bun scripts/run.ts check-determinism src/workflows/my-workflow/index.ts')
+}
+
+export const main = () => {
+	const inputPath = process.argv[3]
+
+	if (!inputPath) {
+		printUsage()
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	const warnings = checkWorkflowDeterminism(resolvedInput)
+
+	if (warnings.length > 0) {
+		printDeterminismWarnings(warnings)
+	} else {
+		console.info('No non-determinism warnings found.')
+	}
+}

package/scripts/src/compile-to-js.ts

@@ -4,6 +4,7 @@ import path from 'node:path'
 import { $ } from 'bun'
 import { parseCompileCliArgs, skipTypeChecksFlag } from './compile-cli-args'
 import { assertWorkflowTypecheck } from './typecheck-workflow'
+import { checkWorkflowDeterminism, printDeterminismWarnings } from './validate-workflow-determinism'
 import { assertWorkflowRuntimeCompatibility } from './validate-workflow-runtime-compat'
 import { wrapWorkflowCode } from './workflow-wrapper'
 
@@ -60,6 +61,12 @@ export const main = async (
 		assertWorkflowTypecheck(resolvedInput)
 	}
 	assertWorkflowRuntimeCompatibility(resolvedInput)
+	if (!parsedSkipTypeChecks) {
+		const warnings = checkWorkflowDeterminism(resolvedInput)
+		if (warnings.length > 0) {
+			printDeterminismWarnings(warnings)
+		}
+	}
 	console.info(`📁 Using input file: ${resolvedInput}`)
 
 	// If no explicit output path → same dir, swap extension to .js

package/scripts/src/generate-chain-selectors.ts

@@ -78,34 +78,16 @@ const CHAIN_CONFIGS: ChainSelectorConfig[] = [
 	},
 ]
 
-const readYamlFile = (filename: string): string => {
-	// Look for chain-selectors in node_modules by trying multiple possible locations
-	// This handles different execution contexts (local dev, CI, etc.)
-	const possiblePaths = [
-		// Try workspace root (3 levels up from scripts/)
-		join(process.cwd(), '..', '..', '..', 'node_modules', 'chain-selectors', filename),
-		// Try 2 levels up (in case cwd is already in scripts/src/)
-		join(process.cwd(), '..', '..', 'node_modules', 'chain-selectors', filename),
-		// Try current directory's node_modules
-		join(process.cwd(), 'node_modules', 'chain-selectors', filename),
-		// Try parent directory's node_modules
-		join(process.cwd(), '..', 'node_modules', 'chain-selectors', filename),
-	]
-
-	for (const path of possiblePaths) {
-		try {
-			return readFileSync(path, 'utf-8')
-		} catch {
-			// Try next path
-			continue
-		}
-	}
+const resolveChainSelectorsDir = (): string => {
+	// Use require.resolve to find the package through bun/Node module resolution,
+	// which correctly handles workspace hoisting, .bun cache, etc.
+	const packageDir = require.resolve('chain-selectors/selectors.yml')
+	return join(packageDir, '..')
+}
 
-	throw new Error(
-		`Failed to find ${filename} in any of the expected locations. Tried:\n${possiblePaths.join(
-			'\n',
-		)}`,
-	)
+const readYamlFile = (filename: string): string => {
+	const filePath = join(resolveChainSelectorsDir(), filename)
+	return readFileSync(filePath, 'utf-8')
 }
 
 const parseChainSelectors = (): NetworkInfo[] => {

package/scripts/src/generate-sdks.ts

@@ -1,5 +1,7 @@
 import { rmSync } from 'node:fs'
+import { file_capabilities_blockchain_aptos_v1alpha_client } from '@cre/generated/capabilities/blockchain/aptos/v1alpha/client_pb'
 import { file_capabilities_blockchain_evm_v1alpha_client } from '@cre/generated/capabilities/blockchain/evm/v1alpha/client_pb'
+import { file_capabilities_blockchain_solana_v1alpha_client } from '@cre/generated/capabilities/blockchain/solana/v1alpha/client_pb'
 import { file_capabilities_internal_actionandtrigger_v1_action_and_trigger } from '@cre/generated/capabilities/internal/actionandtrigger/v1/action_and_trigger_pb'
 import { file_capabilities_internal_basicaction_v1_basic_action } from '@cre/generated/capabilities/internal/basicaction/v1/basic_action_pb'
 import { file_capabilities_internal_basictrigger_v1_basic_trigger } from '@cre/generated/capabilities/internal/basictrigger/v1/basic_trigger_pb'
@@ -63,6 +65,16 @@ export const main = () => {
 		...generateMocks(file_capabilities_blockchain_evm_v1alpha_client, TEST_GENERATED_DIR),
 	)
 
+	generateSdk(file_capabilities_blockchain_aptos_v1alpha_client, './src/generated-sdk')
+	allMockExports.push(
+		...generateMocks(file_capabilities_blockchain_aptos_v1alpha_client, TEST_GENERATED_DIR),
+	)
+
+	generateSdk(file_capabilities_blockchain_solana_v1alpha_client, './src/generated-sdk')
+	allMockExports.push(
+		...generateMocks(file_capabilities_blockchain_solana_v1alpha_client, TEST_GENERATED_DIR),
+	)
+
 	generateSdk(file_capabilities_networking_http_v1alpha_client, './src/generated-sdk')
 	allMockExports.push(
 		...generateMocks(file_capabilities_networking_http_v1alpha_client, TEST_GENERATED_DIR),