@0xsequence/catapult 1.4.0 → 1.5.0

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

@@ -1,172 +0,0 @@
-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, { 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

@@ -1,127 +0,0 @@
-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.NonceManager(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().then(signer => new ethers.NonceManager(signer)) // 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
-    }
-  }
-}