Block Ingestion

Block Ingestion / Lifecycle

1. Life begins as either a File or a ChainLinq data object.

2. The file is broken up into blocks by blocksize.

3. Each block is joined with presently 4 (Tuple count 5) randomizer blocks which are either brand new or reused bright-blocks and randomizers.

4. A handle block is made that is a list of the hashes of the randomizer blocks used and the resultant bright-blocks from the brightening process.

5. The handle block is either pocketed, leaving only the bright-blocks in-chain/pool, or stored.

• Public CBL blocks (whether user-encrypted prior to ingestion or not) must be accepted by the network, relative to reputation rules, etc.
• Private CBL blocks are limited in scope/usefulness to the nodes within quorum, which is the scope of the encryption keys themselves. These may be accepted/ingested into brightchain locally or refused according to node preferences.

Time passes.

6. A user presents either the 5 addresses of the tuple stripe, called a Bright Handle, making up the CBL or the single address of the CBL if committed to chain.

7. The network retrieves the remainder of the blocks from the CBL and aligns them for re-constitution.

8. The randomizers are all tossed and the recreated identifiable "Source" blocks are the result. Take care while keeping these in memory to not commit them to chain and treat them as Source blocks which are not directly committable without brightening.

9. Upon ingestion, blocks are committed with a contracted lifetime that must be met. If the expiration is set, we will update a list of blocks expiring at that second. Another worker task will be responsible for looking at the expiring seconds since its last run and making sure those blocks have been flagged for garbage collection. Other processes may extend the block lifetimes and will update the ledger and give its own 'energy' to extend it, or do so on behalf of a user with their credit.

Ingestion diagram

 | File Source | Randomizers A-D       | Bright Blocks |
 +-------------+-----+-----+-----+-----+---------------+
 | S0          | R0A | R0B | R0C | R0D | B0            |
 +-------------+-----+-----+-----+-----+---------------+
 | S1          | R1A | R1B | R1C | R1D | B1            |
 +-------------+-----+-----+-----+-----+---------------+
 | ...         | ... | ... | ... | ... | B...          |
 +-------------+-----+-----+-----+-----+---------------+
 | SN          | RNA | RNB | RNC | RND | BN            |
 +-------------+-----+-----+-----+-----+---------------+
   ^ Discard   [ ________ Keep Hashes of These ________]
     this
     column

1. Divide file into N blocks by block size
2. XOR the source block bytewise with each of the randomizers, which a fraction of may be reused.

• S0[0...X] ^ R0A[0...X] ^ R0B[0...X] ^ R0C[0...X] ^ R0D[0...X] = B0[0...X] (where X is block length in bytes)

3. Drop the source blocks and commit the bright blocks (randomizers + highly random, cross correlated brightened blocks), R[0-N][A-D] and B[0-N].
4. Collect the hashes of all the randomizers and bright block outputs and generate a CBL from the (in-order) list.

• Those hashes are called the Constituent Block List or CBL

CBL Compilation

• The raw binary data is basically just one hash after another, a row at a time with no padding:
• SHA256(R0A),SHA256(R0B),SHA256(R0C),SHA256(R0D),SHA256(B0)
• SHA256(R1A),SHA256(R1B),SHA256(R1C),SHA256(R1D),SHA256(B1)
• ...
• SHA256(RNA),SHA256(RNB),SHA256(RNC),SHA256(RND),SHA256(BN)

Bright Address

• A Bright Address is the sha256 hash, or address of a block you wish to access. These are usually Constituent Block List or CBL blocks that contain the "recipe" to put the source back together.
• A Bright Address will likely be the raw hash put in Bitcoin Base58
• https://{hash}.brightchain.net or https://brightchain.net/b/{hash}

Bright Handle

• A Bright Handle is a collection of the (presently) five (5) SHA-256 hashes of a CBL or other identifiable block put into a URL.
• These handles can be committed to BrightChain or pocketed.
• Without this handle, the file can not be reconstructed.