Error when contract start block is less than network's (#670)

* Remove old dockerfiles

* Clean up FetchState.make API

* Add an error that start_block for contract should be higher than for network

Author: DZakh

.github/Dockerfile

@@ -966,9 +966,7 @@ let make = (
   ~startBlock,
   ~endBlock,
   ~eventConfigs: array<Internal.eventConfig>,
-  ~staticContracts: dict<array<Address.t>>,
-  ~staticContractStartBlocks: dict<option<int>>=Js.Dict.empty(),
-  ~dynamicContracts: array<indexingContract>,
+  ~contracts: array<indexingContract>,
   ~maxAddrInPartition,
   ~chainId,
   ~blockLag=?,
@@ -1042,52 +1040,21 @@ let make = (
 
       let pendingNormalPartition = ref(makePendingNormalPartition())
 
-      let registerAddress = (contractName, address, ~dc: option<indexingContract>=?) => {
-        let pendingPartition = pendingNormalPartition.contents
-        switch pendingPartition.addressesByContractName->Utils.Dict.dangerouslyGetNonOption(
-          contractName,
-        ) {
-        | Some(addresses) => addresses->Array.push(address)
-        | None => pendingPartition.addressesByContractName->Js.Dict.set(contractName, [address])
-        }
-        indexingContracts->Js.Dict.set(
-          address->Address.toString,
-          switch dc {
-          | Some(dc) => dc
-          | None => {
-              address,
-              contractName,
-              startBlock: switch staticContractStartBlocks->Js.Dict.get(contractName) {
-              | Some(Some(contractStartBlock)) => contractStartBlock
-              | Some(None) | None => startBlock
-              },
-              register: Config,
-            }
-          },
-        )
-        if (
-          pendingPartition.addressesByContractName->addressesByContractNameCount ===
-            maxAddrInPartition
-        ) {
-          partitions->Array.push(pendingPartition)
-          pendingNormalPartition := makePendingNormalPartition()
-        }
-      }
-
-      staticContracts
-      ->Js.Dict.entries
-      ->Array.forEach(((contractName, addresses)) => {
-        if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          addresses->Array.forEach(a => {
-            registerAddress(contractName, a)
-          })
-        }
-      })
-
-      dynamicContracts->Array.forEach(dc => {
-        let contractName = dc.contractName
+      contracts->Array.forEach(contract => {
+        let contractName = contract.contractName
         if contractNamesWithNormalEvents->Utils.Set.has(contractName) {
-          registerAddress(contractName, dc.address, ~dc)
+          let pendingPartition = pendingNormalPartition.contents
+          pendingPartition.addressesByContractName->Utils.Dict.push(contractName, contract.address)
+          indexingContracts->Js.Dict.set(contract.address->Address.toString, contract)
+          if (
+            pendingPartition.addressesByContractName->addressesByContractNameCount ===
+              maxAddrInPartition
+          ) {
+            // FIXME: should split into separate partitions
+            // depending on the start block
+            partitions->Array.push(pendingPartition)
+            pendingNormalPartition := makePendingNormalPartition()
+          }
         }
       })
 

.github/Dockerfile.typescript

@@ -51,8 +51,7 @@ let make = (
   let eventRouter = EventRouter.empty()
 
   // Aggregate events we want to fetch
-  let staticContracts = Js.Dict.empty()
-  let staticContractStartBlocks = Js.Dict.empty()
+  let contracts = []
   let eventConfigs: array<Internal.eventConfig> = []
 
   chainConfig.contracts->Array.forEach(contract => {
@@ -91,15 +90,29 @@ let make = (
       }
     })
 
-    staticContracts->Js.Dict.set(contractName, contract.addresses)
-    staticContractStartBlocks->Js.Dict.set(contractName, contract.startBlock)
+    switch contract.startBlock {
+    | Some(startBlock) if startBlock < chainConfig.startBlock =>
+      Js.Exn.raiseError(
+        `The start block for contract "${contractName}" is less than the chain start block. This is not supported yet.`,
+      )
+    | _ => ()
+    }
+
+    contract.addresses->Array.forEach(address => {
+      contracts->Array.push({
+        FetchState.address,
+        contractName: contract.name,
+        startBlock: switch contract.startBlock {
+        | Some(startBlock) => startBlock
+        | None => chainConfig.startBlock
+        },
+        register: Config,
+      })
+    })
   })
 
-  let fetchState = FetchState.make(
-    ~maxAddrInPartition,
-    ~staticContracts,
-    ~staticContractStartBlocks,
-    ~dynamicContracts=dynamicContracts->Array.map(dc => {
+  dynamicContracts->Array.forEach(dc =>
+    contracts->Array.push({
       FetchState.address: dc.contractAddress,
       contractName: (dc.contractType :> string),
       startBlock: dc.registeringEventBlockNumber,
@@ -110,7 +123,12 @@ let make = (
         registeringEventName: dc.registeringEventName,
         registeringEventSrcAddress: dc.registeringEventSrcAddress,
       }),
-    }),
+    })
+  )
+
+  let fetchState = FetchState.make(
+    ~maxAddrInPartition,
+    ~contracts,
     ~startBlock,
     ~endBlock,
     ~eventConfigs,
@@ -314,7 +332,11 @@ let cleanUpProcessingFilters = (
 /**
  * Helper function to get the configured start block for a contract from config
  */
-let getContractStartBlock = (config: Config.t, ~chain: ChainMap.Chain.t, ~contractName: string): option<int> => {
+let getContractStartBlock = (
+  config: Config.t,
+  ~chain: ChainMap.Chain.t,
+  ~contractName: string,
+): option<int> => {
   let chainConfig = config.chainMap->ChainMap.get(chain)
   chainConfig.contracts
   ->Js.Array2.find(contract => contract.name === contractName)
@@ -338,7 +360,11 @@ let runContractRegistersOrThrow = async (
       let {timestamp, blockNumber, logIndex} = eventItem
 
       // Use contract-specific start block if configured, otherwise fall back to registration block
-      let contractStartBlock = switch getContractStartBlock(config, ~chain=eventItem.chain, ~contractName=(contractName: Enums.ContractType.t :> string)) {
+      let contractStartBlock = switch getContractStartBlock(
+        config,
+        ~chain=eventItem.chain,
+        ~contractName=(contractName: Enums.ContractType.t :> string),
+      ) {
       | Some(configuredStartBlock) => configuredStartBlock
       | None => blockNumber
       }
@@ -374,7 +400,9 @@ let runContractRegistersOrThrow = async (
 
     // Catch sync and async errors
     try {
-      let result = contractRegister(eventItem->UserContext.getContractRegisterArgs(~onRegister, ~config))
+      let result = contractRegister(
+        eventItem->UserContext.getContractRegisterArgs(~onRegister, ~config),
+      )
 
       // Even though `contractRegister` always returns a promise,
       // in the ReScript type, but it might return a non-promise value for TS API.

codegenerator/cli/npm/envio/src/FetchState.res

@@ -27,9 +27,8 @@ let populateChainQueuesWithRandomEvents = (~runTime=1000, ~maxBlockTime=15, ())
     let fetcherStateInit: FetchState.t = FetchState.make(
       ~maxAddrInPartition=Env.maxAddrInPartition,
       ~endBlock=None,
-      ~staticContracts=Js.Dict.empty(),
       ~eventConfigs,
-      ~dynamicContracts=[],
+      ~contracts=[],
       ~startBlock=0,
       ~chainId=0,
     )