From a73b68e4d114b3e427d790dd46ea8f4560684dbc Mon Sep 17 00:00:00 2001
From: jbenet <juan@benet.ai>
Date: Thu, 17 Oct 2019 03:21:27 -0700
Subject: [PATCH 01/16] mining: renamed sector_state fsm

---
 src/systems/filecoin_mining/storage_mining/_index.md          | 2 +-
 .../diagrams/{sector_state.dot => sector_state_fsm.dot}       | 4 +++-
 .../{sector_state.dot.svg => sector_state_fsm.dot.svg}        | 0
 3 files changed, 4 insertions(+), 2 deletions(-)
 rename src/systems/filecoin_mining/storage_mining/diagrams/{sector_state.dot => sector_state_fsm.dot} (95%)
 rename src/systems/filecoin_mining/storage_mining/diagrams/{sector_state.dot.svg => sector_state_fsm.dot.svg} (100%)

diff --git a/src/systems/filecoin_mining/storage_mining/_index.md b/src/systems/filecoin_mining/storage_mining/_index.md
index 5729403c0..d938b9c35 100644
--- a/src/systems/filecoin_mining/storage_mining/_index.md
+++ b/src/systems/filecoin_mining/storage_mining/_index.md
@@ -19,7 +19,7 @@ Filecoin Storage Mining Subsystem
 
 # Sector in StorageMiner State Machine (new one)
 
-{{< diagram src="diagrams/sector_state.dot.svg" title="Sector State (new one)" >}}
+{{< diagram src="diagrams/sector_state_fsm.dot.svg" title="Sector State (new one)" >}}
 
 {{< diagram src="diagrams/sector_state_legend.dot.svg" title="Sector State Legend (new one)" >}}
 
diff --git a/src/systems/filecoin_mining/storage_mining/diagrams/sector_state.dot b/src/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot
similarity index 95%
rename from src/systems/filecoin_mining/storage_mining/diagrams/sector_state.dot
rename to src/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot
index 94d8b9de7..6797c0a3c 100644
--- a/src/systems/filecoin_mining/storage_mining/diagrams/sector_state.dot
+++ b/src/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot
@@ -5,7 +5,9 @@ digraph sectoRecovering {
   nodesep=2
   node [shape=circle width=1.2 fixedsize=true]
   edge [penwidth=2]
-  Cleared
+
+  Cleared [shape=doublecircle] // doublecircle because it is the init state
+
   subgraph cluster_0 {
       label="Proving Set"
       style=filled
diff --git a/src/systems/filecoin_mining/storage_mining/diagrams/sector_state.dot.svg b/src/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg
similarity index 100%
rename from src/systems/filecoin_mining/storage_mining/diagrams/sector_state.dot.svg
rename to src/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg

From 49364dfacecd1b2b9a46086ad85dddd49b947dd1 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Mon, 7 Oct 2019 23:34:54 +0200
Subject: [PATCH 02/16] updated ec and weight fn

---
 src/algorithms/expected_consensus.md          | 123 +++++++++++++-----
 .../filcrypto/filecoin_crypto_lib.id          |  15 ---
 .../storage_power_consensus_subsystem.id      |   8 +-
 .../filecoin_blockchain/struct/block/block.id |   5 +-
 .../filecoin_blockchain/struct/block/other.id |  13 +-
 .../struct/block/tipset.id                    |   2 +-
 .../filecoin_blockchain/struct/chain/chain.id |   3 +-
 7 files changed, 101 insertions(+), 68 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index e67cdb42b..dbe1c1437 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -2,6 +2,8 @@
 title: "Expected Consensus"
 ---
 
+TODO: move pseudocode to id files entirely
+
 {{<label expected_consensus>}}
 ## Algorithm
 
@@ -159,6 +161,24 @@ We use the ECVRF algorithm from [Goldberg et al. Section 5](https://tools.ietf.o
   - Secp256k1 for our curve
   - Note that the operation type in step 2.1 is necessary to prevent an adversary from guessing an election proof for a miner ahead of time.
 
+They are crafted as follows:
+
+Input: parentTickets at round N-1, miner's private key SK
+Output: newTicket
+
+```
+0. Prepare new ticket
+    i. newTicket <-- New()
+1. Draw prior ticket
+    i. priorTicket <-- chain.TicketAtEpoch(N-1)
+2. Run it through VRF and get determinstic output
+    i. # take the VRFResult of that ticket as input, specifying the personalization (see data-structures)
+            input <-- VRFPersonalization.Ticket | priorTicket.Output
+    ii. # run it through the VRF and store the output in the new ticket
+            newTicket.vrfResult <-- self.VRFKeyPair.Generate(input)
+4. Return the new ticket
+```
+
 ### Ticket Validation
 
 For ticket generation, see [ticket generation](expected-consensus.md#ticket-generation).
@@ -181,19 +201,12 @@ For each ticket, idx: tickets
         else:
             parent = tickets[idx - 1]
     ii. # generate the VRFInput
-        input <-- VRFPersonalization.Ticket | parent.VDFOutput
+        input <-- VRFPersonalization.Ticket | parent.Output
     iii. # verify the VRF
-        VRFState <-- ECVRF_Verify(PK, ticket.VRFProof, input)
-        if VRFState == "INVALID":
-            return 0
-2. Verify its VDF Proof
-    i. # generate the VDF input
-        VRFOutput <-- ECVRF_proof_to_hash(ticket.VRFProof)
-    ii. # verify
-        VDFState <-- VDF_verify(vk, VRFOutput, ticket.VDFOutput, ticket.VDFProof)
-        if VDFState == "NO":
+        VRFState <-- ticket.VrfResult.Verify(input, PK)
+        if VRFState == false:
             return 0
-3. Return results
+2. Return results
     return 1
 ```
 
@@ -220,6 +233,51 @@ If the miner scratches a winning ticket in this round, it can use newEP, along w
 
 It is important to note that every block contains two artifacts: one, a ticket derived from last block's ticket to prove that they have waited the appropriate delay, and two, an election proof derived from the ticket `K` rounds back used to run leader election.
 
+Succinctly, the process of crafting a new ElectionProof in round N is as follows. We use:
+
+    The ECVRF algorithm (must yield a pseudorandom, deterministic output) from Goldberg et al. Section 5, with:
+        Sha256 for our hashing function
+        Secp256k1 for our curve
+
+Note: We draw the miner power from the prior round. This means that if a miner wins a block on their ProvingPeriodEnd even if they have not yet resubmitted a PoSt, they retain their power (until the next round).
+
+At round N:
+
+```
+Input: parentTickets from N-K, miner's public key PK, miner's secret key SK, the Storage Power actor S
+Output: 1 or 0
+
+0. Prepare new election proof
+    i. newEP <-- New()
+1. Draw parentTicket from K blocks back
+    i. electionSeed <-- chain.TicketAtEpoch(N-K)
+2. Run it through VRF and get determinstic output
+    i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
+        input <-- VRFPersonalization.ElectionProof | parentTicket.Output
+    ii. # run it through the VRF and store the VRFProof in the new ticket
+        newEP.VrfResult <-- self.VRFKeyPair.Generate(input)
+3. Determine the miner's power fraction
+    i. # Determine total storage this round
+        S <-- storageMarket(N)
+        p_n <-- S.GetTotalPower()
+    ii. # Determine own power at prior tipSet
+        p_m <-- LookupMinerPower(self.addr)
+    iii. # Get power fraction
+		p_f <-- p_m/p_n
+4. Determine if the miner drew a winning lottery ticket
+    # Conceptually we are mapping the pseudorandom, deterministic VRFOutput onto [0,1] by dividing by 2^HashLen (64 Bytes using Sha256) and comparing that to the miner's power (portion of network storage).
+    # In practice, we actually multiply the power fraction by 2^HashLen for comparison with the ticket value in order to avoid dealing with floats.
+    i.  # Map the miner's power onto [0, 2^HashLen] (64 Bytes using sha256)
+        normalized_power <-- p_f * 2^HashLen
+    ii. # Compare the miner's power fraction to the value of the ticket drawn: more power means win more often.
+        # winning ticket
+        if readLittleEndian(VRFOutput) <= normalized_power
+            return newEP
+        # otherwise parentTicket is not a winning lottery ticket
+        else
+            Return 0
+```
+
 ### Election Validation
 
 For election proof generation, see [checking election results](expected-consensus.md#checking-election-results).
@@ -229,43 +287,32 @@ In order to determine that the mined block was generated by an eligible miner, o
 Succinctly, the process of verifying a block's election proof at round N, is as follows.
 
 ```text
-Input: received block, storage market actor S, miner's public key PK, a public parameter K
+Input: received block, storage power actor S, miner's public key PK, a public parameter K
 Output: 0, 1
 
 0. Get the election proof, total power, miner power
         i. electionProof <-- block.electionProof
         ii. # get total market power
             S <-- storageMarket(N)
-            p_n <-- S.GetTotalStorage()
+            p_n <-- S.GetTotalPower()
         iii. # get miner power
-            p_m <-- GetMinersPowerAt(N, PK)
-1. Ensure the miner was not slashed or late: in that case, their power would be 0 and can just abort.
-        i. # Check for a reported fault or late submission
-            if p_m == 0
-                return 0
-2. Determine the miner's power fraction
-        i. # Get power fraction
+            p_m <-- LookupMinerPower(miner.addr)
+        iv. # Get power fraction
               p_f <-- p_m/p_n
-3. Ensure that the scratched ticket is a winner
-        i. # get the deterministic output from the election proof
-            VRFOutput <-- ECVRF_proof_to_hash(electionProof.VRFProof)
-        ii. # map p_f onto [0, 2^HashLen]
-            normalized_power <-- p_f * 2^HashLen
-          iii. # Compare the miner's scratchValue to the miner's normalized power fraction
-              if readLittleEndian(VRFOutput) > normalized_power:
-                return 0
 4. Get the appropriate ticket from the ticket chain
         i. # Get the tipset K rounds back
-            appropriateTipset <-- lookback(K)
-        ii. # Take its min ticket (already validated)
-            scratchedTicket <-- appropriateTipset.minTicket()
+            ticket <-- chain.TicketAtEpoch(N-K)
 5. Verify Election Proof validity
         i. # generate the VRFInput from the scratched ticket
             input <-- VRFPersonalization.ElectionProof | scratchedTicket.VDFOutput
         ii. # Check that the election proof was correctly generated by the miner
             # using the appropriate ticket
-            VRFState <-- ECVRF_Verify(miner.PK, electionProof.VRFProof, input)
-            if VRFState == "INVALID":
+            VRFState <-- electionProof.Verify(input, miner.PK)
+            if VRFState == false:
+                return 0
+        iii. Ensure that the scratched ticket is a winner
+            # internally -> map p_f onto [0, 2^HashLen] and compare the miner's scratchValue to the miner's normalized power fraction
+            if electionProof.IsWinning(p_f) == false:
                 return 0
 5. Everything checks out, it's a valid election proof
         return 1
@@ -292,10 +339,16 @@ w[r+1] = w[r] + floor(1000 * (wForkFactor(wPowerFactor[r+1] + wBlocksFactor[r+1]
 
 with, for a given tipset ts in round r+1:
 
-- wBlocksFactor[r+1] = v * |blocksInTipset(ts)|
+- wBlocksFactor[r+1] = v * |blocksInTipset(ts)| = v * k
   - with v = vt * log2(totalPowerAtTipset(ts) * vs)/vs
 - wPowerFactor[r+1]  = log2(totalPowerAtTipset(ts))
-- wForkFactor[r+1]   = CDF(X, k) with X -> Bin(eNumberOfBlocksPerRound * numberOfMinersInPowerTable, 1/numberOfMinersInPowerTable)
+Take X -> Bin(eNumberOfBlocksPerRound * numberOfMinersInPowerTable, 1/numberOfMinersInPowerTable), for simplicity, we take:
+X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
+- wForkFactor[r+1]   = 1 if |blocksInTipset(ts)| > E[X] - 2*stdDev[X], CDF(X, |blocksInTipset(ts)) otherwise.
+
+with:
+    - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
+    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000*eNumberOfBlocksPerRound choose i) (1/10,000)^i (9,999/10,000)^(eNumberOfBlocksPerRound - i))
 
 The weight should be calculated using big integer arithmetic with order of operations defined above. The multiplication by 1,000 and flooring is meant to help generate uniform weights across implementations.
 
diff --git a/src/libraries/filcrypto/filecoin_crypto_lib.id b/src/libraries/filcrypto/filecoin_crypto_lib.id
index 1b5dc8f6a..428842837 100644
--- a/src/libraries/filcrypto/filecoin_crypto_lib.id
+++ b/src/libraries/filcrypto/filecoin_crypto_lib.id
@@ -20,21 +20,6 @@ type VRFResult struct {
     ValidateSyntax() bool
 }
 
-type VDF struct {
-    evalKey            Bytes      @(internal)
-    VerifKey           Bytes      @(internal)
-
-    Eval(input Bytes)  VDFResult  @(static)
-}
-
-type VDFResult struct {
-    Output  Bytes  @(internal)
-    Proof   Bytes  @(internal)
-
-    Verify(input Bytes) bool @(static)
-    ValidateSyntax() bool
-}
-
 type SigKeyPair struct {
     PublicKey  SigPublicKey
     SecretKey  SigSecretKey
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
index 0f1c4a667..4228cb6cb 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
@@ -37,10 +37,10 @@ type StoragePowerConsensusSubsystem struct {//(@mutable)
 
 type PowerTable struct {
     // all power here is always verified
-    minerPower {addr.Address: StorageMiner}
-    LookupMinerStorage(a addr.Address) UVarint
-    LookupMinerPowerFraction(a addr.Address) block.PowerFraction
-    RemovePower(a addr.Address)
+    minerPower {base.Address: StorageMiner}
+    LookupMinerPower(addr base.Address) UVarint
+    GetTotalPower() UVarint
+    RemovePower(addr base.Address)
 }
 
 type StorageMiner struct {
diff --git a/src/systems/filecoin_blockchain/struct/block/block.id b/src/systems/filecoin_blockchain/struct/block/block.id
index f815c4a95..ffa798130 100644
--- a/src/systems/filecoin_blockchain/struct/block/block.id
+++ b/src/systems/filecoin_blockchain/struct/block/block.id
@@ -29,8 +29,8 @@ type BlockHeader struct {
 
     // Consensus things
     Timestamp        clock.Time
-    Tickets          [Ticket]
-    ElectionProof
+    Ticket           Ticket
+    ElectionProof    ElectionProof
 
     // Signatures
     BlockSig         filcrypto.Signature
@@ -40,7 +40,6 @@ type BlockHeader struct {
     //	ComputeUnsignedFingerprint() []
 
     ValidateTickets(pubKey filcrypto.PubKey) bool
-    ExtractElectionSeed() ElectionSeed
 }
 
 // TODO: remove this. header is signed
diff --git a/src/systems/filecoin_blockchain/struct/block/other.id b/src/systems/filecoin_blockchain/struct/block/other.id
index 81b527a54..4a0a46200 100644
--- a/src/systems/filecoin_blockchain/struct/block/other.id
+++ b/src/systems/filecoin_blockchain/struct/block/other.id
@@ -3,12 +3,11 @@ import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 // TODO: move all this stuff elsewhere. a consensus lib?
 
 type Ticket struct {
-    vrfResult         filcrypto.VRFResult
-    vdfResult         filcrypto.VDFResult
+    VrfResult         filcrypto.VRFResult
 
-    // Generate(k VRFKeyPair, seed ElectionSeed) Ticket
+    Output            Bytes     @(cached)
     ValidateSyntax()  bool
-    Validate()        bool
+    Verify(input Bytes, pk VRFPublicKey) bool
 }
 
 type StoragePower UVarint
@@ -16,14 +15,10 @@ type PowerFraction Float
 
 type ElectionSeed filcrypto.VDFResult
 
-type ElectionArtifacts struct {
-    TK Ticket
-    T1 Ticket
-}
-
 type ElectionProof struct {
     vrfResult filcrypto.VRFResult
     IsWinning(minerPower PowerFraction) bool @(cached)
+    Verify(input Bytes, pk VRFPublicKey) bool
 
     ValidateSyntax() bool
     Verify(seed ElectionSeed, minerPK filcrypto.PubKey) bool
diff --git a/src/systems/filecoin_blockchain/struct/block/tipset.id b/src/systems/filecoin_blockchain/struct/block/tipset.id
index a8a985107..762f49256 100644
--- a/src/systems/filecoin_blockchain/struct/block/tipset.id
+++ b/src/systems/filecoin_blockchain/struct/block/tipset.id
@@ -13,4 +13,4 @@ type Tipset struct {
 
     ValidateSyntax()   bool           @(cached)
     LatestTimestamp()  clock.Time     @(cached)
-}
+}
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/struct/chain/chain.id b/src/systems/filecoin_blockchain/struct/chain/chain.id
index b836eae31..a7dff1b8f 100644
--- a/src/systems/filecoin_blockchain/struct/chain/chain.id
+++ b/src/systems/filecoin_blockchain/struct/chain/chain.id
@@ -8,4 +8,5 @@ type Chain struct {
     LatestCheckpoint()  block.ChainEpoch
 
     TipsetAtEpoch(epoch block.ChainEpoch) block.Tipset
-}
+    TicketAtEpoch(epoch Epoch)  Ticket
+}
\ No newline at end of file

From 06e880e96cc88a045e1ba84c3a8d9b3ae192aa02 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Tue, 8 Oct 2019 00:36:49 +0200
Subject: [PATCH 03/16] nonces insteead of ticket array

---
 src/algorithms/expected_consensus.md          | 114 ++++++------------
 src/listings/data_structures.md               |  18 +--
 .../storage_power_consensus/_index.md         |  10 +-
 .../filecoin_blockchain/struct/block/other.id |   2 +-
 4 files changed, 52 insertions(+), 92 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index dbe1c1437..3bf637008 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -2,13 +2,13 @@
 title: "Expected Consensus"
 ---
 
-TODO: move pseudocode to id files entirely
-
 {{<label expected_consensus>}}
 ## Algorithm
 
 Expected Consensus (EC) is a probabilistic Byzantine fault-tolerant consensus protocol. At a high level, it operates by running a leader election every round in which, on expectation, one participant may be eligible to submit a block. EC guarantees that this winner will be anonymous until they reveal themselves by submitting a proof of their election (we call this proof an `Election Proof`). All valid blocks submitted in a given round form a `Tipset`. Every block in a Tipset adds weight to its chain. The 'best' chain is the one with the highest weight, which is to say that the fork choice rule is to choose the heaviest known chain. For more details on how to select the heaviest chain, see {{<sref chain_selection>}}.
 
+At a very high level, with every new block generated, a miner will craft a new ticket from the prior one in the chain. While on expectation at least one block will be generated at every round, in cases where no one finds a block in a given round, a miner may increment a given nonce as part of the input with which they attempt to run leader election in order to ensure liveness in the protocol. These nonces help mark block height. Every block in a given Tipset will contain election proofs with the same nonce (i.e. they are mined at the same height).
+
 The {{<sref storage_power_consensus>}} subsystem uses access to EC to use the following facilities:
 - Access to verifiable randomness for the protocol, derived from {{<sref tickets>}}.
 - Running and verifying {{<sref leader_election "leader election">}} for block generation.
@@ -36,7 +36,7 @@ Whenever comparing tickets is evoked in Filecoin, for instance when discussing s
 
 ### The Ticket chain
 
-While each Filecoin block header contains a ticket array, it is useful to provide nodes with a ticket chain abstraction.
+While each Filecoin block header contains a ticket field, it is useful to provide nodes with a ticket chain abstraction.
 
 Namely, tickets are used throughout the Filecoin system as sources of on-chain randomness. For instance,
 - They are drawn by Storage Miners as SealSeeds to commit new sectors
@@ -48,49 +48,15 @@ Each of these ticket uses may require drawing tickets at different chain heights
 
 This ticket chain will track one-to-one with a block at each height in a given subchain, but omits certain details including other blocks mined at that height.
 
-Simply, it is composed inductively as follows:
+Simply, it is composed inductively as follows. For a given chain:
 
 - At height 0, take the genesis block, return its ticket
-- At height n+1, take the block used at height n.
-  - If the ticket it returned in the previous step is not the final ticket in its ticket array, return the next one.
-  - If the ticket it returned in the previous step is the final ticket in its ticket array,
-    - use EC to select the next heaviest tipset in the subchain.
-    - select the block in that tipset with the smallest final ticket, return its first ticket
-
-We illustrate this below:
-```
-                     ┌────────────────────────────────────────────────────────────────────────────────────┐
-                      │                                                                                    │
-                      ▼                                  ◀─────────────────────────────────────────────────┼────────────────────────────────────────────┐
-          ┌─┐        ┌─┐        ┌─┐        ┌─┐          ┌─┐                                       ┌─┐      │    ┌─┐         ┌─┐         ┌─┐           ┌─┤
-   ◀──────│T1◀───────│T2◀───────│T3◀───────│T4◀─────────│T5◀───────────────    ...    ◀───────────T1+k─────┼───T2+k◀────────T3+k────────T4+k──────────T5│k
-          └─┘        └─┘        └─┘        └─┘          └─┘                                       └─┘      │    └─┘         └─┘         └─┘           └─┤
-                                 ▲                       │                                                 │                 │           │             ││
-           │          │          │          │                                                      │       │     │                                      │
-                                 ├───────────────────────┼─────────────────────────────────────────────────┼─────────────────┼────┐      │             ││
-           │          │                     │                                                      │       │     │                │                     │
-                       ─ ─ ─ ─ ─ ┴ ─   ─ ─ ─             ┘                                            ─ ─ ─│─ ─ ─          ─ ┘    │      └ ─ ─ ─   ─ ─ ┘│
-        ┌──┼──────┬─┬┐         ┌──┼─┼─┼──┬─┬┐        ┌──┼──────┬─┬┐                             ┌──┼─┼────┬─┬┐         ┌──┼──────┬─┬┐        ┌──┼─┼────┬─┬┐
-        │         │E1│         │         │E2│        │         │E3│                             │         E1+l         │         E2+l        │         E3+l
-        │  │      └─┘│         │  │ │ │  └─┘│        │  │      └─┘│                             │  │ │    └─┘│         │  │      └─┘│        │  │ │    └─┘│
-        │            │         │            │        │            │                             │            │         │            │        │            │
- ◀──────│  ▼         │◀────────│  ▼ ▼ ▼     │◀───────│  ▼         │◀──────     ...     ◀────────│  ▼ ▼       │◀────────│  ▼         │◀───────│  ▼ ▼       │
-        │ ┌─┐        │         │ ┌─┬─┬─┐    │        │ ┌─┐        │                             │ ┌─┬─┐      │         │ ┌─┐        │        │ ┌─┬─┐      │
-        │ │T1     B1 │         │ │T2 │ │ B2 │        │ │T5     B3 │                             │ │ │ │  B1+l│         │ │ │    B2+l│        │ │ │ │  B3+l│
-        └─┴─┴────────┘         └─┴─┴─┴─┴────┘        └─┴─┴────────┘                             └─┴─┴─┴──────┘         └─┴─┴────────┘        └─┴─┴─┴──────┘
-```
-
-
-
-The above represents an instance of a block-chain, and its associated ticket-chain. The details of how it works should be clear by the end of this section, but quickly, some observations:
-
-- Block 1 contains a single ticket T1
-- Block 2 contains 3 tickets T2, T3, T4 meaning it was likely generated after 2 failed leader election attempts in the network.
-- Block B1+l has two tickets and an Election Proof E1+l that was generated using T2. This means B1+l's miner tried to generate an election proof using T1 and failed, succeeding on their second attempt with T2.
+- At height n+1, take the heaviest tipset in our chain at height n.
+    - select the block in that tipset with the smallest final ticket, return its ticket
 
 ## Tickets in EC
 
-Within EC, a miner generates a new ticket in their block for every ticket they use (or "scratch") running leader election, thereby ensuring the ticket chain is always at least as long as the block chain.
+Within EC, a miner generates a new ticket in their block for every ticket they use (or "scratch") running leader election, thereby ensuring the ticket chain is always as long as the block chain.
 
 Tickets are used to achieve the following:
 - Ensure leader secrecy -- meaning a block producer will not be known until they release their block to the network.
@@ -99,10 +65,8 @@ Tickets are used to achieve the following:
 
 In practice, EC defines two different fields within a block:
 
-- A `Tickets` array — this stores new tickets generated during this block generation attempt. It proves appropriate delay. It is from this array that miners will sample randomness to run leader election in `K` rounds. See [Ticket generation](#ticket-generation).
-- An `ElectionProof` — this stores a proof that a given miner scratched a winning lottery ticket using the appropriate ticket `K` rounds back. It proves that the leader was elected in this round. See [Checking election results](#checking-election-results).
-
-On expectation, the `Tickets` array will contain a single ticket. For cases in which it contains more than one, see [Losing Tickets](#losing-tickets).
+- A `Ticket` field — this stores the new ticket generated during this block generation attempt. It is from this ticket that miners will sample randomness to run leader election in `K` rounds.
+- An `ElectionProof` — this stores a proof that a given miner scratched a winning lottery ticket using the appropriate ticket `K` rounds back along with a nonce showing how many rounds generating the EP took. It proves that the leader was elected in this round.
 
 ```
 But why the randomness lookback?
@@ -123,9 +87,9 @@ more space on-chain.
 
 ### Ticket generation
 
-This section discusses how tickets are generated by EC for the `Tickets` array. For how tickets are validated, see [ticket validation](mining.md#ticket-validation).
+This section discusses how tickets are generated by EC for the `Ticket` field.
 
-At round `N`, new tickets are generated using tickets drawn from the [Tipset](#tipsets) at round `N-1`. This ensures the miner cannot publish a new block (corresponding to the `ElectionProof` generated by a winning ticket `K` rounds back) until the correct round. Because a Tipset can contain multiple blocks (see [Chain Selection](#chain-selection) below), the smallest ticket in the Tipset must be drawn otherwise the block will be invalid.
+At round `N`, a new ticket is generated using tickets drawn from the Tipset at round `N-1`. Because a Tipset can contain multiple blocks (see [Chain Selection](#chain-selection) below), the smallest ticket in the Tipset must be drawn otherwise the block will be invalid.
 
 ```
    ┌──────────────────────┐                     
@@ -181,25 +145,18 @@ Output: newTicket
 
 ### Ticket Validation
 
-For ticket generation, see [ticket generation](expected-consensus.md#ticket-generation).
-
-A ticket can be verified to have been generated in the appropriate number of rounds by looking at the `Tickets` array, and ensuring that each subsequent ticket (leading to the final ticket in that array) was generated using the previous one in the array (or in the prior block if the array is empty). Note that this has implications on block size, and client memory requirements, though on expectation, the `Tickets` array should only contain one Ticket. Put another way, each Ticket should be generated from the prior one in the ticket-chain.
+Each Ticket should be generated from the prior one in the ticket-chain.
 
 Succinctly, the process of verifying a block's tickets is as follows.
 ```text
 Input: received block, storage market actor S, miner's public key PK, a public VDF validation key vk
 Output: 0, 1
 
-0. Get the tickets
-    i. tickets <-- block.tickets
-For each ticket, idx: tickets
+0. Get the ticket
+    i. ticket <-- block.ticket
 1. Verify its VRF Proof
     i. # get the appropriate parent
-        if idx == 0:
-            # the first was derived from the prior block's last ticket
-            parent = parentBlock.lastTicket
-        else:
-            parent = tickets[idx - 1]
+        parent = chain.TicketAtEpoch(N-1)
     ii. # generate the VRFInput
         input <-- VRFPersonalization.Ticket | parent.Output
     iii. # verify the VRF
@@ -210,8 +167,6 @@ For each ticket, idx: tickets
     return 1
 ```
 
-Notice that there is an implicit check that all tickets in the `Tickets` array are signed by the same miner.
-
 {{<label leader_election>}}
 ## Secret Leader Election
 
@@ -244,18 +199,19 @@ Note: We draw the miner power from the prior round. This means that if a miner w
 At round N:
 
 ```
-Input: parentTickets from N-K, miner's public key PK, miner's secret key SK, the Storage Power actor S
+Input: electionSeed from N-K, miner's public key PK, miner's secret key SK, the Storage Power actor S, a Nonce nonce starting with value 0
 Output: 1 or 0
 
 0. Prepare new election proof
     i. newEP <-- New()
-1. Draw parentTicket from K blocks back
+1. Draw electionSeed from K blocks back
     i. electionSeed <-- chain.TicketAtEpoch(N-K)
 2. Run it through VRF and get determinstic output
     i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
-        input <-- VRFPersonalization.ElectionProof | parentTicket.Output
+        input <-- VRFPersonalization.ElectionProof | electionSeed.Output | nonce
     ii. # run it through the VRF and store the VRFProof in the new ticket
         newEP.VrfResult <-- self.VRFKeyPair.Generate(input)
+        newEP.Nonce <-- nonce
 3. Determine the miner's power fraction
     i. # Determine total storage this round
         S <-- storageMarket(N)
@@ -276,11 +232,13 @@ Output: 1 or 0
         # otherwise parentTicket is not a winning lottery ticket
         else
             Return 0
+Return 1
 ```
 
-### Election Validation
+If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
+While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
 
-For election proof generation, see [checking election results](expected-consensus.md#checking-election-results).
+### Election Validation
 
 In order to determine that the mined block was generated by an eligible miner, one must check its `ElectionProof`.
 
@@ -290,19 +248,26 @@ Succinctly, the process of verifying a block's election proof at round N, is as
 Input: received block, storage power actor S, miner's public key PK, a public parameter K
 Output: 0, 1
 
-0. Get the election proof, total power, miner power
+0. Get the election proof
         i. electionProof <-- block.electionProof
-        ii. # get total market power
+1. Verify it was generated in the appropriate round, specifically, for a block generated at round N, if the last block was generated at round N-L, the EP's nonce value should be L. Any EP with a nonce L' > L should be rejected.
+        i. # get nonce
+            Nonce <-- electionProof.Nonce
+            cur_round <-- chain.Current_Round()
+            if block.Parents.Height() + Nonce > cur_round:
+                return 0
+2. Get the total power, miner power
+        i. # get total market power
             S <-- storageMarket(N)
             p_n <-- S.GetTotalPower()
-        iii. # get miner power
+        ii. # get miner power
             p_m <-- LookupMinerPower(miner.addr)
-        iv. # Get power fraction
+        iii. # Get power fraction
               p_f <-- p_m/p_n
-4. Get the appropriate ticket from the ticket chain
+3. Get the appropriate ticket from the ticket chain
         i. # Get the tipset K rounds back
             ticket <-- chain.TicketAtEpoch(N-K)
-5. Verify Election Proof validity
+4. Verify Election Proof validity
         i. # generate the VRFInput from the scratched ticket
             input <-- VRFPersonalization.ElectionProof | scratchedTicket.VDFOutput
         ii. # Check that the election proof was correctly generated by the miner
@@ -348,8 +313,9 @@ X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
 
 with:
     - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
-    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000*eNumberOfBlocksPerRound choose i) (1/10,000)^i (9,999/10,000)^(eNumberOfBlocksPerRound - i))
+    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000* choose i) (1/10,000)^i (9,999/10,000)n- i
 
+CDF(X, k) with
 The weight should be calculated using big integer arithmetic with order of operations defined above. The multiplication by 1,000 and flooring is meant to help generate uniform weights across implementations.
 
 ```sh
@@ -382,7 +348,7 @@ The probability that two Tipsets with different blocks would have all the same t
 
 {{<label finality>}}
 ## Finality in EC
-TODO
+EC enforces a version of soft finality whereby all miners at round N will reject all blocks coming in prior to round N-F. For illustrative purposes, we can take F to be 500. While strictly speaking EC is a probabilistically final protocol, choosing such an F simplifies miner implementations and enforces a socially-bound finality at no cost to liveness in the chain.
 
 ## Slashing in EC
 
@@ -390,7 +356,7 @@ Due to the existence of potential forks, a miner can try to unduly influence pro
 
 This is detectable when a miner submits two blocks that satisfy either of the following "slashing conditions":
 
-(1) one block contains at least one ticket in its ticket array generated at the same round as one of the tickets in the other block's ticket array.
+(1) one block contains the same electionProof nonce as one of the other blocks'.
 (2) one block's parent is a Tipset that could have validly included the other block according to Tipset validity rules, however the parent of the first block does not include the other block.
 
   - While it cannot be proven that a miner omits known blocks from a Tipset in general (i.e. network latency could simply mean the miner did not receive a particular block) in this case it can be proven because a miner must be aware of a block they mined in a previous round.
diff --git a/src/listings/data_structures.md b/src/listings/data_structures.md
index 87353710b..6eedfdac8 100644
--- a/src/listings/data_structures.md
+++ b/src/listings/data_structures.md
@@ -20,8 +20,9 @@ For more detail, see the full {{<sref app_address "address spec">}}.
 A block header contains information relevant to a particular point in time over which the network may achieve consensus. The block header contains:
 
 - The address of the miner that mined the block
-- An array of the tickets that led to this particular miner being selected as the leader for this round (see
-{{<sref leader_election>}} for more details), as well as a signature on the winning ticket
+- A ticket associated to this block's creation to be used as randomness elsewhere in the protocol (see
+{{<sref leader_election>}} for more details)
+- An electionProof showing this miner was eligible to mine, as well as a Nonce relating the number of rounds over which the block was mined (on expectation 1)
 - The set of parent blocks and aggregate {{<sref chain_selection "chain weight">}} of the parents
 - This block's height
 - Merkle root of the state tree (after applying the messages -- state transitions -- included in this block)
@@ -57,10 +58,7 @@ We define VRF personalizations as follow, to enable domain separation across ope
 # Ticket
 
 A ticket contains a shared random value referenced by a particular `Block` in the Filecoin blockchain.
-Every miner must produce a new `Ticket` each time they run a leader election attempt.
-In that sense, every new block produced will have one or more associated tickets
-(specifically, the block may contain more than one ticket if it corresponds to
-one or more zero-winner epochs of {{<sref expected_consensus>}}).
+Every miner must produce a new `Ticket` for each ticket used in a leader election attempt.
 
 To produce the ticket values,
 we use an [EC-VRF per Goldberg et al.](https://tools.ietf.org/html/draft-irtf-cfrg-vrf-04#page-10)
@@ -73,9 +71,9 @@ with Secp256k1 and SHA-256 to obtain a deterministic, pseudorandom output.
 The ticket is represented concretely by the `Ticket` data structure.
 Whenever the Filecoin protocol refers to ticket values
 (notably in crafting {{<sref post "PoSTs">}} or running leader election),
-what is meant is that the bytes of the `VDFResult` field in the `Ticket` struct are used.
+what is meant is that the bytes of the `VRFResult` field in the `Ticket` struct are used.
 Specifically, tickets are compared lexicographically,
-interpreting the bytes of the `VDFResult` as an unsigned integer value (little-endian).
+interpreting the bytes of the `VRFResult.Output` as an unsigned integer value (little-endian).
 
 # ElectionProof
 
@@ -84,7 +82,9 @@ by a miner during the leader election process.
 Its output value determines whether the miner is elected as one of the leaders,
 and hence is eligible to produce a block for the current epoch.
 The inclusion of the `ElectionProof` in the block allows other network participants
-to verify that the block was mined by a valid leader.
+to verify that the block was mined by a valid leader. With every leader election attempt for a given ticket,
+(in cases where no blocks are found in a round) a miner increments that ElectionProof's associated `Nonce`, marking
+increased block height.
 
 {{<goFile ElectionProof>}}
 
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
index 4f47fb2e9..efcb40abd 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
@@ -11,7 +11,7 @@ The Storage Power Consensus subsystem is the main interface which enables Fileco
 Succinctly, the SPC subsystem offers the following services:
 - Access to the _Power Table_ for every subchain, accounting for individual storage miner power and total power on-chain.
 - Access to {{<sref expected_consensus>}} for individual storage miners, enabling:
-    - Access to verifiable randomness {{<sref tickets>}}as needed in the rest of the protocol. 
+    - Access to verifiable randomness {{<sref tickets>}} as needed in the rest of the protocol.
     - Running  {{<sref leader_election>}} to produce new blocks.
     - Running {{<sref chain_selection>}} across subchains using EC's weighting function. 
     - Identification of {{<sref finality "the most recently finalized tipset">}}, for use by all protocol participants.
@@ -44,12 +44,6 @@ Conversely, storage faults only lead to power loss once they are detected (up to
 
 Put another way, power accounting in the SPC is delayed between storage being proven or faulted, and power being updated in the power table (and so for leader election). This ensures fairness over time.
 
-To illustrate this, an example:
-
-Miner M1 has a provingPeriod of 30. M1 submits a PoST at height 39. Their next `provingPeriodEnd` will be 69, but M1 can submit a new PoST at any height X, for X in (39, 69]. Let's assume X is 67.
-
-At height Y in (39, 67], M1 will attempt to generate an `ElectionProof` using the storage market actor from height 39 for their own power (and an actor from Y for total network power); at height 68, M1 will use the storage market actor from height 67 for their own power, and the storage market actor from height 68 for total power and so on.
-
 ## Repeated leader election attempts
 
-In the case that no miner is eligible to produce a block in a given round of EC, the storage power consensus subsystem will be called by the block producer to attempt another leader election.
\ No newline at end of file
+In the case that no miner is eligible to produce a block in a given round of EC, the storage power consensus subsystem will be called by the block producer to attempt another leader election by incrementing the nonce appended to the ticket drawn from the past in order to attempt to craft a new valid `ElectionProof`
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/struct/block/other.id b/src/systems/filecoin_blockchain/struct/block/other.id
index 4a0a46200..09957afde 100644
--- a/src/systems/filecoin_blockchain/struct/block/other.id
+++ b/src/systems/filecoin_blockchain/struct/block/other.id
@@ -11,7 +11,6 @@ type Ticket struct {
 }
 
 type StoragePower UVarint
-type PowerFraction Float
 
 type ElectionSeed filcrypto.VDFResult
 
@@ -19,6 +18,7 @@ type ElectionProof struct {
     vrfResult filcrypto.VRFResult
     IsWinning(minerPower PowerFraction) bool @(cached)
     Verify(input Bytes, pk VRFPublicKey) bool
+    Nonce             UVarint
 
     ValidateSyntax() bool
     Verify(seed ElectionSeed, minerPK filcrypto.PubKey) bool

From 479f2a83f0ac427c599a0708dfba0d69bb362495 Mon Sep 17 00:00:00 2001
From: nicola <nicola@users.noreply.github.com>
Date: Wed, 9 Oct 2019 16:20:26 +0900
Subject: [PATCH 04/16] latest commits

---
 .../storage_power_consensus_subsystem.go                  | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
index a3fc8b189..f3ddf9d9c 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
@@ -2,6 +2,7 @@ package storage_power_consensus
 
 import (
 	"errors"
+
 	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 	block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
 	chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
@@ -39,9 +40,10 @@ func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block block.BlockHead
 	}
 
 	// and value
-	minerPower := spc.powerTable().LookupMinerPowerFraction(block.MinerAddress())
-	if !block.ElectionProof().IsWinning(minerPower) {
-		return errors.New("election proof was not a winner")
+	minerPower := spc.powerTable().LookupMinerPower(block.MinerAddress())
+	totalPower := spc.powerTable().GetTotalPower()
+	if !block.ElectionProof().IsWinning(float(minerPower) / totalPower) {
+		return spc.StoragePowerConsensusError("election proof was not a winner")
 	}
 
 	return nil

From 8f8ed7067bc541c1cd8cab217cf35a2a8e5a0c1f Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Mon, 7 Oct 2019 23:34:54 +0200
Subject: [PATCH 05/16] updated ec and weight fn

---
 src/algorithms/expected_consensus.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index 3bf637008..a66d4cac0 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -2,6 +2,8 @@
 title: "Expected Consensus"
 ---
 
+TODO: move pseudocode to id files entirely
+
 {{<label expected_consensus>}}
 ## Algorithm
 
@@ -235,6 +237,8 @@ Output: 1 or 0
 Return 1
 ```
 
+### Election Validation
+
 If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
 While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
 
@@ -313,7 +317,7 @@ X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
 
 with:
     - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
-    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000* choose i) (1/10,000)^i (9,999/10,000)n- i
+    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000*eNumberOfBlocksPerRound choose i) (1/10,000)^i (9,999/10,000)^(eNumberOfBlocksPerRound - i))
 
 CDF(X, k) with
 The weight should be calculated using big integer arithmetic with order of operations defined above. The multiplication by 1,000 and flooring is meant to help generate uniform weights across implementations.
@@ -362,4 +366,4 @@ This is detectable when a miner submits two blocks that satisfy either of the fo
   - While it cannot be proven that a miner omits known blocks from a Tipset in general (i.e. network latency could simply mean the miner did not receive a particular block) in this case it can be proven because a miner must be aware of a block they mined in a previous round.
 
 Any node that detects this occurring should take both block headers, and call [`storagemarket.SlashConsensusFault`](actors.md#slashconsensusfault). The network will then take all of that node's collateral, give a portion of it to
-the reporter, and keep the rest.
\ No newline at end of file
+the reporter, and keep the rest.

From a0c4ed1eaa1e61d5fc40db05ac86951e96587e30 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Tue, 8 Oct 2019 00:36:49 +0200
Subject: [PATCH 06/16] nonces insteead of ticket array

---
 src/algorithms/expected_consensus.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index a66d4cac0..3dc23f096 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -2,8 +2,6 @@
 title: "Expected Consensus"
 ---
 
-TODO: move pseudocode to id files entirely
-
 {{<label expected_consensus>}}
 ## Algorithm
 
@@ -237,7 +235,8 @@ Output: 1 or 0
 Return 1
 ```
 
-### Election Validation
+If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
+While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
 
 If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
 While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
@@ -317,7 +316,7 @@ X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
 
 with:
     - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
-    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000*eNumberOfBlocksPerRound choose i) (1/10,000)^i (9,999/10,000)^(eNumberOfBlocksPerRound - i))
+    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000* choose i) (1/10,000)^i (9,999/10,000)n- i
 
 CDF(X, k) with
 The weight should be calculated using big integer arithmetic with order of operations defined above. The multiplication by 1,000 and flooring is meant to help generate uniform weights across implementations.

From 043020495104fda8515293afa8f991760b952d98 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Tue, 8 Oct 2019 20:26:25 +0200
Subject: [PATCH 07/16] working slowly through wt fnd

---
 src/algorithms/expected_consensus.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index 3dc23f096..a43d2fa56 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -295,38 +295,38 @@ Just as there can be 0 miners win in a round, multiple miners can be elected in
 
 It is possible for forks to emerge naturally in Expected Consensus. EC relies on weighted chains in order to quickly converge on 'one true chain', with every block adding to the chain's weight. This means the heaviest chain should reflect the most amount of work performed, or in Filecoin's case, the most storage provided.
 
-In short, the weight at each block is equal to its `ParentWeight` plus that block's delta weight.
+In short, the weight at each block is equal to its `ParentWeight` plus that block's delta weight. Details of Filecoin's chain weighting function [are included here](https://observablehq.com/d/3812cd65c054082d).
+
 Delta weight is a term composed of a few elements:
-- A wForkFactor: which seeks to cut the weight derived from rounds in which produced Tipsets do not correspond to what an honest chain is likely to have yielded (pointing to selfish mining or other non-collaborative miner behavior).
-- A wPowerFactor: which adds weight to the chain proportional to the total power backing the chain, i.e. accounted for in the chain's power table. 
-- A wBlocksFactor: which adds weight to the chain proportional to the number of blocks mined in a given round. Like wForkFactor, it rewards miner cooperation (which will yield more blocks per round on expectation).
+- wForkFactor: which seeks to cut the weight derived from rounds in which produced Tipsets do not correspond to what an honest chain is likely to have yielded (pointing to selfish mining or other non-collaborative miner behavior).
+- wPowerFactor: which adds weight to the chain proportional to the total power backing the chain, i.e. accounted for in the chain's power table.
+- wBlocksFactor: which adds weight to the chain proportional to the number of blocks mined in a given round. Like wForkFactor, it rewards miner cooperation (which will yield more blocks per round on expectation).
 
-We have:
+The weight should be calculated using big integer arithmetic with order of operations defined above. We use brackets instead of parentheses below for legibility. We have:
 
-w[r+1] = w[r] + floor(1000 * (wForkFactor(wPowerFactor[r+1] + wBlocksFactor[r+1])))
+`w[r+1] = w[r] + (wForkFactor[r+1](wPowerFactor[r+1] + wBlocksFactor[r+1]))`
 
-with, for a given tipset ts in round r+1:
+For a given tipset `ts` in round `r+1`, we define:
 
+- wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))
 - wBlocksFactor[r+1] = v * |blocksInTipset(ts)| = v * k
-  - with v = vt * log2(totalPowerAtTipset(ts) * vs)/vs
-- wPowerFactor[r+1]  = log2(totalPowerAtTipset(ts))
+  - with v = vt * log2b(totalPowerAtTipset(ts) * vs)/vs
+
+
 Take X -> Bin(eNumberOfBlocksPerRound * numberOfMinersInPowerTable, 1/numberOfMinersInPowerTable), for simplicity, we take:
 X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
 - wForkFactor[r+1]   = 1 if |blocksInTipset(ts)| > E[X] - 2*stdDev[X], CDF(X, |blocksInTipset(ts)) otherwise.
 
 with:
+    - log2b(X) = floor(log2(x)), the binary length of X.
     - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
     - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000* choose i) (1/10,000)^i (9,999/10,000)n- i
 
-CDF(X, k) with
-The weight should be calculated using big integer arithmetic with order of operations defined above. The multiplication by 1,000 and flooring is meant to help generate uniform weights across implementations.
 
 ```sh
 Note that if your implementation does not allow for rounding to the fourth decimal, miners should apply the [tie-breaker below](#selecting-between-tipsets-with-equal-weight). Weight changes will be on the order of single digit numbers on expectation, so this should not have an outsized impact on chain consensus across implementations.
 ```
 
-Details of Filecoin's chain weighting function [are included here](https://observablehq.com/d/3812cd65c054082d).
-
  The exact value for these parameters remain to be determined, but for testing purposes, you may use:
  - `vt = 350`
  - `vs = E-5`

From 04dbb6e94f25cd8e01cb5bdc2b851fe3f12e731e Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Thu, 10 Oct 2019 00:55:26 +0200
Subject: [PATCH 08/16] simplified wt fn

---
 src/algorithms/expected_consensus.md | 30 +++++++++++-----------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index a43d2fa56..e36e0ea91 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -304,33 +304,27 @@ Delta weight is a term composed of a few elements:
 
 The weight should be calculated using big integer arithmetic with order of operations defined above. We use brackets instead of parentheses below for legibility. We have:
 
-`w[r+1] = w[r] + (wForkFactor[r+1](wPowerFactor[r+1] + wBlocksFactor[r+1]))`
+`w[r+1] = w[r] + wPowerFactor[r+1] + wBlocksFactor[r+1]`
 
 For a given tipset `ts` in round `r+1`, we define:
 
-- wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))
-- wBlocksFactor[r+1] = v * |blocksInTipset(ts)| = v * k
-  - with v = vt * log2b(totalPowerAtTipset(ts) * vs)/vs
-
-
-Take X -> Bin(eNumberOfBlocksPerRound * numberOfMinersInPowerTable, 1/numberOfMinersInPowerTable), for simplicity, we take:
-X -> Bin(eNumberOfBlocksPerRound * 10,000, 1/10,000). We have:
-- wForkFactor[r+1]   = 1 if |blocksInTipset(ts)| > E[X] - 2*stdDev[X], CDF(X, |blocksInTipset(ts)) otherwise.
-
-with:
-    - log2b(X) = floor(log2(x)), the binary length of X.
-    - stdDev[X] = sqrt(eNumberOfBlocksPerRound * (1 - 1/10,000))
-    - CDF(X, |blocksInTipset(ts)) = Sum_i=0^k ((10,000* choose i) (1/10,000)^i (9,999/10,000)n- i
+- `wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))`
+  - with `log2b(X) = floor(log2(x))`, the binary length of X.
+- wBlocksFactor[r+1] =  `wPowerFactor[r+1] * wRatio * b / e`
+  - with `b = |blocksInTipset(ts)|`
+  - `e = expected number of blocks per round in the protocol`
+  - and `wRatio in ]0, 1[`
+Thus, for stability of weight across implementations, we take:
+- wBlocksFactor[r+1] =  `(wPowerFactor[r+1] * b * wRatio_num * 2^8) / (e * wRatio_den)`
 
+ The exact value for these parameters remain to be determined, but for testing purposes, you may use:
+ - `e = 5`
+ - `wRatio = .5, or wRatio_num = 1, wRatio_den = 2`
 
 ```sh
 Note that if your implementation does not allow for rounding to the fourth decimal, miners should apply the [tie-breaker below](#selecting-between-tipsets-with-equal-weight). Weight changes will be on the order of single digit numbers on expectation, so this should not have an outsized impact on chain consensus across implementations.
 ```
 
- The exact value for these parameters remain to be determined, but for testing purposes, you may use:
- - `vt = 350`
- - `vs = E-5`
-
 `ParentWeight` is the aggregate chain weight of a given block's parent set. It is calculated as
 the `ParentWeight` of any of its parent blocks (all blocks in a given Tipset should have
 the same `ParentWeight` value) plus the delta weight of each parent. To make the

From 2533377e4fdf105eb883ad9a62b61685ae112f81 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Thu, 10 Oct 2019 01:08:10 +0200
Subject: [PATCH 09/16] added special case for log2b

---
 src/algorithms/expected_consensus.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index e36e0ea91..1551e558e 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -309,7 +309,8 @@ The weight should be calculated using big integer arithmetic with order of opera
 For a given tipset `ts` in round `r+1`, we define:
 
 - `wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))`
-  - with `log2b(X) = floor(log2(x))`, the binary length of X.
+  - with `log2b(X) = floor(log2(x))`, the binary length of X
+    - While it should never be used (given it would mean an empty power table), we define the special case: `log2b(0) = 0`.
 - wBlocksFactor[r+1] =  `wPowerFactor[r+1] * wRatio * b / e`
   - with `b = |blocksInTipset(ts)|`
   - `e = expected number of blocks per round in the protocol`

From f23fa7d0061c31e8dc5ff4fa22555bc1914e9bd4 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Thu, 10 Oct 2019 01:11:15 +0200
Subject: [PATCH 10/16] fix

---
 src/algorithms/expected_consensus.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index 1551e558e..93daefb5f 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -309,8 +309,8 @@ The weight should be calculated using big integer arithmetic with order of opera
 For a given tipset `ts` in round `r+1`, we define:
 
 - `wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))`
-  - with `log2b(X) = floor(log2(x))`, the binary length of X
-    - While it should never be used (given it would mean an empty power table), we define the special case: `log2b(0) = 0`.
+  - with `log2b(X) = floor(log2(x)) = (binary length of X) - 1`
+    - We define the special case: `log2b(0) = 0`. Note that it should never be used (given it would mean an empty power table.
 - wBlocksFactor[r+1] =  `wPowerFactor[r+1] * wRatio * b / e`
   - with `b = |blocksInTipset(ts)|`
   - `e = expected number of blocks per round in the protocol`

From e8b52bd3a73d4d5b44555c0e20e81368a59364b1 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Thu, 10 Oct 2019 01:18:48 +0200
Subject: [PATCH 11/16] fix 2^8 mistake thanks to Kubuxu

---
 src/algorithms/expected_consensus.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index 93daefb5f..167225b23 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -308,7 +308,7 @@ The weight should be calculated using big integer arithmetic with order of opera
 
 For a given tipset `ts` in round `r+1`, we define:
 
-- `wPowerFactor[r+1]  = log2b(totalPowerAtTipset(ts))`
+- `wPowerFactor[r+1]  = `
   - with `log2b(X) = floor(log2(x)) = (binary length of X) - 1`
     - We define the special case: `log2b(0) = 0`. Note that it should never be used (given it would mean an empty power table.
 - wBlocksFactor[r+1] =  `wPowerFactor[r+1] * wRatio * b / e`
@@ -316,7 +316,11 @@ For a given tipset `ts` in round `r+1`, we define:
   - `e = expected number of blocks per round in the protocol`
   - and `wRatio in ]0, 1[`
 Thus, for stability of weight across implementations, we take:
-- wBlocksFactor[r+1] =  `(wPowerFactor[r+1] * b * wRatio_num * 2^8) / (e * wRatio_den)`
+- wBlocksFactor[r+1] =  `(wPowerFactor[r+1] * b * wRatio_num) / (e * wRatio_den)`
+
+We get:
+- `w[r+1] = w[r] + log2b(totalPowerAtTipset(ts)) * 2^8 + (log2b(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)`
+ Using the 2^8 here to prevent precision loss ahead of the division in the wBlocksFactor.
 
  The exact value for these parameters remain to be determined, but for testing purposes, you may use:
  - `e = 5`

From fde3386567c599958c504ac9b866640c54b42782 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Fri, 11 Oct 2019 03:35:06 +0300
Subject: [PATCH 12/16] lots of progress on all functions related to ticket
 creation/validation, and EP creation/validation as well as randomness
 sampling

---
 hugo/data/sref_locations.yaml                 |   3 +-
 hugo/data/sref_titles.yaml                    |   3 +-
 src/algorithms/expected_consensus.md          | 193 ++----------------
 src/systems/filecoin_blockchain/blockchain.id |   2 +-
 .../blockchain/block_producer.go              |   0
 .../storage_power_consensus/_index.md         |  50 ++++-
 .../expected_consensus.id                     |   6 -
 .../expected_consensus.md                     |   5 -
 .../storage_power_consensus_subsystem.go      | 119 ++++++++---
 .../storage_power_consensus_subsystem.id      |  51 +++--
 .../filecoin_blockchain/struct/block/block.go |   4 +
 .../filecoin_mining/storage_mining/sratch.id  |   1 -
 .../storage_mining_subsystem.go               |  80 +++++---
 .../storage_mining_subsystem.id               |  21 +-
 14 files changed, 263 insertions(+), 275 deletions(-)
 create mode 100644 src/systems/filecoin_blockchain/blockchain/block_producer.go
 delete mode 100644 src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id
 delete mode 100644 src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.md

diff --git a/hugo/data/sref_locations.yaml b/hugo/data/sref_locations.yaml
index 03b59a99c..6e8f6dcaf 100644
--- a/hugo/data/sref_locations.yaml
+++ b/hugo/data/sref_locations.yaml
@@ -14,6 +14,7 @@ chainsync: [systems, filecoin_blockchain, chainsync]
 
 ### SPC
 storage_power_consensus: [systems, filecoin_blockchain, storage_power_consensus]
+ticket_chain: [systems, filecoin_blockchain, storage_power_consensus, ticket_chain]
 power_table: [systems, filecoin_blockchain, storage_power_consensus]
 expected_consensus: [algorithms, expected_consensus]
 tickets: [algorithms, expected_consenus, tickets]
@@ -41,4 +42,4 @@ post: [algorithms, proof_of_spacetime]
 
 # nodes
 
-# token
\ No newline at end of file
+# token
diff --git a/hugo/data/sref_titles.yaml b/hugo/data/sref_titles.yaml
index 94b804ad6..10a17a7df 100644
--- a/hugo/data/sref_titles.yaml
+++ b/hugo/data/sref_titles.yaml
@@ -10,6 +10,7 @@ sys_vm: "VM"
 block_producer: "Block Producer"
 ### SPC
 storage_power_consensus: "Storage Power Consensus"
+ticket_chain: "Ticket Chain"
 power_table: "Power Table"
 expected_consensus: "Expected Consensus"
 tickets: "Tickets"
@@ -38,4 +39,4 @@ post: "Proof of Spacetime"
 
 # nodes
 
-# token
\ No newline at end of file
+# token
diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index 167225b23..cecec1959 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -34,26 +34,6 @@ You can find the Ticket data structure {{<sref data_structures "here">}}.
 
 Whenever comparing tickets is evoked in Filecoin, for instance when discussing selecting the "min ticket" in a Tipset, the comparison is that of the little endian representation of the ticket's VFOutput bytes.
 
-### The Ticket chain
-
-While each Filecoin block header contains a ticket field, it is useful to provide nodes with a ticket chain abstraction.
-
-Namely, tickets are used throughout the Filecoin system as sources of on-chain randomness. For instance,
-- They are drawn by Storage Miners as SealSeeds to commit new sectors
-- They are drawn by Storage Miners as PoStChallenges to generate PoSts
-- They are drawn by the Storage Power subsystem as randomness in leader election to determine their eligibility to mine a block
-- They are drawn by the Storage Power subsystem in order to generate new tickets for future use.
-
-Each of these ticket uses may require drawing tickets at different chain heights, according to the security requirements of the particular protocol making use of tickets. Due to the nature of Filecoin's Tipsets and the possibility of using losing tickets (that did not yield leaders in leader election) for randomness at a given height, tracking the canonical ticket of a subchain at a given height can be arduous to reason about in terms of blocks. To that end, it is helpful to create a ticket chain abstraction made up of only those tickets to be used for randomness at a given height.
-
-This ticket chain will track one-to-one with a block at each height in a given subchain, but omits certain details including other blocks mined at that height.
-
-Simply, it is composed inductively as follows. For a given chain:
-
-- At height 0, take the genesis block, return its ticket
-- At height n+1, take the heaviest tipset in our chain at height n.
-    - select the block in that tipset with the smallest final ticket, return its ticket
-
 ## Tickets in EC
 
 Within EC, a miner generates a new ticket in their block for every ticket they use (or "scratch") running leader election, thereby ensuring the ticket chain is always as long as the block chain.
@@ -89,32 +69,7 @@ more space on-chain.
 
 This section discusses how tickets are generated by EC for the `Ticket` field.
 
-At round `N`, a new ticket is generated using tickets drawn from the Tipset at round `N-1`. Because a Tipset can contain multiple blocks (see [Chain Selection](#chain-selection) below), the smallest ticket in the Tipset must be drawn otherwise the block will be invalid.
-
-```
-   ┌──────────────────────┐                     
-   │                      │                     
-   │                      │                     
-   │┌────┐                │                     
-   ││ TA │              A │                     
-   └┴────┴────────────────┘                     
-                                                
-   ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                      
-                          │                     
-   │                                            
-    ┌────┐                │       TA < TB < TC  
-   ││ TB │              B                       
-    ┴────┘─ ─ ─ ─ ─ ─ ─ ─ ┘                     
-                                                
-   ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─                      
-                          │                     
-   │                                            
-    ┌────┐                │                     
-   ││ TC │              C                       
-    ┴────┘─ ─ ─ ─ ─ ─ ─ ─ ┘                     
-```
-
-In the above diagram, a miner will use block A's Ticket to generate a new ticket (or an election proof farther in the future) since it is the smallest in the Tipset.
+At round `N`, a new ticket is generated using tickets drawn from the Tipset at round `N-1` (for more on how tickets are drawn see {{<sref ticket_chain>}}).
 
 The miner runs the prior ticket through a Verifiable Random Function (VRF) to get a new unique output.
 
@@ -125,58 +80,20 @@ We use the ECVRF algorithm from [Goldberg et al. Section 5](https://tools.ietf.o
   - Secp256k1 for our curve
   - Note that the operation type in step 2.1 is necessary to prevent an adversary from guessing an election proof for a miner ahead of time.
 
-They are crafted as follows:
-
-Input: parentTickets at round N-1, miner's private key SK
-Output: newTicket
-
-```
-0. Prepare new ticket
-    i. newTicket <-- New()
-1. Draw prior ticket
-    i. priorTicket <-- chain.TicketAtEpoch(N-1)
-2. Run it through VRF and get determinstic output
-    i. # take the VRFResult of that ticket as input, specifying the personalization (see data-structures)
-            input <-- VRFPersonalization.Ticket | priorTicket.Output
-    ii. # run it through the VRF and store the output in the new ticket
-            newTicket.vrfResult <-- self.VRFKeyPair.Generate(input)
-4. Return the new ticket
-```
-
 ### Ticket Validation
 
 Each Ticket should be generated from the prior one in the ticket-chain.
 
-Succinctly, the process of verifying a block's tickets is as follows.
-```text
-Input: received block, storage market actor S, miner's public key PK, a public VDF validation key vk
-Output: 0, 1
-
-0. Get the ticket
-    i. ticket <-- block.ticket
-1. Verify its VRF Proof
-    i. # get the appropriate parent
-        parent = chain.TicketAtEpoch(N-1)
-    ii. # generate the VRFInput
-        input <-- VRFPersonalization.Ticket | parent.Output
-    iii. # verify the VRF
-        VRFState <-- ticket.VrfResult.Verify(input, PK)
-        if VRFState == false:
-            return 0
-2. Return results
-    return 1
-```
-
 {{<label leader_election>}}
 ## Secret Leader Election
 
 Expected Consensus is a consensus protocol that works by electing a miner from a weighted set in proportion to their power. In the case of Filecoin, participants and powers are drawn from the storage [power table](storage-market.md#the-power-table), where power is equivalent to storage provided through time.
 
-Leader Election in Expected Consensus must be Secret, Fair and Verifiable. This is achieved through the use of randomness used to run the election. In the case of Filecoin's EC, the blockchain tracks an independent ticket chain. These tickets are used as randomness inputs for Leader Election. Every block generated references an `ElectionProof` derived from a past ticket. The ticket chain is extended by the miner who generates a new ticket with each attempted election.
+Leader Election in Expected Consensus must be Secret, Fair and Verifiable. This is achieved through the use of randomness used to run the election. In the case of Filecoin's EC, the blockchain tracks an independent ticket chain. These tickets are used as randomness inputs for Leader Election. Every block generated references an `ElectionProof` derived from a past ticket. The ticket chain is extended by the miner who generates a new block for each successful leader election.
 
 ### Running a leader election
 
-Now, a miner must also check whether they are eligible to mine a block in this round. For how Election Proofs are validated, see [election validation](mining.md#election-validation).
+Now, a miner must also check whether they are eligible to mine a block in this round.
 
 To do so, the miner will use tickets from K rounds back as randomness to uniformly draw a value from 0 to 1. Comparing this value to their power, they determine whether they are eligible to mine. A user's `power` is defined as the ratio of the amount of storage they proved as of their last PoSt submission to the total storage in the network as of the current block.
 
@@ -184,9 +101,9 @@ We use the ECVRF algorithm (must yield a pseudorandom, deterministic output) fro
   - Sha256 for our hashing function
   - Secp256k1 for our curve
 
-If the miner scratches a winning ticket in this round, it can use newEP, along with a newTicket to generate and publish a new block (see [Block Generation](#block-generation)). Otherwise, it waits to hear of another block generated in this round.
+If the miner scratches a winning ticket in this round, it can use newEP, along with a newTicket to generate and publish a new block. Otherwise, it waits to hear of another block generated in this round.
 
-It is important to note that every block contains two artifacts: one, a ticket derived from last block's ticket to prove that they have waited the appropriate delay, and two, an election proof derived from the ticket `K` rounds back used to run leader election.
+It is important to note that every block contains two artifacts: one, a ticket derived from last block's ticket to extend the ticket-chain, and two, an election proof derived from the ticket `K` rounds back used to run leader election.
 
 Succinctly, the process of crafting a new ElectionProof in round N is as follows. We use:
 
@@ -196,96 +113,13 @@ Succinctly, the process of crafting a new ElectionProof in round N is as follows
 
 Note: We draw the miner power from the prior round. This means that if a miner wins a block on their ProvingPeriodEnd even if they have not yet resubmitted a PoSt, they retain their power (until the next round).
 
-At round N:
-
-```
-Input: electionSeed from N-K, miner's public key PK, miner's secret key SK, the Storage Power actor S, a Nonce nonce starting with value 0
-Output: 1 or 0
-
-0. Prepare new election proof
-    i. newEP <-- New()
-1. Draw electionSeed from K blocks back
-    i. electionSeed <-- chain.TicketAtEpoch(N-K)
-2. Run it through VRF and get determinstic output
-    i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
-        input <-- VRFPersonalization.ElectionProof | electionSeed.Output | nonce
-    ii. # run it through the VRF and store the VRFProof in the new ticket
-        newEP.VrfResult <-- self.VRFKeyPair.Generate(input)
-        newEP.Nonce <-- nonce
-3. Determine the miner's power fraction
-    i. # Determine total storage this round
-        S <-- storageMarket(N)
-        p_n <-- S.GetTotalPower()
-    ii. # Determine own power at prior tipSet
-        p_m <-- LookupMinerPower(self.addr)
-    iii. # Get power fraction
-		p_f <-- p_m/p_n
-4. Determine if the miner drew a winning lottery ticket
-    # Conceptually we are mapping the pseudorandom, deterministic VRFOutput onto [0,1] by dividing by 2^HashLen (64 Bytes using Sha256) and comparing that to the miner's power (portion of network storage).
-    # In practice, we actually multiply the power fraction by 2^HashLen for comparison with the ticket value in order to avoid dealing with floats.
-    i.  # Map the miner's power onto [0, 2^HashLen] (64 Bytes using sha256)
-        normalized_power <-- p_f * 2^HashLen
-    ii. # Compare the miner's power fraction to the value of the ticket drawn: more power means win more often.
-        # winning ticket
-        if readLittleEndian(VRFOutput) <= normalized_power
-            return newEP
-        # otherwise parentTicket is not a winning lottery ticket
-        else
-            Return 0
-Return 1
-```
-
-If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
-While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
-
-If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment nonce and try again.
-While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the honest majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
+If successful, the miner can craft a block, passing it to the block producer. If unsuccessful, it will wait to hear of another block mined this round to try again. In the case no other block was found in this round the miner can increment its nonce and try leader election again using the same past ticket and new nonce.
+While a miner could try to run through multiple nonces in parallel in order to quickly generate a block, this effort will be futile as the rational majority of miners will reject blocks crafted with ElectionProofs whose nonces prove too high (see below).
 
 ### Election Validation
 
 In order to determine that the mined block was generated by an eligible miner, one must check its `ElectionProof`.
 
-Succinctly, the process of verifying a block's election proof at round N, is as follows.
-
-```text
-Input: received block, storage power actor S, miner's public key PK, a public parameter K
-Output: 0, 1
-
-0. Get the election proof
-        i. electionProof <-- block.electionProof
-1. Verify it was generated in the appropriate round, specifically, for a block generated at round N, if the last block was generated at round N-L, the EP's nonce value should be L. Any EP with a nonce L' > L should be rejected.
-        i. # get nonce
-            Nonce <-- electionProof.Nonce
-            cur_round <-- chain.Current_Round()
-            if block.Parents.Height() + Nonce > cur_round:
-                return 0
-2. Get the total power, miner power
-        i. # get total market power
-            S <-- storageMarket(N)
-            p_n <-- S.GetTotalPower()
-        ii. # get miner power
-            p_m <-- LookupMinerPower(miner.addr)
-        iii. # Get power fraction
-              p_f <-- p_m/p_n
-3. Get the appropriate ticket from the ticket chain
-        i. # Get the tipset K rounds back
-            ticket <-- chain.TicketAtEpoch(N-K)
-4. Verify Election Proof validity
-        i. # generate the VRFInput from the scratched ticket
-            input <-- VRFPersonalization.ElectionProof | scratchedTicket.VDFOutput
-        ii. # Check that the election proof was correctly generated by the miner
-            # using the appropriate ticket
-            VRFState <-- electionProof.Verify(input, miner.PK)
-            if VRFState == false:
-                return 0
-        iii. Ensure that the scratched ticket is a winner
-            # internally -> map p_f onto [0, 2^HashLen] and compare the miner's scratchValue to the miner's normalized power fraction
-            if electionProof.IsWinning(p_f) == false:
-                return 0
-5. Everything checks out, it's a valid election proof
-        return 1
-```
-
 {{<label chain_selection>}}
 ## Chain Selection
 
@@ -304,7 +138,7 @@ Delta weight is a term composed of a few elements:
 
 The weight should be calculated using big integer arithmetic with order of operations defined above. We use brackets instead of parentheses below for legibility. We have:
 
-`w[r+1] = w[r] + wPowerFactor[r+1] + wBlocksFactor[r+1]`
+`w[r+1] = w[r] + (wPowerFactor[r+1] + wBlocksFactor[r+1]) * 2^8`
 
 For a given tipset `ts` in round `r+1`, we define:
 
@@ -350,18 +184,19 @@ The probability that two Tipsets with different blocks would have all the same t
 
 {{<label finality>}}
 ## Finality in EC
-EC enforces a version of soft finality whereby all miners at round N will reject all blocks coming in prior to round N-F. For illustrative purposes, we can take F to be 500. While strictly speaking EC is a probabilistically final protocol, choosing such an F simplifies miner implementations and enforces a socially-bound finality at no cost to liveness in the chain.
+EC enforces a version of soft finality whereby all miners at round N will reject all blocks that fork off prior to round N-F. For illustrative purposes, we can take F to be 500. While strictly speaking EC is a probabilistically final protocol, choosing such an F simplifies miner implementations and enforces a macroeconomically-enforced finality at no cost to liveness in the chain.
 
 ## Slashing in EC
 
 Due to the existence of potential forks, a miner can try to unduly influence protocol fairness. This means they may choose to disregard the protocol in order to gain an advantage over the power they should normally get from their storage on the network. A miner should be slashed if they are provably deviating from the honest protocol.
 
-This is detectable when a miner submits two blocks that satisfy either of the following "slashing conditions":
+This is detectable when a miner submits two blocks that satisfy any of the following "slashing conditions":
 
-(1) one block contains the same electionProof nonce as one of the other blocks'.
+(1) two blocks contains the same electionProof nonce, mined at the same height.
 (2) one block's parent is a Tipset that could have validly included the other block according to Tipset validity rules, however the parent of the first block does not include the other block.
 
   - While it cannot be proven that a miner omits known blocks from a Tipset in general (i.e. network latency could simply mean the miner did not receive a particular block) in this case it can be proven because a miner must be aware of a block they mined in a previous round.
 
-Any node that detects this occurring should take both block headers, and call [`storagemarket.SlashConsensusFault`](actors.md#slashconsensusfault). The network will then take all of that node's collateral, give a portion of it to
-the reporter, and keep the rest.
+Any node that detects this occurring should take both block headers, and call [`storagemarket.SlashConsensusFault`](actors.md#slashconsensusfault). The network will then take all of that node's collateral.
+
+Note that a miner will likewise be slashed on failing to submit their Proof-of-Spacetime in time, given the undue power over consensus it gives them.
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/blockchain.id b/src/systems/filecoin_blockchain/blockchain.id
index f36a8ec5f..714f47606 100644
--- a/src/systems/filecoin_blockchain/blockchain.id
+++ b/src/systems/filecoin_blockchain/blockchain.id
@@ -54,5 +54,5 @@ type BlockchainSubsystem struct @(mutable) {
     ChooseTipset(tipsets [block.Tipset]) block.Tipset
 
     // call by StorageMining
-    GetPostRandomness() chain.Randomness
+    // GetPostRandomness() chain.Randomness
 }
diff --git a/src/systems/filecoin_blockchain/blockchain/block_producer.go b/src/systems/filecoin_blockchain/blockchain/block_producer.go
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
index efcb40abd..06062dd56 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
@@ -46,4 +46,52 @@ Put another way, power accounting in the SPC is delayed between storage being pr
 
 ## Repeated leader election attempts
 
-In the case that no miner is eligible to produce a block in a given round of EC, the storage power consensus subsystem will be called by the block producer to attempt another leader election by incrementing the nonce appended to the ticket drawn from the past in order to attempt to craft a new valid `ElectionProof`
\ No newline at end of file
+In the case that no miner is eligible to produce a block in a given round of EC, the storage power consensus subsystem will be called by the block producer to attempt another leader election by incrementing the nonce appended to the ticket drawn from the past in order to attempt to craft a new valid `ElectionProof` and trying again.
+
+{{<label ticket_chain>}}
+### The Ticket chain and randomness on-chain
+
+While each Filecoin block header contains a ticket field (see {{<sref tickets>}}), it is useful to provide nodes with a ticket chain abstraction.
+
+Namely, tickets are used throughout the Filecoin system as sources of on-chain randomness. For instance,
+- The {{<sref sector_sealer>}} uses tickets as SealSeeds to bind sector commitments to a given subchain.
+- The {{<sref post_generator>}} likewise uses tickets as PoStChallenges to prove sectors remain committed as of a given block.
+- They are drawn by the Storage Power subsystem as randomness in {{<leader_election>}} to determine their eligibility to mine a block
+- They are drawn by the Storage Power subsystem in order to generate new tickets for future use.
+
+Each of these ticket uses may require drawing tickets at different chain heights, according to the security requirements of the particular protocol making use of tickets. Due to the nature of Filecoin's Tipsets and the possibility of using losing tickets (that did not yield leaders in leader election) for randomness at a given height, tracking the canonical ticket of a subchain at a given height can be arduous to reason about in terms of blocks. To that end, it is helpful to create a ticket chain abstraction made up of only those tickets to be used for randomness at a given height.
+
+This ticket chain will track one-to-one with a block at each height in a given subchain, but omits certain details including other blocks mined at that height.
+
+It is composed inductively as follows. For a given chain:
+
+- At height 0, take the genesis block, return its ticket
+- At height n+1, take the heaviest tipset in our chain at height n.
+    - select the block in that tipset with the smallest final ticket, return its ticket
+
+Because a Tipset can contain multiple blocks, the smallest ticket in the Tipset must be drawn otherwise the block will be invalid.
+
+```
+   ┌──────────────────────┐
+   │                      │
+   │                      │
+   │┌────┐                │
+   ││ TA │              A │
+   └┴────┴────────────────┘
+
+   ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                          │
+   │
+    ┌────┐                │       TA < TB < TC
+   ││ TB │              B
+    ┴────┘─ ─ ─ ─ ─ ─ ─ ─ ┘
+
+   ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                          │
+   │
+    ┌────┐                │
+   ││ TC │              C
+    ┴────┘─ ─ ─ ─ ─ ─ ─ ─ ┘
+```
+
+In the above diagram, a miner will use block A's Ticket to generate a new ticket (or an election proof farther in the future) since it is the smallest in the Tipset.
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id b/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id
deleted file mode 100644
index adfb1b5f6..000000000
--- a/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id
+++ /dev/null
@@ -1,6 +0,0 @@
-type ExpectedConsensus struct {
-    // ComputeWeight(Chain)							ChainWeight
-    // TryElection(StorageMiner, TipSet)				ElectionProof
-    // VerifyElection(StorageMiner, ElectionProof)		bool
-    // IsConsensusFault([Block])						bool
-}
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.md b/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.md
deleted file mode 100644
index ed0df5a54..000000000
--- a/src/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-title: Expected Consensus
----
-
-{{< readfile file="expected_consensus.id" code="true" lang="go" >}}
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
index f3ddf9d9c..36e466413 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
@@ -8,68 +8,139 @@ import (
 	chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
 	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
 	util "github.com/filecoin-project/specs/util"
+	base_mining "github.com/filecoin-project/specs/systems/filecoin_mining"
+	clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 )
 
 const (
 	SPC_LOOKBACK_RANDOMNESS = 300 // this is EC.K maybe move it there. TODO
 	SPC_LOOKBACK_TICKET     = 1   // we chain blocks together one after the other
+	SPC_LOOKBACK_POST       = -1  // TODO complete
+	SPC_LOOKBACK_SEAL       = -1  // TODO complete
 )
 
-func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block block.BlockHeader) error {
+const VRFPersonalization {
+	ticket: 0,
+	electionProof: 1
+}
+
+// Storage Power Consensus Subsystem
+
+func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block blockchain.Block_I) error {
+	minerPK := spc.PowerTable.GetMinerPublicKey(block.MinerAddress())
+	minerPower := spc.PowerTable.GetMinerPower(block.MinerAddress())
 
 	// 1. Verify miner has not been slashed and is still valid miner
-	if spc.powerTable().LookupMinerStorage(block.MinerAddress()) <= 0 {
-		return errors.New("block miner not valid")
+	if minerPower <= 0 {
+		return spc.StoragePowerConsensusError("block miner not valid")
 	}
 
-	minerPK := filcrypto.PubKey{} // TODO get the key from the state tree spc.StorageMiningSubsystem.GetMinerKeyByAddress(block.MinerAddress())
 	// 2. Verify ParentWeight
 	if block.Weight() != spc.computeTipsetWeight(block.Parents()) {
 		return errors.New("invalid parent weight")
 	}
 
 	// 3. Verify Tickets
-	if !block.ValidateTickets(minerPK) {
-		return errors.New("tickets were invalid")
+	if !validateTicket(block.Ticket, minerPK) {
+		return spc.StoragePowerConsensusError("ticket was invalid")
 	}
 
 	// 4. Verify ElectionProof construction
-	seed := block.ExtractElectionSeed()
-	if !block.ElectionProof().Verify(seed, minerPK) {
-		return errors.New("election proof was not a valid signature of the last ticket")
+	if !spc.ValidateElectionProof(block.Height, block.ElectionProof, block.MinerAddress) {
+		return spc.StoragePowerConsensusError("election proof was not a valid signature of the last ticket")
 	}
 
-	// and value
-	minerPower := spc.powerTable().LookupMinerPower(block.MinerAddress())
-	totalPower := spc.powerTable().GetTotalPower()
-	if !block.ElectionProof().IsWinning(float(minerPower) / totalPower) {
+	// 5. and value
+	if !spc.IsWinningElectionProof(block.ElectionProof, block.MinerAddress)
 		return spc.StoragePowerConsensusError("election proof was not a winner")
 	}
 
 	return nil
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) computeTipsetWeight(tipset block.Tipset) block.ChainWeight {
+func (spc *StoragePowerConsensusSubsystem_I) validateTicket(ticket base.Ticket, pk filcrypto.PublicKey) bool {
+	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain)
+	input := VRFPersonalization.Ticket
+	input.append(T1.Output)
+	return ticket.Verify(input, pk)
+}
+
+func (spc *StoragePowerConsensusSubsystem_I) computeTipsetWeight(tipset blockchain.Tipset) base.ChainWeight {
 	panic("TODO")
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) TicketAtEpoch(chain chain.Chain, epoch block.ChainEpoch) block.Ticket {
+func (spc *StoragePowerConsensusSubsystem_I) StoragePowerConsensusError(errMsg string) base.StoragePowerConsensusError {
 	panic("TODO")
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetElectionArtifacts(chain chain.Chain, epoch block.ChainEpoch) block.ElectionArtifacts {
-	return &block.ElectionArtifacts_I{
-		TK_: spc.TicketAtEpoch(chain, epoch-SPC_LOOKBACK_RANDOMNESS),
-		T1_: spc.TicketAtEpoch(chain, epoch-SPC_LOOKBACK_TICKET),
+func (spc *StoragePowerConsensusSubsystem_I) GetTicketProductionSeed(chain blockchain.Chain) base_mining.SealSeed {
+	return &base_mining.SealSeed_I {
+		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_TICKET)
 	}
 }
 
-func (pt *PowerTable_I) LookupMinerStorage(addr addr.Address) util.UVarint {
-	panic("")
+func (spc *StoragePowerConsensusSubsystem_I) GetElectionProofSeed(chain blockchain.Chain) base_mining.SealSeed {
+	return &base_mining.SealSeed_I {
+		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_RANDOMNESS),
+	}
 }
-func (pt *PowerTable_I) LookupMinerPowerFraction(addr addr.Address) block.PowerFraction {
-	panic("")
+
+func (spc *StoragePowerConsensusSubsystem_I) GetSealSeed(chain blockchain.Chain) base_mining.SealSeed {
+	return &base_mining.SealSeed_I {
+		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_SEAL)
+	}
 }
-func (pt *PowerTable_I) RemovePower(addr addr.Address) {
+
+func (spc *StoragePowerConsensusSubsystem_I) GetPoStChallenge(chain blockchain.Chain) base_mining.PoStChallenge {
+	return &base_mining.PoStChallenge_I {
+		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_POST)
+	}
+}
+
+func (spc *StoragePowerConsensusSubsystem_I) ValidateElectionProof(height BlockHeight, electionProof base.ElectionProof, workerAddr base.Address) bool {
+	// 1. Check that ElectionProof was validated in appropriate time
+	if (height + electionProof.ElectionNonce > clock.roundTime + 1) {
+		return false
+	}
+
+	// 2. Determine that ticket was validly scratched
+	minerPK := spc.PowerTable.GetMinerPublicKey(workerAddr)
+	input := VRFPersonalization.ElectionProof
+	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain)
+	input.append(TK.Output)
+	input.appent(electionProof.ElectionNonce)
+
+	return electionProof.Verify(input, minerPK)
+}
+
+func (spc *StoragePowerConsensusSubsystem_I) IsWinningElectionProof(electionProof base.ElectionProof, workerAddr base.Address) bool {
+	// 1. Determine miner power fraction
+	minerPower := spc.PowerTable.GetMinerPower(workerAddr)
+	totalPower := spc.PowerTable.GetTotalPower()
+
+	// Conceptually we are mapping the pseudorandom, deterministic VRFOutput onto [0,1]
+	// by dividing by 2^HashLen (64 Bytes using Sha256) and comparing that to the miner's
+	// power (portion of network storage).
+	return (minerPower * 2^(len(electionProof.Output)*8) < electionProof.Output * totalPower)
+}
+
+// Power Table
+
+func (pt *PowerTable_I) GetMinerPower(addr base.Address) base.StoragePower {
+	return pt.miners[addr].minerStoragePower
+}
+func (pt *PowerTable_I) GetTotalPower() base.StoragePower {
+	totalPower := 0
+	for _, miner := range pt.miners {
+		totalPower += miner.minerStoragePower
+	}
+	return totalPower
+}
+
+func (pt *PowerTable_I) GetMinerPublicKey() filcrypto.PublicKey {
+	return pt.miners[addr].minerPK
+}
+
+func (pt *PowerTable_I) RemovePower(addr base.Address) {
 	panic("")
 }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
index 4228cb6cb..667c4edb8 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
@@ -14,39 +14,52 @@ type StoragePowerConsensusSubsystem struct {//(@mutable)
     GenerateElectionProof(tipset block.Tipset) block.ElectionProof
     ChooseTipsetToMine(tipsets [block.Tipset]) [block.Tipset]
 
-    // call by StorageMiningSubsystem in sealing sector
-    GetSealSeed(chain chain.Chain, epoch block.ChainEpoch) base_mining.SealSeed
-
-    // call by StorageMiningSubsystem after sealing
-    GetPoStChallenge(chain chain.Chain, epoch block.ChainEpoch) base_mining.PoStChallenge
+    ec                   ExpectedConsensus
 
     // call by BlockchainSubsystem during block reception
     ValidateBlock(block block.Block) error
 
-    // call by StorageMiningSubsystem during block production
-    GetElectionArtifacts(chain chain.Chain, epoch block.ChainEpoch) block.ElectionArtifacts
+    validateElectionProof(base.ElectionProof, base.Address)
+
+    validateTicket(base.Ticket, base.Address)
+
+    computeTipsetWeight(tipset block.Tipset) block.ChainWeight
+
+    IsWinningElectionProof(electionProof base.ElectionProof, workerAddr base.Address) bool
+
+    StoragePowerConsensusError() base.StoragePowerConsensusError
 
-    // call by StoragePowerConsensusSubsystem itself during block production
-    TicketAtEpoch(chain chain.Chain, epoch block.ChainEpoch) block.Ticket
+    // Randomness methods
 
     // call by StorageMiningSubsystem during block production
-    TryLeaderElection(electionProof block.ElectionProof) bool
+    GetTicketProductionSeed(chain blockchain.Chain) base.Ticket
 
-    computeTipsetWeight(tipset block.Tipset) block.ChainWeight
+    // call by StorageMiningSubsystem during block production
+    GetElectionProofSeed(chain blockchain.Chain) base.Ticket
+
+    // call by StorageMiningSubsystem in sealing sector
+    GetSealSeed(chain chain.Chain) base_mining.SealSeed
+
+    // call by StorageMiningSubsystem after sealing
+    GetPoStChallenge(chain chain.Chain) base_mining.PoStChallenge
+}
+
+type ExpectedConsensus struct {
+    // ComputeWeight(Chain)							        ChainWeight
+    // IsConsensusFault([Block])						    bool
 }
 
 type PowerTable struct {
     // all power here is always verified
-    minerPower {base.Address: StorageMiner}
-    LookupMinerPower(addr base.Address) UVarint
-    GetTotalPower() UVarint
+    miners {base.Address: StorageMiner}
+    GetMinerPower(addr base.Address) base.StoragePower
+    GetTotalPower() base.StoragePower
+    GetMinerPublicKey(addr base.Address) filcrypto.PublicKey
     RemovePower(addr base.Address)
 }
 
 type StorageMiner struct {
-    minerAddress  addr.Address
-    minerStorage
-    VRFKeyPair    filcrypto.VRFKeyPair
+    minerAddress       base.Address
+    minerStoragePower  base.StoragePower
+    minerPK            filcrypto.PublicKey
 }
-
-type minerStorage UVarint
diff --git a/src/systems/filecoin_blockchain/struct/block/block.go b/src/systems/filecoin_blockchain/struct/block/block.go
index c3d12c68b..3c6c44356 100644
--- a/src/systems/filecoin_blockchain/struct/block/block.go
+++ b/src/systems/filecoin_blockchain/struct/block/block.go
@@ -59,3 +59,7 @@ func (self *BlockHeader_I) ValidateTickets(pubKey filcrypto.PubKey) bool {
 
 	return true
 }
+
+func (chain *Chain_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
+	return chain.ticketChain.TicketAtEpoch(epoch)
+}
diff --git a/src/systems/filecoin_mining/storage_mining/sratch.id b/src/systems/filecoin_mining/storage_mining/sratch.id
index 7cddc9114..c02a00a36 100644
--- a/src/systems/filecoin_mining/storage_mining/sratch.id
+++ b/src/systems/filecoin_mining/storage_mining/sratch.id
@@ -1,7 +1,6 @@
 /*
 type PubKey struct {}
 type StorageDeal struct {}
-type ElectionArtifacts struct {
     TK Ticket,
     T1 Ticket,
 }
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
index ac16244dd..9d73998c0 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
@@ -36,38 +36,64 @@ func (sms *StorageMiningSubsystem_I) CommitSectorError() deal.StorageDeal {
 	panic("TODO")
 }
 
-func (sms *StorageMiningSubsystem_I) OnNewTipset(chain chain.Chain, epoch block.ChainEpoch, tipset block.Tipset) {
-	panic("TODO")
+
+// triggered by new block reception and tipset assembly
+func (sms *StorageMiningSubsystem_I) OnNewBestChain() {
+	// new election, reset nonce
+	sms.ElectionNonce = 0
+	sms.tryLeaderElection()
 }
 
-func (sms *StorageMiningSubsystem_I) OnNewRound(newTipset block.Tipset) block.ElectionArtifacts {
-	panic("TODO: fix this below")
-
-	// TODO this below has been commented due to incomplete implementation
-	// ea := sms.Consensus().GetElectionArtifacts(sms.CurrentChain, sms.CurrentEpoch)
-	// EP := sms.DrawElectionProof(ea.TK(), sms.workerPrivateKey)
-	// if newTipset {
-	// 	T0 := GenerateNextTicket(ea.T1, workerPrivateKey)
-	// } else {
-	// 	T1 := GenerateNextTicket(T0, workerPrivateKey)
-	// }
-
-	// if sms.Consensus().TryLeaderElection(EP) {
-	// 	// TODO: move this into SPC or Blockchain
-	// 	// SMS should probably not have ability to call BlockProducer directly.
-	// 	sms.BlockProducer().GenerateBlock(EP, ea.T1(), sms.CurrentTipset(), workerKey)
-	// } else {
-	// 	// TODO when not elected
-	// }
-
-	// return ea
+// triggered by wall clock
+func (sms *StorageMiningSubsystem_I) OnNewRound() {
+	// repeat on prior tipset, increment nonce
+	sms.ElectionNonce += 1
+	sms.tryLeaderElection()
 }
 
-func (sms *StorageMiningSubsystem_I) DrawElectionProof(tk block.Ticket, workerKey filcrypto.PrivKey) block.ElectionProof {
-	// return generateElectionProof(tk, workerKey)
-	panic("TODO")
+func (sms *StorageMiningSubsystem_I) tryLeaderElection() {
+	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain)
+	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain)
+
+	for _, worker := range sms.workers {
+		newTicket := PrepareNewTicket(worker.VRFKeyPair, T1)
+		newEP := DrawElectionProof(TK, sms.electionNonce, worker.VRFKeyPair)
+
+		if storagePowerConsensus.IsWinningLeaderElection(newEP, worker.address) {
+			BlockProducer.GenerateBlockHeader(newEP, newTicket, sms.CurrentTipset, worker.workerAddress)
+		}
+	}
 }
 
-func (sms *StorageMiningSubsystem_I) GenerateNextTicket(t1 block.Ticket, workerKey filcrypto.PrivKey) block.Ticket {
+// TODO this should be moved into storage market
+func (sp *StorageProvider_I) NotifyStorageDealStaged(storageDealNotification StorageDealStagedNotification) {
 	panic("TODO")
 }
+func (sms *StorageMiningSubsystem_I) PrepareNewTicket(priorTicket Ticket, vrfKP libcrypto.VRFKeyPair) Ticket {
+	// 0. prepare new ticket
+	var newTicket Ticket
+
+	// 1. run it through the VRF and get deterministic output
+	// 1.i. take the VRFResult of that ticket as input, specifying the personalization (see data structures)
+	input := VRFPersonalization.Ticket
+	input.append(priorTicket.Output)
+	// 2.ii. run through VRF
+	newTicket.VRFResult := vrfKP.Generate(input)
+
+	return newTicket
+}
+
+func (sms *StorageMiningSubsystem_I) DrawElectionProof(lookbackTicket Ticket, nonce ElectionNonce, vrfKP libcrypto.VRFKeyPair) ElectionProof {
+	// 0. Prepare new election proof
+	var newEP ElectionProof
+
+	// 1. Run it through VRF and get determinstic output
+    // 1.i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
+	input := VRFPersonalization.ElectionProof
+	input.append(lookbackTicket.Output)
+	input.append(nonce)
+    // ii. # run it through the VRF and store the VRFProof in the new ticket
+	newEP.VRFResult := vrfKP.Generate
+	newEP.ElectionNonce := nonce
+	return newEP
+}
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
index 6b72d7aa8..192b5aaf4 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
@@ -20,7 +20,12 @@ type StorageMiningSubsystem struct {
     MinerActor         StorageMinerActor
     SectorIndex        sectoridx.SectorIndexerSubsystem
     StorageProving     storage_proving.StorageProvingSubsystem
+<<<<<<< HEAD
     BlockProducer      blockproducer.BlockProducer
+=======
+    BlockProducer      blockproducer.BlockProducer
+    electionNonce      ElectionNonce
+>>>>>>> lots of progress on all functions related to ticket creation/validation, and EP creation/validation as well as randomness sampling
 
     // Need access to SPC in order to mine a block
     Consensus          spc.StoragePowerConsensusSubsystem
@@ -51,21 +56,17 @@ type StorageMiningSubsystem struct {
     CommitSectorError()
 
     // call by StorageMiningSubsystem itself in BlockProduction
-    DrawElectionProof(tk chain.Randomness, workerKey filcrypto.PrivKey) block.ElectionProof
+    DrawElectionProof(lookbackTicket Ticket, nonce ElectionNonce, vrfKP libcrypto.VRFKeyPair) ElectionProof {
 
     // call by StorageMiningSubsystem itself in BlockProduction
-    // use T1 randomness when producing on a tipset
-    // use T0 randomness when producing on a null block
-    GenerateNextTicket(seed chain.Randomness, workerKey filcrypto.PrivKey) block.Ticket
+    PrepareNewTicket(priorTicket Ticket, workerKeyPair libcrypto.VRFKeyPair) Ticket
 
     // call by BlockChain when a new block is produced
-    OnNewTipset(
-        chain   chain.Chain
-        epoch   block.ChainEpoch
-        tipset  block.Tipset
-    )
+    OnNewBestChain()
 
     // call by clock during BlockProduction
     // TODO: define clock better
-    OnNewRound(newTipset block.Tipset) block.ElectionArtifacts
+    OnNewRound()
+
+    tryLeaderElection()
 }

From 743dcfd977c93fa1c89a86cc8d07b878f900f02b Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Fri, 11 Oct 2019 03:43:27 +0300
Subject: [PATCH 13/16] fix missed merge conflict

---
 .../filecoin_mining/storage_mining/storage_mining_subsystem.go   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
index 9d73998c0..e1cc54624 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
@@ -36,7 +36,6 @@ func (sms *StorageMiningSubsystem_I) CommitSectorError() deal.StorageDeal {
 	panic("TODO")
 }
 
-
 // triggered by new block reception and tipset assembly
 func (sms *StorageMiningSubsystem_I) OnNewBestChain() {
 	// new election, reset nonce

From e1c38ec7360cd513b1d9e202d1262206daa93dd2 Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Fri, 11 Oct 2019 08:19:30 +0300
Subject: [PATCH 14/16] ticket sampling coded.

---
 src/algorithms/expected_consensus.md          |  4 ++
 .../chainsync/block_syncer.go                 |  2 +
 .../storage_power_consensus/_index.md         | 62 ++++++++++++++++++-
 .../storage_power_consensus_subsystem.go      | 22 ++++---
 .../storage_power_consensus_subsystem.id      | 11 ++--
 .../struct/block/tipset.go                    | 58 +++++++++++++++++
 .../storage_mining_subsystem.go               |  4 +-
 7 files changed, 148 insertions(+), 15 deletions(-)

diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index cecec1959..c3a020865 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -63,6 +63,10 @@ However this introduces a tradeoff:
 decreasing the cost of running a targeted attack (given they have local predictability).
 - It means electionProofs are stored separately from new tickets on a block, taking up
 more space on-chain.
+
+How is K selected?
+- On the one end, there is no advantage to picking K larger than finality (by definition a fully-global lottery).
+- On the other, making K smaller reduces adversarial power to grind.
 ```
 
 ### Ticket generation
diff --git a/src/systems/filecoin_blockchain/chainsync/block_syncer.go b/src/systems/filecoin_blockchain/chainsync/block_syncer.go
index 71569ab8c..d72df5233 100644
--- a/src/systems/filecoin_blockchain/chainsync/block_syncer.go
+++ b/src/systems/filecoin_blockchain/chainsync/block_syncer.go
@@ -16,6 +16,8 @@ func (self *BlockSyncer_I) OnNewBlock(block block.Block) error {
 // The syntactic stage may be validated without reference to additional data (see block)
 func (bs *BlockSyncer_I) validateBlockSyntax(block block.Block) error {
 	panic("TODO")
+
+	// if !block.Epoch().WithinFinality
 	// if !block.MinerAddress().VerifySyntax(StorageMinerActor.Address.Protocol()) {
 	// 	return ErrInvalidBlockSyntax("bad miner address syntax")
 	// }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
index 06062dd56..29cb6d242 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
@@ -94,4 +94,64 @@ Because a Tipset can contain multiple blocks, the smallest ticket in the Tipset
     ┴────┘─ ─ ─ ─ ─ ─ ─ ─ ┘
 ```
 
-In the above diagram, a miner will use block A's Ticket to generate a new ticket (or an election proof farther in the future) since it is the smallest in the Tipset.
\ No newline at end of file
+In the above diagram, a miner will use block A's Ticket to generate a new ticket (or an election proof farther in the future) since it is the smallest in the Tipset.
+
+## Drawing randomness for sector commitments
+
+Tickets are used as input to the SEAL above in order to tie Proofs-of-Replication to a given chain, thereby preventing long-range attacks (from another miner in the future trying to reuse SEALs).
+
+The ticket has to be drawn from a finalized block in order to prevent the miner from potential losing storage (in case of a chain reorg) even though their storage is intact.
+
+Verification should ensure that the ticket was drawn no farther back than necessary by the miner. We note that tickets can uniquely be associated to a given round in the protocol (lest a hash collision be found), but that the round number is explicited by the miner in `commitSector`.
+
+We present precisely how ticket selection and verification should work. In the below, we use the following notation:
+
+- `F`-- Finality (number of rounds)
+- `X`-- round in which SEALing starts
+- `Z`-- round in which the SEAL appears (in a block)
+- `Y`-- round announced in the SEAL `commitSector` (should be X, but a miner could use any Y <= X), denoted by the ticket selection
+ - `T`-- estimated time for SEAL, dependent on sector size
+ - `G = T + variance`-- necessary flexibility to account for network delay and SEAL-time variance.
+
+We expect Filecoin will be able to produce estimates for sector commitment time based on sector sizes, e.g.:
+`(estimate, variance) <--- SEALTime(sectors)`
+G and T will be selected using these.
+
+###### Picking a Ticket to Seal
+
+When starting to prepare a SEAL in round X, the miner should draw a ticket from X-F with which to compute the SEAL.
+
+###### Verifying a Seal's ticket
+
+When verifying a SEAL in round Z, a verifier should ensure that the ticket used to generate the SEAL is found in the range of rounds [Z-T-F-G, Z-T-F+G].
+
+###### In Detail
+
+```
+                                           Prover
+                       ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                      │
+
+                      ▼
+                     X-F ◀───────F────────▶ X ◀──────────T─────────▶ Z
+                 -G   .  +G                 .                        .
+              ───(┌───────┐)───────────────( )──────────────────────( )────────▶
+                  └───────┘                 '                        '        time
+             [Z-T-F-G, Z-T-F+G]
+                      ▲
+
+                      └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                                          Verifier
+```
+
+Note that the prover here is submitting a message on chain (i.e. the SEAL). Using an older ticket than necessary to generate the SEAL is something the miner may do to gain more confidence about finality (since we are in a probabilistically final system). However it has a cost in terms of securing the chain in the face of long-range attacks (specifically, by mixing in chain randomness here, we ensure that an attacker going back a month in time to try and create their own chain would have to completely regenerate any and all sectors drawing randomness since to use for their fork's power).
+
+We break this down as follows:
+
+- The miner should draw from `X-F`.
+- The verifier wants to find what `X-F` should have been (to ensure the miner is not drawing from farther back) even though Y (i.e. the round of the ticket actually used) is an unverifiable value.
+- Thus, the verifier will need to make an inference about what `X-F` is likely to have been based on:
+  - (known) round in which the message is received (Z)
+  - (known) finality value (F)
+  - (approximate) SEAL time (T)
+- Because T is an approximate value, and to account for network delay and variance in SEAL time across miners, the verifier allows for G offset from the assumed value of `X-F`: `Z-T-F`, hence verifying that the ticket is drawn from the range `[Z-T-F-G, Z-T-F+G]`.
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
index 36e466413..da4ff8054 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
@@ -12,11 +12,13 @@ import (
 	clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 )
 
+const FINALITY = 500
+
 const (
 	SPC_LOOKBACK_RANDOMNESS = 300 // this is EC.K maybe move it there. TODO
 	SPC_LOOKBACK_TICKET     = 1   // we chain blocks together one after the other
-	SPC_LOOKBACK_POST       = -1  // TODO complete
-	SPC_LOOKBACK_SEAL       = -1  // TODO complete
+	SPC_LOOKBACK_POST       = 1   // cheap to generate, should be set as close to current TS as possible
+	SPC_LOOKBACK_SEAL       = FINALITY  // should be set to finality
 )
 
 const VRFPersonalization {
@@ -59,7 +61,7 @@ func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block blockchain.Bloc
 }
 
 func (spc *StoragePowerConsensusSubsystem_I) validateTicket(ticket base.Ticket, pk filcrypto.PublicKey) bool {
-	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain)
+	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
 	input := VRFPersonalization.Ticket
 	input.append(T1.Output)
 	return ticket.Verify(input, pk)
@@ -73,25 +75,25 @@ func (spc *StoragePowerConsensusSubsystem_I) StoragePowerConsensusError(errMsg s
 	panic("TODO")
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetTicketProductionSeed(chain blockchain.Chain) base_mining.SealSeed {
+func (spc *StoragePowerConsensusSubsystem_I) GetTicketProductionSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
 	return &base_mining.SealSeed_I {
 		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_TICKET)
 	}
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetElectionProofSeed(chain blockchain.Chain) base_mining.SealSeed {
+func (spc *StoragePowerConsensusSubsystem_I) GetElectionProofSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
 	return &base_mining.SealSeed_I {
 		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_RANDOMNESS),
 	}
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetSealSeed(chain blockchain.Chain) base_mining.SealSeed {
+func (spc *StoragePowerConsensusSubsystem_I) GetSealSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
 	return &base_mining.SealSeed_I {
 		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_SEAL)
 	}
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetPoStChallenge(chain blockchain.Chain) base_mining.PoStChallenge {
+func (spc *StoragePowerConsensusSubsystem_I) GetPoStChallenge(chain blockchain.Chain, epoch Epoch) base_mining.PoStChallenge {
 	return &base_mining.PoStChallenge_I {
 		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_POST)
 	}
@@ -106,7 +108,7 @@ func (spc *StoragePowerConsensusSubsystem_I) ValidateElectionProof(height BlockH
 	// 2. Determine that ticket was validly scratched
 	minerPK := spc.PowerTable.GetMinerPublicKey(workerAddr)
 	input := VRFPersonalization.ElectionProof
-	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain)
+	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
 	input.append(TK.Output)
 	input.appent(electionProof.ElectionNonce)
 
@@ -124,6 +126,10 @@ func (spc *StoragePowerConsensusSubsystem_I) IsWinningElectionProof(electionProo
 	return (minerPower * 2^(len(electionProof.Output)*8) < electionProof.Output * totalPower)
 }
 
+func (spc *StoragePowerConsensusSubsystem_I) GetFinality() Epoch {
+	return FINALITY
+}
+
 // Power Table
 
 func (pt *PowerTable_I) GetMinerPower(addr base.Address) base.StoragePower {
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
index 667c4edb8..daa87789d 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
@@ -32,16 +32,18 @@ type StoragePowerConsensusSubsystem struct {//(@mutable)
     // Randomness methods
 
     // call by StorageMiningSubsystem during block production
-    GetTicketProductionSeed(chain blockchain.Chain) base.Ticket
+    GetTicketProductionSeed(chain blockchain.Chain, epoch Epoch) base.Ticket
 
     // call by StorageMiningSubsystem during block production
-    GetElectionProofSeed(chain blockchain.Chain) base.Ticket
+    GetElectionProofSeed(chain blockchain.Chain, epoch Epoch) base.Ticket
 
     // call by StorageMiningSubsystem in sealing sector
-    GetSealSeed(chain chain.Chain) base_mining.SealSeed
+    GetSealSeed(chain chain.Chain, epoch Epoch) base_mining.SealSeed
 
     // call by StorageMiningSubsystem after sealing
-    GetPoStChallenge(chain chain.Chain) base_mining.PoStChallenge
+    GetPoStChallenge(chain chain.Chain, epoch Epoch) base_mining.PoStChallenge
+
+    GetFinality()   Epoch
 }
 
 type ExpectedConsensus struct {
@@ -51,6 +53,7 @@ type ExpectedConsensus struct {
 
 type PowerTable struct {
     // all power here is always verified
+    RegisterMiner(addr base.Address)
     miners {base.Address: StorageMiner}
     GetMinerPower(addr base.Address) base.StoragePower
     GetTotalPower() base.StoragePower
diff --git a/src/systems/filecoin_blockchain/struct/block/tipset.go b/src/systems/filecoin_blockchain/struct/block/tipset.go
index 0d4f5a35d..c001d411b 100644
--- a/src/systems/filecoin_blockchain/struct/block/tipset.go
+++ b/src/systems/filecoin_blockchain/struct/block/tipset.go
@@ -4,6 +4,22 @@ import (
 	clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 )
 
+func (ts *Tipset_I) MinTicket() base.Ticket {
+	var ret Ticket
+
+	for _, currBlock := range ts.Blocks() {
+		tix := currBlock.Ticket()
+		if ret == nil {
+			ret = tix
+		} else {
+			ret = SmallerBytes(tix, ret)
+		}
+	}
+
+	Assert(ret != nil)
+	return tix
+}
+
 func (ts *Tipset_I) ValidateSyntax() bool {
 
 	if len(ts.Blocks_) <= 0 {
@@ -56,3 +72,45 @@ func (ts *Tipset_I) LatestTimestamp() clock.Time {
 // 	}
 // 	return currTree
 // }
+<<<<<<< HEAD:src/systems/filecoin_blockchain/struct/block/tipset.go
+=======
+
+func (bl *Block_I) TipsetAtEpoch(epoch Epoch) Tipset_I {
+	dist := bl.Epoch() - epoch - 1
+	current := bl.ParentTipset_
+	parents := current.Parents_
+	for i := range dist {
+		current = parents
+		parent = current.Parents_
+	}
+
+	return current
+}
+
+func (bl *Block_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
+	ts := bl.TipsetAtEpoch(epoch)
+	return ts.MinTicket()
+}
+
+func (chain *Chain_I) TipsetAtEpoch(epoch base.Epoch) base.Tipset_I {
+	dist := chain.HeadEpoch() - epoch
+	current := chain.HeadTipset()
+	parents := current.Parents_
+	for i := range dist {
+		current = parents
+		parent = current.Parents_
+	}
+
+	return current
+}
+
+func (chain *Chain_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
+	ts := chain.TipsetAtEpoch(epoch)
+	return ts.MinTicket()
+}
+
+func (chain *Chain_I) FinalizedEpoch() Epoch {
+	ep := HeadEpoch()
+	return ep - spc.GetFinality()
+}
+>>>>>>> ticket sampling coded.:src/systems/filecoin_blockchain/blockchain/block.go
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
index e1cc54624..2bcc3b40e 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
@@ -51,8 +51,8 @@ func (sms *StorageMiningSubsystem_I) OnNewRound() {
 }
 
 func (sms *StorageMiningSubsystem_I) tryLeaderElection() {
-	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain)
-	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain)
+	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
+	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
 
 	for _, worker := range sms.workers {
 		newTicket := PrepareNewTicket(worker.VRFKeyPair, T1)

From c8b3b06d75c99df84c3dd99b452b956d99347eac Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Sat, 12 Oct 2019 21:59:30 +0300
Subject: [PATCH 15/16] added faults, collateral, storage power actor methods

---
 hugo/data/sref_locations.yaml                 | 13 ++-
 hugo/data/sref_titles.yaml                    |  4 +
 src/algorithms/expected_consensus.md          | 25 ++---
 .../storage_power_consensus/_index.md         | 52 ++++-------
 .../storage_power_actor.go                    | 93 ++++++++++++++++++-
 .../storage_power_actor.id                    | 49 +++++++---
 .../storage_power_actor.md                    | 37 ++++++++
 .../storage_power_consensus_subsystem.go      | 23 +----
 .../storage_power_consensus_subsystem.id      | 25 ++---
 .../filecoin_blockchain/struct/block/other.id |  3 +-
 .../filecoin_markets/storage_market/faults.md | 10 +-
 .../storage_market/storage_market_actor.md    | 10 ++
 .../storage_mining_subsystem.id               |  5 +
 13 files changed, 245 insertions(+), 104 deletions(-)

diff --git a/hugo/data/sref_locations.yaml b/hugo/data/sref_locations.yaml
index 6e8f6dcaf..21174be8d 100644
--- a/hugo/data/sref_locations.yaml
+++ b/hugo/data/sref_locations.yaml
@@ -15,12 +15,19 @@ chainsync: [systems, filecoin_blockchain, chainsync]
 ### SPC
 storage_power_consensus: [systems, filecoin_blockchain, storage_power_consensus]
 ticket_chain: [systems, filecoin_blockchain, storage_power_consensus, ticket_chain]
-power_table: [systems, filecoin_blockchain, storage_power_consensus]
-expected_consensus: [algorithms, expected_consensus]
+
+### Storage Market Actor
+power_table: [systems, filecoin_blockchain, storage_power_consensus, storage_power_actor, power_table]
+pledge_collateral: [systems, filecoin_blockchain, storage_power_consensus, storage_power_actor, pledge_collateral]
+
+### EC
 tickets: [algorithms, expected_consenus, tickets]
+expected_consensus: [algorithms, expected_consensus]
 leader_election: [algorithms, expected_consensus, leader_election]
 chain_selection: [algorithms, expected_consensus, chain_selection]
 finality: [algorithms, expected_consensus, finality]
+consensus_faults: [algorithms, expected_consensus, consensus_faults]
+
 ### Message Pool
 message_pool: [systems, filecoin_blockchain, message_pool]
 message_syncer: [systems, filecoin_blockchain, message_syncer]
@@ -31,6 +38,8 @@ message_storage: [systems, filecoin_blockchain, message_storage]
 # markets
 retrieval_market: [systems, filecoin_markets, retrieval_market]
 storage_market: [systems, filecoin_markets, storage_market]
+storage_deal_collateral: [systems, filecoin_markets, storage_market, storage_deal_collateral]
+storage_faults: [systems, filecoin_markets, storage_market, faults]
 
 # mining
 
diff --git a/hugo/data/sref_titles.yaml b/hugo/data/sref_titles.yaml
index 10a17a7df..d7caf0512 100644
--- a/hugo/data/sref_titles.yaml
+++ b/hugo/data/sref_titles.yaml
@@ -17,6 +17,8 @@ tickets: "Tickets"
 leader_election: "Secret Leader Election"
 chain_selection: "Chain Selection"
 finality: "EC Finality"
+consensus_faults: "Consensus Faults"
+
 ### Message Pool
 message_pool: "Message Pool"
 message_syncer: "Message Syncer"
@@ -27,6 +29,8 @@ message_storage: "Message Storage"
 # markets
 retrieval_market: "Retrieval Market"
 storage_market: "Storage Market"
+storage_deal_collateral: "Storage Deal Collateral"
+storage_faults: "Storage Faults"
 
 # mining
 
diff --git a/src/algorithms/expected_consensus.md b/src/algorithms/expected_consensus.md
index c3a020865..fe2eba392 100644
--- a/src/algorithms/expected_consensus.md
+++ b/src/algorithms/expected_consensus.md
@@ -146,9 +146,7 @@ The weight should be calculated using big integer arithmetic with order of opera
 
 For a given tipset `ts` in round `r+1`, we define:
 
-- `wPowerFactor[r+1]  = `
-  - with `log2b(X) = floor(log2(x)) = (binary length of X) - 1`
-    - We define the special case: `log2b(0) = 0`. Note that it should never be used (given it would mean an empty power table.
+- `wPowerFactor[r+1]  = wFunction(totalPowerAtTipset(ts))`
 - wBlocksFactor[r+1] =  `wPowerFactor[r+1] * wRatio * b / e`
   - with `b = |blocksInTipset(ts)|`
   - `e = expected number of blocks per round in the protocol`
@@ -157,12 +155,14 @@ Thus, for stability of weight across implementations, we take:
 - wBlocksFactor[r+1] =  `(wPowerFactor[r+1] * b * wRatio_num) / (e * wRatio_den)`
 
 We get:
-- `w[r+1] = w[r] + log2b(totalPowerAtTipset(ts)) * 2^8 + (log2b(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)`
+- `w[r+1] = w[r] + wFunction(totalPowerAtTipset(ts)) * 2^8 + (wFunction(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)`
  Using the 2^8 here to prevent precision loss ahead of the division in the wBlocksFactor.
 
  The exact value for these parameters remain to be determined, but for testing purposes, you may use:
  - `e = 5`
  - `wRatio = .5, or wRatio_num = 1, wRatio_den = 2`
+- `wFunction = log2b` with
+  - `log2b(X) = floor(log2(x)) = (binary length of X) - 1` and `log2b(0) = 0`. Note that that special case should never be used (given it would mean an empty power table.
 
 ```sh
 Note that if your implementation does not allow for rounding to the fourth decimal, miners should apply the [tie-breaker below](#selecting-between-tipsets-with-equal-weight). Weight changes will be on the order of single digit numbers on expectation, so this should not have an outsized impact on chain consensus across implementations.
@@ -190,17 +190,20 @@ The probability that two Tipsets with different blocks would have all the same t
 ## Finality in EC
 EC enforces a version of soft finality whereby all miners at round N will reject all blocks that fork off prior to round N-F. For illustrative purposes, we can take F to be 500. While strictly speaking EC is a probabilistically final protocol, choosing such an F simplifies miner implementations and enforces a macroeconomically-enforced finality at no cost to liveness in the chain.
 
-## Slashing in EC
+{{<label consensus_faults>}}
+## Consensus Faults
 
-Due to the existence of potential forks, a miner can try to unduly influence protocol fairness. This means they may choose to disregard the protocol in order to gain an advantage over the power they should normally get from their storage on the network. A miner should be slashed if they are provably deviating from the honest protocol.
+Due to the existence of potential forks in EC, a miner can try to unduly influence protocol fairness. This means they may choose to disregard the protocol in order to gain an advantage over the power they should normally get from their storage on the network. A miner should be slashed if they are provably deviating from the honest protocol.
 
-This is detectable when a miner submits two blocks that satisfy any of the following "slashing conditions":
+This is detectable when a given miner submits two blocks that satisfy any of the following "consensus faults":
 
-(1) two blocks contains the same electionProof nonce, mined at the same height.
-(2) one block's parent is a Tipset that could have validly included the other block according to Tipset validity rules, however the parent of the first block does not include the other block.
+- (1) `double-fork mining fault`: two blocks contains the same electionProof nonce, mined at the same height.
+- (2) `parent grinding fault`: one block's parent is a Tipset that could have validly included the other block according to Tipset validity rules, however the parent of the first block does not include the other block.
 
   - While it cannot be proven that a miner omits known blocks from a Tipset in general (i.e. network latency could simply mean the miner did not receive a particular block) in this case it can be proven because a miner must be aware of a block they mined in a previous round.
 
-Any node that detects this occurring should take both block headers, and call [`storagemarket.SlashConsensusFault`](actors.md#slashconsensusfault). The network will then take all of that node's collateral.
+Any node that detects either of the above events should submit both block headers to the `StoragePowerActor`'s `ReportConsensusFault` method. The "slasher" will receive a portion (TODO: define how much) of the offending miner's {{<sref pledge_collateral>}} as a reward for notifying the network of the fault.
+(TODO: FIP of submitting commitments to block headers to prevent miners censoring slashers in order to gain rewards).
 
-Note that a miner will likewise be slashed on failing to submit their Proof-of-Spacetime in time, given the undue power over consensus it gives them.
\ No newline at end of file
+It is important to note that there exists a third type of consensus fault directly reported by the `CronActor` on `StorageDeal` failures via the `ReportUncommittedPowerFault` method:
+- (3) `uncommitted power fault` which occurs when a miner fails to submit their `PostProof` and is thus participating in leader election with undue power (see {{<sref storage_faults>}}).
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
index 29cb6d242..58729078f 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/_index.md
@@ -13,7 +13,7 @@ Succinctly, the SPC subsystem offers the following services:
 - Access to {{<sref expected_consensus>}} for individual storage miners, enabling:
     - Access to verifiable randomness {{<sref tickets>}} as needed in the rest of the protocol.
     - Running  {{<sref leader_election>}} to produce new blocks.
-    - Running {{<sref chain_selection>}} across subchains using EC's weighting function. 
+    - Running {{<sref chain_selection>}} across subchains using EC's weighting function.
     - Identification of {{<sref finality "the most recently finalized tipset">}}, for use by all protocol participants.
 
 Much of the Storage Power Consensus' subsystem functionality is detailed in the code below but we touch upon some of its behaviors in more detail.
@@ -22,7 +22,7 @@ Much of the Storage Power Consensus' subsystem functionality is detailed in the
 
 ## Distinguishing between storage miners and block miners
 
-There are two ways to earn Filecoin tokens in the Filecoin network: 
+There are two ways to earn Filecoin tokens in the Filecoin network:
 - By participating in the {{<sref storage_market>}} as a storage provider and being paid by clients for file storage deals.
 - By mining new blocks on the network, helping modify system state and secure the Filecoin consensus mechanism.
 
@@ -30,20 +30,6 @@ We must distinguish between both types of "miners" (storage and block miners). {
 
 However, given Filecoin's "useful Proof-of-Work" is achieved through file storage (PoRep and PoSt), there is little overhead cost for storage miners to participate in leader election. Such a {{<sref storage_miner_actor>}} need only register with the {{<sref storage_power_actor>}} in order to participate in Expected Consensus and mine blocks.
 
-{{<label power_table>}}
-## The Power Table
-
-The portion of blocks a given miner generates through leader election in EC (and so the block rewards they earn) is proportional to their `Power Fraction` over time. That is, a miner whose storage represents 1% of total storage on the network should mine 1% of blocks on expectation.
-
-SPC provides a power table abstraction which tracks miner power (i.e. miner storage in relation to network storage) over time. The power table is updated for new sector commitments (incrementing miner power), when PoSts fail to be put on-chain (decrementing miner power) or for other storage and consensus faults.
-
-An invariant of the storage power consensus subsystem is that all storage in the power table must be verified. That is, miners can only derive power from storage they have already proven to the network. 
-
-In order to achieve this, Filecoin delays updating power for new sector commitments until the first valid PoSt in the next proving period corresponding to that sector.
-Conversely, storage faults only lead to power loss once they are detected (up to one proving period after the fault) so miners will mine with no more power than they have used to store data over time.
-
-Put another way, power accounting in the SPC is delayed between storage being proven or faulted, and power being updated in the power table (and so for leader election). This ensures fairness over time.
-
 ## Repeated leader election attempts
 
 In the case that no miner is eligible to produce a block in a given round of EC, the storage power consensus subsystem will be called by the block producer to attempt another leader election by incrementing the nonce appended to the ticket drawn from the past in order to attempt to craft a new valid `ElectionProof` and trying again.
@@ -117,31 +103,31 @@ We expect Filecoin will be able to produce estimates for sector commitment time
 `(estimate, variance) <--- SEALTime(sectors)`
 G and T will be selected using these.
 
-###### Picking a Ticket to Seal
+#### Picking a Ticket to Seal
 
 When starting to prepare a SEAL in round X, the miner should draw a ticket from X-F with which to compute the SEAL.
 
-###### Verifying a Seal's ticket
+#### Verifying a Seal's ticket
 
 When verifying a SEAL in round Z, a verifier should ensure that the ticket used to generate the SEAL is found in the range of rounds [Z-T-F-G, Z-T-F+G].
 
-###### In Detail
+#### In Detail
 
 ```
-                                           Prover
-                       ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-                      │
-
-                      ▼
-                     X-F ◀───────F────────▶ X ◀──────────T─────────▶ Z
-                 -G   .  +G                 .                        .
-              ───(┌───────┐)───────────────( )──────────────────────( )────────▶
-                  └───────┘                 '                        '        time
-             [Z-T-F-G, Z-T-F+G]
-                      ▲
-
-                      └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-                                          Verifier
+                               Prover
+           ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+          │
+
+          ▼
+         X-F ◀───────F────────▶ X ◀──────────T─────────▶ Z
+     -G   .  +G                 .                        .
+  ───(┌───────┐)───────────────( )──────────────────────( )────────▶
+      └───────┘                 '                        '        time
+ [Z-T-F-G, Z-T-F+G]
+          ▲
+
+          └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+                              Verifier
 ```
 
 Note that the prover here is submitting a message on chain (i.e. the SEAL). Using an older ticket than necessary to generate the SEAL is something the miner may do to gain more confidence about finality (since we are in a probabilistically final system). However it has a cost in terms of securing the chain in the face of long-range attacks (specifically, by mixing in chain randomness here, we ensure that an attacker going back a month in time to try and create their own chain would have to completely regenerate any and all sectors drawing randomness since to use for their fork's power).
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
index b18bea2c1..238e58054 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
@@ -1,8 +1,95 @@
 package storage_power_consensus
 
-import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
+import (
+	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
+	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
+  sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
+  block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
+  deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+	blockchain "github.com/filecoin-project/specs/systems/filecoin_blockchain/blockchain"
+)
 
-func (spa *StoragePowerActor_I) UpdatePower(address addr.Address, newPower StoragePower) {
+const PLEDGE_COLLATERAL_PER_GB = -1 // TODO define
+
+// Actor
+func (spa *StoragePowerActor_I) ReportConsensusFault(slasherAddr addr.Address, faultType ec.ConsensusFaultType, proof [Block]) {
+	panic("TODO")
+
+	// Use EC's IsValidConsensusFault method to validate the proof
+	// slash block miner's pledge collateral
+	// reward slasher
+}
+
+func (spa *StoragePowerActor_I) ReportUncommittedPowerFault(cheaterAddr addr.Address, numSectors UVarint) {
 	panic("TODO")
-	// spa.Miners()[addr.Address] = spa.Miners()[addr.Address] + newPower
+	// Quite a bit more straightforward since only called by the cron actor (ie publicly verified)
+
+	// slash cheater pledge collateral accordingly based on num sectors faulted
+}
+
+func (spa *StoragePowerActor_I) CommitPledgeCollateral(deals [deal.StorageDeal]) {
+
+	panic("TODO")
+	// check that based on deals (ie sector sizes and num sectors) miner has enough associated balance in the storage miner wallet
+	// pledge and associate
+}
+
+func (spa *StoragePowerActor_I) DecommitPledgeCollateral(deals [deal.StorageDeal]) {
+	panic("TODO")
+	// must check more than finality post deal expiration
+	// return appropriate amount to storage market based on deals
+}
+
+
+
+// Power Table
+
+func (pt *PowerTable_I) RegisterMiner(addr addr.Address, pk filcrypto.PublicKey, sectorSize sector.SectorSize) {
+	pt.miners[addr] := StorageMiner{
+		minerAddress: addr,
+		minerStoragePower: 0,
+		minerSuspendedPower: 0,
+		minerPK: pk,
+		minerSectorSize: sectorSize
+	}
+}
+
+func (pt *PowerTable_I) GetMinerPower(addr addr.Address) block.StoragePower {
+	return pt.miners[addr].minerStoragePower
+}
+
+func (pt *PowerTable_I) GetTotalPower() block.StoragePower {
+	totalPower := 0
+	for _, miner := range pt.miners {
+		totalPower += miner.minerStoragePower
+	}
+	return totalPower
+}
+
+func (pt *PowerTable_I) GetMinerPublicKey() filcrypto.PublicKey {
+	return pt.miners[addr].minerPK
+}
+
+func (pt *PowerTable_I) IncrementPower(addr addr.Address, numSectors UVarint) {
+	pt.miners.[addr].minerStoragePower += numSectors * pt.miners.[addr].minerSectorSize
+}
+
+// must be atomic
+func (pt *PowerTable_I) SuspendPower(addr addr.Address, numSectors UVarint) {
+	pt.miners.[addr].minerStoragePower -= numSectors * pt.miners.[addr].minerSectorSize
+	pt.miners.[addr].minerSuspendedPower += numSectors * pt.miners.[addr].minerSectorSize
+}
+
+// must be atomic
+func (pt *PowerTable_I) UnsuspendPower(addr addr.Address, numSectors UVarint) {
+	pt.miners.[addr].minerSuspendedPower -= numSectors * pt.miners.[addr].minerSectorSize
+	pt.miners.[addr].minerStoragePower += numSectors * pt.miners.[addr].minerSectorSize
+}
+
+func (pt *PowerTable_I) RemovePower(addr addr.Address, numSectors UVarint) {
+	pt.miners.[addr].minerSuspendedPower -= numSectors * pt.miners.[addr].minerSectorSize
+}
+
+func (pt *PowerTable_I) RemoveAllPower(addr addr.Address, numSectors UVarint) {
+	pt.miners.[addr].minerStoragePower = 0
 }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
index c68126e96..d5d47d0f5 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
@@ -1,13 +1,14 @@
 import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
+import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
+import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
 import libp2p "github.com/filecoin-project/specs/libraries/libp2p"
-
-type BytesAmount UVarint
-type StoragePower UVarint
+import spc "github.com/filecoin-project/specs/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem"
+import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
 
 type StoragePowerActor struct {
     // TODO: bytesamount might be inefficient
-    Miners {addr.Address: StoragePower}
+    Miners {addr.Address: block.StoragePower}
 
     // call by StorageMiningSubsytem on miner creation
     CreateStorageMiner(
@@ -18,11 +19,11 @@ type StoragePowerActor struct {
     ) addr.Address
 
     // TODO add NotifyConsensusFault(addr.Address, [Block]) TODO maybe rename to Arbitrate
-    UpdatePower(address addr.Address, newPower StoragePower)
+    UpdatePower(address addr.Address, newPower block.StoragePower)
 
-    TotalStorage() StoragePower
+    TotalStorage() block.StoragePower
 
-    PowerLookup(minerAddr addr.Address) StoragePower
+    PowerLookup(minerAddr addr.Address) block.StoragePower
 
     // call by StorageMinerActor on successful seal
     // TODO: workerKey of type StorageMiner.WorkerPubKey
@@ -30,16 +31,42 @@ type StoragePowerActor struct {
 
     SuspendMiner(address addr.Address)
 
-    // UpdateStoragePowerSubsystem(Tipset, StateTree)
+    ec              spc.ExpectedConsensus
+    ReportConsensusFault(slasherAddr addr.Address, faultType ec.ConsensusFaultType, proof [Block]) struct {}
+    ReportUncommittedPowerFault(cheaterAddr addr.Address, numSectors UVarint)
+    PowerTable      PowerTable
 
-    // VerifyElectionProof(base.Address, base.ElectionProof)	bool
+    // VerifyElectionProof(addr.Address, base.ElectionProof)	bool
 
     // TODO: old methods, should be removed
     // UpdateStoragePowerSubsystem(Tipset, StateTree)
     // VerifyElectionProof(addr.Address, base.ElectionProof)	bool
     // NotifyStorageFault(addr.Address)
     // TryPublishBlock(StateTree)					Block
+    CommitPledgeCollateral(deals [deal.StorageDeal])
+    DecommitPledgeCollateral(deals [deal.StorageDeal])
+
+    pledgeCollateralBalances {addr.Address: UVarint}
+}
+
+type PowerTable struct {
+    // all power here is always verified
+    RegisterMiner(addr addr.Address, pk filcrypto.PublicKey, sectorSize sector.SectorSize)
+    miners {addr.Address: StorageMiner}
+    GetMinerPower(addr addr.Address) block.StoragePower
+    GetTotalPower() block.StoragePower
+    GetMinerPublicKey(addr addr.Address) filcrypto.PublicKey
+    IncrementPower(addr addr.Address, numSectors UVarint)
+    SuspendPower(addr addr.Address, numSectors UVarint)
+    UnsuspendPower(addr addr.Address, numSectors UVarint)
+    RemovePower(addr addr.Address, numSectors UVarint)
+    RemoveAllPower(addr addr.Address, numSectors UVarint)
+}
 
-    // RegisterStorageMiner(SealProof)				Address
-    // TryUpdateStorage(base.Address, newPower)			error
+type StorageMiner struct {
+    minerAddress        addr.Address
+    minerStoragePower   block.StoragePower
+    minerSuspendedPower block.StoragePower
+    minerPK             filcrypto.PublicKey
+    minerSectorSize     sector.SectorSize
 }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md
index 8a369f313..27f88847c 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md
@@ -4,3 +4,40 @@ title: Storage Power Actor
 
 {{< readfile file="storage_power_actor.id" code="true" lang="go" >}}
 
+
+{{<label power_table>}}
+## The Power Table
+
+The portion of blocks a given miner generates through leader election in EC (and so the block rewards they earn) is proportional to their `Power Fraction` over time. That is, a miner whose storage represents 1% of total storage on the network should mine 1% of blocks on expectation.
+
+SPC provides a power table abstraction which tracks miner power (i.e. miner storage in relation to network storage) over time. The power table is updated for new sector commitments (incrementing miner power), when PoSts fail to be put on-chain (decrementing miner power) or for other storage and consensus faults.
+
+An invariant of the storage power consensus subsystem is that all storage in the power table must be verified. That is, miners can only derive power from storage they have already proven to the network.
+
+In order to achieve this, Filecoin delays updating power for new sector commitments until the first valid PoSt in the next proving period corresponding to that sector.
+Conversely, storage faults only lead to power loss once they are detected (up to one proving period after the fault) so miners will mine with no more power than they have used to store data over time.
+
+Put another way, power accounting in the SPC is delayed between storage being proven or faulted, and power being updated in the power table (and so for leader election). This ensures fairness over time.
+Finally, we also account for "suspended" power in order to make accounting simple in the presence of faults (see {{<sref consensus_faults>}}) and subsequent recovery.
+
+The Miner lifecycle in the power table should be roughly as follows:
+- MinerRegistration: A new miner with an associated worker public key and address is registered on the power table by the storage mining subsystem, along with their associated sector size (there is only one per worker).
+- UpdatePower: These power increments and decrements (in multiples of the associated sector size) are called by various storage actor (and must thus be verified by every full node on the network). Specifically:
+    - Power is incremented to account for a new SectorCommitment at the first PoSt past the first ProvingPeriod.
+    - All Power is decremented immediately after a missed PoSt.
+    - Power is decremented immediately after faults are declared, proportional to the faulty sector size.
+    - Power is incremented after a PoSt recovering from a fault.
+    - Power is definitively removed from the Power Table past the sector failure timeout (see {{<sref storage_faults>}})
+
+{{<label pledge_collateral>}}
+## Pledge Collateral
+
+Consensus in Filecoin is secured in part by economic incentives enforced by Pledge Collateral.
+
+Pledge collateral amount is committed based on power pledged to the system (i.e. proportional to number of sectors committed and sector size for a miner). It is a system-wide parameter and is committed to the `StoragePowerActor`. TODO: define parameter value. Pledge Collateral submission methods take on storage deals to determine the appropriate amount of collateral to be pledged. Pledge collateral can be posted by the `StorageMinerActor` at any time by a miner up to sector commitments. A sector commitment without the requisite posted pledge collateral will be deemed invalid.
+
+Pledge Collateral will be slashed when {{<sref consensus_faults>}} are reported to the `StoragePowerActor`'s `ReportConsensusFault` method or when the `CronActor` calls the `StoragePowerActor`'s `ReportUncommittedPowerFault` method.
+
+Pledge Collateral is slashed for any fault affecting storage-power consensus, these include:
+- faults to expected consensus in particular (see {{<sref consensus_faults>}}) which will be reported by a slasher to the `StoragePowerActor` in exchange for a reward.
+- faults affecting consensus power more generally, specifically uncommitted power faults (i.e. {{<sref storage faults>}}) which will be reported by the `CronActor` automatically.
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
index da4ff8054..6289c8dfa 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
@@ -128,25 +128,4 @@ func (spc *StoragePowerConsensusSubsystem_I) IsWinningElectionProof(electionProo
 
 func (spc *StoragePowerConsensusSubsystem_I) GetFinality() Epoch {
 	return FINALITY
-}
-
-// Power Table
-
-func (pt *PowerTable_I) GetMinerPower(addr base.Address) base.StoragePower {
-	return pt.miners[addr].minerStoragePower
-}
-func (pt *PowerTable_I) GetTotalPower() base.StoragePower {
-	totalPower := 0
-	for _, miner := range pt.miners {
-		totalPower += miner.minerStoragePower
-	}
-	return totalPower
-}
-
-func (pt *PowerTable_I) GetMinerPublicKey() filcrypto.PublicKey {
-	return pt.miners[addr].minerPK
-}
-
-func (pt *PowerTable_I) RemovePower(addr base.Address) {
-	panic("")
-}
+}
\ No newline at end of file
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
index daa87789d..3a5fb6f60 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
@@ -6,8 +6,6 @@ import st "github.com/filecoin-project/specs/systems/filecoin_vm/state_tree"
 import base_mining "github.com/filecoin-project/specs/systems/filecoin_mining"
 
 type StoragePowerConsensusSubsystem struct {//(@mutable)
-    // TODO: this is incorrect, it does not belong
-    powerTable           PowerTable
     actor                StoragePowerActor
     associatedStateTree  &st.StateTree  // TODO: remove this. should not store this here.
 
@@ -47,22 +45,11 @@ type StoragePowerConsensusSubsystem struct {//(@mutable)
 }
 
 type ExpectedConsensus struct {
-    // ComputeWeight(Chain)							        ChainWeight
-    // IsConsensusFault([Block])						    bool
-}
-
-type PowerTable struct {
-    // all power here is always verified
-    RegisterMiner(addr base.Address)
-    miners {base.Address: StorageMiner}
-    GetMinerPower(addr base.Address) base.StoragePower
-    GetTotalPower() base.StoragePower
-    GetMinerPublicKey(addr base.Address) filcrypto.PublicKey
-    RemovePower(addr base.Address)
-}
+    ComputeWeight(Chain)                                ChainWeight
+    IsValidConsensusFault(ConsensusFaultType, [Block])	bool
 
-type StorageMiner struct {
-    minerAddress       base.Address
-    minerStoragePower  base.StoragePower
-    minerPK            filcrypto.PublicKey
+    ConsensusFaultType union {
+        DoubleForkMiningFault,
+        ParentGrindingFault
+    }
 }
diff --git a/src/systems/filecoin_blockchain/struct/block/other.id b/src/systems/filecoin_blockchain/struct/block/other.id
index 09957afde..3b617e367 100644
--- a/src/systems/filecoin_blockchain/struct/block/other.id
+++ b/src/systems/filecoin_blockchain/struct/block/other.id
@@ -10,7 +10,8 @@ type Ticket struct {
     Verify(input Bytes, pk VRFPublicKey) bool
 }
 
-type StoragePower UVarint
+type BytesAmount UVarint
+type StoragePower BytesAmount
 
 type ElectionSeed filcrypto.VDFResult
 
diff --git a/src/systems/filecoin_markets/storage_market/faults.md b/src/systems/filecoin_markets/storage_market/faults.md
index 3df201770..2bd69d363 100644
--- a/src/systems/filecoin_markets/storage_market/faults.md
+++ b/src/systems/filecoin_markets/storage_market/faults.md
@@ -2,11 +2,17 @@
 title: "Faults"
 ---
 
+{{<label storage_faults>}}
 There are two main categories of faults in the Filecoin network. 
 
 - ConsensusFaults
 - StorageDealFaults
 
-ConsensusFaults are faults that hurt network consensus and StorageDealFaults are faults where data in a `StorageDeal` is not maintained by the providers. `PledgeCollateral` is slashed for ConsensusFaults and `StorageDealCollateral` for StorageDealFaults.
+ConsensusFaults are faults that impact network consensus and StorageDealFaults are faults where data in a `StorageDeal` is not maintained by the providers pursuant to deal terms.
 
-Any misbehavior may result in more than one fault and can lead to slashing on both collaterals. For example, missing a `PoStProof` will incur a penalty on both `PledgeCollateral` and `StorageDealCollateral` if there is the data is stored in a `StorageDeal`.
\ No newline at end of file
+{{<sref pledge_collateral>}} is slashed for ConsensusFaults and {{<sref storage_deal_collateral>}} for StorageDealFaults.
+
+Any misbehavior may result in more than one fault thus lead to slashing on both collaterals. For example, missing a `PoStProof` will incur a penalty on both `PledgeCollateral` and `StorageDealCollateral` given it impacts both a given `StorageDeal` and power derived from the sector commitments in {{<sref storage_power_consensus>}}.
+
+## Storage Faults
+TODO: complete this.
\ No newline at end of file
diff --git a/src/systems/filecoin_markets/storage_market/storage_market_actor.md b/src/systems/filecoin_markets/storage_market/storage_market_actor.md
index 85b7be3f1..5aec7b159 100644
--- a/src/systems/filecoin_markets/storage_market/storage_market_actor.md
+++ b/src/systems/filecoin_markets/storage_market/storage_market_actor.md
@@ -7,3 +7,13 @@ title: Storage Market Actor
 (You can see the _old_ Storage Market Actor [here](docs/systems/filecoin_markets/storage_market/storage_market_actor_old) )
 
 {{< readfile file="storage_market_actor.id" code="true" lang="go" >}}
+
+{{<label storage_deal_collateral>}}
+## Storage Deal Collateral
+
+Storage Deals have an associated collateral amount. This `StorageDealCollateral` is held in the `StorageMarketActor`.
+Its value is agreed upon by the storage provider and client off-chain, but must be greater than a protocol-defined minimum in any deal. Storage providers will choose to offer greater collateral to signal high-quality storage to clients.
+
+On `SectorFailureTimeout` (see {{<sref faults>}}), the `StorageDealCollateral` will be burned. In the future, the Filecoin protocol may be amended to send up to half of the collateral to storage clients as damages in such cases.
+
+Upon graceful deal expiration, storage providers must wait for finality number of epochs (as defined in {{<sref finality>}}) before being able to withdraw their `StorageDealCollateral` from the `StorageMarketActor`.
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
index 192b5aaf4..10ad97497 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
@@ -10,6 +10,11 @@ import blockproducer "github.com/filecoin-project/specs/systems/filecoin_blockch
 import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
 import storage_proving "github.com/filecoin-project/specs/systems/filecoin_mining/storage_proving"
 
+type SectorSize union {
+    32GB    UVarint
+    64GB    UVarint
+}
+
 type StorageMiningSubsystem struct {
     // TODO: constructor
     // InitStorageMiningSubsystem() struct{}

From c57ac59ce854dbc372de0120cce7329bda36d69a Mon Sep 17 00:00:00 2001
From: Henri S <sternhenri@users.noreply.github.com>
Date: Sun, 13 Oct 2019 22:40:47 +0300
Subject: [PATCH 16/16] compiles in spite of heavy commenting out

---
 .../filcrypto/filecoin_crypto_lib.go          |   8 -
 src/systems/filecoin_blockchain/blockchain.id |   8 +-
 .../blockchain/block_producer.go              |   1 +
 .../storage_power_actor.go                    |  84 ++++---
 .../storage_power_actor.id                    |  41 ++--
 .../storage_power_consensus_subsystem.go      | 188 ++++++++-------
 .../storage_power_consensus_subsystem.id      |  42 ++--
 .../filecoin_blockchain/struct/block/block.go |  77 +++---
 .../filecoin_blockchain/struct/block/block.id |  21 +-
 .../filecoin_blockchain/struct/block/other.go |  15 +-
 .../filecoin_blockchain/struct/block/other.id |  18 +-
 .../struct/block/tipset.go                    |  63 +----
 .../struct/block/tipset.id                    |   3 +-
 .../filecoin_blockchain/struct/chain/chain.go |   1 -
 .../filecoin_blockchain/struct/chain/chain.id |  12 -
 .../diagrams/storage_client_fsm.dot           |  34 +++
 .../diagrams/storage_client_fsm.dot.svg       | 145 +++++++++++
 .../diagrams/storage_provider_fsm.dot         |  39 +++
 .../diagrams/storage_provider_fsm.dot.svg     | 225 ++++++++++++++++++
 .../storage_market/storage_provider.go        |  14 +-
 .../storage_market/storage_provider.id        |  12 +-
 .../storage_mining_subsystem.go               |  96 ++++----
 .../storage_mining_subsystem.id               |  20 +-
 23 files changed, 786 insertions(+), 381 deletions(-)
 delete mode 100644 src/systems/filecoin_blockchain/struct/chain/chain.go
 delete mode 100644 src/systems/filecoin_blockchain/struct/chain/chain.id
 create mode 100644 src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot
 create mode 100644 src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot.svg
 create mode 100644 src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot
 create mode 100644 src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot.svg

diff --git a/src/libraries/filcrypto/filecoin_crypto_lib.go b/src/libraries/filcrypto/filecoin_crypto_lib.go
index ed1fe50c5..b4da8737b 100644
--- a/src/libraries/filcrypto/filecoin_crypto_lib.go
+++ b/src/libraries/filcrypto/filecoin_crypto_lib.go
@@ -9,11 +9,3 @@ func (self *VRFResult_I) Verify(input util.Bytes, pk VRFPublicKey) bool {
 func (self *VRFResult_I) ValidateSyntax() bool {
 	panic("TODO")
 }
-
-func (self *VDFResult_I) Verify(input util.Bytes) bool {
-	panic("TODO")
-}
-
-func (self *VDFResult_I) ValidateSyntax() bool {
-	panic("TODO")
-}
diff --git a/src/systems/filecoin_blockchain/blockchain.id b/src/systems/filecoin_blockchain/blockchain.id
index 714f47606..54b474254 100644
--- a/src/systems/filecoin_blockchain/blockchain.id
+++ b/src/systems/filecoin_blockchain/blockchain.id
@@ -1,7 +1,6 @@
 import clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 import st "github.com/filecoin-project/specs/systems/filecoin_vm/state_tree"
 import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-import chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
 
 type SectorID struct {}
 
@@ -18,8 +17,8 @@ type BlockchainSubsystem struct @(mutable) {
     Clock              &clock.WallClock
 
     LatestEpoch()      block.ChainEpoch
-    BestChain()        chain.Chain
-    CandidateChains()  [chain.Chain]
+    BestChain()        block.Chain
+    CandidateChains()  [block.Chain]
 
     // // Receiving blocks and tipset
     // should be channels or notifications
@@ -52,7 +51,4 @@ type BlockchainSubsystem struct @(mutable) {
 
     // call by BlockchainSubsystem itself in BlockReception after Round Cutoff
     ChooseTipset(tipsets [block.Tipset]) block.Tipset
-
-    // call by StorageMining
-    // GetPostRandomness() chain.Randomness
 }
diff --git a/src/systems/filecoin_blockchain/blockchain/block_producer.go b/src/systems/filecoin_blockchain/blockchain/block_producer.go
index e69de29bb..85e0fc0d6 100644
--- a/src/systems/filecoin_blockchain/blockchain/block_producer.go
+++ b/src/systems/filecoin_blockchain/blockchain/block_producer.go
@@ -0,0 +1 @@
+package block_producer
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
index 238e58054..287da4cd0 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.go
@@ -2,17 +2,17 @@ package storage_power_consensus
 
 import (
 	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
+	block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
+	deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+	sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
 	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-  sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
-  block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-  deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
-	blockchain "github.com/filecoin-project/specs/systems/filecoin_blockchain/blockchain"
+	util "github.com/filecoin-project/specs/util"
 )
 
 const PLEDGE_COLLATERAL_PER_GB = -1 // TODO define
 
 // Actor
-func (spa *StoragePowerActor_I) ReportConsensusFault(slasherAddr addr.Address, faultType ec.ConsensusFaultType, proof [Block]) {
+func (spa *StoragePowerActor_I) ReportConsensusFault(slasherAddr addr.Address, faultType ConsensusFaultType, proof []block.Block) {
 	panic("TODO")
 
 	// Use EC's IsValidConsensusFault method to validate the proof
@@ -20,76 +20,84 @@ func (spa *StoragePowerActor_I) ReportConsensusFault(slasherAddr addr.Address, f
 	// reward slasher
 }
 
-func (spa *StoragePowerActor_I) ReportUncommittedPowerFault(cheaterAddr addr.Address, numSectors UVarint) {
+func (spa *StoragePowerActor_I) ReportUncommittedPowerFault(cheaterAddr addr.Address, numSectors util.UVarint) {
 	panic("TODO")
 	// Quite a bit more straightforward since only called by the cron actor (ie publicly verified)
 
 	// slash cheater pledge collateral accordingly based on num sectors faulted
 }
 
-func (spa *StoragePowerActor_I) CommitPledgeCollateral(deals [deal.StorageDeal]) {
+func (spa *StoragePowerActor_I) CommitPledgeCollateral(deals []deal.StorageDeal) {
 
 	panic("TODO")
 	// check that based on deals (ie sector sizes and num sectors) miner has enough associated balance in the storage miner wallet
 	// pledge and associate
 }
 
-func (spa *StoragePowerActor_I) DecommitPledgeCollateral(deals [deal.StorageDeal]) {
+func (spa *StoragePowerActor_I) DecommitPledgeCollateral(deals []deal.StorageDeal) {
 	panic("TODO")
 	// must check more than finality post deal expiration
 	// return appropriate amount to storage market based on deals
 }
 
-
-
 // Power Table
 
-func (pt *PowerTable_I) RegisterMiner(addr addr.Address, pk filcrypto.PublicKey, sectorSize sector.SectorSize) {
-	pt.miners[addr] := StorageMiner{
-		minerAddress: addr,
-		minerStoragePower: 0,
-		minerSuspendedPower: 0,
-		minerPK: pk,
-		minerSectorSize: sectorSize
-	}
+func (pt *PowerTable_I) RegisterMiner(addr addr.Address, pk filcrypto.PubKey, sectorSize sector.SectorSize) {
+	panic("")
+	// newMiner := &StorageMiner_I{
+	// 	MinerAddress_:        addr,
+	// 	MinerStoragePower_:   0,
+	// 	MinerSuspendedPower_: 0,
+	// 	MinerPK_:             pk,
+	// 	MinerSectorSize_:     sectorSize,
+	// }
+	// pt.miners[&addr] = *newMiner
 }
 
 func (pt *PowerTable_I) GetMinerPower(addr addr.Address) block.StoragePower {
-	return pt.miners[addr].minerStoragePower
+	panic("")
+	// return pt.miners[addr].MinerStoragePower
 }
 
 func (pt *PowerTable_I) GetTotalPower() block.StoragePower {
-	totalPower := 0
-	for _, miner := range pt.miners {
-		totalPower += miner.minerStoragePower
-	}
-	return totalPower
+	panic("")
+	// totalPower := 0
+	// for _, miner := range pt.miners {
+	// 	totalPower += miner.MinerStoragePower
+	// }
+	// return totalPower
 }
 
-func (pt *PowerTable_I) GetMinerPublicKey() filcrypto.PublicKey {
-	return pt.miners[addr].minerPK
+func (pt *PowerTable_I) GetMinerPublicKey(addr addr.Address) filcrypto.PubKey {
+	panic("")
+	// return pt.miners[addr].MinerPK
 }
 
-func (pt *PowerTable_I) IncrementPower(addr addr.Address, numSectors UVarint) {
-	pt.miners.[addr].minerStoragePower += numSectors * pt.miners.[addr].minerSectorSize
+func (pt *PowerTable_I) IncrementPower(addr addr.Address, numSectors util.UVarint) {
+	panic("")
+	// pt.miners[addr].MinerStoragePower += numSectors * pt.miners[addr].minerSectorSize
 }
 
 // must be atomic
-func (pt *PowerTable_I) SuspendPower(addr addr.Address, numSectors UVarint) {
-	pt.miners.[addr].minerStoragePower -= numSectors * pt.miners.[addr].minerSectorSize
-	pt.miners.[addr].minerSuspendedPower += numSectors * pt.miners.[addr].minerSectorSize
+func (pt *PowerTable_I) SuspendPower(addr addr.Address, numSectors util.UVarint) {
+	panic("")
+	// pt.miners[addr].MinerStoragePower -= numSectors * pt.miners[addr].minerSectorSize
+	// pt.miners[addr].MinerSuspendedPower += numSectors * pt.miners[addr].minerSectorSize
 }
 
 // must be atomic
-func (pt *PowerTable_I) UnsuspendPower(addr addr.Address, numSectors UVarint) {
-	pt.miners.[addr].minerSuspendedPower -= numSectors * pt.miners.[addr].minerSectorSize
-	pt.miners.[addr].minerStoragePower += numSectors * pt.miners.[addr].minerSectorSize
+func (pt *PowerTable_I) UnsuspendPower(addr addr.Address, numSectors util.UVarint) {
+	panic("")
+	// pt.miners[addr].MinerSuspendedPower -= numSectors * pt.miners[addr].minerSectorSize
+	// pt.miners[addr].MinerStoragePower += numSectors * pt.miners[addr].minerSectorSize
 }
 
-func (pt *PowerTable_I) RemovePower(addr addr.Address, numSectors UVarint) {
-	pt.miners.[addr].minerSuspendedPower -= numSectors * pt.miners.[addr].minerSectorSize
+func (pt *PowerTable_I) RemovePower(addr addr.Address, numSectors util.UVarint) {
+	panic("")
+	// pt.miners[addr].MinerSuspendedPower -= numSectors * pt.miners[addr].minerSectorSize
 }
 
-func (pt *PowerTable_I) RemoveAllPower(addr addr.Address, numSectors UVarint) {
-	pt.miners.[addr].minerStoragePower = 0
+func (pt *PowerTable_I) RemoveAllPower(addr addr.Address, numSectors util.UVarint) {
+	panic("")
+	// pt.miners[addr].MinerStoragePower = 0
 }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
index d5d47d0f5..7bb74052a 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.id
@@ -1,10 +1,9 @@
 import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
-import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
 import libp2p "github.com/filecoin-project/specs/libraries/libp2p"
-import spc "github.com/filecoin-project/specs/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem"
 import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
+import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
 
 type StoragePowerActor struct {
     // TODO: bytesamount might be inefficient
@@ -18,7 +17,7 @@ type StoragePowerActor struct {
         peerId        libp2p.PeerID  // TODO: will be removed likely (see: https://github.com/filecoin-project/specs/pull/555#pullrequestreview-300991681)
     ) addr.Address
 
-    // TODO add NotifyConsensusFault(addr.Address, [Block]) TODO maybe rename to Arbitrate
+    // TODO add NotifyConsensusFault(addr.Address, [block.Block]) TODO maybe rename to Arbitrate
     UpdatePower(address addr.Address, newPower block.StoragePower)
 
     TotalStorage() block.StoragePower
@@ -31,18 +30,22 @@ type StoragePowerActor struct {
 
     SuspendMiner(address addr.Address)
 
-    ec              spc.ExpectedConsensus
-    ReportConsensusFault(slasherAddr addr.Address, faultType ec.ConsensusFaultType, proof [Block]) struct {}
+    expectedConsensus ExpectedConsensus
+    ReportConsensusFault(
+        slasherAddr  addr.Address
+        faultType    ConsensusFaultType
+        proof        [block.Block]
+    )
     ReportUncommittedPowerFault(cheaterAddr addr.Address, numSectors UVarint)
-    PowerTable      PowerTable
+    PowerTable
 
-    // VerifyElectionProof(addr.Address, base.ElectionProof)	bool
+    // VerifyElectionProof(addr.Address, ElectionProof)	bool
 
     // TODO: old methods, should be removed
     // UpdateStoragePowerSubsystem(Tipset, StateTree)
-    // VerifyElectionProof(addr.Address, base.ElectionProof)	bool
+    // VerifyElectionProof(addr.Address, ElectionProof)	bool
     // NotifyStorageFault(addr.Address)
-    // TryPublishBlock(StateTree)					Block
+    // TryPublishBlock(StateTree)					block.Block
     CommitPledgeCollateral(deals [deal.StorageDeal])
     DecommitPledgeCollateral(deals [deal.StorageDeal])
 
@@ -51,11 +54,15 @@ type StoragePowerActor struct {
 
 type PowerTable struct {
     // all power here is always verified
-    RegisterMiner(addr addr.Address, pk filcrypto.PublicKey, sectorSize sector.SectorSize)
+    RegisterMiner(
+        addr        addr.Address
+        pk          filcrypto.PubKey
+        sectorSize  sector.SectorSize
+    )
     miners {addr.Address: StorageMiner}
     GetMinerPower(addr addr.Address) block.StoragePower
     GetTotalPower() block.StoragePower
-    GetMinerPublicKey(addr addr.Address) filcrypto.PublicKey
+    GetMinerPublicKey(addr addr.Address) filcrypto.PubKey
     IncrementPower(addr addr.Address, numSectors UVarint)
     SuspendPower(addr addr.Address, numSectors UVarint)
     UnsuspendPower(addr addr.Address, numSectors UVarint)
@@ -64,9 +71,9 @@ type PowerTable struct {
 }
 
 type StorageMiner struct {
-    minerAddress        addr.Address
-    minerStoragePower   block.StoragePower
-    minerSuspendedPower block.StoragePower
-    minerPK             filcrypto.PublicKey
-    minerSectorSize     sector.SectorSize
+    MinerAddress         addr.Address
+    MinerStoragePower    block.StoragePower
+    MinerSuspendedPower  block.StoragePower
+    MinerPK              filcrypto.PubKey
+    MinerSectorSize      sector.SectorSize
 }
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
index 6289c8dfa..cfbbb82f0 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go
@@ -1,131 +1,139 @@
 package storage_power_consensus
 
 import (
-	"errors"
-
 	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 	block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-	chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
-	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-	util "github.com/filecoin-project/specs/util"
 	base_mining "github.com/filecoin-project/specs/systems/filecoin_mining"
-	clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
+	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
 )
 
 const FINALITY = 500
 
 const (
-	SPC_LOOKBACK_RANDOMNESS = 300 // this is EC.K maybe move it there. TODO
-	SPC_LOOKBACK_TICKET     = 1   // we chain blocks together one after the other
-	SPC_LOOKBACK_POST       = 1   // cheap to generate, should be set as close to current TS as possible
-	SPC_LOOKBACK_SEAL       = FINALITY  // should be set to finality
+	SPC_LOOKBACK_RANDOMNESS = 300      // this is EC.K maybe move it there. TODO
+	SPC_LOOKBACK_TICKET     = 1        // we chain blocks together one after the other
+	SPC_LOOKBACK_POST       = 1        // cheap to generate, should be set as close to current TS as possible
+	SPC_LOOKBACK_SEAL       = FINALITY // should be set to finality
 )
 
-const VRFPersonalization {
-	ticket: 0,
-	electionProof: 1
-}
+const (
+	VRFPersonalizationTicket        = iota
+	VRFPersonalizationElectionProof = iota
+)
 
 // Storage Power Consensus Subsystem
 
-func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block blockchain.Block_I) error {
-	minerPK := spc.PowerTable.GetMinerPublicKey(block.MinerAddress())
-	minerPower := spc.PowerTable.GetMinerPower(block.MinerAddress())
-
-	// 1. Verify miner has not been slashed and is still valid miner
-	if minerPower <= 0 {
-		return spc.StoragePowerConsensusError("block miner not valid")
-	}
-
-	// 2. Verify ParentWeight
-	if block.Weight() != spc.computeTipsetWeight(block.Parents()) {
-		return errors.New("invalid parent weight")
-	}
-
-	// 3. Verify Tickets
-	if !validateTicket(block.Ticket, minerPK) {
-		return spc.StoragePowerConsensusError("ticket was invalid")
-	}
-
-	// 4. Verify ElectionProof construction
-	if !spc.ValidateElectionProof(block.Height, block.ElectionProof, block.MinerAddress) {
-		return spc.StoragePowerConsensusError("election proof was not a valid signature of the last ticket")
-	}
-
-	// 5. and value
-	if !spc.IsWinningElectionProof(block.ElectionProof, block.MinerAddress)
-		return spc.StoragePowerConsensusError("election proof was not a winner")
-	}
-
-	return nil
+func (spc *StoragePowerConsensusSubsystem_I) ValidateBlock(block block.Block_I) error {
+	panic("")
+	// minerPK := PowerTable.GetMinerPublicKey(block.MinerAddress())
+	// minerPower := PowerTable.GetMinerPower(block.MinerAddress())
+
+	// // 1. Verify miner has not been slashed and is still valid miner
+	// if minerPower <= 0 {
+	// 	return StoragePowerConsensusError("block miner not valid")
+	// }
+
+	// // 2. Verify ParentWeight
+	// if block.Weight() != computeTipsetWeight(block.Parents()) {
+	// 	return errors.New("invalid parent weight")
+	// }
+
+	// // 3. Verify Tickets
+	// if !validateTicket(block.Ticket, minerPK) {
+	// 	return StoragePowerConsensusError("ticket was invalid")
+	// }
+
+	// // 4. Verify ElectionProof construction
+	// if !ValidateElectionProof(block.Height, block.ElectionProof, block.MinerAddress) {
+	// 	return StoragePowerConsensusError("election proof was not a valid signature of the last ticket")
+	// }
+
+	// // 5. and value
+	// if !IsWinningElectionProof(block.ElectionProof, block.MinerAddress) {
+	// 	return StoragePowerConsensusError("election proof was not a winner")
+	// }
+
+	// return nil
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) validateTicket(ticket base.Ticket, pk filcrypto.PublicKey) bool {
-	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
-	input := VRFPersonalization.Ticket
-	input.append(T1.Output)
-	return ticket.Verify(input, pk)
+func (spc *StoragePowerConsensusSubsystem_I) validateTicket(ticket block.Ticket, pk filcrypto.PubKey) bool {
+	panic("")
+	// T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
+	// input := VRFPersonalizationTicket
+	// input.append(T1.Output)
+	// return ticket.Verify(input, pk)
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) computeTipsetWeight(tipset blockchain.Tipset) base.ChainWeight {
+func (spc *StoragePowerConsensusSubsystem_I) computeTipsetWeight(tipset block.Tipset) block.ChainWeight {
 	panic("TODO")
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) StoragePowerConsensusError(errMsg string) base.StoragePowerConsensusError {
+func (spc *StoragePowerConsensusSubsystem_I) StoragePowerConsensusError(errMsg string) StoragePowerConsensusError {
 	panic("TODO")
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetTicketProductionSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
-	return &base_mining.SealSeed_I {
-		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_TICKET)
-	}
-}
+func (spc *StoragePowerConsensusSubsystem_I) GetTicketProductionSeed(chain block.Chain, epoch block.ChainEpoch) base_mining.SealSeed {
+	panic("")
 
-func (spc *StoragePowerConsensusSubsystem_I) GetElectionProofSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
-	return &base_mining.SealSeed_I {
-		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_RANDOMNESS),
-	}
+	// return &base_mining.SealSeed
+	// 	chain.TicketAtEpoch(epoch - SPC_LOOKBACK_TICKET),
+	// }
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetSealSeed(chain blockchain.Chain, epoch Epoch) base_mining.SealSeed {
-	return &base_mining.SealSeed_I {
-		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_SEAL)
-	}
+func (spc *StoragePowerConsensusSubsystem_I) GetElectionProofSeed(chain block.Chain, epoch block.ChainEpoch) base_mining.SealSeed {
+	panic("")
+
+	// return &base_mining.SealSeed_I{
+	// 	chain.TicketAtEpoch(epoch - SPC_LOOKBACK_RANDOMNESS),
+	// }
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetPoStChallenge(chain blockchain.Chain, epoch Epoch) base_mining.PoStChallenge {
-	return &base_mining.PoStChallenge_I {
-		chain.TicketAtEpoch(epoch-SPC_LOOKBACK_POST)
-	}
+func (spc *StoragePowerConsensusSubsystem_I) GetSealSeed(chain block.Chain, epoch block.ChainEpoch) base_mining.SealSeed {
+	panic("")
+
+	// return &base_mining.SealSeed_I{
+	// 	chain.TicketAtEpoch(epoch - SPC_LOOKBACK_SEAL),
+	// }
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) ValidateElectionProof(height BlockHeight, electionProof base.ElectionProof, workerAddr base.Address) bool {
-	// 1. Check that ElectionProof was validated in appropriate time
-	if (height + electionProof.ElectionNonce > clock.roundTime + 1) {
-		return false
-	}
+func (spc *StoragePowerConsensusSubsystem_I) GetPoStChallenge(chain block.Chain, epoch block.ChainEpoch) base_mining.PoStChallenge {
+	panic("")
 
-	// 2. Determine that ticket was validly scratched
-	minerPK := spc.PowerTable.GetMinerPublicKey(workerAddr)
-	input := VRFPersonalization.ElectionProof
-	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
-	input.append(TK.Output)
-	input.appent(electionProof.ElectionNonce)
+	// return &base_mining.PoStChallenge_I{
+	// 	chain.TicketAtEpoch(epoch - SPC_LOOKBACK_POST),
+	// }
+}
 
-	return electionProof.Verify(input, minerPK)
+func (spc *StoragePowerConsensusSubsystem_I) ValidateElectionProof(height block.ChainEpoch, electionProof block.ElectionProof, workerAddr addr.Address) bool {
+	panic("")
+	// // 1. Check that ElectionProof was validated in appropriate time
+	// if height+electionProof.ElectionNonce > clock.roundTime+1 {
+	// 	return false
+	// }
+
+	// // 2. Determine that ticket was validly scratched
+	// minerPK := spc.PowerTable.GetMinerPublicKey(workerAddr)
+	// input := VRFPersonalizationElectionProof
+	// TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain, sms.block.LatestEpoch())
+	// input.append(TK.Output)
+	// input.appent(electionProof.ElectionNonce)
+
+	// return electionProof.Verify(input, minerPK)
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) IsWinningElectionProof(electionProof base.ElectionProof, workerAddr base.Address) bool {
+func (spc *StoragePowerConsensusSubsystem_I) IsWinningElectionProof(electionProof block.ElectionProof, workerAddr addr.Address) bool {
+	panic("")
 	// 1. Determine miner power fraction
-	minerPower := spc.PowerTable.GetMinerPower(workerAddr)
-	totalPower := spc.PowerTable.GetTotalPower()
+	// minerPower := spc.PowerTable.GetMinerPower(workerAddr)
+	// totalPower := spc.PowerTable.GetTotalPower()
 
-	// Conceptually we are mapping the pseudorandom, deterministic VRFOutput onto [0,1]
-	// by dividing by 2^HashLen (64 Bytes using Sha256) and comparing that to the miner's
-	// power (portion of network storage).
-	return (minerPower * 2^(len(electionProof.Output)*8) < electionProof.Output * totalPower)
+	// // Conceptually we are mapping the pseudorandom, deterministic VRFOutput onto [0,1]
+	// // by dividing by 2^HashLen (64 Bytes using Sha256) and comparing that to the miner's
+	// // power (portion of network storage).
+	// return (minerPower*2^(len(electionProof.Output)*8) < electionProof.Output*totalPower)
 }
 
-func (spc *StoragePowerConsensusSubsystem_I) GetFinality() Epoch {
-	return FINALITY
-}
\ No newline at end of file
+func (spc *StoragePowerConsensusSubsystem_I) GetFinality() block.ChainEpoch {
+	panic("")
+	// return FINALITY
+}
diff --git a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
index 3a5fb6f60..3586816be 100644
--- a/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
+++ b/src/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id
@@ -1,9 +1,8 @@
 import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-import chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
 import st "github.com/filecoin-project/specs/systems/filecoin_vm/state_tree"
 import base_mining "github.com/filecoin-project/specs/systems/filecoin_mining"
+import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 
 type StoragePowerConsensusSubsystem struct {//(@mutable)
     actor                StoragePowerActor
@@ -12,44 +11,51 @@ type StoragePowerConsensusSubsystem struct {//(@mutable)
     GenerateElectionProof(tipset block.Tipset) block.ElectionProof
     ChooseTipsetToMine(tipsets [block.Tipset]) [block.Tipset]
 
-    ec                   ExpectedConsensus
+    ec ExpectedConsensus
 
     // call by BlockchainSubsystem during block reception
     ValidateBlock(block block.Block) error
 
-    validateElectionProof(base.ElectionProof, base.Address)
+    validateElectionProof(
+        height         block.ChainEpoch
+        electionProof  block.ElectionProof
+        workerAddr     addr.Address
+    ) bool
 
-    validateTicket(base.Ticket, base.Address)
+    validateTicket(tix block.Ticket, pk filcrypto.VRFPublicKey) bool
 
     computeTipsetWeight(tipset block.Tipset) block.ChainWeight
 
-    IsWinningElectionProof(electionProof base.ElectionProof, workerAddr base.Address) bool
+    IsWinningElectionProof(electionProof block.ElectionProof, workerAddr addr.Address) bool
 
-    StoragePowerConsensusError() base.StoragePowerConsensusError
+    StoragePowerConsensusError() StoragePowerConsensusError
 
     // Randomness methods
 
     // call by StorageMiningSubsystem during block production
-    GetTicketProductionSeed(chain blockchain.Chain, epoch Epoch) base.Ticket
+    GetTicketProductionSeed(chain block.Chain, epoch block.ChainEpoch) block.Ticket
 
     // call by StorageMiningSubsystem during block production
-    GetElectionProofSeed(chain blockchain.Chain, epoch Epoch) base.Ticket
+    GetElectionProofSeed(chain block.Chain, epoch block.ChainEpoch) block.Ticket
 
     // call by StorageMiningSubsystem in sealing sector
-    GetSealSeed(chain chain.Chain, epoch Epoch) base_mining.SealSeed
+    GetSealSeed(chain block.Chain, epoch block.ChainEpoch) base_mining.SealSeed
 
     // call by StorageMiningSubsystem after sealing
-    GetPoStChallenge(chain chain.Chain, epoch Epoch) base_mining.PoStChallenge
+    GetPoStChallenge(chain block.Chain, epoch block.ChainEpoch) base_mining.PoStChallenge
 
-    GetFinality()   Epoch
+    GetFinality() block.ChainEpoch
 }
 
 type ExpectedConsensus struct {
-    ComputeWeight(Chain)                                ChainWeight
-    IsValidConsensusFault(ConsensusFaultType, [Block])	bool
+    ComputeWeight(chain block.Chain) block.ChainWeight
+    IsValidConsensusFault(faults ConsensusFaultType, blocks [block.Block]) bool
+}
 
-    ConsensusFaultType union {
-        DoubleForkMiningFault,
-        ParentGrindingFault
-    }
+type ConsensusFaultType union {
+    DoubleForkMiningFault  ConsensusFault
+    ParentGrindingFault    ConsensusFault
 }
+
+type ConsensusFault struct {}
+type StoragePowerConsensusError struct {}
diff --git a/src/systems/filecoin_blockchain/struct/block/block.go b/src/systems/filecoin_blockchain/struct/block/block.go
index 3c6c44356..02c20c7ee 100644
--- a/src/systems/filecoin_blockchain/struct/block/block.go
+++ b/src/systems/filecoin_blockchain/struct/block/block.go
@@ -1,7 +1,6 @@
 package block
 
 import (
-	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 	util "github.com/filecoin-project/specs/util"
 )
 
@@ -12,54 +11,52 @@ func SmallerBytes(a, b util.Bytes) util.Bytes {
 	return a
 }
 
-func (block *BlockHeader_I) ExtractElectionSeed() ElectionSeed {
-	panic("TODO")
-	// var ret []byte
+func (chain *Chain_I) TipsetAtEpoch(epoch ChainEpoch) Tipset {
+	panic("")
 
-	// for _, currBlock := range lookbackTipset.Blocks() {
-	// 	for _, currTicket := range currBlock.Tickets() {
-
-	// 		currSeed := Hash(
-	// 			HashRole_ElectionSeedFromVRFOutput,
-	// 			currTicket.VRFResult().bytes(),
-	// 		)
-	// 		if ret == nil {
-	// 			ret = currSeed
-	// 		} else {
-	//             ret = SmallerBytes(currSeed, ret)
-	//         }
-	// 	}
+	// dist := chain.HeadEpoch() - epoch
+	// current := chain.HeadTipset()
+	// parents := current.Parents()
+	// for i := 0; i < dist; i++ {
+	// 	current = parents
+	// 	parents = current.Parents
 	// }
 
-	// Assert(ret != nil)
-	// return ElectionSeed.FromBytesInternal(nil, ret)
+	// return current
 }
 
-// func GenerateElectionTicket(k VRFKeyPair, seed ElectionSeed) Ticket {
-// 	var vrfResult VRFResult = VRFEval(k, seed.ToBytesInternal())
+func (chain *Chain_I) TicketAtEpoch(epoch ChainEpoch) Ticket {
+	ts := chain.TipsetAtEpoch(epoch)
+	return ts.MinTicket()
+}
 
-// 	var vdfInput []byte = Hash(
-// 		HashRole_TicketVDFInputFromVRFOutput,
-// 		vrfResult.ToBytesInternal(),
-// 	)
-// 	var vdfResult VDFResult = VDFEval(vdfInput)
+func (chain *Chain_I) FinalizedEpoch() ChainEpoch {
+	panic("")
+	// ep := chain.HeadEpoch()
+	// return ep - GetFinality()
+}
 
-// 	return &TicketI{
-// 		vrfResult,
-// 		vdfResult,
-// 	}
-// }
+func (chain *Chain_I) HeadEpoch() ChainEpoch {
+	panic("")
+}
 
-func (self *BlockHeader_I) ValidateTickets(pubKey filcrypto.PubKey) bool {
-	for _, tix := range self.Tickets_ {
-		panic("TODO")
-		panic(tix)
-		// tix.Validate()
-	}
+func (chain *Chain_I) HeadTipset() Tipset {
+	panic("")
+}
 
-	return true
+func (bl *Block_I) TipsetAtEpoch(epoch ChainEpoch) Tipset_I {
+	panic("")
+	// dist := bl.Epoch - epoch - 1
+	// current := bl.ParentTipset
+	// parents := current.Parents
+	// for i := range dist {
+	// 	current = parents
+	// 	parent = current.Parents
+	// }
+	// return current
 }
 
-func (chain *Chain_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
-	return chain.ticketChain.TicketAtEpoch(epoch)
+func (bl *Block_I) TicketAtEpoch(epoch ChainEpoch) Ticket {
+	ts := bl.TipsetAtEpoch(epoch)
+	return ts.MinTicket()
 }
diff --git a/src/systems/filecoin_blockchain/struct/block/block.id b/src/systems/filecoin_blockchain/struct/block/block.id
index ffa798130..84ac8ea4a 100644
--- a/src/systems/filecoin_blockchain/struct/block/block.id
+++ b/src/systems/filecoin_blockchain/struct/block/block.id
@@ -6,12 +6,11 @@ import clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
 import msg "github.com/filecoin-project/specs/systems/filecoin_vm/message"
 
-type ChainWeight UVarint
-type ChainEpoch UVarint
-
 type BlockCID ipld.CID
 type MessageRoot ipld.CID
 type ReceiptRoot ipld.CID
+type ChainWeight UVarint
+type ChainEpoch UVarint
 
 type BlockHeader struct {
     // Chain linking
@@ -29,8 +28,8 @@ type BlockHeader struct {
 
     // Consensus things
     Timestamp        clock.Time
-    Ticket           Ticket
-    ElectionProof    ElectionProof
+    Ticket
+    ElectionProof
 
     // Signatures
     BlockSig         filcrypto.Signature
@@ -38,8 +37,6 @@ type BlockHeader struct {
 
     //	SerializeSigned()            []byte
     //	ComputeUnsignedFingerprint() []
-
-    ValidateTickets(pubKey filcrypto.PubKey) bool
 }
 
 // TODO: remove this. header is signed
@@ -53,3 +50,13 @@ type Block struct {
     Messages  [msg.Message]
     Receipts  [msg.MessageReceipt]
 }
+
+type Chain struct {
+    HeadEpoch()         ChainEpoch
+    HeadTipset()        Tipset
+    FinalizedEpoch()    ChainEpoch
+    LatestCheckpoint()  ChainEpoch
+
+    TipsetAtEpoch(epoch ChainEpoch) Tipset
+    TicketAtEpoch(epoch ChainEpoch) Ticket
+}
diff --git a/src/systems/filecoin_blockchain/struct/block/other.go b/src/systems/filecoin_blockchain/struct/block/other.go
index 912351f40..fb895c572 100644
--- a/src/systems/filecoin_blockchain/struct/block/other.go
+++ b/src/systems/filecoin_blockchain/struct/block/other.go
@@ -7,24 +7,17 @@ import (
 
 func (tix *Ticket_I) ValidateSyntax() bool {
 
-	return tix.vrfResult_.ValidateSyntax() &&
-		tix.vdfResult_.ValidateSyntax()
-
+	return tix.VRFResult_.ValidateSyntax()
 }
 
 func (tix *Ticket_I) Validate(input util.Bytes, pk filcrypto.VRFPublicKey) bool {
-	return tix.vrfResult_.Verify(input, pk) &&
-		tix.vdfResult_.Verify(tix.vdfResult_.Output())
+	return tix.VRFResult_.Verify(input, pk)
 }
 
 func (ep *ElectionProof_I) ValidateSyntax() bool {
-	return ep.vrfResult_.ValidateSyntax()
+	return ep.VRFResult_.ValidateSyntax()
 }
 
 func (ep *ElectionProof_I) Validate(input util.Bytes, pk filcrypto.VRFPublicKey) bool {
-	return ep.vrfResult_.Verify(input, pk)
-}
-
-func (ep *ElectionProof_I) IsWinning(power PowerFraction) bool {
-	panic("TODO")
+	return ep.VRFResult_.Verify(input, pk)
 }
diff --git a/src/systems/filecoin_blockchain/struct/block/other.id b/src/systems/filecoin_blockchain/struct/block/other.id
index 3b617e367..da8e0d16e 100644
--- a/src/systems/filecoin_blockchain/struct/block/other.id
+++ b/src/systems/filecoin_blockchain/struct/block/other.id
@@ -3,24 +3,22 @@ import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 // TODO: move all this stuff elsewhere. a consensus lib?
 
 type Ticket struct {
-    VrfResult         filcrypto.VRFResult
+    VRFResult         filcrypto.VRFResult
 
-    Output            Bytes     @(cached)
+    Output            Bytes                @(cached)
     ValidateSyntax()  bool
-    Verify(input Bytes, pk VRFPublicKey) bool
+    Verify(input Bytes, pk filcrypto.VRFPublicKey) bool
 }
 
 type BytesAmount UVarint
 type StoragePower BytesAmount
 
-type ElectionSeed filcrypto.VDFResult
-
 type ElectionProof struct {
-    vrfResult filcrypto.VRFResult
-    IsWinning(minerPower PowerFraction) bool @(cached)
-    Verify(input Bytes, pk VRFPublicKey) bool
-    Nonce             UVarint
+    VRFResult filcrypto.VRFResult
+    Verify(input Bytes, pk filcrypto.VRFPublicKey) bool
+    Nonce ElectionNonce
 
     ValidateSyntax() bool
-    Verify(seed ElectionSeed, minerPK filcrypto.PubKey) bool
 }
+
+type ElectionNonce UVarint
diff --git a/src/systems/filecoin_blockchain/struct/block/tipset.go b/src/systems/filecoin_blockchain/struct/block/tipset.go
index c001d411b..b56683fd7 100644
--- a/src/systems/filecoin_blockchain/struct/block/tipset.go
+++ b/src/systems/filecoin_blockchain/struct/block/tipset.go
@@ -4,20 +4,19 @@ import (
 	clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock"
 )
 
-func (ts *Tipset_I) MinTicket() base.Ticket {
+func (ts *Tipset_I) MinTicket() Ticket {
 	var ret Ticket
 
-	for _, currBlock := range ts.Blocks() {
-		tix := currBlock.Ticket()
-		if ret == nil {
-			ret = tix
-		} else {
-			ret = SmallerBytes(tix, ret)
-		}
-	}
+	// for _, currBlock := range ts.Blocks() {
+	// 	tix := currBlock.Ticket()
+	// 	if ret == nil {
+	// 		ret = tix
+	// 	} else {
+	// 		ret = SmallerBytes(tix, ret)
+	// 	}
+	// }
 
-	Assert(ret != nil)
-	return tix
+	return ret
 }
 
 func (ts *Tipset_I) ValidateSyntax() bool {
@@ -72,45 +71,3 @@ func (ts *Tipset_I) LatestTimestamp() clock.Time {
 // 	}
 // 	return currTree
 // }
-<<<<<<< HEAD:src/systems/filecoin_blockchain/struct/block/tipset.go
-=======
-
-func (bl *Block_I) TipsetAtEpoch(epoch Epoch) Tipset_I {
-	dist := bl.Epoch() - epoch - 1
-	current := bl.ParentTipset_
-	parents := current.Parents_
-	for i := range dist {
-		current = parents
-		parent = current.Parents_
-	}
-
-	return current
-}
-
-func (bl *Block_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
-	ts := bl.TipsetAtEpoch(epoch)
-	return ts.MinTicket()
-}
-
-func (chain *Chain_I) TipsetAtEpoch(epoch base.Epoch) base.Tipset_I {
-	dist := chain.HeadEpoch() - epoch
-	current := chain.HeadTipset()
-	parents := current.Parents_
-	for i := range dist {
-		current = parents
-		parent = current.Parents_
-	}
-
-	return current
-}
-
-func (chain *Chain_I) TicketAtEpoch(epoch base.Epoch) base.Ticket_I {
-	ts := chain.TipsetAtEpoch(epoch)
-	return ts.MinTicket()
-}
-
-func (chain *Chain_I) FinalizedEpoch() Epoch {
-	ep := HeadEpoch()
-	return ep - spc.GetFinality()
-}
->>>>>>> ticket sampling coded.:src/systems/filecoin_blockchain/blockchain/block.go
diff --git a/src/systems/filecoin_blockchain/struct/block/tipset.id b/src/systems/filecoin_blockchain/struct/block/tipset.id
index 762f49256..25d64ec26 100644
--- a/src/systems/filecoin_blockchain/struct/block/tipset.id
+++ b/src/systems/filecoin_blockchain/struct/block/tipset.id
@@ -13,4 +13,5 @@ type Tipset struct {
 
     ValidateSyntax()   bool           @(cached)
     LatestTimestamp()  clock.Time     @(cached)
-}
\ No newline at end of file
+    MinTicket()        Ticket         @(cached)
+}
diff --git a/src/systems/filecoin_blockchain/struct/chain/chain.go b/src/systems/filecoin_blockchain/struct/chain/chain.go
deleted file mode 100644
index fef1d2010..000000000
--- a/src/systems/filecoin_blockchain/struct/chain/chain.go
+++ /dev/null
@@ -1 +0,0 @@
-package chain
diff --git a/src/systems/filecoin_blockchain/struct/chain/chain.id b/src/systems/filecoin_blockchain/struct/chain/chain.id
deleted file mode 100644
index a7dff1b8f..000000000
--- a/src/systems/filecoin_blockchain/struct/chain/chain.id
+++ /dev/null
@@ -1,12 +0,0 @@
-import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-
-type Randomness struct {}
-
-type Chain struct {
-    HeadEpoch()         block.ChainEpoch
-    FinalizedEpoch()    block.ChainEpoch
-    LatestCheckpoint()  block.ChainEpoch
-
-    TipsetAtEpoch(epoch block.ChainEpoch) block.Tipset
-    TicketAtEpoch(epoch Epoch)  Ticket
-}
\ No newline at end of file
diff --git a/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot b/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot
new file mode 100644
index 000000000..ea9af3912
--- /dev/null
+++ b/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot
@@ -0,0 +1,34 @@
+digraph finite_state_machine {
+  rankdir=LR;
+  size="8,5"
+  node [shape = circle];
+
+  { // states
+    SStart
+    SSetup
+  }
+
+  SStart -> AFindMiner
+  AFindMiner -> SSetup
+
+  SSetup -> APreparePiece
+  APreparePiece -> SDealMaking
+
+  SDealMaking -> ASendDealProposal
+  ASendDealProposal -> SDealMaking
+
+  SDealMaking -> AGetAcceptedDeal
+  AGetAcceptedDeal -> SDealMadeNotDone
+
+  { // may
+    edge [style=dashed]
+
+    SDealMadeNotDone -> APostDealOnChain
+    APostDealOnChain -> SDealMadeDone
+  }
+
+  SDealMadeDone -> APostDealOnChain
+  APostDealOnChain -> SDealMadeDone
+
+
+}
diff --git a/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot.svg b/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot.svg
new file mode 100644
index 000000000..14d2a054c
--- /dev/null
+++ b/src/systems/filecoin_markets/storage_market/diagrams/storage_client_fsm.dot.svg
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.40.1 (20161225.0304)
+ -->
+<!-- Title: finite_state_machine Pages: 1 -->
+<svg width="576pt" height="144pt"
+ viewBox="0.00 0.00 576.00 143.52" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(.4065 .4065) rotate(0) translate(4 349.1006)">
+<title>finite_state_machine</title>
+<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-349.1006 1413.1351,-349.1006 1413.1351,4 -4,4"/>
+<!-- SStart -->
+<g id="node1" class="node">
+<title>SStart</title>
+<ellipse fill="none" stroke="#000000" cx="31.7275" cy="-263.2745" rx="31.9567" ry="31.9567"/>
+<text text-anchor="middle" x="31.7275" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">SStart</text>
+</g>
+<!-- AFindMiner -->
+<g id="node3" class="node">
+<title>AFindMiner</title>
+<ellipse fill="none" stroke="#000000" cx="153.7792" cy="-263.2745" rx="54.1489" ry="54.1489"/>
+<text text-anchor="middle" x="153.7792" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">AFindMiner</text>
+</g>
+<!-- SStart&#45;&gt;AFindMiner -->
+<g id="edge1" class="edge">
+<title>SStart&#45;&gt;AFindMiner</title>
+<path fill="none" stroke="#000000" d="M63.4766,-263.2745C71.3796,-263.2745 80.1411,-263.2745 89.0084,-263.2745"/>
+<polygon fill="#000000" stroke="#000000" points="89.0248,-266.7746 99.0248,-263.2745 89.0248,-259.7746 89.0248,-266.7746"/>
+</g>
+<!-- SSetup -->
+<g id="node2" class="node">
+<title>SSetup</title>
+<ellipse fill="none" stroke="#000000" cx="279.2724" cy="-263.2745" rx="35.3389" ry="35.3389"/>
+<text text-anchor="middle" x="279.2724" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">SSetup</text>
+</g>
+<!-- APreparePiece -->
+<g id="node4" class="node">
+<title>APreparePiece</title>
+<ellipse fill="none" stroke="#000000" cx="413.091" cy="-263.2745" rx="62.7992" ry="62.7992"/>
+<text text-anchor="middle" x="413.091" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">APreparePiece</text>
+</g>
+<!-- SSetup&#45;&gt;APreparePiece -->
+<g id="edge3" class="edge">
+<title>SSetup&#45;&gt;APreparePiece</title>
+<path fill="none" stroke="#000000" d="M314.782,-263.2745C322.6291,-263.2745 331.2214,-263.2745 339.9564,-263.2745"/>
+<polygon fill="#000000" stroke="#000000" points="340.2401,-266.7746 350.2401,-263.2745 340.24,-259.7746 340.2401,-266.7746"/>
+</g>
+<!-- AFindMiner&#45;&gt;SSetup -->
+<g id="edge2" class="edge">
+<title>AFindMiner&#45;&gt;SSetup</title>
+<path fill="none" stroke="#000000" d="M208.4573,-263.2745C216.9097,-263.2745 225.5607,-263.2745 233.7831,-263.2745"/>
+<polygon fill="#000000" stroke="#000000" points="233.9216,-266.7746 243.9215,-263.2745 233.9215,-259.7746 233.9216,-266.7746"/>
+</g>
+<!-- SDealMaking -->
+<g id="node5" class="node">
+<title>SDealMaking</title>
+<ellipse fill="none" stroke="#000000" cx="570.9699" cy="-263.2745" rx="59.4599" ry="59.4599"/>
+<text text-anchor="middle" x="570.9699" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">SDealMaking</text>
+</g>
+<!-- APreparePiece&#45;&gt;SDealMaking -->
+<g id="edge4" class="edge">
+<title>APreparePiece&#45;&gt;SDealMaking</title>
+<path fill="none" stroke="#000000" d="M475.9425,-263.2745C484.3179,-263.2745 492.9456,-263.2745 501.4266,-263.2745"/>
+<polygon fill="#000000" stroke="#000000" points="501.6719,-266.7746 511.6719,-263.2745 501.6718,-259.7746 501.6719,-266.7746"/>
+</g>
+<!-- ASendDealProposal -->
+<g id="node6" class="node">
+<title>ASendDealProposal</title>
+<ellipse fill="none" stroke="#000000" cx="748.0255" cy="-263.2745" rx="81.6526" ry="81.6526"/>
+<text text-anchor="middle" x="748.0255" y="-259.0745" font-family="Times,serif" font-size="14.00" fill="#000000">ASendDealProposal</text>
+</g>
+<!-- SDealMaking&#45;&gt;ASendDealProposal -->
+<g id="edge5" class="edge">
+<title>SDealMaking&#45;&gt;ASendDealProposal</title>
+<path fill="none" stroke="#000000" d="M629.9269,-256.871C638.4053,-256.6651 647.2926,-256.551 656.2243,-256.5286"/>
+<polygon fill="#000000" stroke="#000000" points="656.3032,-260.0286 666.308,-256.5423 656.3128,-253.0286 656.3032,-260.0286"/>
+</g>
+<!-- AGetAcceptedDeal -->
+<g id="node7" class="node">
+<title>AGetAcceptedDeal</title>
+<ellipse fill="none" stroke="#000000" cx="748.0255" cy="-84.2745" rx="79.1867" ry="79.1867"/>
+<text text-anchor="middle" x="748.0255" y="-80.0745" font-family="Times,serif" font-size="14.00" fill="#000000">AGetAcceptedDeal</text>
+</g>
+<!-- SDealMaking&#45;&gt;AGetAcceptedDeal -->
+<g id="edge7" class="edge">
+<title>SDealMaking&#45;&gt;AGetAcceptedDeal</title>
+<path fill="none" stroke="#000000" d="M612.9296,-220.854C634.3374,-199.2111 660.8241,-172.4336 684.6575,-148.3384"/>
+<polygon fill="#000000" stroke="#000000" points="687.4163,-150.5263 691.9603,-140.9554 682.4396,-145.6036 687.4163,-150.5263"/>
+</g>
+<!-- ASendDealProposal&#45;&gt;SDealMaking -->
+<g id="edge6" class="edge">
+<title>ASendDealProposal&#45;&gt;SDealMaking</title>
+<path fill="none" stroke="#000000" d="M666.308,-270.0067C657.4902,-270.0528 648.5818,-270.0092 639.9354,-269.8758"/>
+<polygon fill="#000000" stroke="#000000" points="639.9941,-266.3764 629.9269,-269.678 639.8557,-273.375 639.9941,-266.3764"/>
+</g>
+<!-- SDealMadeNotDone -->
+<g id="node8" class="node">
+<title>SDealMadeNotDone</title>
+<ellipse fill="none" stroke="#000000" cx="950.1261" cy="-84.2745" rx="84.0496" ry="84.0496"/>
+<text text-anchor="middle" x="950.1261" y="-80.0745" font-family="Times,serif" font-size="14.00" fill="#000000">SDealMadeNotDone</text>
+</g>
+<!-- AGetAcceptedDeal&#45;&gt;SDealMadeNotDone -->
+<g id="edge8" class="edge">
+<title>AGetAcceptedDeal&#45;&gt;SDealMadeNotDone</title>
+<path fill="none" stroke="#000000" d="M827.6109,-84.2745C836.7774,-84.2745 846.1909,-84.2745 855.5305,-84.2745"/>
+<polygon fill="#000000" stroke="#000000" points="855.6209,-87.7746 865.6209,-84.2745 855.6208,-80.7746 855.6209,-87.7746"/>
+</g>
+<!-- APostDealOnChain -->
+<g id="node9" class="node">
+<title>APostDealOnChain</title>
+<ellipse fill="none" stroke="#000000" cx="1150.7586" cy="-84.2745" rx="80.2162" ry="80.2162"/>
+<text text-anchor="middle" x="1150.7586" y="-80.0745" font-family="Times,serif" font-size="14.00" fill="#000000">APostDealOnChain</text>
+</g>
+<!-- SDealMadeNotDone&#45;&gt;APostDealOnChain -->
+<g id="edge9" class="edge">
+<title>SDealMadeNotDone&#45;&gt;APostDealOnChain</title>
+<path fill="none" stroke="#000000" stroke-dasharray="5,2" d="M1034.6309,-84.2745C1043.0059,-84.2745 1051.5317,-84.2745 1059.9668,-84.2745"/>
+<polygon fill="#000000" stroke="#000000" points="1060.1947,-87.7746 1070.1947,-84.2745 1060.1947,-80.7746 1060.1947,-87.7746"/>
+</g>
+<!-- SDealMadeDone -->
+<g id="node10" class="node">
+<title>SDealMadeDone</title>
+<ellipse fill="none" stroke="#000000" cx="1338.1258" cy="-84.2745" rx="71.0186" ry="71.0186"/>
+<text text-anchor="middle" x="1338.1258" y="-80.0745" font-family="Times,serif" font-size="14.00" fill="#000000">SDealMadeDone</text>
+</g>
+<!-- APostDealOnChain&#45;&gt;SDealMadeDone -->
+<g id="edge10" class="edge">
+<title>APostDealOnChain&#45;&gt;SDealMadeDone</title>
+<path fill="none" stroke="#000000" stroke-dasharray="5,2" d="M1230.2192,-70.9137C1239.5215,-70.7303 1249.0154,-70.7281 1258.3224,-70.9071"/>
+<polygon fill="#000000" stroke="#000000" points="1258.2409,-74.406 1268.3301,-71.1724 1258.4264,-67.4085 1258.2409,-74.406"/>
+</g>
+<!-- APostDealOnChain&#45;&gt;SDealMadeDone -->
+<g id="edge12" class="edge">
+<title>APostDealOnChain&#45;&gt;SDealMadeDone</title>
+<path fill="none" stroke="#000000" d="M1230.2192,-97.6352C1239.5215,-97.8186 1249.0154,-97.8209 1258.3224,-97.6419"/>
+<polygon fill="#000000" stroke="#000000" points="1258.4264,-101.1405 1268.3301,-97.3766 1258.2409,-94.1429 1258.4264,-101.1405"/>
+</g>
+<!-- SDealMadeDone&#45;&gt;APostDealOnChain -->
+<g id="edge11" class="edge">
+<title>SDealMadeDone&#45;&gt;APostDealOnChain</title>
+<path fill="none" stroke="#000000" d="M1267.09,-84.2745C1258.6875,-84.2745 1250.0266,-84.2745 1241.4,-84.2745"/>
+<polygon fill="#000000" stroke="#000000" points="1241.3066,-80.7746 1231.3066,-84.2745 1241.3065,-87.7746 1241.3066,-80.7746"/>
+</g>
+</g>
+</svg>
diff --git a/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot b/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot
new file mode 100644
index 000000000..e3f0fc2f2
--- /dev/null
+++ b/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot
@@ -0,0 +1,39 @@
+digraph tcp_state {
+  compound=true;
+  node [shape=Mrecord]
+  edge [style=solid]
+
+  CLOSED ;
+  LISTEN;
+  SYN_RCVD;
+  SYN_SENT;
+  ESTABLISHED;
+  FIN_WAIT_1;
+  FIN_WAIT_2;
+  CLOSING;
+  TIME_WAIT;
+  CLOSE_WAIT;
+  LAST_ACK;
+
+  CLOSED -> LISTEN [label="appl:被动打开 send:<nothing>"];
+  CLOSED -> SYN_SENT [label="appl:主动打开 send:SYN"];
+  LISTEN -> SYN_RCVD [label="recv:SYN send:SYN,ACK"];
+  LISTEN -> SYN_SENT [label="appl:发送数据 send:SYN"];
+  SYN_RCVD -> LISTEN [label="recv:RST"];
+  SYN_RCVD -> CLOSED [label="超时 send:RST"];
+  SYN_RCVD -> FIN_WAIT_1 [label="appl:关闭 send:FIN"];
+  SYN_RCVD -> ESTABLISHED [label="recv:ACK send:<无>"];
+  SYN_SENT -> SYN_RCVD [label="recv:SYN send:SYN,ACK 同时打开"];
+  SYN_SENT -> CLOSED [label="appl:关闭 或超时"];
+  SYN_SENT -> ESTABLISHED [label="recv:SYN,ACK send:ACK"];
+  ESTABLISHED -> CLOSE_WAIT [label="recv:FIN send:ACK"];
+  ESTABLISHED -> FIN_WAIT_1 [label="appl:关闭 send:FIN"];
+  CLOSE_WAIT -> LAST_ACK [label="appl:关闭 send:FIN"];
+  LAST_ACK -> CLOSED [label="recv:ACK send:无"];
+  FIN_WAIT_1 -> CLOSING [label="recv:FIN send:ACK"];
+  FIN_WAIT_1 -> TIME_WAIT [label="recv:FIN,ACK send:ACK"];
+  FIN_WAIT_1 -> FIN_WAIT_2 [label="recv:ACK send:无"];
+  CLOSING -> TIME_WAIT [label="recv:ACK send:无"];
+  FIN_WAIT_2 -> TIME_WAIT [label="recv:FIN send:ACK"];
+  TIME_WAIT -> CLOSED ;
+}
\ No newline at end of file
diff --git a/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot.svg b/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot.svg
new file mode 100644
index 000000000..975bbc551
--- /dev/null
+++ b/src/systems/filecoin_markets/storage_market/diagrams/storage_provider_fsm.dot.svg
@@ -0,0 +1,225 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.40.1 (20161225.0304)
+ -->
+<!-- Title: tcp_state Pages: 1 -->
+<svg width="786pt" height="693pt"
+ viewBox="0.00 0.00 786.23 693.20" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 689.1994)">
+<title>tcp_state</title>
+<polygon fill="#ffffff" stroke="transparent" points="-4,4 -4,-689.1994 782.2284,-689.1994 782.2284,4 -4,4"/>
+<!-- CLOSED -->
+<g id="node1" class="node">
+<title>CLOSED</title>
+<path fill="none" stroke="#000000" d="M380.0042,-648.6994C380.0042,-648.6994 426.4525,-648.6994 426.4525,-648.6994 432.4525,-648.6994 438.4525,-654.6994 438.4525,-660.6994 438.4525,-660.6994 438.4525,-672.6994 438.4525,-672.6994 438.4525,-678.6994 432.4525,-684.6994 426.4525,-684.6994 426.4525,-684.6994 380.0042,-684.6994 380.0042,-684.6994 374.0042,-684.6994 368.0042,-678.6994 368.0042,-672.6994 368.0042,-672.6994 368.0042,-660.6994 368.0042,-660.6994 368.0042,-654.6994 374.0042,-648.6994 380.0042,-648.6994"/>
+<text text-anchor="middle" x="403.2284" y="-662.4994" font-family="Times,serif" font-size="14.00" fill="#000000">CLOSED</text>
+</g>
+<!-- LISTEN -->
+<g id="node2" class="node">
+<title>LISTEN</title>
+<path fill="none" stroke="#000000" d="M123.1214,-556.0995C123.1214,-556.0995 163.3353,-556.0995 163.3353,-556.0995 169.3353,-556.0995 175.3353,-562.0995 175.3353,-568.0995 175.3353,-568.0995 175.3353,-580.0995 175.3353,-580.0995 175.3353,-586.0995 169.3353,-592.0995 163.3353,-592.0995 163.3353,-592.0995 123.1214,-592.0995 123.1214,-592.0995 117.1214,-592.0995 111.1214,-586.0995 111.1214,-580.0995 111.1214,-580.0995 111.1214,-568.0995 111.1214,-568.0995 111.1214,-562.0995 117.1214,-556.0995 123.1214,-556.0995"/>
+<text text-anchor="middle" x="143.2284" y="-569.8995" font-family="Times,serif" font-size="14.00" fill="#000000">LISTEN</text>
+</g>
+<!-- CLOSED&#45;&gt;LISTEN -->
+<g id="edge1" class="edge">
+<title>CLOSED&#45;&gt;LISTEN</title>
+<path fill="none" stroke="#000000" d="M367.8051,-664.1702C300.6824,-659.0237 160.325,-646.433 145.6131,-630.1994 138.8597,-622.7475 137.1621,-612.1912 137.5421,-602.2426"/>
+<polygon fill="#000000" stroke="#000000" points="141.0283,-602.5554 138.5655,-592.2509 134.0647,-601.8422 141.0283,-602.5554"/>
+<text text-anchor="middle" x="233.036" y="-618.9994" font-family="Times,serif" font-size="14.00" fill="#000000">appl:被动打开 send:&lt;nothing&gt;</text>
+</g>
+<!-- SYN_SENT -->
+<g id="node4" class="node">
+<title>SYN_SENT</title>
+<path fill="none" stroke="#000000" d="M323.2249,-463.4996C323.2249,-463.4996 385.2318,-463.4996 385.2318,-463.4996 391.2318,-463.4996 397.2318,-469.4996 397.2318,-475.4996 397.2318,-475.4996 397.2318,-487.4996 397.2318,-487.4996 397.2318,-493.4996 391.2318,-499.4996 385.2318,-499.4996 385.2318,-499.4996 323.2249,-499.4996 323.2249,-499.4996 317.2249,-499.4996 311.2249,-493.4996 311.2249,-487.4996 311.2249,-487.4996 311.2249,-475.4996 311.2249,-475.4996 311.2249,-469.4996 317.2249,-463.4996 323.2249,-463.4996"/>
+<text text-anchor="middle" x="354.2284" y="-477.2996" font-family="Times,serif" font-size="14.00" fill="#000000">SYN_SENT</text>
+</g>
+<!-- CLOSED&#45;&gt;SYN_SENT -->
+<g id="edge2" class="edge">
+<title>CLOSED&#45;&gt;SYN_SENT</title>
+<path fill="none" stroke="#000000" d="M417.5476,-648.5403C433.3389,-626.156 454.7139,-587.2015 440.2284,-555.5995 430.7715,-534.9682 412.4208,-517.9042 395.0913,-505.3728"/>
+<polygon fill="#000000" stroke="#000000" points="396.9281,-502.3879 386.7095,-499.5893 392.9526,-508.1494 396.9281,-502.3879"/>
+<text text-anchor="middle" x="516.7542" y="-572.6994" font-family="Times,serif" font-size="14.00" fill="#000000">appl:主动打开 send:SYN</text>
+</g>
+<!-- SYN_RCVD -->
+<g id="node3" class="node">
+<title>SYN_RCVD</title>
+<path fill="none" stroke="#000000" d="M127.2767,-370.8997C127.2767,-370.8997 193.18,-370.8997 193.18,-370.8997 199.18,-370.8997 205.18,-376.8997 205.18,-382.8997 205.18,-382.8997 205.18,-394.8997 205.18,-394.8997 205.18,-400.8997 199.18,-406.8997 193.18,-406.8997 193.18,-406.8997 127.2767,-406.8997 127.2767,-406.8997 121.2767,-406.8997 115.2767,-400.8997 115.2767,-394.8997 115.2767,-394.8997 115.2767,-382.8997 115.2767,-382.8997 115.2767,-376.8997 121.2767,-370.8997 127.2767,-370.8997"/>
+<text text-anchor="middle" x="160.2284" y="-384.6997" font-family="Times,serif" font-size="14.00" fill="#000000">SYN_RCVD</text>
+</g>
+<!-- LISTEN&#45;&gt;SYN_RCVD -->
+<g id="edge3" class="edge">
+<title>LISTEN&#45;&gt;SYN_RCVD</title>
+<path fill="none" stroke="#000000" d="M144.5159,-555.9966C146.1181,-533.9951 149.0236,-495.7479 152.1248,-462.9996 153.5496,-447.9539 155.3608,-431.2152 156.9094,-417.4591"/>
+<polygon fill="#000000" stroke="#000000" points="160.4287,-417.4875 158.0826,-407.1557 153.4736,-416.6955 160.4287,-417.4875"/>
+<text text-anchor="middle" x="226.2801" y="-477.2996" font-family="Times,serif" font-size="14.00" fill="#000000">recv:SYN send:SYN,ACK</text>
+</g>
+<!-- LISTEN&#45;&gt;SYN_SENT -->
+<g id="edge4" class="edge">
+<title>LISTEN&#45;&gt;SYN_SENT</title>
+<path fill="none" stroke="#000000" d="M149.4255,-555.9653C154.75,-543.243 163.7237,-526.9626 177.1766,-517.9996 222.0765,-488.0848 244.7128,-512.3695 297.2284,-499.9996 298.51,-499.6977 299.8043,-499.3804 301.1068,-499.05"/>
+<polygon fill="#000000" stroke="#000000" points="302.4562,-502.3097 311.1803,-496.298 300.6114,-495.5572 302.4562,-502.3097"/>
+<text text-anchor="middle" x="248.7542" y="-526.3995" font-family="Times,serif" font-size="14.00" fill="#000000">appl:发送数据 send:SYN</text>
+</g>
+<!-- SYN_RCVD&#45;&gt;CLOSED -->
+<g id="edge6" class="edge">
+<title>SYN_RCVD&#45;&gt;CLOSED</title>
+<path fill="none" stroke="#000000" d="M114.9606,-406.7385C59.7193,-431.4482 -22.921,-479.6616 6.5008,-537.5995 38.0856,-599.7967 68.5173,-604.15 133.2284,-630.1994 173.0053,-646.2116 291.8618,-657.8507 357.8382,-663.2798"/>
+<polygon fill="#000000" stroke="#000000" points="357.7033,-666.7802 367.9528,-664.0976 358.2674,-659.803 357.7033,-666.7802"/>
+<text text-anchor="middle" x="50.5921" y="-526.3995" font-family="Times,serif" font-size="14.00" fill="#000000">超时 send:RST</text>
+</g>
+<!-- SYN_RCVD&#45;&gt;LISTEN -->
+<g id="edge5" class="edge">
+<title>SYN_RCVD&#45;&gt;LISTEN</title>
+<path fill="none" stroke="#000000" d="M135.1945,-407.1785C119.0881,-420.5846 99.5483,-440.3475 90.5731,-462.9996 78.7386,-492.8678 99.0226,-526.0197 117.7479,-548.2689"/>
+<polygon fill="#000000" stroke="#000000" points="115.2762,-550.758 124.5137,-555.9464 120.528,-546.1299 115.2762,-550.758"/>
+<text text-anchor="middle" x="117.056" y="-477.2996" font-family="Times,serif" font-size="14.00" fill="#000000">recv:RST</text>
+</g>
+<!-- ESTABLISHED -->
+<g id="node5" class="node">
+<title>ESTABLISHED</title>
+<path fill="none" stroke="#000000" d="M348.7303,-278.2997C348.7303,-278.2997 433.7264,-278.2997 433.7264,-278.2997 439.7264,-278.2997 445.7264,-284.2997 445.7264,-290.2997 445.7264,-290.2997 445.7264,-302.2997 445.7264,-302.2997 445.7264,-308.2997 439.7264,-314.2997 433.7264,-314.2997 433.7264,-314.2997 348.7303,-314.2997 348.7303,-314.2997 342.7303,-314.2997 336.7303,-308.2997 336.7303,-302.2997 336.7303,-302.2997 336.7303,-290.2997 336.7303,-290.2997 336.7303,-284.2997 342.7303,-278.2997 348.7303,-278.2997"/>
+<text text-anchor="middle" x="391.2284" y="-292.0997" font-family="Times,serif" font-size="14.00" fill="#000000">ESTABLISHED</text>
+</g>
+<!-- SYN_RCVD&#45;&gt;ESTABLISHED -->
+<g id="edge8" class="edge">
+<title>SYN_RCVD&#45;&gt;ESTABLISHED</title>
+<path fill="none" stroke="#000000" d="M190.7083,-370.7777C211.6213,-358.869 240.2888,-343.5589 266.8475,-332.7997 285.9398,-325.0653 307.2808,-318.1954 326.8215,-312.5607"/>
+<polygon fill="#000000" stroke="#000000" points="327.8798,-315.8987 336.5519,-309.8123 325.977,-309.1623 327.8798,-315.8987"/>
+<text text-anchor="middle" x="326.4188" y="-341.1997" font-family="Times,serif" font-size="14.00" fill="#000000">recv:ACK send:&lt;无&gt;</text>
+</g>
+<!-- FIN_WAIT_1 -->
+<g id="node6" class="node">
+<title>FIN_WAIT_1</title>
+<path fill="none" stroke="#000000" d="M218.9559,-185.6998C218.9559,-185.6998 289.5008,-185.6998 289.5008,-185.6998 295.5008,-185.6998 301.5008,-191.6998 301.5008,-197.6998 301.5008,-197.6998 301.5008,-209.6998 301.5008,-209.6998 301.5008,-215.6998 295.5008,-221.6998 289.5008,-221.6998 289.5008,-221.6998 218.9559,-221.6998 218.9559,-221.6998 212.9559,-221.6998 206.9559,-215.6998 206.9559,-209.6998 206.9559,-209.6998 206.9559,-197.6998 206.9559,-197.6998 206.9559,-191.6998 212.9559,-185.6998 218.9559,-185.6998"/>
+<text text-anchor="middle" x="254.2284" y="-199.4998" font-family="Times,serif" font-size="14.00" fill="#000000">FIN_WAIT_1</text>
+</g>
+<!-- SYN_RCVD&#45;&gt;FIN_WAIT_1 -->
+<g id="edge7" class="edge">
+<title>SYN_RCVD&#45;&gt;FIN_WAIT_1</title>
+<path fill="none" stroke="#000000" d="M169.4126,-370.8047C185.9793,-338.1649 220.9473,-269.2704 240.4126,-230.9197"/>
+<polygon fill="#000000" stroke="#000000" points="243.6018,-232.3695 245.0068,-221.8682 237.3598,-229.2013 243.6018,-232.3695"/>
+<text text-anchor="middle" x="272.0301" y="-294.8997" font-family="Times,serif" font-size="14.00" fill="#000000">appl:关闭 send:FIN</text>
+</g>
+<!-- SYN_SENT&#45;&gt;CLOSED -->
+<g id="edge10" class="edge">
+<title>SYN_SENT&#45;&gt;CLOSED</title>
+<path fill="none" stroke="#000000" d="M345.172,-499.7971C335.3282,-522.3209 322.5308,-561.4161 334.7352,-592.5995 342.2233,-611.7322 357.2259,-628.8867 371.2861,-641.8599"/>
+<polygon fill="#000000" stroke="#000000" points="369.1337,-644.6285 378.9467,-648.6231 373.7666,-639.3809 369.1337,-644.6285"/>
+<text text-anchor="middle" x="384.9749" y="-572.6994" font-family="Times,serif" font-size="14.00" fill="#000000">appl:关闭 或超时</text>
+</g>
+<!-- SYN_SENT&#45;&gt;SYN_RCVD -->
+<g id="edge9" class="edge">
+<title>SYN_SENT&#45;&gt;SYN_RCVD</title>
+<path fill="none" stroke="#000000" d="M311.1797,-466.7037C306.5012,-465.3427 301.7851,-464.0742 297.2284,-462.9996 244.9079,-450.6604 218.4003,-480.0287 177.6248,-444.9996 169.4452,-437.9727 165.0549,-427.1783 162.7189,-416.9282"/>
+<polygon fill="#000000" stroke="#000000" points="166.1581,-416.2755 161.0035,-407.0191 159.2607,-417.4695 166.1581,-416.2755"/>
+<text text-anchor="middle" x="282.0301" y="-433.7996" font-family="Times,serif" font-size="14.00" fill="#000000">recv:SYN send:SYN,ACK 同时打开</text>
+</g>
+<!-- SYN_SENT&#45;&gt;ESTABLISHED -->
+<g id="edge11" class="edge">
+<title>SYN_SENT&#45;&gt;ESTABLISHED</title>
+<path fill="none" stroke="#000000" d="M375.2876,-463.2312C380.0899,-457.8806 384.5601,-451.661 387.2284,-444.9996 403.034,-405.5406 400.1688,-355.3523 396.1078,-324.5429"/>
+<polygon fill="#000000" stroke="#000000" points="399.5506,-323.8961 394.6501,-314.5027 392.6233,-324.9019 399.5506,-323.8961"/>
+<text text-anchor="middle" x="475.056" y="-384.6997" font-family="Times,serif" font-size="14.00" fill="#000000">recv:SYN,ACK send:ACK</text>
+</g>
+<!-- ESTABLISHED&#45;&gt;FIN_WAIT_1 -->
+<g id="edge13" class="edge">
+<title>ESTABLISHED&#45;&gt;FIN_WAIT_1</title>
+<path fill="none" stroke="#000000" d="M348.0385,-278.113C337.1121,-272.802 325.6429,-266.5811 315.6248,-259.7997 302.5395,-250.9421 289.4218,-239.4054 278.6908,-229.099"/>
+<polygon fill="#000000" stroke="#000000" points="280.9186,-226.3811 271.3332,-221.8676 276.0118,-231.3735 280.9186,-226.3811"/>
+<text text-anchor="middle" x="371.0301" y="-248.5997" font-family="Times,serif" font-size="14.00" fill="#000000">appl:关闭 send:FIN</text>
+</g>
+<!-- CLOSE_WAIT -->
+<g id="node10" class="node">
+<title>CLOSE_WAIT</title>
+<path fill="none" stroke="#000000" d="M450.0662,-185.6998C450.0662,-185.6998 528.3905,-185.6998 528.3905,-185.6998 534.3905,-185.6998 540.3905,-191.6998 540.3905,-197.6998 540.3905,-197.6998 540.3905,-209.6998 540.3905,-209.6998 540.3905,-215.6998 534.3905,-221.6998 528.3905,-221.6998 528.3905,-221.6998 450.0662,-221.6998 450.0662,-221.6998 444.0662,-221.6998 438.0662,-215.6998 438.0662,-209.6998 438.0662,-209.6998 438.0662,-197.6998 438.0662,-197.6998 438.0662,-191.6998 444.0662,-185.6998 450.0662,-185.6998"/>
+<text text-anchor="middle" x="489.2284" y="-199.4998" font-family="Times,serif" font-size="14.00" fill="#000000">CLOSE_WAIT</text>
+</g>
+<!-- ESTABLISHED&#45;&gt;CLOSE_WAIT -->
+<g id="edge12" class="edge">
+<title>ESTABLISHED&#45;&gt;CLOSE_WAIT</title>
+<path fill="none" stroke="#000000" d="M410.59,-278.005C425.3547,-264.0539 445.8702,-244.6688 462.2446,-229.1967"/>
+<polygon fill="#000000" stroke="#000000" points="465.0422,-231.3686 469.9069,-221.9566 460.2346,-226.2806 465.0422,-231.3686"/>
+<text text-anchor="middle" x="504.8026" y="-245.7998" font-family="Times,serif" font-size="14.00" fill="#000000">recv:FIN send:ACK</text>
+</g>
+<!-- FIN_WAIT_2 -->
+<g id="node7" class="node">
+<title>FIN_WAIT_2</title>
+<path fill="none" stroke="#000000" d="M319.9559,-93.0999C319.9559,-93.0999 390.5008,-93.0999 390.5008,-93.0999 396.5008,-93.0999 402.5008,-99.0999 402.5008,-105.0999 402.5008,-105.0999 402.5008,-117.0999 402.5008,-117.0999 402.5008,-123.0999 396.5008,-129.0999 390.5008,-129.0999 390.5008,-129.0999 319.9559,-129.0999 319.9559,-129.0999 313.9559,-129.0999 307.9559,-123.0999 307.9559,-117.0999 307.9559,-117.0999 307.9559,-105.0999 307.9559,-105.0999 307.9559,-99.0999 313.9559,-93.0999 319.9559,-93.0999"/>
+<text text-anchor="middle" x="355.2284" y="-106.8999" font-family="Times,serif" font-size="14.00" fill="#000000">FIN_WAIT_2</text>
+</g>
+<!-- FIN_WAIT_1&#45;&gt;FIN_WAIT_2 -->
+<g id="edge18" class="edge">
+<title>FIN_WAIT_1&#45;&gt;FIN_WAIT_2</title>
+<path fill="none" stroke="#000000" d="M249.8156,-185.6337C248.0013,-173.7491 247.8581,-158.4451 255.6385,-147.5999 258.6056,-143.4641 277.587,-136.0921 298.196,-129.0509"/>
+<polygon fill="#000000" stroke="#000000" points="299.3612,-132.3518 307.7279,-125.8519 297.1339,-125.7156 299.3612,-132.3518"/>
+<text text-anchor="middle" x="307.5233" y="-155.9998" font-family="Times,serif" font-size="14.00" fill="#000000">recv:ACK send:无</text>
+</g>
+<!-- CLOSING -->
+<g id="node8" class="node">
+<title>CLOSING</title>
+<path fill="none" stroke="#000000" d="M448.8939,-93.0999C448.8939,-93.0999 501.5628,-93.0999 501.5628,-93.0999 507.5628,-93.0999 513.5628,-99.0999 513.5628,-105.0999 513.5628,-105.0999 513.5628,-117.0999 513.5628,-117.0999 513.5628,-123.0999 507.5628,-129.0999 501.5628,-129.0999 501.5628,-129.0999 448.8939,-129.0999 448.8939,-129.0999 442.8939,-129.0999 436.8939,-123.0999 436.8939,-117.0999 436.8939,-117.0999 436.8939,-105.0999 436.8939,-105.0999 436.8939,-99.0999 442.8939,-93.0999 448.8939,-93.0999"/>
+<text text-anchor="middle" x="475.2284" y="-106.8999" font-family="Times,serif" font-size="14.00" fill="#000000">CLOSING</text>
+</g>
+<!-- FIN_WAIT_1&#45;&gt;CLOSING -->
+<g id="edge16" class="edge">
+<title>FIN_WAIT_1&#45;&gt;CLOSING</title>
+<path fill="none" stroke="#000000" d="M301.656,-190.7084C320.4209,-184.7197 341.8528,-176.7916 360.2284,-167.1998 373.3264,-160.3628 374.1963,-154.8329 387.0799,-147.5999 399.632,-140.5531 413.8204,-134.0843 427.0876,-128.6132"/>
+<polygon fill="#000000" stroke="#000000" points="428.5747,-131.7877 436.5488,-124.8118 425.9649,-125.2924 428.5747,-131.7877"/>
+<text text-anchor="middle" x="442.8026" y="-153.1999" font-family="Times,serif" font-size="14.00" fill="#000000">recv:FIN send:ACK</text>
+</g>
+<!-- TIME_WAIT -->
+<g id="node9" class="node">
+<title>TIME_WAIT</title>
+<path fill="none" stroke="#000000" d="M381.1283,-.5C381.1283,-.5 449.3284,-.5 449.3284,-.5 455.3284,-.5 461.3284,-6.5 461.3284,-12.5 461.3284,-12.5 461.3284,-24.5 461.3284,-24.5 461.3284,-30.5 455.3284,-36.5 449.3284,-36.5 449.3284,-36.5 381.1283,-36.5 381.1283,-36.5 375.1283,-36.5 369.1283,-30.5 369.1283,-24.5 369.1283,-24.5 369.1283,-12.5 369.1283,-12.5 369.1283,-6.5 375.1283,-.5 381.1283,-.5"/>
+<text text-anchor="middle" x="415.2284" y="-14.3" font-family="Times,serif" font-size="14.00" fill="#000000">TIME_WAIT</text>
+</g>
+<!-- FIN_WAIT_1&#45;&gt;TIME_WAIT -->
+<g id="edge17" class="edge">
+<title>FIN_WAIT_1&#45;&gt;TIME_WAIT</title>
+<path fill="none" stroke="#000000" d="M216.8514,-185.5429C178.1175,-164.2594 126.6533,-127.4523 153.0213,-92.5999 177.8103,-59.8347 289.6841,-37.4175 359.0477,-26.391"/>
+<polygon fill="#000000" stroke="#000000" points="359.6159,-29.8448 368.9578,-24.847 358.5381,-22.9283 359.6159,-29.8448"/>
+<text text-anchor="middle" x="225.3319" y="-106.8999" font-family="Times,serif" font-size="14.00" fill="#000000">recv:FIN,ACK send:ACK</text>
+</g>
+<!-- FIN_WAIT_2&#45;&gt;TIME_WAIT -->
+<g id="edge20" class="edge">
+<title>FIN_WAIT_2&#45;&gt;TIME_WAIT</title>
+<path fill="none" stroke="#000000" d="M345.4271,-93.0157C340.5738,-81.4151 337.0913,-66.4398 344.0799,-55 348.0605,-48.4841 353.6147,-43.0833 359.8826,-38.6191"/>
+<polygon fill="#000000" stroke="#000000" points="362.1369,-41.3397 368.7915,-33.0955 358.4482,-35.3904 362.1369,-41.3397"/>
+<text text-anchor="middle" x="399.8026" y="-60.6" font-family="Times,serif" font-size="14.00" fill="#000000">recv:FIN send:ACK</text>
+</g>
+<!-- CLOSING&#45;&gt;TIME_WAIT -->
+<g id="edge19" class="edge">
+<title>CLOSING&#45;&gt;TIME_WAIT</title>
+<path fill="none" stroke="#000000" d="M473.7208,-92.9839C472.0594,-81.3702 468.5675,-66.3923 461.2284,-55 458.6058,-50.9291 455.3728,-47.1123 451.8461,-43.5954"/>
+<polygon fill="#000000" stroke="#000000" points="454.0743,-40.8921 444.2963,-36.8125 449.396,-46.0993 454.0743,-40.8921"/>
+<text text-anchor="middle" x="521.5233" y="-63.3999" font-family="Times,serif" font-size="14.00" fill="#000000">recv:ACK send:无</text>
+</g>
+<!-- TIME_WAIT&#45;&gt;CLOSED -->
+<g id="edge21" class="edge">
+<title>TIME_WAIT&#45;&gt;CLOSED</title>
+<path fill="none" stroke="#000000" d="M461.5713,-20.6248C559.4315,-26.3778 778.2284,-46.4674 778.2284,-111.0999 778.2284,-574.0995 778.2284,-574.0995 778.2284,-574.0995 778.2284,-641.2959 548.4124,-660.033 448.5999,-665.0021"/>
+<polygon fill="#000000" stroke="#000000" points="448.3309,-661.5108 438.5074,-665.4794 448.6617,-668.503 448.3309,-661.5108"/>
+</g>
+<!-- LAST_ACK -->
+<g id="node11" class="node">
+<title>LAST_ACK</title>
+<path fill="none" stroke="#000000" d="M578.4491,-93.0999C578.4491,-93.0999 642.0076,-93.0999 642.0076,-93.0999 648.0076,-93.0999 654.0076,-99.0999 654.0076,-105.0999 654.0076,-105.0999 654.0076,-117.0999 654.0076,-117.0999 654.0076,-123.0999 648.0076,-129.0999 642.0076,-129.0999 642.0076,-129.0999 578.4491,-129.0999 578.4491,-129.0999 572.4491,-129.0999 566.4491,-123.0999 566.4491,-117.0999 566.4491,-117.0999 566.4491,-105.0999 566.4491,-105.0999 566.4491,-99.0999 572.4491,-93.0999 578.4491,-93.0999"/>
+<text text-anchor="middle" x="610.2284" y="-106.8999" font-family="Times,serif" font-size="14.00" fill="#000000">LAST_ACK</text>
+</g>
+<!-- CLOSE_WAIT&#45;&gt;LAST_ACK -->
+<g id="edge14" class="edge">
+<title>CLOSE_WAIT&#45;&gt;LAST_ACK</title>
+<path fill="none" stroke="#000000" d="M495.2734,-185.6811C500.1626,-173.5101 508.1367,-157.8521 519.6248,-147.5999 530.2135,-138.1505 543.5616,-130.9786 556.7335,-125.6049"/>
+<polygon fill="#000000" stroke="#000000" points="558.1377,-128.8159 566.2516,-122.003 555.6601,-122.269 558.1377,-128.8159"/>
+<text text-anchor="middle" x="575.0301" y="-155.9998" font-family="Times,serif" font-size="14.00" fill="#000000">appl:关闭 send:FIN</text>
+</g>
+<!-- LAST_ACK&#45;&gt;CLOSED -->
+<g id="edge15" class="edge">
+<title>LAST_ACK&#45;&gt;CLOSED</title>
+<path fill="none" stroke="#000000" d="M621.9441,-129.1662C625.2932,-134.8938 628.7128,-141.3621 631.2284,-147.5999 640.8396,-171.4329 645.2284,-178.0019 645.2284,-203.6998 645.2284,-574.0995 645.2284,-574.0995 645.2284,-574.0995 645.2284,-615.7428 518.6506,-645.5857 448.5825,-658.9154"/>
+<polygon fill="#000000" stroke="#000000" points="447.8658,-655.4886 438.6764,-660.7616 449.1484,-662.3701 447.8658,-655.4886"/>
+<text text-anchor="middle" x="697.5233" y="-387.4996" font-family="Times,serif" font-size="14.00" fill="#000000">recv:ACK send:无</text>
+</g>
+</g>
+</svg>
diff --git a/src/systems/filecoin_markets/storage_market/storage_provider.go b/src/systems/filecoin_markets/storage_market/storage_provider.go
index 3e41fa88c..cee390930 100644
--- a/src/systems/filecoin_markets/storage_market/storage_provider.go
+++ b/src/systems/filecoin_markets/storage_market/storage_provider.go
@@ -1,8 +1,11 @@
 package storage_market
 
-import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-import actor "github.com/filecoin-project/specs/systems/filecoin_vm/actor"
-import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+import (
+	actor "github.com/filecoin-project/specs/systems/filecoin_vm/actor"
+	addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
+
+	deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+)
 
 // import deal_status "github.com/filecoin-project/specs/systems/filecoin_markets/storage_market"
 
@@ -59,3 +62,8 @@ func (provider *StorageProvider_I) HandleStorageDealQuery(dealCID deal.DealCID)
 
 	return StorageDealNotFound
 }
+
+// TODO this should be moved into storage market
+func (sp *StorageProvider_I) NotifyStorageDealStaged(storageDealNotification StorageDealStagedNotification) {
+	panic("TODO")
+}
diff --git a/src/systems/filecoin_markets/storage_market/storage_provider.id b/src/systems/filecoin_markets/storage_market/storage_provider.id
index 8990d8885..667e6018d 100644
--- a/src/systems/filecoin_markets/storage_market/storage_provider.id
+++ b/src/systems/filecoin_markets/storage_market/storage_provider.id
@@ -1,11 +1,11 @@
 import addr "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
 import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
-// import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
+import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector"
 
-// type StorageDealStagedNotification struct {
-//     Deal      deal.StorageDeal
-//     SectorID  sector.SectorID
-// }
+type StorageDealStagedNotification struct {
+    Deal      deal.StorageDeal
+    SectorID  sector.SectorID
+}
 
 type StorageProvider struct {
     DealStatus {deal.DealCID: StorageDealStatus}
@@ -24,7 +24,7 @@ type StorageProvider struct {
     verifyStorageClient(address addr.Address, signature deal.Signature) bool
 
     // TODO: Call by StorageMiningSubsystem
-    // NotifyStorageDealStaged(storageDealNotification StorageDealStagedNotification)
+    NotifyStorageDealStaged(storageDealNotification StorageDealStagedNotification)
 
     // Call by StorageClient
     HandleStorageDealQuery(dealCID deal.DealCID) StorageDealStatus
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
index 2bcc3b40e..c37862eae 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go
@@ -3,13 +3,14 @@ package storage_mining
 // import sectoridx "github.com/filecoin-project/specs/systems/filecoin_mining/sector_index"
 // import spc "github.com/filecoin-project/specs/systems/filecoin_blockchain/storage_power_consensus"
 // import actor "github.com/filecoin-project/specs/systems/filecoin_vm/actor"
-import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
-import libp2p "github.com/filecoin-project/specs/libraries/libp2p"
-import address "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
-import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-import chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
-import util "github.com/filecoin-project/specs/util"
-import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+import (
+	filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
+	libp2p "github.com/filecoin-project/specs/libraries/libp2p"
+	block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
+	deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
+	address "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
+	util "github.com/filecoin-project/specs/util"
+)
 
 func (sms *StorageMiningSubsystem_I) CreateMiner(ownerPubKey filcrypto.PubKey, workerPubKey filcrypto.PubKey, sectorSize util.UInt, peerId libp2p.PeerID) address.Address {
 	ownerAddr := sms.generateOwnerAddress(workerPubKey)
@@ -22,7 +23,7 @@ func (sms *StorageMiningSubsystem_I) HandleStorageDeal(deal deal.StorageDeal) {
 	sms.SectorIndex().AddNewDeal(deal)
 	// stagedDealResponse := sms.SectorIndex().AddNewDeal(deal)
 	// TODO: way within a node to notify different components
-	// sms.StorageProvider().NotifyStorageDealStaged(&storage_provider.StorageDealStagedNotification_I{
+	// markeet.StorageProvider().NotifyStorageDealStaged(&storage_provider.StorageDealStagedNotification_I{
 	// 	Deal_:     deal,
 	// 	SectorID_: stagedDealResponse.SectorID(),
 	// })
@@ -38,61 +39,62 @@ func (sms *StorageMiningSubsystem_I) CommitSectorError() deal.StorageDeal {
 
 // triggered by new block reception and tipset assembly
 func (sms *StorageMiningSubsystem_I) OnNewBestChain() {
+	panic("")
 	// new election, reset nonce
-	sms.ElectionNonce = 0
-	sms.tryLeaderElection()
+	// sms.electionNonce = 0
+	// sms.tryLeaderElection()
 }
 
 // triggered by wall clock
 func (sms *StorageMiningSubsystem_I) OnNewRound() {
+	panic("")
 	// repeat on prior tipset, increment nonce
-	sms.ElectionNonce += 1
-	sms.tryLeaderElection()
+	// sms.electionNonce += 1
+	// sms.tryLeaderElection()
 }
 
 func (sms *StorageMiningSubsystem_I) tryLeaderElection() {
-	T1 := storagePowerConsensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
-	TK := storagePowerConsensus.GetElectionProofSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
+	panic("")
+	// T1 := sms.Consensus.GetTicketProductionSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
+	// TK := sms.Consensus.GetElectionProofSeed(sms.CurrentChain, sms.Blockchain.LatestEpoch())
 
-	for _, worker := range sms.workers {
-		newTicket := PrepareNewTicket(worker.VRFKeyPair, T1)
-		newEP := DrawElectionProof(TK, sms.electionNonce, worker.VRFKeyPair)
+	// for _, worker := range sms.workers {
+	// 	newTicket := PrepareNewTicket(worker.VRFKeyPair, T1)
+	// 	newEP := DrawElectionProof(TK, sms.electionNonce, worker.VRFKeyPair)
 
-		if storagePowerConsensus.IsWinningLeaderElection(newEP, worker.address) {
-			BlockProducer.GenerateBlockHeader(newEP, newTicket, sms.CurrentTipset, worker.workerAddress)
-		}
-	}
+	// 	if sms.Consensus.IsWinningLeaderElection(newEP, worker.address) {
+	// 		BlockProducer.GenerateBlockHeader(newEP, newTicket, sms.CurrentTipset, worker.workerAddress)
+	// 	}
+	// }
 }
 
-// TODO this should be moved into storage market
-func (sp *StorageProvider_I) NotifyStorageDealStaged(storageDealNotification StorageDealStagedNotification) {
-	panic("TODO")
-}
-func (sms *StorageMiningSubsystem_I) PrepareNewTicket(priorTicket Ticket, vrfKP libcrypto.VRFKeyPair) Ticket {
-	// 0. prepare new ticket
-	var newTicket Ticket
+func (sms *StorageMiningSubsystem_I) PrepareNewTicket(priorTicket block.Ticket, vrfKP filcrypto.VRFKeyPair) block.Ticket {
+	panic("")
+	// // 0. prepare new ticket
+	// var newTicket Ticket
 
-	// 1. run it through the VRF and get deterministic output
-	// 1.i. take the VRFResult of that ticket as input, specifying the personalization (see data structures)
-	input := VRFPersonalization.Ticket
-	input.append(priorTicket.Output)
-	// 2.ii. run through VRF
-	newTicket.VRFResult := vrfKP.Generate(input)
+	// // 1. run it through the VRF and get deterministic output
+	// // 1.i. take the VRFResult of that ticket as input, specifying the personalization (see data structures)
+	// input := VRFPersonalization.Ticket
+	// input.append(priorTicket.Output)
+	// // 2.ii. run through VRF
+	// newTicket.VRFResult := vrfKP.Generate(input)
 
-	return newTicket
+	// return newTicket
 }
 
-func (sms *StorageMiningSubsystem_I) DrawElectionProof(lookbackTicket Ticket, nonce ElectionNonce, vrfKP libcrypto.VRFKeyPair) ElectionProof {
-	// 0. Prepare new election proof
-	var newEP ElectionProof
+func (sms *StorageMiningSubsystem_I) DrawElectionProof(lookbackTicket block.Ticket, nonce block.ElectionNonce, vrfKP filcrypto.VRFKeyPair) block.ElectionProof {
+	panic("")
+	// // 0. Prepare new election proof
+	// var newEP ElectionProof
 
-	// 1. Run it through VRF and get determinstic output
-    // 1.i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
-	input := VRFPersonalization.ElectionProof
-	input.append(lookbackTicket.Output)
-	input.append(nonce)
-    // ii. # run it through the VRF and store the VRFProof in the new ticket
-	newEP.VRFResult := vrfKP.Generate
-	newEP.ElectionNonce := nonce
-	return newEP
+	// // 1. Run it through VRF and get determinstic output
+	// // 1.i. # take the VRFOutput of that ticket as input, specified for the appropriate operation type
+	// input := VRFPersonalization.ElectionProof
+	// input.append(lookbackTicket.Output)
+	// input.append(nonce)
+	// // ii. # run it through the VRF and store the VRFProof in the new ticket
+	// newEP.VRFResult := vrfKP.Generate
+	// newEP.ElectionNonce := nonce
+	// return newEP
 }
diff --git a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
index 10ad97497..b91986ee2 100644
--- a/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
+++ b/src/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id
@@ -4,17 +4,11 @@ import filcrypto "github.com/filecoin-project/specs/libraries/filcrypto"
 import actor "github.com/filecoin-project/specs/systems/filecoin_vm/actor"
 import address "github.com/filecoin-project/specs/systems/filecoin_vm/actor/address"
 import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block"
-import chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain"
 import blockchain "github.com/filecoin-project/specs/systems/filecoin_blockchain"
 import blockproducer "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block_producer"
 import deal "github.com/filecoin-project/specs/systems/filecoin_markets/deal"
 import storage_proving "github.com/filecoin-project/specs/systems/filecoin_mining/storage_proving"
 
-type SectorSize union {
-    32GB    UVarint
-    64GB    UVarint
-}
-
 type StorageMiningSubsystem struct {
     // TODO: constructor
     // InitStorageMiningSubsystem() struct{}
@@ -25,12 +19,8 @@ type StorageMiningSubsystem struct {
     MinerActor         StorageMinerActor
     SectorIndex        sectoridx.SectorIndexerSubsystem
     StorageProving     storage_proving.StorageProvingSubsystem
-<<<<<<< HEAD
-    BlockProducer      blockproducer.BlockProducer
-=======
     BlockProducer      blockproducer.BlockProducer
-    electionNonce      ElectionNonce
->>>>>>> lots of progress on all functions related to ticket creation/validation, and EP creation/validation as well as randomness sampling
+    electionNonce      block.ElectionNonce
 
     // Need access to SPC in order to mine a block
     Consensus          spc.StoragePowerConsensusSubsystem
@@ -61,10 +51,14 @@ type StorageMiningSubsystem struct {
     CommitSectorError()
 
     // call by StorageMiningSubsystem itself in BlockProduction
-    DrawElectionProof(lookbackTicket Ticket, nonce ElectionNonce, vrfKP libcrypto.VRFKeyPair) ElectionProof {
+    DrawElectionProof(
+        lookbackTicket  block.Ticket
+        nonce           block.ElectionNonce
+        vrfKP           filcrypto.VRFKeyPair
+    ) block.ElectionProof
 
     // call by StorageMiningSubsystem itself in BlockProduction
-    PrepareNewTicket(priorTicket Ticket, workerKeyPair libcrypto.VRFKeyPair) Ticket
+    PrepareNewTicket(priorTicket block.Ticket, workerKeyPair filcrypto.VRFKeyPair) block.Ticket
 
     // call by BlockChain when a new block is produced
     OnNewBestChain()