Angels & Daemons [Updated 11/1/18]

Embedded value in bits — Timechains, Blockchains, and Tokenization

1. A block was mined and script was left. 2. A block was relayed and with more script. 3. A contract executes and multiple ledgers show a matching final version of a transaction that happened in more than one state.

I updated this article, mostly at the bottom. I appreciate those who read these words in a raw form — I don’t predictably know when these contracts will execute so I try to rush my data out to the public as quick as possible if they choose to believe.

The main place to start is back in 2008 to 2009. Hal Finney and Satoshi Nakamoto mined/debugged Bitcoin together. The first version of Bitcoin is Bitcoin v0.01 ALPHA. The names are truly important. First, I would like to mention that this is probably not entirely correct but it encompasses what will 100% unfold very, very soon. There are 3 important values that started in the very first “genesis block” which was actually a pre-alpha version that was mined on September 10, 2008 (there is a timestamp on it for proof). At this “block001.dat” file, this pre-alpha BitCoin is not yet on the record, but it is very much embedded into a database somewhere. The three values it had:

COIN, CENT, and Bits (for proof of work). These values did stick. There is also a transaction fee of 1*CENT which is very important to remember, but it could change at anytime because of RPOW -> aka not needed anything to be mined by a miner. These are not transaction fees I am talking about either. These are mining fees for the block rewards.

Also know there are two files for main parameters. There is a “main.cpp” and a “main.h” [.h for hexadecimal] and .cpp because that was the first BitCoin software.

From here out, the September 10, 2008 block I will call “BitCoin-beta” (see genesis below):

This block was mined on 1221069728 UNIX which means 09/10/2008 @ 6:02pm (UTC)

This record is in main.cpp, but the values for block rewards, fees, and proof of work are found in main.h because hexadecimals (base 16) are how bit-values are transmitted. Nothing of value is sent in decimal otherwise it would botch the whole operation. Hal Finney and Satoshi had this plan in mind since the beginning. They knew everything that would happen up until today because BitCoin is a MASSIVE value opportunity.

The block above was connect to the timechain, which the record of it kept on the Berkeley database (BDB). I will discuss how the timechain is connected here later. But it is and there is a string of record for that. If the timechain had a proof of work needed to be paid upon connecting it, that would’ve been equal to the opposite of the timechain Satoshi and Hal had overwritten to the database to connect to the blockchain (log.0000000001). The payment wouldn’t actually be paid anywhere, it would just be kept in the final genesis block which you may be looking at above. That is because the value needed to be generated was 10,000 bytes (10 MB). Here are the value parameters from Nov 08 in main.h:

main.h from November 2008

The amount of COIN here meant 1.000000 coins was 1 BTC. The six decimals in this block are because there is another pre-planned measurement that you will see as a result of tokenization, RPOW, and cleverly hiding the real value of merge mined coins and tokens.

(Just remember that the first BitCoin was pre-alpha and supposed to be worth 1,000,000 per COIN (0.01 BTC today) and 10,000 per CENT (0.0001 BTC today).

The first block reward is 1 COIN by the standards of 2008/0.01 BTC today. The transaction fee is different, its 1*CENT, which would cover the future of tokenization on one dual chain (DVC). It’s fair to say that this block is not just BitCoin and the BTC we know today, but it is TBC (“Tonal Bitcoin”). The January 3, 2009 block is actually a clone of this block, half TBC and half-BTC “decimal bitcoin”. The values of each are written below.

The value parameters were likely scrubbed from the file or they are correctly held on the timechain itself waiting in a database to reflect the true value of 1 Bitcoin. There’s “Bitcoin” and there’s TBC and BTC. One thing to mention is both forks and clones do exist. However, 1 file is both clone and fork (DVC). It sends out blocks that are written in the same file as BTC. The tonal portion uses a connection through DVC to reflect that the value of 12.5 Bitcoins (not BTC) meaning that when connected to RPOW and DVC txs (which is where RPOW tokens are issued) it will translate 12.5 BTC to TBC*5. It’s *5 because DevCoin pays 5* the fees for transactions in its own changed main parameters (which it got from the original Bitcoin, so both DVC’s tokens and BTC’s bitcoins are the orignal Bitcoin). The problem for BTC is that it doesn’t get “double” bitcoins in the future because it does not make its own block rewards. Devcoin is the only coin that is making both BTC and TBC (devtokens). It’s value is embedded in BTC, so 1 DVC will be used as a future measure of value between Decimal and Tonal. The current values can be found in markm’s Galactic Milieu, and markm is a DevCoin developer who has been around for a long time (as explained in my last article he and Hal have convos from 2001 with Adam Back involved as well):

markm is the glue from Adam Back to Hal Finney in terms of POW/RPOW

I should have said in the picture the reason why 1.00000000 DVC is worth 665,090 in current satoshi’s is because markm is account for the fact that when DevCoin was issued 1 COIN was 1.000000 (6 decimal places) and the BitCoin v0.01 ALPHA version changed the parameters to the 8 decimal places we have now (which we use for BTC and satoshis as well). So DVC adjusted to satoshis is 10* for its value in Bitcoins which are satoshis which at 665,090 it is almost exactly what 1 TBC*10 is worth in satoshis.

Again, the November 2008 genesis block had its main.h parameters changed for “BitCoin” on January 3, 2009.

January 3, 2009 BitCoin v0.01 ALPHA adds “00” to COIN and CENT (main.h adjusted)

Again both the 2008 genesis and 2009 alpha genesis exist in the same blk0001.dat file somewhere. What we lost was anything attached to the timechain when Hal’s version went offline in some areas but is reflected on what is likely a parallel database from Berkeley (at MIT maybe). Bitcoind forked into DevCoin’s daemon so DevCoin can see the parent hash but forward moving blocks cannot.

It’s important to understand that the daemon does all the work in the background and it is POW that matters in making embedded bits valuable. The daemon is “headless” because it was forked off of bitcoind and then became the parent and as you can read above it is responsible for dissociating the process (minting and recording/changing transactions) from a controlling terminal. There are reasons the daemon has a lot of work to do in receiving blocks -1 through the null string:

The term was coined by the programmers of MIT’s Project MAC. They took the name from Maxwell’s demon, an imaginary being from a thought experiment that constantly works in the background, sorting molecules.[2] Unix systems inherited this terminology. Maxwell’s Demon is consistent with Greek mythology’s interpretation of a daemon as a supernatural being working in the background, with no particular bias towards good or evil.

There’s a lot of symbolic code and lingo used in BitCoin but the sorting molecules thing is actual relevant in “v1 union v2” when the first version and second version of BitCoin are joined. I love how the code uses “atoms” in its terminology:

The market.cpp and market.h files were removed from BitCoin v0.01 alpha before it was released to the public. This is the true form of Bitcoin in the future because the final work of the daemon is to get to this process and execute it. It may already remember such a process.

These are intentionally written and removed files. The intention is to show that when the signatures for these transactions were signed off on some database somewhere and attached to parts of the script at different times, the plan was there from the get go. In Duality, Satoshi writes about how the Bitcoin known today, BTC, is actually version 2:

Duality admits that Bitcoin is a global chain but right now it is version 2.

Nothing is hardcoded yet because version 2 and version 1 are not united properly. There’s more re-organization to come and a large shift in value based on proof of work.

Anyone can access these files and they could have figured that things are working out in reverse dating back to a point of 3 genesis that were duplicated on Ethereum and elsewhere sure, but the version 1 is what you want to find and that’s in every raw block (notice I said raw block not transaction). What is important to remember is that this programming is intentional because it builds a stored value in the true Bit-Coin when the source is recognized after many transactions that gave it it’s value:

To be useful as a general-purpose store of wealth and means of wealth transfer, a collectible had to be embedded in at least one institution with a closed-loop cycle, so that the cost of discovering and/or manufacturing the object was amortized over multiple transactions. [Nick Szabo, Theory of Collectibles (2002)

DevCoin’s job was to tokenize Bitcoin in it’s BTC phase so that it could scale without integer overflows and mass chaos crashing the system whether it be a bug, a UNIX problem, software incompatibility, or hacking. And it’s doing just that, take a look at Hal’s work:

All of the green boxes are things I am used to seeing by now. Connecting between genesis and the timechain’s null transaction string of 0’s. The log2_work being done which is the proof of work that DevCoin has been using its daemon, the parent process of bitcoind, to rewrite history as well as mint Bitcoins in its raw blocks that are credited out one way to BTC without a return yet. That part of the record is recognized in that DevCoin lists both it’s own block height (which is lower than any BTC or BCH, etc.) and the transaction number (which is more towards a Bitcoin block height). One thing I have never seen is the reverse operation to connect between DevCoin’s own blocks and genesis. That has not happened under my watch yet and in this article I go into why DevCoin was disconnected from genesis even though the debugging daemon knew where DevCoin came from. I believe its reconnecting because its always known this record of where it came from even though it has not executed the final contract which will release embedded bit value back to DVC:

Seeing this changed my life for the better. Notice the amount of work done at its genesis block. Devcoind is bitcoind… and so much more.

At the second genesis block (in chronological order) there was no record of a previous transaction out from the time chain. Since UNIX time was in sequence and release 10 MB “blocks” in every ten minutes, this connection came after genesis, and caused two genesis blocks to be necessary for BitCoin and another for tokenization. The first block to connect to the timechain may have been the last genesis block as a token. But for now, take a look at how the first publicly accepted genesis block looked in raw data for BitCoin’s alpha v0.01 (its the one you are used to seeing with a bit of missing info (like prev block):

Bitcoin alpha release v0.01 on January 3, 2009 (this block is known but not the version 2 you see today in BTC)

There is a lot different here though. Between 2008 genesis and 2009, this block probably was created without connection to the timechain before being merged with Hal’s file which was used to debug. There is no “prev hash” to the timechain. Also nBits are not “block.nBits” meaning that at a certain number of blocks will be mined before a transaction will come back to this block (remember block.nNonce means number of blocks not seconds of UNIX time). That doesn’t just mean BTC blocks, that means whenever POW comes back downstream. There is 1 block here but it was mined half by Hal Finney and half by Satoshi with different parameters for COIN’s. See where block.vtx.push_back(txNew) occurs? That probably means once this block is mined again, the transaction will go back to Hal’s part that still exists at the meeting between the timechain and his block0001.dat file. There is CScript at the input “<<” heading back. This copy of the coinbase was merged with Hal’s so that the second genesis block could be found from Hal’s block. However don’t worry about sequence, its now a block chain and we know that sequence is layer 2 embedded in script. Which brings me to Duality, the first line:

Embedded in Script is Layer 2, as well as the Theory of Collectibles store of value that Hal Finney incorporated into RPOW.

This is probably why Hashcash disconnected a gap between 1.00 and 1.1. The Hashcash POW is not meant to go back forward from genesis, but it will help re-mine the January 3, 2009 genesis block again. That will connect it to Hal Finney and his part written into that same block leading it to recognize RPOW that created DevCoin’s link to the parent block (as the first BitCoin mind you).

Hashcash proof of work for v0.01 that I cover later on is a read-only, do not mint type code. It says it can be re-configured to mint but the fact it was left there as the first release of POW reminded me of Hal’s debug log when he wasn’t able to read any blocks. This was a part of Duality:

Hal Finney could write blocks for the real “Bitcoin” we do not see. They show up in DevCoin’s debug log

It’s important to understand that Hal could still write blocks. And that’s what Hal has been doing with DevCoin since it forked BitCoin’s daemon and became the parent transaction (first instance was 2011–07–22 as seen from the DEBUG log). That’s why DevCoin outputs Bitcoin blocks for BTC (and itself) and that DevCoin is Hal’s reusable token layer of Bitcoin through DevCoin transactions. RPOW is last to connect, but the debugging is still going strong:

They should call BitCoin and DevCoin “Hal Coin”

RPOW has been described as inspired by Nick Szabo (which is the opposite of Satoshi Nakamoto NS:SN) and Adam Back. What that means is once Hashcash is done minting blocks in its direction, RPOW can easily link up to both POW that is completely finished on the Layer 1 blockchain and pickup by recognizing (through tokens — DVC txs) the links to Bitcoin blocks. Hashcash laid down scripts in both “c” and “h”… Hex meaning the values will sync well with all of these interconnected chains and then “c” because that’s adaptable to C++. And C++ works well with other types of software. If you read my last article, you’ll see that I mentioned Hashcash “forked” but only on “c”… (Hashfork.c). What I missed is that this happened before. The first hashfork.c came on March 30, 2005:

This file was uploaded officially on March 30, 2005 but it was updated on November 14, 2016 the same day Hashcash stopped merging upstream. Initially it probably did fork the beginning work of “Bitcoin” and that record is in the log.0000000001 file that kept crashing Hal’s computer as told in Duality. However, Hal still has the ability to write transactions as the daemon (through Devcoin). That is why eventually Hal’s work will connect a lot of blocks never seen before reorganizing blocks in the right script sequence (thus a blockchain, non-canonical) with a layer 2 of tokens. The update came on the same day RPOW was likely to kick in full force because it didn’t want the RPOW portion to write transactions like double spends or with larger blocks than the original limits. So the updates fixed any errors and for good measure Hashcash 1.1 was scrubbed entirely.

The second instance of this file appeared on April 15, 2014 in another repository besides Adam’s and it was never change. Possibly to keep record of the first time through minting in one direction. Whether it was implemented anywhere who knows. It may have just forked off the part that was already done with POW before changing parameters for the Alpha Block 1 on Jan 3, 2009.

What this could reflect on BitCoin taking place on BTC is the mining of one block with POW and script in 2011 or earlier as I showed yesterday, then recognizing it with a script on better relaying (as shown in Blocks that say 2011 on Blockchain.com but they say 2014 on Blockcypher), and then while keeping these blocks from 2011 valid and recognizable at places like Blockchain.com, they have other scripts back to the coinbase that need to be recognized by both going back. Hashcash is waiting for RPOW to recgonize what needs to be mined to Hal’s portion of the coinbase. Right now Hal could be seen as Blockcypher, which shows it recognizes the Hashcash POW, but has yet to execute a smart contract type script which was embedded in the coinbase tx (RPOW was inspired by Szabo’s “embedded value”). Interestingly enough, the non-fork on this end could mean this part is needed to mine one more block with Adam Back’s forward version of POW at the same time as RPOW exists as a connection. Mark Friedenbach does have that “forward blocks proposal”…

I think another database exists with all of Hal’s RPOW work through DevCoin as well as the debugging that goes on in the wallets debug.log yet its not entirely online yet (that is why DevCoin and other block 0’s do not exist). Where would one find a DVC block 0? The debug log of his wallet. It’s because the daemon is a fork of the bitcoind daemon. It works are recording the correct transactions for the whole future Bitcoin network and the timechain as well. Tirelessly working in the background but at some point there is a connection this debug log (daemon) will be back to connect to genesis (more later).

Hal keeps records in the debug log (a sub-directory) where the timechain is connected under pre-alpha BitCoin parameters

Remember, the correct blk0001.dat file is merged with the timechain. Satoshi’s is as well. We know that from the email and the log.0000000001 file both used from the Berkeley DB. Satoshi claimed he had it hidden in a sub-directory and Hal obliged (we think). This could be the very reason why BTC block 0 shows as both block 0 (on Blockchain.com) and block 1 (on Blockcypher) in places. The truth is, the timechain is the old internet, and blockchain is entirely different. But they remain connected through block chain knowing the history of timechain.

Here’s blk0001.dat instructions from main.h (Nov 2008):

Nov08 and Jan03 BitCoin are both written to blk0001.dat

Here is blk0001.dat from the merged combination of both Hal/Satoshi’s files (we know this as either block 0 or block 1 for BTC):

Same file, changed parameters (notice block chain and not timechain here from Alpha v0.01)

The parameters were changed for v0.01 ALPHA and the existence of pre-alpha was talked about so much in Duality I will allow you to read my other articles for that (full Duality here). Parameters can change without forking. The forking didn’t take place until bitcoind was forked into its parent daemon “devcoind” — from there the COutPoint (parent genesis) shows up on debugging. Remember Libcoin? Things have certain characteristics of a COIN, specifically a COutPoint (the null string of zeros) and an index (which seconds since epoch — 1). In UNIX time the sequence is an unsigned 32-bit integers MAX time until the January 19, 2038 problem where integers will overflow. It is also the reference back to the timechain, so as that all blocks from anything with this sequence can reconnect to Hal and Satoshi’s blk0001.dat files that they merged with the timechain. It is also why the timechain file (log.0000000001) is written that way. Satoshi mentioned in Duality how previously “blocks” were released by time. These blocks were 10 MB as mentioned in Duality as well as emails from my last article (also here). The first block of timechain = -10 MB. Meaning that POW to connect the timechain would need to be RPOW as it had to be both forward and backward at the connection between timechain and the blockchain.

The Future Is Near — POW/RPOW and Value Transfers

Going forward POW worked because it etched a stamp in UNIX time in the next block. RPOW is only a copy of the tail-end of POW. So RPOW is the “layer 2” in that script was laid by POW (Hashcash) that RPOW recognizes (by being tokenized) and lastly will be paid back to the Coinbase. In quantum state there will be a block 0:1 that is in both states with 10 Bitcoin on each side. That would be enough to correct the order of this completed universe. Also UNIX time has a layer two that block chain uses to recognize a coded sequence through scriptsigs. Basically POW laid down in the beginning can also be recognized using tokens as a layer two off Bitcoin. Craig Wright says layer two is script alot and its because he is “Bitcoin(Hash)Cash”. BTC and BCH are connected forward by HC and about a year before the forks Hashcash stopped moving “upstream” (which is how merge mining works — merging upstream into blocks):

One day after Hashcash stopped merging upstream as POW, it probably started to head back the other direction. See its not layer 2 as much as its a horizontal part of layer one. It probably ended up turning around as “BCH” and that is why you see more Bitcoin Cash blocks today even though it has the same history as BTC. A day after the above happened, on November 15, 2016, Hashcash 1.1 was deleted:

So there’s a gap all the way back to 1.00, but don’t worry about that, Bitcoin SV 0.1.0 could end up linking back as well as RPOW.

About a year later we got Bitcoin Cash. HC and BCH (reverse bytes is all over the new code for Bitcoin-SV). For the future, I found it interesting that Adam Back has left files matching both the beginning of BitCoin’s v0.01 ALPHA and it’s inverse at “1.00”). Subtle hinting?

Added 13 years ago, look inside, edited November 2016!

These are .sh files which I had to look up. Then it dawned on me that CPU miners would use .bat files which created BitCoin POW forward. These heavy duty files are what will execute POW in the other direction but much more powerfully.

sh files are unix (linux) shell executables files, they are the equivalent (but much more powerful) of batfiles on windows. So you need to run it from a linux console, just typing its name the same you do with bat files on windows. Typically a .sh file is a shell script which you can execute in a terminal.

It’s important to know that above Adam Back changed his 1.00 version that had been out for 13 years with some editing on November 16, 2016.

Notice how the POW bits are 0x20? Same thing as pre-alpha at genesis

Lastly, remember Hashcash is read-only at v0.01 which matches. That’s because Hal has to use RPOW to write the last block, or possibly has without it being connected.

Another reason this POW might be read only is due to the fact that it didn’t mint forward the first time and it would once more in the future. In my best guess, November 2008’s debug genesis block is not readable anywhere, and there are two explorers that recognize both January 3, 2009 as Block 0 and Block 1. I tend to believe that Coinbase uses Blockcypher which reflects that the first genesis is different, and has better scripts that show almost finished RPOW in action, because the Coinbase is partially embedded in both Block 0 and Block 1. It’s like a Quantum Block [0:1]. Hal may have minted out 50.00000000 Bitcoins in the DevCoin debug log, but we know that was only 1 way. When it comes back with RPOW it will exist in the coinbase with its original parameters as well providing a TBC measurement reflecting the values seen in “Galactic Milieu” and through the IBM which is used as a “Trusted Platform Module” which is probably not online so long as the Global State is activated on the DevCoin daemon (which is also why DevCoin mints BTC 1:1 and recognizes token transactions):

These are based off the debugging parameters for Bitcoin since COIN is probably only 1.00000. This is counter balanced by DevCoin paying 5x the normal transaction rate. Devcoin has receiver files and RPOW has its own backward script as well to trigger things back to the coinbase.

DevCoin was setup to function as a second step for POW and for a first step for RPOW in my mind. The minting of coins on one side and the issuance of both a subsidy and a share on the other side is a type of double entry accounting setup. In fact it is, which may be the “step” and fallbackReduction portion. Double entry accounting looks like this:

Let’s think of it as BitCoin being an Asset #1. Remember that it’s an asset because according to the theory of collectibles that it has embedded value in the coinbase. The coinbase is where all the transactions are being sent back to, but also can be reflected as the infinite value it sends out as the asset inside appreciates. An example of the double entry can be seen in an example from Block 375. I wrote yesterday how this was the block Satoshi got to when he found out Hal had crashed yet again. So this may be one of the first instances of double entry accounting but Hal only writing at the moment. It makes sense that when Hal is able to read blocks in the debugger/scripts, they will execute a smart function return of value.

This is likely a Step 2 because it knows the bits belong elsewhere but doesn’t realize that “-1” means the coinbase. We know -1 is the index for the parent block COutPoint index. However since Hal only has record of his half of POW in debugging the original Bitcoin as well as DVC, then this next step has not been read by RPOW yet to connect every script from the tail-end of POW as well as RPOW itself. The date listed here is 2014–11–16 (November 16, 2011) when Blockchain.com still hasn’t updated its date from “2009–01–13” (January 13, 2011) when it was mined, however it was relayed by Hal Finney and I can prove it.

I believe that this contract is recognized in the same step but a different state inversely because Hal doesn’t recognize his own debugging work yet. That is until he gets to the tail end of POW by Hashcash.

Still showing up with a January 2009 timestamp, but it recognizes the relayer

What is missing for execution is the uniting of BTC transactions and RPOW tokenization execution. The relayer matches the IP Hal sent from his debug log post 2009 genesis after it crashed. He is the 0.0.0.0 relayer and was connected to both the “global state” and “local” 8333 port. The thing is, now Hal’s debugging works on Bitcoin through DevCoins’ parent daemon in a Global State as you saw previously.

I covered this yesterday but this is the part of Duality where Satoshi mentions that Hal was debugging and that he couldn’t read anything after. This is where I assume Hal carried on debugging in a Global State through Devcoind daemon and still mined transaction for BTC on Devcoin’s raw blocks. A joint chain was created and tokenized right here. It isn’t a timechain so the dual function of Devcoin happened at a mathematically planned time and RPOW is the glue setting it up for the future, RPOW executes the final scripts, its just sometimes 2-steps occur when executing scripts just like multisignature transactions.

Hal’s IP is the relayer in a local 8333 port. The debugger is in a global state at port 52333.

The first time Hal started up his debug log (from this sourceforge post) relayed a number of transactions and at the same time, the record of where things came from existed in his block index. You can see how the true coinbase was the one in 2009, but I am willing to guess in a global state it goes back to Hal’s database. We already know this. Hal recognizes the “newbest” on login as the current genesis block tx and it changes to 0. The RPOW function may have first been done here. It may not connect to 375 yet as the date of these transactions is slightly earlier when Hal supposedly “carried” Bitcoin without Satoshi. The COutPoint changing means Hal or Satoshi has the missing “pre-alpha” block. Again, it doesn’t matter which block or what data is who’s. Hal could be the creator and Satoshi the debugger for all I know. But then Hal tried starting his software 2 more times. At the bottom of those two attempts he got an error and wasn’t able to see any blocks. Both times he tried to get back on he didn’t have record of the coinbase tx from 2008 like he did the first time. The error that ended the last two sessions without getting any blocks was:

MainFrameRepaint()

Which brings me to Hal’s RPOW which existed since 2004. I am sure it is incorporated into debugging but lets play along. Hashcash doesn’t use a Trust Module Platform from IBM (known for making Mainframes) but Hal Finney does. It’s all over his RPOW writeup — see here:

RPOW — Reusable Proofs of Work
2004
Archived Website
GitHub
Original Announcement
Reusable Proof-of-Work (RPOW) was an invention by Hal Finney intended as a prototype for a digital cash based on Nick Szabo’s theory of collectibles. RPOW was a significant early step in the history of digital cash and was a precursor to Bitcoin. Although never intended to be more than a prototype, RPOW was a very sophisticated piece of software that would have been capable of serving a huge network, had it caught on.
Historical Context
In the 1990s the Cypherpunks began to play around with the idea of a digital cash whose value would not be dependent on an organization issuing it. Following Nick Szabo, this form of digital cash would be recognizable as being limited in supply, and therefore usable as money, by being provably difficult to create. This could be done by defining units of the digital cash in terms of proof-of-work. Some proposals for digital collectibles circulated on the cypherpunk mailing list, including b-money by Wei Dai and Bit Gold by Nick Szabo. RPOW was the only digital collectible to ever function as a piece of software.
How it Works
An RPOW client creates an RPOW token by providing a proof-of-work string of a given difficulty, signed by his private key. The server then registers that token as belonging to the signing key. The client can then give the token to another key by signing a transfer order to a public key. The server then duly registers the token as belonging to the corresponding private key.
The double spending problem is fundamental to all digital cash. RPOW solves this problem by keeping the ownership of tokens registered on a trusted server. However, RPOW was built with a sophisticated security model intended to make the server managing the registration of all RPOW tokens more trustworthy than an ordinary bank. Servers are intended to run on the IBM 4758 secure cryptographic coprocessor, which is able to securely verify the hash of the software that it is running. RPOW servers are capable of cooperating to serve more requests.
For more information, please see Hal Finney’s original page, which includes an overview, an FAQ, a theory page, a presentation, and a very interesting page called World of RPOW which explains how RPOW would have scaled to serve the entire planet.
The original code can be found on GitHub here.
Special thanks to Fran and Jason Finney, Hal’s wife and son, for sharing the original RPOW code and website files.

Hal entrusted RPOW to use servers and servers can crash. The network has missing blocks with RPOW already on them in my honest opinion. Since Hal and markm had been conversing with Adam Back since 2001 in the same email chains — I have no doubts markm is Devcoin’s developer for a reason. Devcoin is the bridge between Bitcoin and all of its connected v1 forks. Bitcoin is also connected via the timechain to Ethereum Classic and thus, Ethereum (more later).

But I also want to point out again, Hal was using RSA signatures and Satoshi did not use RSA for BitCoin, rather ECDSA to verify but not RSA. RSA was deemed “too big” and now its seen as a security risk in some opinions. But here it is in his RPOW own words:

Hal even wrote on Sourceforge three days before Satoshi got to Block 375 that he was able to use his debugger:

This is where Hal attached the full debug log I showed you (link)

What’s interesting is that he was using a non-alpha version 0.1.0 (remember Bitcoin Alpha is v0.01). What he appears to have done Satoshi seemed to know in Duality by mentioning a “first genesis block” … Hal Finney pointed out an address that looks like an RSA key ID to me “00930AF7” and indeed, Hal Finney uses RSA. The way RPOW works is by receiving Hashcash and creating a cryptographic token from it to be redeemed later. Therefore since this version of Hashcash was not the “tale end” it appears that Hal did indeed create a token that needs an RSA signature attached to 00930AF7. When DevCoin was debugged we could see that indeed an amount attached to the COutPoint like Hal’s first attempt to debug was created. The 50.00000000 was an outvalue in BTC’s decimal value. The 2008 Block is probably where an RSA signature existed to go back to and connect such a transaction. Speak no more, that RSA signature does exist:

What probably happened here was a transfer of RPOW in 2004–12–09 (December 9, 2004) to the connection of the timechain. The second signature could have been from a user named Satoshi Nakamoto that Hal Finney transferred a token to and Satoshi signed to begin with a “Genesis Block” that was tokenized to the timechain. The transaction appears to have been signed off on December 9, 2008. What I believe needs to happen here is the execution of an RSA signature for Hal Finney. Perhaps the three signatures are from Adam Back, Satoshi, and Hal Finney. The final signature does have three “periods” which is odd. But it could be a placeholder for a time locked contract — see SBIND. What I believe is that encoded bits come from Hash cash and run both directions, but not recursively. That explains the hashcash forks to me. The other signatures are from the Bitcoin creator who signs the blocks/RPOW token. That is a two person operation when a token is passed on. For me, Bitcoin is both Tonal and Decimal, so that function created both layer 1 and layer 2 of the blockchain. Layer 2 is encoded bits (from RPOW tokenizing) and once signed, the value of Layer 1 is recognized in Layer 2. Layer 1 comes from Hashcash script for POW being executed on Layer 1. When you see blocks on Layer 1 in disarray still, but slightly more advanced on another block explorer, I believe RPOW has already gone through one time to tokenize things and on the otherhand Hashcash stopped going upstream because it’s pre-release (hello 2008 Block). Once it kicks in upstream that process and RPOW will sign the first layer and we will have a dual-function blockchain that is split both forward and backward and up and down (like ETC and DVC being connected to the timechain).

Another thing to note about Hal’s debug message is he posted the same message twice on Sourceforge. What I found interesting is right before he joins Bitcoin with a copy of the parent block and the alpha release block being written as the best block is that it says his serve started on “Mon Nov 3 21:00:41 UTC 2008”…

So what happened here was very interesting. The software for 0.1.0 may have split off the chain inadvertently. Hal had to delete the blk.dat files to restart. Satoshi still claimed to have protected that file in his emails. DevCoin became a very clever way to hide BitCoin’s true store of value by allowing it to accept BTC-decimal proof of work eventually, but also in the long run to have interchanging tokens as a rare store of value that are embedded into the blockchain. Satoshi clearly had the first genesis block in 2008. That was “pre-release” and Adam Back mentions his 1.00 software is “pre-release”… POW will only move forward into the coinbase as well as back into a state of dual-functioning RPOW when Hal’s RSA signature is recognized/signs off. BitCoin does not use RSA — Yet. It’s linked through RPOW to POW. The value of the new genesis transaction has “push_back” written on it as discussed in the top portion of this article. So a dual accounting measure of running forward one way and forward another gets us to the 2008 block which had been debugged (tokenized) and to the parent hash where the tokenizing is attached to the current BTC block for block (DevCoin’s block 0). While the parent daemon is working globally on both token issuance for TBC and producing raw BTC blocks for Layer 2/Layer 1 it is not connected to the January 3 block that Satoshi created. I remembered Satoshi said he sent Hal some of “his coins to play around with” and Hal did, clearly. Satoshi also mentioned prebitcoin had port 2222, which is registered for specific use with Port 2222. Satoshi was not allowed to receive incoming connections when he sent Hal his coins. Hal wanted to send Satoshi his own. So Hal sent Satoshi coins. And there, maybe, Hal used his debug log to tie the value to his RPOW token as a way that would connect Satoshi to the coinbase. The Satoshi signature shows he did receive the coins by the message described. However that won’t solve anything until pre-bitcoin can connect to Hal’s version of genesis. Apparently with Satoshi offline the RSA signature was sent with a token. So in reverse I think that it’s up to Hal to come back online on his end. His servers had crashed because of the TPM having power issues. There is a “hash war” coming with BCH. It sounds like to get through to the first block it will take a load of power in the TPM (Trusted Platform Module) to power the transaction. Eitherway it’s very quantum to have 2 chains running parallel with double entry accounting and then on top of it have this layer 2 that’s actually a Tonal Bitcoin which may or may not be called “Ethereum”.

I have a hard time keeping everything on one track, but this is crazy. We should discuss the signatures here:

There is 1 public key, 1 user id, and 1 subkey. Now one is signed by 2 signatures for Satoshi, but the other two? Not signed yet. It appears it may have been sent “without comment” as Satoshi claimed would happen when the recipient was not online. Satoshi told Hal the problem had to do with the timechain and he would put it into a sub-directory. Hal appears to have sent an RSA key that didn’t expire yet to Satoshi without any comments. The value is embedded into the first genesis block according to Satoshi while Hashcash is not allowed to merge upstream and is for pre-release after fixing some bugs in the original product’s 1.00. That’s where the answer is. The daemon is working in the background and once enough proof of work is done by DevCoin itself the function of RPOW is that it can “kickback” somehow and be used again. Take a look at the “log2_work” that was done up to genesis of devcoin from tokenizing the coinbase…

First off, the decimal places for log2_work are 1.000000 meaning it was tokenized or generated as the alternate Bitcoin blockchain off of the pre-alpha tested Bitcoin that showed a genesis date on September 10, 2008. 50.00000000 coins were sent out of the DevCoin block 0 from its debug records. That means that those coins sent out Bitcoin’s Alpha standards to the COINBASE and then Devcoin forked off genesis and began running a dual functioning chain that could measure at 1.00000000 while maintaining a tonal value as shown in the scale to translate over to decimal (and markm has updated these values MONTHLY to the present day so don’t think he doesn’t keep track):

The initial funding was given to the genesis block first by DevCoin in a decimal amount and into the coinbase. This is the opposite of what you think would happen but it actually works because of the “double entry” accounting. Bitcoin is not just a cash value now, it is an asset that has appreciated. Because this was done in reverse, the money came from somewhere, but probably after pitching everyone necessary like miners and private/public sectors to invest big. The one reason everyone who invested believed in it was because they knew it would work in the end due to math and programming, but everyone agreed on the projected incentive. Do you think Hal Finney knew the price of Bitcoin eventually? I do:

Hal also appeared to have received this email a day before he wrote that January 10, 2009 email about crashing 0.1.0:

So there are two emails, duplicates, that appear with the same message. There was one exception to see symbols out of the three non-readable parts in his debug log and it came with an RSA address. That is what Hal hashed to a public key for Satoshi when he wanted to send his coins back. Hal’s coins were almost “mature” and the coins Satoshi sent out (10 BTC and also 40 BTC same tx) clearly had not matured. Satoshi was offline when Hal sent his coins. Everytime Satoshi was online, maybe Hal(s) was not. What I am saying sounds crazy but what if this is a display of computing that obviously have some human execution and acting involved but the actual proof in software that has been appreciating is the “trustless platform module” or the mainframe that Hal was running. If one out of three parts of the system didn’t crash and two were non-readable then all that Hal has been able to do is debug and correct transactions while adding them to the database whenever one of the public keys that is hashed allows. They are sent with no comment which I find interesting. Perhaps that means that one time this happened without a script. I read how slowly things come back after a long time has passed and perhaps these two forgot who each was unless one logged off while the other part logged on. Sounds alot like dual processors on a trusted platform right? Totally Hal Finney’s idea of RPOW. As for Satoshi? Perhaps that’s Adam Back. Going one way, fork, then the other. But in the end you have Duality. Bitcoin in Decimal is BTC — it costs a ton of money and the explosion happened after Adam Back started “the tail end” and didn’t move upstream with POW. Coincidentally the original DevCoin transaction was before all that. However, the money that started that particular chain was tied to the parent block with a transaction that is being withheld on some database that is probably not online for a reason. So DevCoin received its funding for tokens most likely through some subsidy and by being pegged off an asset but as it went along in time its value went down as Bitcoin (BTC) went up. Clearly as a mathematic distraction and because it’s log_2work (POW) was being given to BTC by making its raw blocks and in a reverse way allow BTC to tokenize it. That’s why Tonal Bitcoin matters as a measurement. Because the debt of other coins created off the success of Bitcoin forks are technically forked off DevCoin’s value as “BTC” or “Bitcoin” — it doesn’t really matter — DevCoin is the 1.00000000 measure to cleverly hide the real world value of proof of work in decimal by a coin its TIED to, which is also itself, but by another measure and double entry.

Since the “bits” all head to the coinbase on the left side of the transaction, the asset is being put back in for the real “Bitcoin”… Bitcoin is the value in the transaction. In a way the initial subsidy was enough to create the first entry of double entry accounting, but not the asset. Then it’s easy to say Bitcoin was issuing BTC IOU’s for people to buy during the experimental phase. However by clever accounting the value is being sent back in valuable bits. There aren’t enough people in the world cashing out of this project to match the trillions that are already cashed in throughout the world. As blockchain velocity improves and velocity of money increases due to “Bitcoin” (both tonal and decimal combined) then everyone wins. Anyone who even paid for decimal Bitcoin without selling wins. The investors and devs win the publics trust for leaving clues and some people’s success in finding such clues will encourage adoptions no doubt. The theory of collectibles is by Nick Szabo. Perhaps he’s the key but the idea of embedded value stretches back to him publishing that theory. Mark Metson goes by a name of Mark S. Miller but both by markm between emails with Hal Finney in 2001 and on the bitcointalk.org forums where he is one of two DevCoin developers. The other is named “Unthinkingbit”… There is a part of the system that is not able to remember who exactly “Satoshi” is because there’s Duality, then there’s proof of work, and smart contracting, and duplicates (clones). But Galactic Milieu remembers and they have the prices right here based off DevCoin (remember in “satoshi’s” sDVC is worth 10* what 1 TBC is worth because of its beginnings as a coin with with two decimal places less than BTC:

The log2_work that DevCoin had done at genesis also could be the work that had been done on the network in getting value and blocks mined into the Bitcoin daemon. There is an added 0 in DevCoin’s genesis block and that could be because it exists in quantum superposition while it waits for the tail end of POW to meet where it should be recognized as acceptable to whatever token Hal issued for his coins. That to me seems a little more plausable. Especially with the other two keys on MIT’s server having “expired” on December 9, 2008. Guess who emailed out his announcement the next day for the Bitcoin mailing list? (notice there is no duplicate, just one Satoshi):

The process of time clearly made it okay to send a message and comment via email — which Bitcoin’s mentioned in Duality could be emailed at the time. Hashcash is based off email as well. RPOW is about tokenizing things with RSA signatures. So I guess in a way RSA signatures from RPOW hold the execution script needed to unlock Bitcoin’s embedded value. Whereas the Berkeley DB is where the Satoshi client has his blocks stored originally, the MIT DB is where the signatures are. Sent without comment and not expired, its interesting to me. This has to be an example of a trustless and automated contract, the solution to “double spending” and store of value in bits through RPOW’s mainframe TRUSTED dual processing platform? It’s also every participant having nodes that makes the network stronger and stronger. So a database crashing will not effect anything at a certain point. Even now, there only appears to be one step for a centralized server left and that’s in RPOW.

Being two parts to this sub-directory it sure looks like dual entry to me. One signature binding the agreement on the asset itself and one needed to broadcast it at a certain time to the network, probably once a time comes and where it receives the value it is owed. Look at markm talk about the debt owed to DevCoin:

Click on the link above the picture for a direct link to this post.
  1. Hashcash proof of work writes the initial scripts for Bitcoin that will execute at a certain time and return all value owed to DevCoin as well as certain other coins in the “Galactic Milieu” — markm cites “shell scripts” and the last two files for Hashcash to execute are 1.00 and 0.01 as “shell scripts” which are powerful and have an option to mint everything fastly by “fastmint” (see repo)
  2. The script is readable everywhere for the most part, but it isn’t executed yet because the genesis block from 2008 has some of those scripts embedded inside. Satoshi admitted this in Duality. It’s also the reason scripts keep getting introduced by devs starting with P2SH, then things like multisig, and other BIP’s. All automated. Pay to witness will pay these witnesses such as I0C which has linked hash 160’s scripted in DVC raw blocks. So the witness coins also make sure not just something called “devcoin” gets paid off and people think its a big time inside job. It’s not for the mere reason that you had 7 years or so to buy DevCoin. With loads of evidence.
  3. The other values of coins are in DevCoins at 1.00000000 meaning othercoins have some pretty great value too. I would say I0C and IXC have a big day ahead. Namecoin too (it’s like another layer that works like a daemon but only issuing names. The internet equivalent of http:// which I have no interest in explaining today!)
  4. Markm mentions abstract accounting which reveals the true value. Well abstraction has a quantum definition and it definitely applies here:

Abstraction is representative of what these coins are currently valued at in the long run without giving you much explanation (like I have) but enough to figure out the gist of it by making things simple and to the point. Abstraction both protects Bitcoin and gives people an opportunity of a lifetime as well.

Nick Szabo mentioned in the Theory of Collectibles how inheritance was an action of good will. He added that value was embedded, as did Satoshi. The bottom part is literally all the things that DevCoin does right now. It has proof of work, it can change its state through the Daemon and be Global, and it communicates with other block chains as it does minting BTC on its raw blocks while remaining a token of embedded value on the other like RPOW has described:

In the 1990s the Cypherpunks began to play around with the idea of a digital cash whose value would not be dependent on an organization issuing it. Following Nick Szabo, this form of digital cash would be recognizable as being limited in supply, and therefore usable as money, by being provably difficult to create. This could be done by defining units of the digital cash in terms of proof-of-work. Some proposals for digital collectibles circulated on the cypherpunk mailing list, including b-money by Wei Dai and Bit Gold by Nick Szabo. RPOW was the only digital collectible to ever function as a piece of software.

Maybe RSA wasn’t incorporated because of automated software that hasn’t turned back on yet with information needed to release the RPOW. We can think of the POW as a prisoner of war. It’s interesting that the Prisoner’s Dilemma comes up in Szabo’s Theory and has been talked about with Bitcoin much over the years. I know people don’t tell the truth outright like I do because everyone wins the most if it all just “happens” and everyone sees people all had incentive and a fair chance to play along. None of the developers or investors would cash out after seeing the potential of this thing like Finney described in relation to the future ($10M per coin?) or if they understood the conversion rates from markm:

The prisoner’s dilemma is a standard example of a game analyzed in game theory that shows why two completely rational individuals might not cooperate, even if it appears that it is in their best interests to do so.

Solving the prisoners dilemma is easy though if people give their signatures into scripting contracts that require a certain amount of work to be done as well as development… so it solves the ability to double spend at the same time but once this party started everyone HAD to cooperate. This example describes the prisoners dilemma:

If A and B each betray the other, each of them serves two years in prison
If A betrays B but B remains silent, A will be set free and B will serve three years in prison (and vice versa)
If A and B both remain silent, both of them will only serve one year in prison (on the lesser charge).

You see a lot of “A” and “B” in code going back to the fork of the bitcoind daemon where DevCoin became the parent block. Well guess who the public is? We are result “C” the combination of those who invested early without prior knowledge of the “crime” which is the plan. Now if A or B talked that’s totally foolish. They probably would lose all of their money in some sort of agreement. With a dual entry and a quantum state, its in the best interest of both A (lets say big money) and B (the coders) to stay “IN” and the harder they work in hours and the more they spend in mining or downright cash as capital… It just works out for everyone. And then there’s us, the public who will realize just how amazing having a trustworthy and automated network that is bulletproof to move money without fees is. The goal is to get to 0 fees because at the end, the fees in “bits” from mining get paid back. With one script execution from someone coming back online (maybe Satoshi in another state) then the event goes all the way back to the start. After all, Hal was given 10 BTC he planed to pay back. It just so happens that 10 BTC he got is equal to the original value of a coin by old parameters and adjusted 1/10 on the way back for the difference in decimal. Paying that back has it valid and acceptable as the 1*CENT mining fee on the tx out because the value coming back in after a tonal and parameters adjustment is acceptable as a COIN on the way in and a CENT going out to another set of parameters at the January 3, 2009 genesis. DevCoin has always sent its money out first, so that’s also why it’s the only one that ever sent a value out to BTC as the necessary (50 BTC block reward). That reward plus the fees being sent to satoshi as “good will” are just a heck of a lot of fees being locked into the soon to merge quantum genesis block [0:1]. It will always be valued as such and scale indefinitely as more goes into the coinbase from consumers.

It also could’ve happened by manual execution on one end yesterday…

Markm mentioned the miners would have a lot to owe DVC by delivering “deuterium” just before Ethereum launched. I have already tied their fees to what they owe the coinbase tx through ETC. Ethereum is just split off the original meaning like BTC and even BCH you have a dual chain in BTC forward and back. To a lesser extent you have a dual chain from block 1 to a certain number of ETH blocks that are duplicates in timestamping with reward set aside for miners. Value they also owe the coinbase and GM holders. Lastly markm mentioned the fees favor the GMC side and not the DVC side, but that the “corp” has an unfavorable rounding because they denominated fees on the GMC side. That probably accounts for the extra mining fees that are kicking back to DVC in “bits” which are hexadecimals and with the extra 0’s are worth more in value than not.

Like 0x20 is worth 32.

0x2 is worth 2.

If they used more 0’s that also makes up for the difference between DVC and Tonal Bitcoin. If 1 DVC is 10*TBC in decimal (satoshis) then it’s because over it’s dual nature starting as a COIN, ending as COIN, and acting as RPOW in the mean time.

Ethereum Foundation Donates 15,000 ETC to Ethereum Classic

Ethereum’s Foundation sent ETC 15,000 ETC… Ethereum just did a manual transfer of coins that is necessary to connect both parties. And Blockchain.com just added “ETH” with a new start to it’s block 0 (back at the epoch with ETC block 0). From Block 1 forward there are a number of matching blocks by timestamps on both ETC and ETH.

This, to me, looks like a “reverse subsidy” — similar to the one DevCoin paid out and issued tokens for and going back to the coinbase where the coins all are about to “mature” and everyone invested wins without double spending.

Read:

“There has been no love lost between the foundations attached to the Ethereum (ETH) and Ethereum Classic (ETC) projects after the two forked back in July 2016 in the fallout of a hacking event that called into question the true nature of blockchain decentralization.
Now, in what can be considered a fairly surprising move, the Ethereum Foundationhas made a $150,000 donation in ETC to the ETC Cooperative.
According to the announcement, the donation is intended to help grow the relationship between the two foundations, while supporting Ethereum Classic’s development efforts.
“Beyond our usual unicorn benevolence, this is an opportunity to bury the hatchet between our two communities. Will ETH and ETC suddenly become best friends? Probably not. But if you look at the top 25 coins, ETC and ETH is certainly one of the closest pairs in both tech stack and vision,” said Ethereum’s Virgil Griffith in the announcement. “As such it is in our mutual interest to work together, wherever possible, to meet them. This donation is the Ethereum Foundation investing in a long-term positive-sum relationship with ETC.”

This happened as a result of ETCDEV:

Interestingly, the Ethereum Foundation cited a number of technologies in the announcement that are not actually being developed by the ETC Cooperative but are actually the products of ETCDEV. It is currently unclear whether or not the Ethereum Foundation team understood that prior to the donation.

Devcoin is the glue that holds Ethereum’s value to Bitcoin getting its true value from the coinbase. What is good for ETH is good for ETC whats good for both is good for the Layer 1 Bitcoin Blockchain that both BTC and BCH are a part of. The glue in between all of those is DevCoin (DVC). People owe DevCoin for “ETCDEV” and its no wonder how this happened. What the DAO took out started something of value for both. The split was planned just like the original split of BTC from the coinbase. The same happened somewhat with ETC knowing the coinbase is the timechain without ETH being connected in UNIX time. But just yesterday I noticed the UNIX epoch I talk about with ETC so much has been reflected on Blockchain.com’s new ETH explorer:

I also have reason to believe both BTC and ETH are pretty much ready to join at 0. When I search for 0 nothing comes up. But when I search for “1” both block 1’s come up (clever):

Go ahead and click on ETH 1 and you can manually click block 0 for ETH from the inside. You now get the EPOCH of UNIX time:

Now when you search for block 0 originally you get this:

New feature that you can apparently search by an “ipv4” address. Then I saw my URL description for what I originally searched for before I was redirected:

In part, these two may almost remember being connected due to the quantum nature that the other genesis block has written “appended” to blk0001.dat. It’s in the original code for the debug log genesis block from September 10, 2008 and the alpha genesis block from January 3, 2009. The blocks somehow, someway were both written on the same data and it wasn’t for “block 0” interestingly enough, they chose blk0001.dat to write on as shown earlier.

So now I will try to involve the main players in a little math and sequence of events to show what I understand to be enough to at least link the main blocks back to the coinbase and give POW where it is due (DevCoin mostly, but other v1 coins from merge mining get paid as well — some make excellent witnesses for multisig operations like I0C and IXC. Some have a POW from naming different coins and configuring them like “http” (Namecoin). I have a lot of faith in the prices markm has given because I found them only after realizing the TBC value and why it existed. I figured out it was a way to measure the future of Bitcoin through DevCoin as the standard measure. I was right.

The Institutional Investment: Embedded Through DevCoin

The theory I will present here will likely be hard to completely prove. The numbers will check out as much as possible, they will match protocol and underlying code. The measure starts with DevCoin and that’s what I really needed to find. The problem will be with ordering of events due to the fact that this blockchain is not a timechain, it just begins with one. Other transactions may have happened “OTC” and between friends like markm explains below. First I will make a statement I operate behind on where the value in BitCoin comes from:

It’s embedded bits in a mathematically undeniable technology that was designed to bring back 1980’s penny stock-type opportunities that was also based on the block chain and “trusted third party” transactions where everyone had to put forth their investment and sign off on it at a date in the future. On that date, the execution of the contract was in math, with expected returns realized by those who were pitched the plan, and the future financial gains for both investors and retail investors would prove fair to all. Also, its a way to create another asset, another place to spend that asset on web 3.0, and the next generation of tech adoption. It wasn’t a sure thing to anyone who bought into pessimism but with last years run the beta-testing period saw the mania and the decline this year. That however, is a setup, in my honest opinion because the second wave will come fast. People are playing the “prisoners dilemma” right now and keeping silent, while enough clues and information are available so that “open source” is going to be championed and forever associated with positive thoughts by both institutions and consumers. The massive value is invested in the “bits” which people don’t understand as a currency yet — but they have been invested in and given a value by the agreement to early investors have agreed to seal inside them. Once they go to the coinbase they are a store of value on the blockchain that nobody can deny nor take out and rob. Bitcoin started as a token currency and became a COIN over the years in a sense. DevCoin tokenized the coinbase tx output by losing all of its value while it was largely recognized on BTC, but ETH, ETC, and others. The nature of the first part of this process was to build the first blocks, attract some people on the outside for a few years while securely running through a sequence of pre-planned events and fake news cycles that would put everyone to the test to decide if they would not trust, but they would verify. Our minds and our wallets are the nodes that are allowed to judge for ourselves and its funny how even with raw data right in front of you the pessimism in people tend not to believe what’s unfolding. A few of the things that are about to happen make sense in relation to strategy of this simulation where only BTC is realized and not the TBC measure through DevCoin and POW/RPOW. There is much to explain and its hard to even write about in an order that makes sense because I get my facts and theory together but in trying to support my arguments I find another path of truth from what I was about to conclude on. The easiest way to trace value from an accounting standpoint is to know the basics of merge mining, to know the earliest history of BitCoin and challenge yourself to understand where value came from, and to look where no one else looks. For example, look at a DevCoin raw block yourself like I did and plug in a 12.5 mystery coin block reward (because DVC is supposed to be 50,000) and then plug it into BTC explorers. Then you notice hey these two are co-operating but then you realize only DVC keeps raw blocks of the minting. Then you understand the dual nature of a DVC block paired with a token transaction of 50,000 DVC “tokens” and you notice the developers know a lot more than anyone else. You realize everyone involved in DevCoin will be pessimistic at your optimism, silent and not acknowledge it, or even act dumb to the facts but slightly supportive. You also know who is giving big clues and backing it up with facts. That brings me back to markm, whoever he is, he’s on the core floor of the operation and I thank him for his work on this. Check out his explanation of a few “coins” and companies in the “Galactic Milieu”:

The point is not to dismiss what sounds absolutely bonkers and to notice the meaning behind it. Markm doesn’t ever say that DevCoin mints BTC, but he has spoken about debt owed and value coming back through the real prices he shows. I covered that earlier and its a representation of Tonal Bitcoin (which was invented by BTC dev Luke Dash Jr.). The thing is posts like this come from early (2012 above) and developments for Tonal Bitcoin as a measurement to take us to the next phase of Bitcoin scaling (duality, quantum state) go unnoticed. Going to search on twitter for someone talking about coins where real value is up for the taking is like querying a digital graveyard. However, the facts make one aware and then you can read posts like the above and know the gist of what this really is.

DevCoin Merge Mining Coder Playing Dumb

This is an example of the information you are presented and aware of from open source code. Since I have seen code for DevCoin done by “doublec” from 2011 I know that he is at the very least aware of the “B” chain, or alternate Bitcoin blockchain as DevCoin is called (see wiki). So he has to know exactly the plan since he’s made such important updates to DevCoin in the evolution of its embedded value. I wrote about it in my last article:

“doublec” on github highlighting the b/src/main.cpp implemented on DevCoin.

Also I’d like to point out another thing. We don’t know a lot of people by name or pseudo-name. Many people are anonymous or use more than one account to put out information. The code, however, is there to see in action. It produces data that we can see right in front of us. How was it coded in, how did it end up as an output? If you think that’s unfair because its too hard I am telling you that’s for a reason. This is a valued asset already in the eyes of the institution, both private and public sectors. Nobody deserves to make a great investment. But you can have a chance before the time comes, sometimes years. In crypto I look back years. With my understanding of markm and doublec’s involvement in DevCoin code and the nature of RPOW and POW — I realize markm, Adam Back, and Hal Finney are on record in these email lists since 2001. Turns out doublec is as well and these merge mining codes have emails and public keys in them proving they were sent on September 17, 2001.

2001 was an active year for Hal Finney, Adam Back, and DVC developer markm > why not doublec?

You can take two approaches — pessimism or realizing the facts in front of you. They are there for you to see. Since DevCoin works in function like RPOW and adopts the “reverse end” of POW, I already have linked the token of value that proof of work comes from. BTC was made valuable by its parallel chain that issues tokens of massive investment value that in the end, everyone wins. I also believe this because the wealth transfer in the end is a positive for everyone — don’t think for a second that the very wealthy are even allowed to touch DevCoin’s at this value. At the same time, the developers know this is an escrow, a future payout and work for decades maybe for their first payoff. The trading is nothing more than a zerosum game. Which brings me to my original point. The institutions in markm’s Galactic Milieu:

The private friend to friend connections that markm says have “mutual goals” makes me think of Linux Foundation involvement in Bitcoin.

The point he is making is that everyone’s money is in, the value needs to grow — which these corporations know because of their own technological advancements and the mathematically planned outcome in value. The values like Hal Finney described in 2010 like $10 million a coin. People who know what it is and developed it through their collective private sector contributions are long on math. They don’t care about the fluctuations of BTC because they know the outcome is already embedded into the chain. If you got rich off the test pump to $19,000 good for you. If you didn’t and are discouraged you need to get on board. Also the mention of occasionally mining time to time with the number next to DVC is interesting because “Bitcoin” is supposed to be #3, but obviously DevCoin is coded the parent chain. Admitting a coin can merge mine with the latter means it can and has to merge with the former. That’s how the RPOW works. All the POW gone forward to BTC unspent has embedded value and it is “recyclable” rather re-usable to give the value in bits back to the coinbase tx DevCoin was sprung from. Look again at DevCoin’s payout from the parent block transaction:

DevCoin did it’s part here by paying 50.00000000 in decimal to fund the genesis transaction in a two-state parallel chain. DevCoin funded genesis is what I am saying. You do not have to worry that this came in 2011, this is part of a debug log that rewrites blocks correctly and ads the correct chain to its database — AND it had already done 32.000022 units of log2_work which today is just north of 86.000000 units for POW/RPOW. The work done up to genesis shows that this is the result of forking the bitcoind daemon and becoming the parent. By forking 50 BTC can now be found in the coinbase because DevCoin has sent a coin back in before ever coming out. You cannot find this block anywhere besides the debug log, but when the work is done (debugging) the correct block chain will be whole. It is a unique way to set up the birth of a dual chain with triple entry in the ledger once contracts are executed. The fact that the blk00000.dat file has on extra digit than the originals lets me know that perhaps this is the beginning of the quantum coinbase’s relationship with the linear (forward) genesis. So two linear genesis blocks were created while debugging is the method of secrecy and correcting everything to make sense. Everything is embedded safely and the value is immense but still undeniably short of the true value potential and one day, the debugging is completed. Proof of work uniting at the coinbase. That is why “bits” are waiting on the input side of BTC transactions now because there are signatures on time locked contracts that will be signed. The bits are meant to go back to the start. As of right now all of those bits are to go back to index -1. That is the index of the parent hash and can be hexcoded as 0xFFFFFFFF which any raw block transaction will show in its hex data. For DevCoin it shows this on its raw transactions instead of its raw blocks. That is because DevCoin knows where the coinbase tx is and the purpose is to be in a dual state of both decimal (as a unit of measure and translation) which gives it a huge value in all of the debt it is owed in “work” over the years. 655K satoshi to start, but most likely more. It is 1/2 BitCoin and half of the quantum state future’s coinbase. That’s enough for me.

Exact Math

Genesis Blocks: Pre-Alpha November 08 (debug)/January 3, 2009 (alpha)/DevCoin July 22, 2011 (debug) + Ethereum Classic (epoch) and tie with Ethereum through it (similar to BTC/BCH relationship)

[THIS IS NOT EVERY CHAIN CONNECTED TO THE PARENT HASH JUST KEEPING IT SIMPLE WITH THE BIGGEST PARTS]

Goal: Try to show how changing values and bits equate into a system where fees are paid in all intersecting directions so that the fused genesis block is an example of quantum entanglement where superposition makes sense:

Checkout this article on a dev who is running a quantum OS for Bitcoin

The use of the word “atoms” and “molecules” was in the original genesis blocks “market.cpp” and “market.h” as well as the pre-alpha genesis version. Binary also needs to make sense of two parallel block chains that run in superposition:

I have written a lot about tokens and different splits in the history of Bitcoin like MasterCoin which led to Tether and how forking of the OmniLayer protocol gave way to Wormhole which sounds like a reversal of the original Omni Protocol through Mastercoin. However, how did the first token come to be created? I believe the first token came as an effect of sacrificing a previously agreed upon POW in development to create the parent hash by way of forking the bitcoind daemon. I will just dive into a raw sequence:

  1. Mine the timechain and extract the 10 MB value of log.0000000001 (-10 MB) as a starting point to create bits as a store of value. Have it connect to time by writing “blk0001.dat” instead of a linear starting file where 0 is the first block. The goal is to make the chain based on UNIX time but be able to rearrange bits through debugging to where the chronological order isn’t necessary and by bypassing chronological order of “blocks” we can create infinite amounts of space, transactions, without the problem of double spending. Basically make time irrelevant, but still tied to the POW.
  2. In Unix time the -10 MB taken out of the timechain is not truly taken out, it just forges a connection and a basis for future calculations. It means that at least 80M bits (decimal)/2147483648 (hexadecimal) are owed back to the coinbase which will need to be met in both directions before going forward into the future as a complete and reorganized dual blockchain. In this example I am only using 3 coins to connect to this and forgetting about witnesses and other forks.
  3. Unix Time is directly tied to the bits extracted from the timechain, at 2147483648 it means quite a lot of things because its value is 2³¹ and that’s where the plan of tokens comes in to create “block chain” as we know it. Proof of work is how the debt will be paid back to justify its creation like a base of measure for where the whole system makes sense. The alarm should be going off in your head that equates that with the point of DevCoin being a measured value of 1.00000000 for the tonal representation of BitCoin. I think you might understand how the value spring forward from that connection DevCoin makes between the token state and the coin state and why DevCoin is owed a big return.
In binary, 2147483647 is 01111111111111111111111111111111 and it’s the biggest positive number that will fit in 32 bits when using the “two’s complement” notation — the way of representing numbers that allows for negative values. If we could use that leftmost (high order) bit, the largest possible number would be twice as large since every extra bit doubles the range of numbers that a binary number can represent.

What this leads me to believe is the beginning of layer two began with Devcoin as blk00000.dat and that file is missing somewhere because before going back to the parent hash proof of work has to complete for a reorganization that will ultimately solve problems of integer overflow. The problem is actually being solved in reverse right now because a number was tokenized off the original timechain and the price out wasn’t just the bits, it was figuring out when to pay those bits back after script + cryptography + programming interoperatability was achieved on non-overflow languages (python 3) but there was a definite connection and storage of value from the old internet as well by basing old timechain “blocks” to a system where new blocks scaled extremely fast and feeless without crashing memory and causing financial chaos from integer overflow. So the basis of web 3.0’s economy is the BitCoin block chain. It’s unbeatable in the end. It started with DevCoin taking on all the chaos of the reorganization itself. That looks like this currently:

Never noticed the “us= / them=” notation until now, I think that might be new. Same with the 348948 down to the empty string.

To be continued. For now check out the weird blank transactions being sent to ETC ;)

Link