Class CompilerService

apps/api/src/compiler/compiler.service.ts:28–185

@Injectable()
export class CompilerService {
  private readonly logger: Logger = new Logger(CompilerService.name)

  constructor(
    private workflowActionService: WorkflowActionService,
    private integrationService: IntegrationService,
    private integrationActionService: IntegrationActionService,
    protected integrationDefinitionFactory: IntegrationDefinitionFactory,
  ) {}

  async compile(workflow: Workflow): Promise<{ bytecode: string; abi: object[]; sourcecode: string }> {
    const workflowActions = await this.getOnChainWorkflowActions(workflow)

    const contractPath = path.join(__dirname, '../../../contracts/WorkflowTask.sol.template')
    const contractContent = (await fs.promises.readFile(contractPath, 'utf8')).toString()

    const templates: TemplateEvm[] = []
    const usedVars: VarEvm[] = []
    for (const workflowAction of workflowActions) {
      const template = await this.getTemplate(workflowAction, workflowActions, usedVars)
      usedVars.push(...template.args, ...template.vars)
      templates.push(template)
    }

    const imports = Array.from(new Set(templates.flatMap((template) => template.imports))).map(
      (importFile) => `import "${importFile}";`,
    )
    const code = templates.map((template) => template.code.trim()).join('\n')
    const mutability = templates.reduce((prev, curr) => {
      if (curr.mutability === MutabilityEvm.Modify || prev === MutabilityEvm.Modify) {
        return MutabilityEvm.Modify
      }
      return MutabilityEvm.View
    }, MutabilityEvm.View)
    const args = templates
      .flatMap((template) => template.args)
      .map((arg) => `${arg.type} ${arg.name}`)
      .join(', ')

    const sourcecode = contractContent
      .replace('/* {{imports}} */', imports.join('\n'))
      .replace('/* {{code}} */', code)
      .replace('/* {{mutability}} */', mutability)
      .replace('/* {{args}} */', args)
    const { abi, bytecode } = await this.compileSourceCode(workflow.id, sourcecode)

    return {
      abi,
      bytecode,
      sourcecode,
    }
  }

  private async getOnChainWorkflowActions(workflow: Workflow): Promise<WorkflowAction[]> {
    const actions = await this.workflowActionService.find({ workflow: workflow.id, type: OperationType.EVM })
    const routeAction = actions.find((action) => action.isContractRootAction)
    return routeAction ? this.getActionTree(actions, routeAction) : []
  }