remove old docs

CHALLENGE

-One oracle:
-Implement as a MIPS instruction?
-
-InputOracle -- Preagreed upon inputs (TODO: replace with memory reads from given address range)
-  $a0 = input choice
-    0 -- BlockHash(n)
-    1 -- Transactions(n+1)
-    2 -- Coinbase(n+1)
-    3 -- Uncles(n+1)
-  $a1 = shift amount
-  returns
-  $v0 = inputs[$a0] >> $a1
-
-This has been changed to an MMIO oracle
-hash at 0x30001000 loads len at 0x31000000 and data at 0x31000004
-
-PreimageOracle -- key value store
-  $a0 = dword index in value
-  $t0 = hash[31:0]
-  $t1 = hash[63:32]
-  $t2 = hash[95:64]
-  $t3 = hash[127:96]
-  $t4 = hash[159:128]
-  $t5 = hash[191:160]
-  $t6 = hash[223:192]
-  $t7 = hash[255:224]
-  returns
-  $v0 = preimage[$t7...$t0] >> ($a0 * 32)
-
-Program returns a hash in mem(0x30000800) and exits(jump to 0x5EAD0000) with the hash in the state
-
-Challenge Flow:
-C is challenger, D is defender
-Super nice, the defender barely needs to spend gas!
-
-C: InitiateChallenge(uint blockNumberN, bytes blockHeaderN, bytes blockHeaderNp1,
-                     bytes32 assertionHash, bytes32 finalSystemHash, string[] assertionProof, uint256 stepCount)
-  * checks hashes of the block headers
-  * saves inputs for input oracle
-  * confirms assertionHash != blockHeaderNp1.Hash
-  * confirm assertionProof[0..7] proves the final state of [$t7...$t0] in finalSystemHash is assertionHash
-  * confirm assertionProof[8] proves the final state of $pc in finalSystemHash is 0x5EAD0000
-  * L = 0, R = stepCount   # we agree at L=0, we disagree at R=stepCount
-  * return new challengeId
-  * assertedState[0] = GlobalStartSystemHash + inputOracleMutations
-  * defendedState[0] = GlobalStartSystemHash + inputOracleMutations
-  * assertedState[stepCount] = finalSystemHash
-........
-if it's one step, we are done. considering it's not, we binary search
-........
-C: ProposeState(uint256 challengeId, uint256 riscState)
-  * stepNumber = GetStepNumber(uint256 challengeId) returns floor((L + R) / 2)
-  * assert assertedState[stepNumber] == 0
-  * assertedState[stepNumber] = riscState
-D: RespondState(uint256 challengeId, uint256 riscState) onlyOwner
-  * off-chain: run to step = stepNumber, get state hash, check if it matches
-  * stepNumber = GetStepNumber(uint256 challengeId) returns floor((L + R) / 2)
-  * defendedState[stepNumber] = riscState
-  * if assertedState[stepNumber] == defendedState[stepNumber]:
-      L = stepNumber     # we agree at stepNumber
-    else:
-      R = stepNumber     # we disagree at stepNumber
-    # issue is between [L...R]
-........
-binary search until L+1 == R
-the issue is with the L->R transition
-aka assertedState[L] -> assertedState[R]
-........
-# call this at any time (global), adds them to a preimage lookup for PreimageOracle
-# put these on the MIPS contract
-C: AddPreimage(bytes anything)
-  * preimageLookup[keccak256(anything)] = anything
-C: AddMerkleState(uint256 stateHash, uint32 addr, uint32 value, string proof)
-  * validate proof in assertedState[stepNumber]
-  * riscMemory[stepNumber][address] = value
-
-* Final
-C: ConfirmStateTransition(uint256 challengeId)
-  * assert L+1 == R
-  * do the state transition
-  * if any needed pieces of start state are missing in riscMemory, challenge fails (it can try again)
-  * reconstruct the riscState after transition -> newState 
-  * assert assertedState[R] == newState
-  * pay out bounty
-
-# optional claim for the defender
-# prove the defendedState[L] -> defendedState[R]
-# NOTE, if it's the last step, defendedState[R] might not exist. 
-
-TODO: ensure the state merklization is canonical. if it doesn't match perfectly you can lose
\ No newline at end of file