@0xsequence/catapult 1.1.0

package/src/lib/__tests__/network-utils.spec.ts

@@ -0,0 +1,181 @@
+import { detectNetworkFromRpc, isValidRpcUrl } from '../network-utils'
+import { Network } from '../types'
+
+// Mock ethers.JsonRpcProvider
+jest.mock('ethers', () => ({
+  ...jest.requireActual('ethers'),
+  ethers: {
+    ...jest.requireActual('ethers').ethers,
+    JsonRpcProvider: jest.fn().mockImplementation(() => ({
+      getNetwork: jest.fn()
+    }))
+  }
+}))
+
+describe('Network Utils', () => {
+  describe('isValidRpcUrl', () => {
+    it('should validate valid HTTP RPC URLs', () => {
+      expect(isValidRpcUrl('http://localhost:8545')).toBe(true)
+      expect(isValidRpcUrl('https://mainnet.infura.io/v3/abc123')).toBe(true)
+    })
+
+    it('should validate valid WebSocket RPC URLs', () => {
+      expect(isValidRpcUrl('ws://localhost:8545')).toBe(true)
+      expect(isValidRpcUrl('wss://mainnet.infura.io/v3/abc123')).toBe(true)
+    })
+
+    it('should reject invalid URLs', () => {
+      expect(isValidRpcUrl('invalid-url')).toBe(false)
+      expect(isValidRpcUrl('ftp://example.com')).toBe(false)
+      expect(isValidRpcUrl('')).toBe(false)
+    })
+
+    it('should reject URLs without hostname', () => {
+      expect(isValidRpcUrl('http://')).toBe(false)
+    })
+  })
+
+  describe('detectNetworkFromRpc', () => {
+    let mockGetNetwork: jest.Mock
+
+    beforeEach(() => {
+      // Reset mocks
+      jest.clearAllMocks()
+      
+      // Mock the JsonRpcProvider constructor and getNetwork method
+      const { ethers } = require('ethers')
+      mockGetNetwork = jest.fn()
+      
+      // Mock the provider's getNetwork method
+      ethers.JsonRpcProvider.mockImplementation(() => ({
+        getNetwork: mockGetNetwork
+      }))
+    })
+
+    it('should detect network successfully', async () => {
+      const mockNetwork = {
+        name: 'mainnet',
+        chainId: 1
+      }
+      
+      mockGetNetwork.mockResolvedValue(mockNetwork)
+
+      const result = await detectNetworkFromRpc('https://mainnet.infura.io/v3/abc123')
+
+      expect(result).toEqual({
+        name: 'mainnet',
+        chainId: 1,
+        rpcUrl: 'https://mainnet.infura.io/v3/abc123'
+      })
+
+      // Verify provider was created with correct URL
+      const { ethers } = require('ethers')
+      expect(ethers.JsonRpcProvider).toHaveBeenCalledWith('https://mainnet.infura.io/v3/abc123')
+    })
+
+    it('should handle network with unknown name', async () => {
+      const mockNetwork = {
+        name: 'unknown',
+        chainId: 31337
+      }
+      
+      mockGetNetwork.mockResolvedValue(mockNetwork)
+
+      const result = await detectNetworkFromRpc('http://localhost:8545')
+
+      expect(result).toEqual({
+        name: 'unknown',
+        chainId: 31337,
+        rpcUrl: 'http://localhost:8545'
+      })
+    })
+
+    it('should handle connection errors', async () => {
+      mockGetNetwork.mockRejectedValue(new Error('Connection failed'))
+
+      await expect(detectNetworkFromRpc('http://localhost:8545'))
+        .rejects.toThrow('Failed to detect network from RPC URL "http://localhost:8545": Connection failed')
+    })
+
+    it('should handle network detection errors', async () => {
+      mockGetNetwork.mockRejectedValue(new Error('Network not supported'))
+
+      await expect(detectNetworkFromRpc('http://invalid-rpc.com'))
+        .rejects.toThrow('Failed to detect network from RPC URL "http://invalid-rpc.com": Network not supported')
+    })
+  })
+
+  describe('Integration with Run Command', () => {
+    it('should create a complete Network object from detected information', async () => {
+      const { ethers } = require('ethers')
+      
+      // Mock successful network detection
+      const mockNetwork = {
+        name: 'sepolia',
+        chainId: 11155111
+      }
+      
+      const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
+      ethers.JsonRpcProvider.mockImplementation(() => ({
+        getNetwork: getNetworkMock
+      }))
+
+      const detectedInfo = await detectNetworkFromRpc('https://sepolia.infura.io/v3/abc123')
+
+      // Simulate what the run command does
+      const customNetwork: Network = {
+        name: detectedInfo.name || `custom-${detectedInfo.chainId}`,
+        chainId: detectedInfo.chainId!,
+        rpcUrl: 'https://sepolia.infura.io/v3/abc123',
+        supports: detectedInfo.supports || [],
+        gasLimit: detectedInfo.gasLimit,
+        testnet: detectedInfo.testnet
+      }
+
+      expect(customNetwork).toEqual({
+        name: 'sepolia',
+        chainId: 11155111,
+        rpcUrl: 'https://sepolia.infura.io/v3/abc123',
+        supports: [],
+        gasLimit: undefined,
+        testnet: undefined
+      })
+    })
+
+    it('should handle partial network information gracefully', async () => {
+      const { ethers } = require('ethers')
+      
+      // Mock network with minimal information
+      const mockNetwork = {
+        name: 'unknown',
+        chainId: 42
+      }
+      
+      const getNetworkMock = jest.fn().mockResolvedValue(mockNetwork)
+      ethers.JsonRpcProvider.mockImplementation(() => ({
+        getNetwork: getNetworkMock
+      }))
+
+      const detectedInfo = await detectNetworkFromRpc('http://custom-network:8545')
+
+      // Simulate what the run command does
+      const customNetwork: Network = {
+        name: detectedInfo.name || `custom-${detectedInfo.chainId}`,
+        chainId: detectedInfo.chainId!,
+        rpcUrl: 'http://custom-network:8545',
+        supports: detectedInfo.supports || [],
+        gasLimit: detectedInfo.gasLimit,
+        testnet: detectedInfo.testnet
+      }
+
+      expect(customNetwork).toEqual({
+        name: 'unknown',
+        chainId: 42,
+        rpcUrl: 'http://custom-network:8545',
+        supports: [],
+        gasLimit: undefined,
+        testnet: undefined
+      })
+    })
+  })
+})

package/src/lib/artifacts/__tests__/fixtures/contract1.json

@@ -0,0 +1,19 @@
+{
+  "contractName": "TestContract1",
+  "sourceName": "contracts/TestContract1.sol",
+  "abi": [
+    {
+      "type": "function",
+      "name": "getValue",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "uint256"
+        }
+      ]
+    }
+  ],
+  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b0000005b6000806000fefe",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
+} 

package/src/lib/artifacts/__tests__/fixtures/contract2.json

@@ -0,0 +1,19 @@
+{
+  "contractName": "TestContract2",
+  "sourceName": "contracts/TestContract2.sol",
+  "abi": [
+    {
+      "type": "function",
+      "name": "setValue",
+      "inputs": [
+        {
+          "name": "value",
+          "type": "uint256"
+        }
+      ],
+      "outputs": []
+    }
+  ],
+  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806355241077146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806355241077146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
+} 

package/src/lib/artifacts/__tests__/fixtures/duplicate-name.json

@@ -0,0 +1,19 @@
+{
+  "contractName": "TestContract1",
+  "sourceName": "contracts/DuplicateTestContract1.sol",
+  "abi": [
+    {
+      "type": "function",
+      "name": "differentFunction",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b0000005b6000806000fefe",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b6000fefe"
+} 

package/src/lib/artifacts/__tests__/fixtures/nested/nested-contract.json

@@ -0,0 +1,18 @@
+{
+  "contractName": "NestedContract",
+  "sourceName": "contracts/nested/NestedContract.sol",
+  "abi": [
+    {
+      "type": "function",
+      "name": "nestedFunction",
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "",
+          "type": "bool"
+        }
+      ]
+    }
+  ],
+  "bytecode": "0x608060405234801561001057600080fd5b50600436106100365760003560e01c806320965255146100365780636d4ce63c14610040575b600080fd5b610040610058565b005b610048610062565b6040516100579190610078565b60405180910390f35b0000005b6000806000fefe"
+} 

package/src/lib/artifacts/__tests__/fixtures/not-an-artifact.json

@@ -0,0 +1,8 @@
+{
+  "name": "NotAnArtifact",
+  "data": {
+    "some": "random",
+    "json": "data"
+  },
+  "version": "1.0.0"
+} 

package/src/lib/artifacts/__tests__/fixtures/readme.txt

@@ -0,0 +1,2 @@
+This is just a text file that should be ignored during artifact scanning.
+It has no JSON content and should not interfere with the test. 

package/src/lib/contracts/__tests__/repository.spec.ts

@@ -0,0 +1,344 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { ContractRepository } from '../repository'
+import { Contract } from '../../types/contracts'
+
+describe('ContractRepository', () => {
+  let repository: ContractRepository
+  let tempDir: string
+
+  beforeEach(async () => {
+    repository = new ContractRepository()
+    
+    // Create a temporary directory for test files
+    tempDir = path.join(__dirname, 'temp-test-files')
+    await fs.mkdir(tempDir, { recursive: true })
+  })
+
+  afterEach(async () => {
+    // Clean up temporary files
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true })
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  })
+
+  describe('loadFrom method', () => {
+    it('should find and load standard artifact files', async () => {
+      const artifactContent = JSON.stringify({
+        contractName: 'TestContract',
+        abi: [{ type: 'function', name: 'test' }],
+        bytecode: '0x608060405234801561001057600080fd5b50',
+        deployedBytecode: '0x608060405234801561001057600080fd5b506004361061003957600080fd5b50'
+      })
+
+      const artifactPath = path.join(tempDir, 'TestContract.json')
+      await fs.writeFile(artifactPath, artifactContent)
+
+      await repository.loadFrom(tempDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(1)
+
+      const contract = contracts[0]
+      expect(contract.contractName).toBe('TestContract')
+      expect(contract.creationCode).toBe('0x608060405234801561001057600080fd5b50')
+      expect(contract.runtimeBytecode).toBe('0x608060405234801561001057600080fd5b506004361061003957600080fd5b50')
+      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
+      expect(contract._sources.has(artifactPath)).toBe(true)
+    })
+
+    it('should find and load build-info files', async () => {
+      const buildInfoContent = JSON.stringify({
+        _format: 'hh-sol-build-info-1',
+        id: 'test-build-id',
+        solcVersion: '0.8.0',
+        solcLongVersion: '0.8.0+commit.c7dfd78e',
+        input: {
+          language: 'Solidity',
+          sources: {
+            'src/TestContract.sol': {
+              content: 'contract TestContract { function test() public {} }'
+            }
+          },
+          settings: {
+            outputSelection: {
+              '*': {
+                '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']
+              }
+            }
+          }
+        },
+        output: {
+          contracts: {
+            'src/TestContract.sol': {
+              TestContract: {
+                abi: [{ type: 'function', name: 'test' }],
+                evm: {
+                  bytecode: {
+                    object: '0x608060405234801561001057600080fd5b50'
+                  },
+                  deployedBytecode: {
+                    object: '0x608060405234801561001057600080fd5b506004361061003939600080fd5b50'
+                  }
+                }
+              }
+            }
+          },
+          sources: {}
+        }
+      })
+
+      const buildInfoDir = path.join(tempDir, 'build-info')
+      await fs.mkdir(buildInfoDir, { recursive: true })
+      const buildInfoPath = path.join(buildInfoDir, 'test-buildinfo.json')
+      await fs.writeFile(buildInfoPath, buildInfoContent)
+
+      await repository.loadFrom(tempDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(1)
+
+      const contract = contracts[0]
+      expect(contract.contractName).toBe('TestContract')
+      expect(contract.sourceName).toBe('src/TestContract.sol')
+      expect(contract.creationCode).toBe('0x608060405234801561001057600080fd5b50')
+      expect(contract.runtimeBytecode).toBe('0x608060405234801561001057600080fd5b506004361061003939600080fd5b50')
+      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
+      expect(contract.buildInfoId).toBe('test-build-id')
+      expect(contract.source).toBe('contract TestContract { function test() public {} }')
+      expect(contract._sources.has(buildInfoPath)).toBe(true)
+    })
+
+    it('should hydrate contracts from multiple source files', async () => {
+      // Create a basic artifact file (minimal info, will be hydrated by build-info)
+      const artifactContent = JSON.stringify({
+        contractName: 'TestContract',
+        abi: [],
+        bytecode: '0x608060405234801561001057600080fd5b50'
+      })
+      const artifactPath = path.join(tempDir, 'TestContract.json')
+      await fs.writeFile(artifactPath, artifactContent)
+
+      // Create a build-info file with the same bytecode but more complete information
+      const buildInfoContent = JSON.stringify({
+        _format: 'hh-sol-build-info-1',
+        id: 'test-build-id',
+        solcVersion: '0.8.0',
+        solcLongVersion: '0.8.0+commit.c7dfd78e',
+        input: {
+          language: 'Solidity',
+          sources: {
+            'src/TestContract.sol': {
+              content: 'contract TestContract { function test() public {} }'
+            }
+          },
+          settings: {
+            outputSelection: {
+              '*': {
+                '*': ['abi', 'evm.bytecode', 'evm.deployedBytecode']
+              }
+            }
+          }
+        },
+        output: {
+          contracts: {
+            'src/TestContract.sol': {
+              TestContract: {
+                abi: [{ type: 'function', name: 'test' }],
+                evm: {
+                  bytecode: {
+                    object: '0x608060405234801561001057600080fd5b50'
+                  },
+                  deployedBytecode: {
+                    object: '0x608060405234801561001057600080fd5b506004361061003939600080fd5b50'
+                  }
+                }
+              }
+            }
+          },
+          sources: {}
+        }
+      })
+
+      const buildInfoDir = path.join(tempDir, 'build-info')
+      await fs.mkdir(buildInfoDir, { recursive: true })
+      const buildInfoPath = path.join(buildInfoDir, 'test-buildinfo.json')
+      await fs.writeFile(buildInfoPath, buildInfoContent)
+
+      await repository.loadFrom(tempDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(1)
+
+      const contract = contracts[0]
+      // Should have information from both sources
+      expect(contract.contractName).toBe('TestContract')
+      expect(contract.sourceName).toBe('src/TestContract.sol')
+      expect(contract.abi).toEqual([{ type: 'function', name: 'test' }])
+      expect(contract.buildInfoId).toBe('test-build-id')
+      expect(contract.source).toBe('contract TestContract { function test() public {} }')
+      expect(contract._sources.has(artifactPath)).toBe(true)
+      expect(contract._sources.has(buildInfoPath)).toBe(true)
+    })
+  })
+
+  describe('disambiguateReferences method', () => {
+    beforeEach(async () => {
+      // Create test files with deliberate name collisions
+      const artifact1Content = JSON.stringify({
+        contractName: 'MyToken',
+        abi: [],
+        bytecode: '0x608060405234801561001057600080fd5b50111111'
+      })
+      const artifact1Path = path.join(tempDir, 'contracts', 'MyToken.json')
+      await fs.mkdir(path.dirname(artifact1Path), { recursive: true })
+      await fs.writeFile(artifact1Path, artifact1Content)
+
+      const artifact2Content = JSON.stringify({
+        contractName: 'MyToken',
+        abi: [],
+        bytecode: '0x608060405234801561001057600080fd5b50222222'
+      })
+      const artifact2Path = path.join(tempDir, 'legacy', 'MyToken.json')
+      await fs.mkdir(path.dirname(artifact2Path), { recursive: true })
+      await fs.writeFile(artifact2Path, artifact2Content)
+
+      await repository.loadFrom(tempDir)
+    })
+
+    it('should identify ambiguous references correctly', () => {
+      const ambiguousRefs = repository.getAmbiguousReferences()
+      expect(ambiguousRefs).toContain('MyToken')
+    })
+
+    it('should allow lookup by unique hash', () => {
+      const contracts = repository.getAll()
+      const contract1 = contracts.find(c => c.creationCode.includes('111111'))
+      const contract2 = contracts.find(c => c.creationCode.includes('222222'))
+
+      expect(contract1).toBeDefined()
+      expect(contract2).toBeDefined()
+
+      const lookupResult1 = repository.lookup(contract1!.uniqueHash)
+      const lookupResult2 = repository.lookup(contract2!.uniqueHash)
+
+      expect(lookupResult1).toBe(contract1)
+      expect(lookupResult2).toBe(contract2)
+    })
+
+    it('should allow lookup by unambiguous path', () => {
+      const contracts = repository.getAll()
+      const contract1 = contracts.find(c => c.creationCode.includes('111111'))
+
+      const lookupResult = repository.lookup(path.join(tempDir, 'contracts', 'MyToken.json'))
+      expect(lookupResult).toBe(contract1)
+    })
+  })
+
+  describe('lookup method', () => {
+    beforeEach(async () => {
+      const artifactContent = JSON.stringify({
+        contractName: 'UniqueContract',
+        abi: [{ type: 'function', name: 'test' }],
+        bytecode: '0x608060405234801561001057600080fd5b50'
+      })
+      const artifactPath = path.join(tempDir, 'UniqueContract.json')
+      await fs.writeFile(artifactPath, artifactContent)
+
+      await repository.loadFrom(tempDir)
+    })
+
+    it('should successfully lookup by contract name', () => {
+      const contract = repository.lookup('UniqueContract')
+      expect(contract).not.toBeNull()
+      expect(contract!.contractName).toBe('UniqueContract')
+    })
+
+    it('should successfully lookup by unique hash', () => {
+      const contracts = repository.getAll()
+      const testContract = contracts[0]
+      
+      const contract = repository.lookup(testContract.uniqueHash)
+      expect(contract).toBe(testContract)
+    })
+
+    it('should successfully lookup by file path', () => {
+      const artifactPath = path.join(tempDir, 'UniqueContract.json')
+      const contract = repository.lookup(artifactPath)
+      expect(contract).not.toBeNull()
+      expect(contract!.contractName).toBe('UniqueContract')
+    })
+
+    it('should return null for non-existent references', () => {
+      const contract = repository.lookup('NonExistentContract')
+      expect(contract).toBeNull()
+    })
+
+    it('should throw error for ambiguous references', async () => {
+      // Add another contract with the same name
+      const artifact2Content = JSON.stringify({
+        contractName: 'UniqueContract',
+        abi: [],
+        bytecode: '0x608060405234801561001057600080fd5b50222222'
+      })
+      const artifact2Path = path.join(tempDir, 'other', 'UniqueContract.json')
+      await fs.mkdir(path.dirname(artifact2Path), { recursive: true })
+      await fs.writeFile(artifact2Path, artifact2Content)
+
+      // Reload to pick up the new file
+      repository = new ContractRepository()
+      await repository.loadFrom(tempDir)
+
+      expect(() => {
+        repository.lookup('UniqueContract')
+      }).toThrow(/Ambiguous contract reference/)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle directories with no contract files', async () => {
+      const emptyDir = path.join(tempDir, 'empty')
+      await fs.mkdir(emptyDir, { recursive: true })
+
+      await repository.loadFrom(emptyDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(0)
+    })
+
+    it('should ignore invalid JSON files', async () => {
+      const invalidJsonPath = path.join(tempDir, 'invalid.json')
+      await fs.writeFile(invalidJsonPath, 'invalid json content')
+
+      const validArtifactContent = JSON.stringify({
+        contractName: 'ValidContract',
+        abi: [],
+        bytecode: '0x608060405234801561001057600080fd5b50'
+      })
+      const validArtifactPath = path.join(tempDir, 'valid.json')
+      await fs.writeFile(validArtifactPath, validArtifactContent)
+
+      await repository.loadFrom(tempDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(1)
+      expect(contracts[0].contractName).toBe('ValidContract')
+    })
+
+    it('should ignore files that are not artifacts or build-info', async () => {
+      const nonArtifactContent = JSON.stringify({
+        name: 'not an artifact',
+        value: 'some data'
+      })
+      const nonArtifactPath = path.join(tempDir, 'notartifact.json')
+      await fs.writeFile(nonArtifactPath, nonArtifactContent)
+
+      await repository.loadFrom(tempDir)
+
+      const contracts = repository.getAll()
+      expect(contracts).toHaveLength(0)
+    })
+  })
+})