Quote from: stwenhao on Today at 07:09:31 PM

Quote

do you have another quote where he explicitly says "20 hours"?

Quote from: satoshi on July 16, 2010, 05:29:28 PM

Yes, about 20 hours. (120 conf / 6 blocks per hour = 20 hours) That's the normal length of time before you can spend it. You know long before that that you won one.

I can also better explain that "10 minutes vs 15 minutes part" if you want:

Quote

Code:

int64 GetBlockValue(int64 nFees)
{
int64 nSubsidy = 10000 * CENT;
for (int i = 100000; i <= nBestHeight; i += 100000)
nSubsidy /= 2;
return nSubsidy + nFees;
}

unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast)
{
const unsigned int nTargetTimespan = 30 * 24 * 60 * 60;
const unsigned int nTargetSpacing = 15 * 60;
const unsigned int nIntervals = nTargetTimespan / nTargetSpacing;

That means:

1. The basic block reward was 100 coins, instead of 50, at the very beginning.
2. There were halvings after 100,000 blocks, instead of every 210,000 blocks.
3. Each difficulty adjustment was done every 30 days (one month), because "nTargetTimespan" is expressed in seconds. Now we have "two weeks", so "14 days", if you compare it with a new version.
4. Each block was produced every 15 minutes, instead of 10 minutes (like previously, "nTargetSpacing" is expressed in seconds).
5. Each halving was done every 100,000 blocks, which means every 25000 hours, so around 1041 days, which means around 2 years and 311 days. This is not a nice number, currently we have it every "4 years".
6. The total supply was 20 million coins, instead of 21 million, at the very beginning (combine points one and two).

You can compare those fragments between versions, and try to create a better combination of numbers, where everything is rounded correctly, and produce "nice numbers" in every step. This part is hard, and you can see, that what we have today, is quite good combination, that is not that obvious from the very beginning, as you can see in those older parts.

100 would make sense cause original coinbase is just this.

the fact that 100 cent equals a usd

1 cent is therefore always coinbase to come into a usd in the first place. cause its the basis. the lowest ground possible.

based on this. he just build everything more and more into code to find ways to transform 1 usd cent into its own monetary understanding (currency)

problem however:

i have no proof besides 0.0.8 as lowest point. so i can only work with logical development evolution here, but not with proof as written code from back then. cause 0.0.8 does not have 100 as reward inside (unfortunately)

but this should not bother us.

cause i found another way to also explain how everything will lead back into the fact that bitcoins coinbase is the principle of a usd cent (it was written in cpp also inside using microsoft product: visual studio)

so working with usd as basis makes the most sense here (however i also wanna mention that 1913 still created a strong foundation for it by appropriate bankers contracts for building up the fed and without orignal german immigrant Paul Warburg, the idea would never have settled, and he did not even wanted to be part of the circle of them himself. idea giver and adviser, more he was never interested into, could also show quite well how germany is connected into the usd itself till todays time, but it was a good thing, they created a lot of stability through building up the FED in the usa, another big step in mankinds evolution i guess forward).

so if we now look inside the code

i got into the idea to save us the stress of decrypting the hash value itself and just using a partial of it

version 0.1.0 inside main.cpp

const uint256 hashGenesisBlock("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");

now i am using a little time saving by the fact that Poker was the original game idea inside its code base anyways (at least those old versions)

and point on the fact:

that you can contract all leading zeros (10 of em) into your 2 hands (i grab the hash with both hands is the ideas to this)

use the 19 to contract this into code line 19 from main.h

this way main.h and main.cpp are transacted basically to each other and kind of connected via this hash.

now use the rest of the values from the hash (52 of em)

to contract this in the fact that Poker uses 52 cards for playing it. also the fact of binary system roots build (Gottried Willhelm Friedrich von Leibniz was the first guy in history having used this system back in his own time to play around with it and build stuff) and Germanies still cookies having 52 tooths from Leibzniz brand of the appropriate sweets company.

and we can a bit sweeten up the fact:

that now any hash will through code line 19 direct us back into the usd cent anyways.

and the cool part is we can also go back in transactions from 0.0.8 now in all other existing older versions. cause i bet he had cent implemented in all of em anyways in main.h

so from my perspective this makes the real coinbase still:

usd cent as well as eur cent

what shows how (back then bitcoin did not exist)

USD/EUR

or

EUR/USD

market was the first streaming market that did in the end lead into the creation of this thing we today now know as Bitcoin.

that i call genius indeed

and:

cool