The critical code

Block operations on tyhe protected array.

These moves on the linear array, blind, no regard for block counts.  When graph operators foul the block  counts, there is partial recovery, but when the block array gets fouled by this code,a day, an hour a week of a generation of trades are lost.  This is what the microprocessor and the interpreter have to protect, subject to verification over the net.


#Node operations know about block counts
# this code does not, except on initialization
class garray:
 def __init__(self,r): # upper is the enclosing block
  self.top = r 
  self.top.count = 1
  self.g =[]
  self.g.append(r)
  # Move a block up the array
 def MOVE(self,dest,src,num) :
  h=[] # grab some temporary storage
  h[0:num] = self.g[src:src+num] # copy the source segment
  self.g[src:src+num] = self.g[dest:dest+num] #move list down
  self.g[dest:dest+num]=h[0:num] # replace
 def DELETE(self,i,num) : pass

 def APPEND(self,n) :
  self.g.append(n)
 def GET(self,i) :
  return(self.g[i])

 The big question, does the block structure ever get fouled?

The graph operators get jammed to a halt, during what we might call big black swan events. Things that are unmeasurabe since they have no real past and block chains are, ultimately, finite. When the terrorists blow up city hall in LA, the  secure digits are stuck where they for for a while.  But gold shipments get stuck worse, so what can I say?