@0xsequence/catapult 1.3.17 → 1.5.0

package/eslint.config.js

@@ -1,48 +0,0 @@
-const typescriptEslint = require('@typescript-eslint/eslint-plugin')
-const tsParser = require('@typescript-eslint/parser')
-
-module.exports = [
-  {
-    files: ['src/**/*.ts'],
-    languageOptions: {
-      parser: tsParser,
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-    },
-    plugins: {
-      '@typescript-eslint': typescriptEslint,
-    },
-    rules: {
-      // Base ESLint rules
-      'prefer-const': 'error',
-      'no-var': 'error',
-      'semi': ['error', 'never'],
-      
-      // Unused variables and imports detection
-      'no-unused-vars': 'off', // Turn off base rule in favor of TypeScript version
-      '@typescript-eslint/no-unused-vars': [
-        'warn',
-        {
-          vars: 'all',
-          args: 'after-used',
-          ignoreRestSiblings: true,
-          argsIgnorePattern: '^_',
-          varsIgnorePattern: '^_',
-          caughtErrorsIgnorePattern: '^_',
-          destructuredArrayIgnorePattern: '^_'
-        }
-      ],
-      
-      // Additional import/export rules for unused detection
-      '@typescript-eslint/no-unused-expressions': 'warn',
-      
-      // TypeScript ESLint rules
-      '@typescript-eslint/explicit-function-return-type': 'off',
-      '@typescript-eslint/no-explicit-any': 'warn',
-      '@typescript-eslint/no-var-requires': 'off',
-    },
-  },
-  {
-    ignores: ['dist/', 'node_modules/'],
-  },
-] 

package/examples/jobs/guards-v1.yaml

@@ -1,17 +0,0 @@
-name: "guards-v1"
-version: "1"
-description: "Deploy both prod and dev guards for Sequence v1"
-depends_on: ["sequence-v1"]
-
-actions:
-  - name: "guard-v1-prod"
-    template: "sequence-factory-v1"
-    arguments:
-      salt: "0xc99c1ab359199e4dcbd4603e9b2956d5681241ceb286359cf6a647ca56e6e128"
-      implementation: "{{sequence-v1.main-module.address}}"
-
-  - name: "guard-v1-dev"
-    template: "sequence-factory-v1"
-    arguments:
-      salt: "6af209e2a5cca04bfdb4839aba939f715b1840930508af89e7692b21ddecd9b6"
-      implementation: "{{sequence-v1.main-module.address}}"

package/examples/jobs/sequence-seq-0001-patch.yaml

@@ -1,59 +0,0 @@
-name: "sequence-v1-seq-0001-patch"
-version: "0001"
-description: "Sequence v1/v2 patch (SEQ-0001) for addressing guard signer takeover"
-depends_on: ["sequence-v1", "guards-v1"]
-
-actions:
-  - name: "main-module-upgradeable-duo-v1"
-    template: "sequence-universal-deployer-2"
-    arguments:
-      salt: "0"
-      creationCode: "{{creationCode(f5b239d7b2e88a5adae55dea68f83bad)}}"
-
-  - name: "main-module-upgradeable-duo-v2"
-    template: "sequence-universal-deployer-2"
-    arguments:
-      salt: "0"
-      creationCode: "{{creationCode(10326ce5047a2d596161984f678926c8)}}"
-
-  # Ommited as sending the transaction deploys the migrator contracts
-  # - name: "migrator-v1"
-  #   template: "sequence-universal-deployer-2"
-  #   arguments:
-  #     salt: "0"
-  #     creationCode:
-  #       type: "constructor-encode"
-  #       arguments:
-  #         - "{{221a4273dd7bb761ca6f3275c28e1d35}}"
-  #         - "0x596aF90CecdBF9A768886E771178fd5561dD27Ab"
-  #         - "0x5ca5d4cb6696df530c26b130a8fd86276a111f6696b3a8f2e76ff5edf94a2d84"
-  #         - "0xc99c1ab359199e4dcbd4603e9b2956d5681241ceb286359cf6a647ca56e6e128"
-
-  # - name: "migrator-v2"
-  #   template: "sequence-universal-deployer-2"
-  #   arguments:
-  #     salt: "0"
-  #     creationCode:
-  #       type: "constructor-encode"
-  #       arguments:
-  #         - "{{7abcec3e347c6024794220b96a854a4e}}"
-  #         - "0x761f5e29944D79d76656323F106CF2efBF5F09e9"
-  #         - "0xacb659ac7f85fbbce197005235ced2d040c7b02942a9dfae647582393d5a4e83"
-  #         - "0x6e2f52838722eda7d569b52db277d0d87d36991a6aa9b9657ef9d8f09b0c33f4"
-
-  - name: "patch-guard-v1-prod"
-    template: "send-transaction"
-    skip_condition:
-      - type: "basic-arithmetic"
-        arguments:
-          operation: "eq"
-          values:
-            - type: "call"
-              arguments:
-                signature: "readNonce(uint256)"
-                values:
-                  - "100"
-            - "1"
-    arguments:
-      to: "{{guards-v1.guard-v1-prod.address}}"
-      data: "{{patches/seq-0001/guard-v1-prod}}"

package/examples/jobs/sequence-v1.yaml

@@ -1,59 +0,0 @@
-
-name: "sequence-v1"
-version: "1.0.0"
-description: "The Sequence v1 contracts"
-
-actions:
-  - name: "factory"
-    template: "sequence-universal-deployer-2"
-    arguments:
-      creationCode: "{{Contract(sequence/v1/factory).creationCode}}"
-      salt: "0"
-
-  - name: "main-module"
-    template: "sequence-universal-deployer-2"
-    depends_on: ["factory"]
-    arguments:
-      salt: "0"
-      creationCode:
-        type: "constructor-encode"
-        arguments:
-          creationCode: "{{Contract(sequence/v1/main-module).creationCode}}"
-          types: ["address"]
-          values: ["{{factory.address}}"]
-
-  - name: "main-module-upgradeable"
-    template: "sequence-universal-deployer-2"
-    arguments:
-      salt: "0"
-      creationCode: "{{Contract(sequence/v1/main-module-upgradeable).creationCode}}"
-
-  - name: "guest-module"
-    template: "sequence-universal-deployer-2"
-    arguments:
-      salt: "0"
-      creationCode: "{{Contract(sequence/v1/guest-module).creationCode}}"
-
-  - name: "sequence-utils"
-    template: "sequence-universal-deployer-2"
-    depends_on: ["factory", "main-module"]
-    arguments:
-      salt: "0"
-      creationCode:
-        type: "constructor-encode"
-        arguments:
-          creationCode: "{{Contract(sequence/v1/sequence-utils).creationCode}}"
-          types: ["address", "address"]
-          values: ["{{factory.address}}", "{{main-module.address}}"]
-
-  - name: "require-fresh-signer-lib"
-    template: "sequence-universal-deployer-2"
-    depends_on: ["sequence-utils"]
-    arguments:
-      salt: "0"
-      creationCode:
-        type: "constructor-encode"
-        arguments:
-          creationCode: "{{Contract(sequence/v1/require-fresh-signer-lib).creationCode}}"
-          types: ["address"]
-          values: ["{{sequence-utils.address}}"]

package/examples/templates/sequence-factory-v1.yaml

@@ -1,56 +0,0 @@
-name: "sequence-factory-v1"
-
-arguments:
-  implementation:
-    type: "address"
-  salt:
-    type: "bytes32"
-
-returns:
-  address:
-    type: "address"
-
-setup:
-  - type: "job-completed"
-    arguments:
-      job: "sequence-v1"
-
-actions:
-  - type: "send-transaction"
-    arguments:
-      to: "{{sequence-v1.factory.address}}"
-      data:
-        type: "abi-encode"
-        arguments:
-          signature: "deploy(address,address)"
-          values:
-            - "{{implementation}}"
-            - "{{salt}}"
-
-skip_condition:
-  - type: "contract-exists"
-    arguments:
-      address:
-        type: "compute-create2"
-        arguments:
-          deployerAddress: "{{sequence-v1.factory.address}}"
-          salt: "{{salt}}"
-          initCode:
-            type: "constructor-encode"
-            arguments:
-              creationCode: "0x603a600e3d39601a805130553df3363d3d373d3d3d363d30545af43d82803e903d91601857fd5bf3"
-              types: ["address"]
-              values: ["{{implementation}}"]
-
-outputs:
-  address:
-    type: "compute-create2"
-    arguments:
-      deployerAddress: "{{sequence-v1.factory.address}}"
-      salt: "{{salt}}"
-      initCode:
-        type: "constructor-encode"
-        arguments:
-          creationCode: "0x603a600e3d39601a805130553df3363d3d373d3d3d363d30545af43d82803e903d91601857fd5bf3"
-          types: ["address"]
-          values: ["{{implementation}}"]

package/jest.config.js

@@ -1,25 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/src'],
-  testMatch: [
-    '**/__tests__/**/*.ts',
-    '**/?(*.)+(spec|test).ts'
-  ],
-  transform: {
-    '^.+\\.ts$': 'ts-jest',
-  },
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/index.ts'
-  ],
-  coverageDirectory: 'coverage',
-  coverageReporters: [
-    'text',
-    'lcov',
-    'html'
-  ],
-  // Increase timeout for blockchain tests
-  testTimeout: 30000
-}; 

package/src/cli.ts

@@ -1,17 +0,0 @@
-import { Command } from 'commander'
-import { makeRunCommand, makeDryRunCommand, makeListCommand, makeUtilsCommand } from './commands'
-import { makeEtherscanCommand } from './commands/etherscan'
-
-export function setupCommands(program: Command): void {
-  // Make run the default command when no subcommand is provided
-  program.addCommand(makeRunCommand(), {
-    isDefault: true,
-    hidden: false // Keep it visible in help
-  })
-  
-  // Add other commands as subcommands
-  program.addCommand(makeDryRunCommand())
-  program.addCommand(makeListCommand())
-  program.addCommand(makeUtilsCommand())
-  program.addCommand(makeEtherscanCommand())
-}

package/src/commands/common.ts

@@ -1,61 +0,0 @@
-import { Command } from 'commander'
-import * as dotenv from 'dotenv'
-import * as path from 'path'
-import { ProjectLoader, ProjectLoaderOptions } from '../lib/core/loader'
-import { deploymentEvents } from '../lib/events'
-
-/**
- * Adds the --project option to a command.
- */
-export const projectOption = (cmd: Command): Command =>
-  cmd.option('-p, --project <path>', 'Project root directory', process.cwd())
-
-/**
- * Adds the --dotenv option to a command.
- */
-export const dotenvOption = (cmd: Command): Command =>
-  cmd.option('--dotenv <path>', 'Path to a custom .env file')
-
-/**
- * Adds the --no-std option to a command.
- */
-export const noStdOption = (cmd: Command): Command =>
-  cmd.option('--no-std', 'Disable loading built-in standard templates')
-
-/**
- * Adds verbosity options to a command.
- */
-export const verbosityOption = (cmd: Command): Command =>
-  cmd.option('-v, --verbose', 'Enable verbose logging (use -vv or -vvv for more detail)', (_, previous) => (previous || 0) + 1, 0)
-
-/**
- * Loads the project using the ProjectLoader and emits corresponding events.
- */
-export async function loadProject(projectRoot: string, options?: ProjectLoaderOptions): Promise<ProjectLoader> {
-  deploymentEvents.emitEvent({
-    type: 'project_loading_started',
-    level: 'info',
-    data: { projectRoot }
-  })
-  
-  const loader = new ProjectLoader(projectRoot, options)
-  await loader.load()
-  
-  deploymentEvents.emitEvent({
-    type: 'project_loaded',
-    level: 'info',
-    data: {
-      jobCount: loader.jobs.size,
-      templateCount: loader.templates.size
-    }
-  })
-  return loader
-}
-
-/**
- * Loads environment variables from the specified .env file path.
- */
-export function loadDotenv(options: { dotenv?: string }): void {
-  const dotenvPath = options.dotenv ? path.resolve(options.dotenv) : path.resolve(process.cwd(), '.env')
-  dotenv.config({ path: dotenvPath })
-}

package/src/commands/dry.ts

@@ -1,209 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { loadProject } from './common'
-import { loadNetworks } from '../lib/network-loader'
-import { DependencyGraph } from '../lib/core/graph'
-import { projectOption, noStdOption, verbosityOption } from './common'
-import { validateContractReferences, extractUsedContractReferences } from '../lib/validation/contract-references'
-import { setVerbosity } from '../index'
-import { resolveSelectedChainIds } from '../lib/network-selection'
-import { Template } from '../lib/types'
-
-interface DryRunOptions {
-  project: string
-  std: boolean
-  network?: string
-  verbose: number
-}
-
-/**
- * Extract only constant-like placeholders from a value, using template metadata when available.
- * A placeholder is treated as a constant candidate if:
- * - It is a bare identifier (no dot, no parentheses), AND
- * - It is NOT declared as a template argument in the current template (when template context provided)
- */
-function extractConstantRefs(value: unknown, refs: string[], templateCtx?: Template) {
-  if (typeof value === 'string') {
-    const m = value.match(/^{{(.*)}}$/)
-    if (m) {
-      const expr = m[1].trim()
-
-      // Skip outputs or function-like references
-      if (expr.includes('.') || expr.includes('(') || expr.includes(')')) return
-
-      // If we have a template context, and the expr matches a declared argument, it's NOT a constant
-      if (templateCtx?.arguments && Object.prototype.hasOwnProperty.call(templateCtx.arguments, expr)) {
-        return
-      }
-
-      // Otherwise, treat as a constant candidate
-      refs.push(expr)
-    }
-  } else if (Array.isArray(value)) {
-    for (const v of value) extractConstantRefs(v, refs, templateCtx)
-  } else if (value && typeof value === 'object') {
-    for (const v of Object.values(value)) extractConstantRefs(v, refs, templateCtx)
-  }
-}
-
-export function makeDryRunCommand(): Command {
-  const dryRun = new Command('dry-run')
-    .description('Validate project configuration and show execution plan without running transactions')
-    .argument('[jobs...]', 'Specific job names to validate (and their dependencies).')
-    .option('-n, --network <selectors>', 'Comma-separated network selectors (by chain ID or name).')
-  
-  projectOption(dryRun)
-  noStdOption(dryRun)
-  verbosityOption(dryRun)
-  
-  dryRun.action(async (jobs: string[], options: DryRunOptions) => {
-    try {
-      // Set verbosity level for logging
-      setVerbosity(options.verbose as 0 | 1 | 2 | 3)
-      
-      console.log(chalk.bold.inverse(' DRY-RUN MODE '))
-      const projectRoot = options.project
-      const loader = await loadProject(projectRoot, {
-        loadStdTemplates: options.std !== false
-      })
-      const allNetworks = await loadNetworks(projectRoot)
-
-      console.log(chalk.blue('\nBuilding dependency graph...'))
-      const graph = new DependencyGraph(loader.jobs, loader.templates)
-      const fullOrder = graph.getExecutionOrder()
-      console.log(chalk.green('   - Dependency graph built successfully.'))
-      
-      console.log(chalk.blue('\nContract Repository:'))
-      console.log(chalk.green(`   - Found ${loader.contractRepository.getAll().length} unique contracts.`))
-      
-      // Check for ambiguous references that are actually being used
-      const usedRefs = await extractUsedContractReferences(loader)
-      const allAmbiguousRefs = loader.contractRepository.getAmbiguousReferences()
-      const usedRefNames = usedRefs.map(ref => ref.reference)
-      const usedAmbiguousRefs = allAmbiguousRefs.filter(ref => usedRefNames.includes(ref))
-      
-      if (usedAmbiguousRefs.length > 0) {
-        console.log(chalk.red('\n   - Found ambiguous contract references being used:'))
-        for (const ref of usedAmbiguousRefs) {
-          console.log(chalk.red(`     ✗ "${ref}" could refer to multiple contracts`))
-        }
-        throw new Error(`Found ${usedAmbiguousRefs.length} ambiguous contract reference(s) being used. Please use more specific references to resolve ambiguity.`)
-      }
-      console.log(chalk.green('   - All used contract references are unambiguous.'))
-      
-      // Validate that all Contract() references point to existing contracts
-      console.log(chalk.blue('\nValidating contract references...'))
-      const missingRefs = await validateContractReferences(loader)
-      if (missingRefs.length > 0) {
-        console.log(chalk.red('\n   - Found missing contract references:'))
-        for (const ref of missingRefs) {
-          console.log(chalk.red(`     ✗ ${ref.reference} in ${ref.location}`))
-        }
-        throw new Error(`Found ${missingRefs.length} missing contract reference(s). Please ensure all referenced contracts exist.`)
-      }
-      console.log(chalk.green('   - All contract references are valid.'))
-
-      // Validate constant references exist
-      console.log(chalk.blue('\nValidating constant references...'))
-      const topLevelConstants = loader.constants
-      const missingConstantRefs: Array<{ ref: string; location: string }> = []
-
-      // Check jobs (arguments and outputs within templates are resolved at runtime; here we just check expressions)
-      for (const [jobName, job] of loader.jobs.entries()) {
-        // Collect refs in job actions
-        for (let i = 0; i < job.actions.length; i++) {
-          const action = job.actions[i]
-          const refs: string[] = []
-          extractConstantRefs(action.arguments, refs)
-          const jobConstants = job.constants || {}
-          for (const r of refs) {
-            if (!(r in jobConstants) && !topLevelConstants.has(r)) {
-              missingConstantRefs.push({ ref: r, location: `job '${jobName}', action ${i + 1}${action.name ? ` '${action.name}'` : ''}` })
-            }
-          }
-        }
-      }
-
-      // Check templates (setup/actions/outputs)
-      for (const [templateName, template] of loader.templates.entries()) {
-        // actions
-        for (let i = 0; i < template.actions.length; i++) {
-          const action = template.actions[i]
-          const refs: string[] = []
-          extractConstantRefs(action.arguments, refs, template)
-          for (const r of refs) {
-            if (!topLevelConstants.has(r)) {
-              missingConstantRefs.push({ ref: r, location: `template '${templateName}', action ${i + 1}${action.name ? ` '${action.name}'` : ''}` })
-            }
-          }
-        }
-        // setup actions
-        if (template.setup?.actions) {
-          for (let i = 0; i < (template.setup.actions?.length || 0); i++) {
-            const action = template.setup.actions![i]
-            const refs: string[] = []
-            extractConstantRefs(action.arguments, refs, template)
-            for (const r of refs) {
-              if (!topLevelConstants.has(r)) {
-                missingConstantRefs.push({ ref: r, location: `template '${templateName}' setup, action ${i + 1}${action.name ? ` '${action.name}'` : ''}` })
-              }
-            }
-          }
-        }
-        // outputs
-        if (template.outputs) {
-          const refs: string[] = []
-          extractConstantRefs(template.outputs, refs, template)
-          for (const r of refs) {
-            if (!topLevelConstants.has(r)) {
-              missingConstantRefs.push({ ref: r, location: `template '${templateName}' outputs` })
-            }
-          }
-        }
-      }
-
-      if (missingConstantRefs.length > 0) {
-        console.log(chalk.red('\n   - Found missing constant references:'))
-        for (const m of missingConstantRefs) {
-          console.log(chalk.red(`     ✗ ${m.ref} in ${m.location}`))
-        }
-        throw new Error(`Found ${missingConstantRefs.length} missing constant reference(s). Ensure they are defined at top-level or in the job's constants.`)
-      }
-      console.log(chalk.green('   - All constant references are valid.'))
-      
-      const runJobs = jobs.length > 0 ? jobs : undefined
-      const runOnNetworks = resolveSelectedChainIds(options.network, allNetworks)
-
-      const jobsToRun = new Set<string>()
-      if (runJobs) {
-        for (const jobName of runJobs) {
-          if (!loader.jobs.has(jobName)) {
-            throw new Error(`Specified job "${jobName}" not found in project.`)
-          }
-          jobsToRun.add(jobName)
-          graph.getDependencies(jobName).forEach(dep => jobsToRun.add(dep))
-        }
-      } else {
-        fullOrder.forEach(j => jobsToRun.add(j))
-      }
-
-      const jobExecutionPlan = fullOrder.filter(jobName => jobsToRun.has(jobName))
-      const targetNetworks = runOnNetworks
-        ? allNetworks.filter(n => runOnNetworks.includes(n.chainId))
-        : allNetworks
-
-      console.log(chalk.blue('\nExecution Plan:'))
-      console.log(chalk.gray(`   - Target Networks: ${targetNetworks.map(n => `${n.name} (ChainID: ${n.chainId})`).join(', ')}`))
-      console.log(chalk.gray(`   - Job Execution Order: ${jobExecutionPlan.join(' -> ')}`))
-      
-      console.log(chalk.green.bold('\n✅ Dry run successful. All job and template definitions appear to be valid.'))
-      
-    } catch (error) {
-      console.error(chalk.red.bold('\n💥 DRY RUN FAILED!'))
-      console.error(chalk.red(error instanceof Error ? error.message : String(error)))
-      process.exit(1)
-    }
-  })
-
-  return dryRun
-}