@0xsequence/catapult 1.1.0

package/src/lib/core/__tests__/static-action.spec.ts

@@ -0,0 +1,172 @@
+import { ExecutionEngine } from '../engine'
+import { ExecutionContext } from '../context'
+import { ContractRepository } from '../../contracts/repository'
+import { Action, Network } from '../../types'
+import { VerificationPlatformRegistry } from '../../verification/etherscan'
+
+describe('Static Action', () => {
+  let engine: ExecutionEngine
+  let context: ExecutionContext
+  let mockNetwork: Network
+  let mockRegistry: ContractRepository
+  let templates: Map<string, any>
+
+  beforeEach(() => {
+    mockNetwork = { name: 'testnet', chainId: 999, rpcUrl: 'http://localhost:8545' }
+    mockRegistry = new ContractRepository()
+    
+    // Create a mock context that doesn't require a real connection
+    context = {
+      getNetwork: () => mockNetwork,
+      setOutput: jest.fn(),
+      getOutput: jest.fn(),
+      setContextPath: jest.fn(),
+      getContextPath: jest.fn(),
+      dispose: jest.fn()
+    } as any
+
+    templates = new Map()
+    const verificationRegistry = new VerificationPlatformRegistry()
+    engine = new ExecutionEngine(templates, undefined, verificationRegistry)
+  })
+
+  describe('static primitive action', () => {
+    it('should store the provided value unchanged', async () => {
+      const action: Action = {
+        type: 'static',
+        name: 'test-static',
+        arguments: {
+          value: 'hello world'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).toHaveBeenCalledWith('test-static.value', 'hello world')
+    })
+
+    it('should work with numeric values', async () => {
+      const action: Action = {
+        type: 'static',
+        name: 'numeric-static',
+        arguments: {
+          value: 42
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).toHaveBeenCalledWith('numeric-static.value', 42)
+    })
+
+    it('should work with boolean values', async () => {
+      const action: Action = {
+        type: 'static',
+        name: 'boolean-static',
+        arguments: {
+          value: true
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).toHaveBeenCalledWith('boolean-static.value', true)
+    })
+
+    it('should work with object values', async () => {
+      const testObject = { foo: 'bar', number: 123 }
+      
+      // Mock the resolver to return the object unchanged
+      const mockResolver = {
+        resolve: jest.fn().mockResolvedValue(testObject)
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'static',
+        name: 'object-static',
+        arguments: {
+          value: testObject
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(mockResolver.resolve).toHaveBeenCalledWith(testObject, context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('object-static.value', testObject)
+    })
+
+    it('should work with array values', async () => {
+      const testArray = [1, 2, 3, 'test']
+      const action: Action = {
+        type: 'static',
+        name: 'array-static',
+        arguments: {
+          value: testArray
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).toHaveBeenCalledWith('array-static.value', testArray)
+    })
+
+    it('should not store outputs when action has no name', async () => {
+      const action: Action = {
+        type: 'static',
+        arguments: {
+          value: 'test value'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(context.setOutput).not.toHaveBeenCalled()
+    })
+
+    it('should resolve template variables from context', async () => {
+      // Mock the resolver to simulate variable resolution
+      const mockResolver = {
+        resolve: jest.fn().mockResolvedValue('resolved value')
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'static',
+        name: 'resolved-static',
+        arguments: {
+          value: '{{some_variable}}'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, new Map())
+
+      expect(mockResolver.resolve).toHaveBeenCalledWith('{{some_variable}}', context, new Map())
+      expect(context.setOutput).toHaveBeenCalledWith('resolved-static.value', 'resolved value')
+    })
+
+    it('should resolve template variables from scope', async () => {
+      const scope = new Map()
+      scope.set('template_var', 'scope value')
+
+      // Mock the resolver to return the scope value
+      const mockResolver = {
+        resolve: jest.fn().mockResolvedValue('scope value')
+      }
+      ;(engine as any).resolver = mockResolver
+
+      const action: Action = {
+        type: 'static',
+        name: 'scope-static',
+        arguments: {
+          value: '{{template_var}}'
+        }
+      }
+
+      await (engine as any).executePrimitive(action, context, scope)
+
+      expect(mockResolver.resolve).toHaveBeenCalledWith('{{template_var}}', context, scope)
+      expect(context.setOutput).toHaveBeenCalledWith('scope-static.value', 'scope value')
+    })
+  })
+})

package/src/lib/core/context.ts

@@ -0,0 +1,127 @@
+import { ethers } from 'ethers'
+import { Network } from '../types'
+import { ContractRepository } from '../contracts/repository'
+
+export class ExecutionContext {
+ public readonly provider: ethers.JsonRpcProvider
+ public readonly signer: ethers.Signer | Promise<ethers.Signer> // Allow Promise for implicit signer
+ public readonly contractRepository: ContractRepository
+ private outputs: Map<string, any> = new Map()
+ private network: Network
+ private etherscanApiKey?: string
+ private currentContextPath?: string
+ private resolvedSigner?: ethers.Signer // Cache for resolved signer
+
+  // Constants registries
+  private topLevelConstants: Map<string, any> = new Map()
+  private jobConstants: Map<string, any> = new Map()
+
+ constructor(
+   network: Network,
+   privateKey: string | undefined, // Make privateKey optional
+   contractRepository: ContractRepository,
+   etherscanApiKey?: string,
+   topLevelConstants?: Map<string, any>
+ ) {
+   this.network = network
+   this.provider = new ethers.JsonRpcProvider(network.rpcUrl)
+   this.contractRepository = contractRepository
+   this.etherscanApiKey = etherscanApiKey
+   if (topLevelConstants) {
+     this.topLevelConstants = new Map(topLevelConstants)
+   }
+
+   // Determine the signer
+   if (privateKey) {
+     this.signer = new ethers.Wallet(privateKey, this.provider)
+   } else if (network.rpcUrl) {
+     // If no private key, but RPC URL is provided, get a signer from the provider.
+     // This returns a Promise that we need to resolve on first use.
+     this.signer = this.provider.getSigner() // Keep as Promise
+   } else {
+     throw new Error('A private key must be provided or an RPC URL must be configured to obtain a signer for the network.')
+   }
+ }
+
+ /**
+  * Get the resolved signer, handling both direct signers and promised signers
+  */
+ public async getResolvedSigner(): Promise<ethers.Signer> {
+   if (this.resolvedSigner) {
+     return this.resolvedSigner
+   }
+
+   if (this.signer instanceof Promise) {
+     this.resolvedSigner = await this.signer
+     return this.resolvedSigner
+   } else {
+     this.resolvedSigner = this.signer
+     return this.resolvedSigner
+   }
+ }
+
+  public getNetwork(): Network {
+    return this.network
+  }
+
+  public getEtherscanApiKey(): string | undefined {
+    return this.etherscanApiKey
+  }
+
+  public getContractRepository(): ContractRepository {
+    return this.contractRepository
+  }
+
+  // To store results like `{{sequence-v1.factory.address}}`
+  public setOutput(key: string, value: any): void {
+    this.outputs.set(key, value)
+  }
+
+  // To retrieve results
+  public getOutput(key:string): any {
+    if (!this.outputs.has(key)) {
+      throw new Error(`Output for key "${key}" not found in context. Check dependencies.`)
+    }
+    return this.outputs.get(key)
+  }
+
+  public getOutputs(): Map<string, any> {
+    return this.outputs
+  }
+
+  // Context path for relative artifact resolution
+  public setContextPath(path?: string): void {
+    this.currentContextPath = path
+  }
+
+  public getContextPath(): string | undefined {
+    return this.currentContextPath
+  }
+
+  // Constants management
+  public setJobConstants(constants?: Record<string, any>): void {
+    this.jobConstants = new Map(Object.entries(constants || {}))
+  }
+
+  public getConstant(name: string): any | undefined {
+    // Resolution order: job-level constants override top-level
+    if (this.jobConstants.has(name)) return this.jobConstants.get(name)
+    if (this.topLevelConstants.has(name)) return this.topLevelConstants.get(name)
+    return undefined
+  }
+
+  /**
+   * Cleanup method to properly dispose of provider connections.
+   * This should be called when the context is no longer needed to prevent hanging connections.
+   */
+  public async dispose(): Promise<void> {
+    try {
+      // Destroy the provider to close any open connections
+      if ((this.provider as any).destroy) {
+        await (this.provider as any).destroy()
+      }
+    } catch (error) {
+      // Ignore errors during cleanup
+    }
+  }
+}