code: func (h *Handler) Update(ctx context.Context, r *Request) (updateAddr storage.Address, err error) {
  
  	// we can't update anything without a store
  	if h.chunkStore == nil {
  		return nil, NewError(ErrInit, "Call Handler.SetStore() before updating")
  	}
  
  	feedUpdate := h.get(&r.Feed)
  	if feedUpdate != nil && feedUpdate.Epoch.Equals(r.Epoch) { // This is the only cheap check we can do for sure
  		return nil, NewError(ErrInvalidValue, "A former update in this epoch is already known to exist")
  	}
  
  	chunk, err := r.toChunk() // Serialize the update into a chunk. Fails if data is too big
  	if err != nil {
  		return nil, err
  	}
  
  	// send the chunk
  	h.chunkStore.Put(ctx, chunk)
  	log.Trace("feed update", "updateAddr", r.idAddr, "epoch time", r.Epoch.Time, "epoch level", r.Epoch.Level, "data", chunk.Data())
  	// update our feed updates map cache entry if the new update is older than the one we have, if we have it.
  	if feedUpdate != nil && r.Epoch.After(feedUpdate.Epoch) {
  		feedUpdate.Epoch = r.Epoch
  		feedUpdate.data = make([]byte, len(r.data))
  		feedUpdate.lastKey = r.idAddr
  		copy(feedUpdate.data, r.data)
  		feedUpdate.Reader = bytes.NewReader(feedUpdate.data)
  	}
  
  	return r.idAddr, nil
  }
docs: // Update publishes a feed update
  // Note that a feed update cannot span chunks, and thus has a MAX NET LENGTH 4096, INCLUDING update header data and signature.
  // This results in a max payload of `maxUpdateDataLength` (check update.go for more details)
  // An error will be returned if the total length of the chunk payload will exceed this limit.
  // Update can only check if the caller is trying to overwrite the very last known version, otherwise it just puts the update
  // on the network.