@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

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

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { $ } from 'bun'
+
+const isJsFile = (p: string) => ['.js', '.mjs', '.cjs'].includes(path.extname(p).toLowerCase())
+
+export const main = async (inputFile?: string, outputFile?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Resolve input/output from params or CLI
+	const inputPath = inputFile ?? cliArgs[0]
+	const outputPathArg = outputFile ?? cliArgs[1]
+
+	if (!inputPath) {
+		console.error(
+			'Usage: bun compile:js-to-wasm <path/to/input.(js|mjs|cjs)> [path/to/output.wasm]',
+		)
+		console.error('Examples:')
+		console.error('  bun compile:js-to-wasm ./build/workflows/test.js')
+		console.error('  bun compile:js-to-wasm ./build/workflows/test.mjs ./artifacts/test.wasm')
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+
+	if (!isJsFile(resolvedInput)) {
+		console.error('❌ Input must be a JavaScript file (.js, .mjs, or .cjs)')
+		process.exit(1)
+	}
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	// Default output = same dir, same basename, .wasm extension
+	const defaultOut = path.join(
+		path.dirname(resolvedInput),
+		path.basename(resolvedInput).replace(/\.(m|c)?js$/i, '.wasm'),
+	)
+	const resolvedOutput = outputPathArg ? path.resolve(outputPathArg) : defaultOut
+
+	// Ensure output directory exists
+	await mkdir(path.dirname(resolvedOutput), { recursive: true })
+
+	console.info(`🔨 Compiling to WASM`)
+	console.info(`📁 Input:  ${resolvedInput}`)
+	console.info(`🎯 Output: ${resolvedOutput}`)
+
+	// Run compilation
+	try {
+		await $`bun cre-compile-workflow ${resolvedInput} ${resolvedOutput}`
+	} catch {
+		// Use npm script which has the correct path setup
+		await $`bun --bun ../cre-sdk-javy-plugin/bin/compile-workflow.ts ${resolvedInput} ${resolvedOutput}`
+	}
+
+	console.info(`✅ Compiled: ${resolvedOutput}`)
+
+	return resolvedOutput
+}

package/scripts/src/compile-workflow.ts

@@ -0,0 +1,66 @@
+import { existsSync } from 'node:fs'
+import { mkdir } from 'node:fs/promises'
+import path from 'node:path'
+import { main as compileToJs } from './compile-to-js'
+import { main as compileToWasm } from './compile-to-wasm'
+
+export const main = async (inputFile?: string, outputWasmFile?: string) => {
+	const cliArgs = process.argv.slice(3)
+
+	// Resolve input/output from params or CLI
+	const inputPath = inputFile ?? cliArgs[0]
+	const outputPathArg = outputWasmFile ?? cliArgs[1]
+
+	if (!inputPath) {
+		console.error('Usage: bun compile:workflow <path/to/workflow.ts> [path/to/output.wasm]')
+		console.error('Examples:')
+		console.error('  bun compile:workflow src/standard_tests/secrets/test.ts')
+		console.error(
+			'  bun compile:workflow src/standard_tests/secrets/test.ts .temp/standard_tests/secrets/test.wasm',
+		)
+		process.exit(1)
+	}
+
+	const resolvedInput = path.resolve(inputPath)
+	if (!existsSync(resolvedInput)) {
+		console.error(`❌ File not found: ${resolvedInput}`)
+		process.exit(1)
+	}
+
+	// Default final output = same dir, same basename, .wasm
+	const defaultWasmOut = path.join(
+		path.dirname(resolvedInput),
+		path.basename(resolvedInput).replace(/\.[^.]+$/, '.wasm'),
+	)
+	const resolvedWasmOutput = outputPathArg ? path.resolve(outputPathArg) : defaultWasmOut
+
+	// Put the intermediate JS next to the final wasm (so custom outputs stay together)
+	const resolvedJsOutput = resolvedWasmOutput.replace(/\.wasm$/i, '.js')
+
+	// Ensure directories exist (handles both intermediate JS dir and wasm dir)
+	await mkdir(path.dirname(resolvedJsOutput), { recursive: true })
+
+	console.info(`🚀 Compiling workflow`)
+	console.info(`📁 Input:   ${resolvedInput}`)
+	console.info(`🧪 JS out:  ${resolvedJsOutput}`)
+	console.info(`🎯 WASM out:${resolvedWasmOutput}\n`)
+
+	// Step 1: TS/JS → JS (bundled)
+	console.info('📦 Step 1: Compiling JS...')
+	await compileToJs(resolvedInput, resolvedJsOutput)
+
+	// Step 2: JS → WASM
+	console.info('\n🔨 Step 2: Compiling to WASM...')
+	await compileToWasm(resolvedJsOutput, resolvedWasmOutput)
+
+	console.info(`\n✅ Workflow built: ${resolvedWasmOutput}`)
+	return resolvedWasmOutput
+}
+
+// Optional: allow direct CLI usage
+if (import.meta.main) {
+	main().catch((e) => {
+		console.error(e)
+		process.exit(1)
+	})
+}

package/scripts/src/fix-imports.ts

@@ -0,0 +1,39 @@
+import { glob } from 'fast-glob'
+import { readFile, writeFile } from 'fs/promises'
+import { dirname, join, relative } from 'path'
+
+const fixImports = async () => {
+	console.log('🔧 Fixing @cre/* imports in built files...')
+
+	// Find all .js and .d.ts files in dist
+	const files = await glob(['dist/**/*.js', 'dist/**/*.d.ts'], {
+		cwd: process.cwd(),
+		absolute: true,
+	})
+
+	let fixedCount = 0
+
+	for (const file of files) {
+		const content = await readFile(file, 'utf-8')
+
+		// Replace @cre/* imports with relative paths
+		const fixedContent = content.replace(/@cre\/([^'"]*)/g, (_, path) => {
+			// Convert @cre/sdk/utils to relative path from current file
+			const currentDir = dirname(file)
+			const targetPath = join(process.cwd(), 'dist', path)
+			const relativePath = relative(currentDir, targetPath)
+
+			// Ensure it starts with ./ or ../
+			return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+		})
+
+		if (fixedContent !== content) {
+			await writeFile(file, fixedContent)
+			fixedCount++
+		}
+	}
+
+	console.log(`✅ Fixed imports in ${fixedCount} files`)
+}
+
+export const main = fixImports

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

@@ -0,0 +1,450 @@
+#!/usr/bin/env bun
+
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { parse } from 'yaml'
+import { z } from 'zod'
+
+// Zod schemas for validation
+const EvmSelectorSchema = z.object({
+	selector: z.number(),
+	name: z.string().optional(),
+})
+
+const NonEvmSelectorSchema = z.object({
+	selector: z.number(),
+	name: z.string().optional(),
+})
+
+const EvmSelectorsSchema = z.object({
+	selectors: z.record(z.string(), EvmSelectorSchema),
+})
+
+const NonEvmSelectorsSchema = z.object({
+	selectors: z.record(z.string(), NonEvmSelectorSchema),
+})
+
+type ChainFamily = 'evm' | 'solana' | 'aptos' | 'sui' | 'ton' | 'tron'
+type NetworkType = 'mainnet' | 'testnet'
+
+interface NetworkInfo {
+	chainId: string
+	chainSelector: {
+		name: string
+		selector: string
+	}
+	chainFamily: ChainFamily
+	networkType: NetworkType
+}
+
+interface ChainSelectorConfig {
+	family: ChainFamily
+	filename: string
+	schema: typeof EvmSelectorsSchema | typeof NonEvmSelectorsSchema
+}
+
+const CHAIN_CONFIGS: ChainSelectorConfig[] = [
+	{
+		family: 'evm',
+		filename: 'selectors.yml',
+		schema: EvmSelectorsSchema,
+	},
+	{
+		family: 'solana',
+		filename: 'selectors_solana.yml',
+		schema: NonEvmSelectorsSchema,
+	},
+	{
+		family: 'aptos',
+		filename: 'selectors_aptos.yml',
+		schema: NonEvmSelectorsSchema,
+	},
+	{
+		family: 'sui',
+		filename: 'selectors_sui.yml',
+		schema: NonEvmSelectorsSchema,
+	},
+	{
+		family: 'ton',
+		filename: 'selectors_ton.yml',
+		schema: NonEvmSelectorsSchema,
+	},
+	{
+		family: 'tron',
+		filename: 'selectors_tron.yml',
+		schema: NonEvmSelectorsSchema,
+	},
+]
+
+const readYamlFile = (filename: string): string => {
+	// Look for chain-selectors in workspace root node_modules (turborepo setup)
+	const workspaceRoot = join(process.cwd(), '..', '..')
+	const chainSelectorsPath = join(workspaceRoot, 'node_modules', 'chain-selectors', filename)
+	try {
+		return readFileSync(chainSelectorsPath, 'utf-8')
+	} catch (error) {
+		throw new Error(`Failed to read ${filename}: ${error}`)
+	}
+}
+
+const parseChainSelectors = (): NetworkInfo[] => {
+	const allNetworks: NetworkInfo[] = []
+
+	for (const config of CHAIN_CONFIGS) {
+		try {
+			console.log(`📂 Reading ${config.family} selectors from ${config.filename}...`)
+			const yamlContent = readYamlFile(config.filename)
+			const parsed = parse(yamlContent)
+			const validated = config.schema.parse(parsed)
+
+			for (const [chainId, selectorData] of Object.entries(validated.selectors)) {
+				const typedSelectorData = selectorData as {
+					selector: number
+					name?: string
+				}
+				// Skip entries without names (they might be test or incomplete entries)
+				if (!typedSelectorData.name) {
+					console.log(`⚠️  Skipping ${config.family} chain ${chainId} - no name provided`)
+					continue
+				}
+
+				allNetworks.push({
+					chainId,
+					chainSelector: {
+						name: typedSelectorData.name,
+						selector: typedSelectorData.selector.toString(),
+					},
+					chainFamily: config.family,
+					networkType: detectNetworkType(typedSelectorData.name),
+				})
+			}
+
+			console.log(`✅ Parsed ${Object.keys(validated.selectors).length} ${config.family} networks`)
+		} catch (error) {
+			console.error(`❌ Failed to process ${config.family}:`, error)
+		}
+	}
+
+	return allNetworks
+}
+
+const detectNetworkType = (networkName: string): NetworkType => {
+	const name = networkName.toLowerCase()
+
+	// Check for testnet indicators
+	const testnetIndicators = [
+		'testnet',
+		'test',
+		'devnet',
+		'dev',
+		'localnet',
+		'local',
+		'goerli',
+		'sepolia',
+		'holesky',
+		'mumbai',
+		'amoy',
+		'fuji',
+		'chapel',
+		'shasta',
+		'nile',
+		'kairos',
+		'shibuya',
+		'pangoro',
+		'cardona',
+		'puppynet',
+		'alfajores',
+		'moonbase',
+		'tatara',
+	]
+
+	// Check if any testnet indicator is present
+	for (const indicator of testnetIndicators) {
+		if (name.includes(indicator)) {
+			return 'testnet'
+		}
+	}
+
+	return 'mainnet'
+}
+
+const sanitizeFilename = (name: string): string => {
+	// Replace invalid characters with dots and ensure it's a valid filename
+	return name.replace(/[^a-zA-Z0-9.-]/g, '.').replace(/\.+/g, '.')
+}
+
+const generateNetworkFiles = (networks: NetworkInfo[]): void => {
+	const baseDir = 'src/generated/chain-selectors'
+
+	// Clean up existing directory
+	try {
+		rmSync(baseDir, { recursive: true, force: true })
+	} catch {
+		// Directory might not exist, that's ok
+	}
+
+	// Create base directory
+	mkdirSync(baseDir, { recursive: true })
+
+	// Group networks by network type and then by family
+	const networksByTypeAndFamily = networks.reduce(
+		(acc, network) => {
+			if (!acc[network.networkType]) {
+				acc[network.networkType] = {} as Record<ChainFamily, NetworkInfo[]>
+			}
+			if (!acc[network.networkType][network.chainFamily]) {
+				acc[network.networkType][network.chainFamily] = []
+			}
+			acc[network.networkType][network.chainFamily].push(network)
+			return acc
+		},
+		{} as Record<NetworkType, Record<ChainFamily, NetworkInfo[]>>,
+	)
+
+	// Create directories and files for each network type and family
+	for (const [networkType, familiesInType] of Object.entries(networksByTypeAndFamily)) {
+		for (const [family, familyNetworks] of Object.entries(familiesInType)) {
+			const familyDir = join(baseDir, networkType, family)
+			mkdirSync(familyDir, { recursive: true })
+
+			for (const network of familyNetworks) {
+				const filename = sanitizeFilename(network.chainSelector.name)
+				const filepath = join(familyDir, `${filename}.ts`)
+
+				const fileContent = `// This file is auto-generated. Do not edit manually.
+// Generated from: https://github.com/smartcontractkit/chain-selectors
+
+import type { NetworkInfo } from "@cre/sdk/utils/chain-selectors/types";
+
+const network: NetworkInfo = {
+	chainId: "${network.chainId}",
+	chainSelector: {
+		name: "${network.chainSelector.name}",
+		selector: "${network.chainSelector.selector}",
+	},
+	chainFamily: "${network.chainFamily}",
+	networkType: "${network.networkType}",
+} as const;
+
+export default network;
+`
+
+				writeFileSync(filepath, fileContent)
+			}
+
+			console.log(`📁 Created ${familyNetworks.length} ${networkType}/${family} network files`)
+		}
+	}
+}
+
+const generateAllNetworksFile = (networks: NetworkInfo[]): void => {
+	// Group networks by type and family for exports
+	const mainnetNetworks = networks.filter((n) => n.networkType === 'mainnet')
+	const testnetNetworks = networks.filter((n) => n.networkType === 'testnet')
+
+	const mainnetByFamily = mainnetNetworks.reduce(
+		(acc, network) => {
+			if (!acc[network.chainFamily]) {
+				acc[network.chainFamily] = []
+			}
+			acc[network.chainFamily].push(network)
+			return acc
+		},
+		{} as Record<ChainFamily, NetworkInfo[]>,
+	)
+
+	const testnetByFamily = testnetNetworks.reduce(
+		(acc, network) => {
+			if (!acc[network.chainFamily]) {
+				acc[network.chainFamily] = []
+			}
+			acc[network.chainFamily].push(network)
+			return acc
+		},
+		{} as Record<ChainFamily, NetworkInfo[]>,
+	)
+
+	// Generate import statements and variable names
+	const generateImportName = (network: NetworkInfo): string => {
+		const sanitized = sanitizeFilename(network.chainSelector.name)
+			.replace(/\./g, '_')
+			.replace(/-/g, '_')
+		return `${network.networkType}_${network.chainFamily}_${sanitized}`
+	}
+
+	const allImports = networks.map((network) => ({
+		importName: generateImportName(network),
+		importPath: `./chain-selectors/${network.networkType}/${
+			network.chainFamily
+		}/${sanitizeFilename(network.chainSelector.name)}`,
+		network,
+	}))
+
+	const content = `// This file is auto-generated. Do not edit manually.
+// Generated from: https://github.com/smartcontractkit/chain-selectors
+
+import type { NetworkInfo, ChainFamily } from "@cre/sdk/utils/chain-selectors/types";
+
+// Import all individual network files
+${allImports
+	.map(({ importName, importPath }) => `import ${importName} from "${importPath}";`)
+	.join('\n')}
+
+export const allNetworks: NetworkInfo[] = [
+${allImports.map(({ importName }) => `	${importName},`).join('\n')}
+] as const;
+
+export const mainnet = {
+${Object.entries(mainnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'mainnet',
+		)
+		return `	${family}: [
+${familyImports.map(({ importName }) => `		${importName},`).join('\n')}
+	] as const,`
+	})
+	.join('\n')}
+} as const;
+
+export const testnet = {
+${Object.entries(testnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'testnet',
+		)
+		return `	${family}: [
+${familyImports.map(({ importName }) => `		${importName},`).join('\n')}
+	] as const,`
+	})
+	.join('\n')}
+} as const;
+
+// Optimized Maps for fast lookups by chain selector
+export const mainnetBySelector = new Map<string, NetworkInfo>([
+${allImports
+	.filter(({ network }) => network.networkType === 'mainnet')
+	.map(({ importName, network }) => `	["${network.chainSelector.selector}", ${importName}],`)
+	.join('\n')}
+]);
+
+export const testnetBySelector = new Map<string, NetworkInfo>([
+${allImports
+	.filter(({ network }) => network.networkType === 'testnet')
+	.map(({ importName, network }) => `	["${network.chainSelector.selector}", ${importName}],`)
+	.join('\n')}
+]);
+
+// Optimized Maps for fast lookups by chain selector name
+export const mainnetByName = new Map<string, NetworkInfo>([
+${allImports
+	.filter(({ network }) => network.networkType === 'mainnet')
+	.map(({ importName, network }) => `	["${network.chainSelector.name}", ${importName}],`)
+	.join('\n')}
+]);
+
+export const testnetByName = new Map<string, NetworkInfo>([
+${allImports
+	.filter(({ network }) => network.networkType === 'testnet')
+	.map(({ importName, network }) => `	["${network.chainSelector.name}", ${importName}],`)
+	.join('\n')}
+]);
+
+// Maps by family and network type for chain selector lookups
+export const mainnetBySelectorByFamily = {
+${Object.entries(mainnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'mainnet',
+		)
+		return `	${family}: new Map<string, NetworkInfo>([
+${familyImports
+	.map(({ importName, network }) => `		["${network.chainSelector.selector}", ${importName}],`)
+	.join('\n')}
+	]),`
+	})
+	.join('\n')}
+} as const;
+
+export const testnetBySelectorByFamily = {
+${Object.entries(testnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'testnet',
+		)
+		return `	${family}: new Map<string, NetworkInfo>([
+${familyImports
+	.map(({ importName, network }) => `		["${network.chainSelector.selector}", ${importName}],`)
+	.join('\n')}
+	]),`
+	})
+	.join('\n')}
+} as const;
+
+// Maps by family and network type for name lookups
+export const mainnetByNameByFamily = {
+${Object.entries(mainnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'mainnet',
+		)
+		return `	${family}: new Map<string, NetworkInfo>([
+${familyImports
+	.map(({ importName, network }) => `		["${network.chainSelector.name}", ${importName}],`)
+	.join('\n')}
+	]),`
+	})
+	.join('\n')}
+} as const;
+
+export const testnetByNameByFamily = {
+${Object.entries(testnetByFamily)
+	.map(([family]) => {
+		const familyImports = allImports.filter(
+			({ network }) => network.chainFamily === family && network.networkType === 'testnet',
+		)
+		return `	${family}: new Map<string, NetworkInfo>([
+${familyImports
+	.map(({ importName, network }) => `		["${network.chainSelector.name}", ${importName}],`)
+	.join('\n')}
+	]),`
+	})
+	.join('\n')}
+} as const;
+`
+
+	writeFileSync('src/generated/networks.ts', content)
+	console.log('📄 Created networks array file with mainnet/testnet grouping')
+}
+
+export const main = () => {
+	try {
+		console.log('🚀 Starting chain selectors generation...')
+
+		const networks = parseChainSelectors()
+		console.log(`📊 Total networks processed: ${networks.length}`)
+
+		// Generate individual network files
+		generateNetworkFiles(networks)
+
+		// Generate main networks array
+		generateAllNetworksFile(networks)
+
+		// Generate summary stats
+		const stats = networks.reduce(
+			(acc, network) => {
+				acc[network.chainFamily] = (acc[network.chainFamily] || 0) + 1
+				return acc
+			},
+			{} as Record<ChainFamily, number>,
+		)
+
+		console.log('📈 Summary by family:')
+		Object.entries(stats).forEach(([family, count]) => {
+			console.log(`  ${family}: ${count} networks`)
+		})
+	} catch (error) {
+		console.error('💥 Generation failed:', error)
+		process.exit(1)
+	}
+}

package/scripts/src/generate-sdks.ts

@@ -0,0 +1,36 @@
+import { file_capabilities_blockchain_evm_v1alpha_client } from '@cre/generated/capabilities/blockchain/evm/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'
+import { file_capabilities_internal_consensus_v1alpha_consensus } from '@cre/generated/capabilities/internal/consensus/v1alpha/consensus_pb'
+import { file_capabilities_internal_nodeaction_v1_node_action } from '@cre/generated/capabilities/internal/nodeaction/v1/node_action_pb'
+import { file_capabilities_networking_http_v1alpha_client } from '@cre/generated/capabilities/networking/http/v1alpha/client_pb'
+import { file_capabilities_networking_http_v1alpha_trigger } from '@cre/generated/capabilities/networking/http/v1alpha/trigger_pb'
+import { file_capabilities_scheduler_cron_v1_trigger } from '@cre/generated/capabilities/scheduler/cron/v1/trigger_pb'
+import { generateSdk } from '@cre/generator/generate-sdk'
+
+export const main = () => {
+	// Internal Testing SDKs
+	generateSdk(file_capabilities_internal_basicaction_v1_basic_action, './src/generated-sdk')
+
+	generateSdk(file_capabilities_internal_basictrigger_v1_basic_trigger, './src/generated-sdk')
+
+	generateSdk(file_capabilities_internal_nodeaction_v1_node_action, './src/generated-sdk')
+
+	generateSdk(file_capabilities_internal_consensus_v1alpha_consensus, './src/generated-sdk')
+
+	generateSdk(
+		file_capabilities_internal_actionandtrigger_v1_action_and_trigger,
+		'./src/generated-sdk',
+	)
+
+	// Production SDKs
+
+	generateSdk(file_capabilities_blockchain_evm_v1alpha_client, './src/generated-sdk')
+
+	generateSdk(file_capabilities_networking_http_v1alpha_client, './src/generated-sdk')
+
+	generateSdk(file_capabilities_networking_http_v1alpha_trigger, './src/generated-sdk')
+
+	generateSdk(file_capabilities_scheduler_cron_v1_trigger, './src/generated-sdk')
+}