I had a quick search about for similar things that might be good reference points to create a system for this purpose. I found this email that has something interesting in it. https://mailing-list-archive.cryptoanarchy.wiki/archive/1995/09/b15b1c8ebf07eff21cc1f67e7002a4a47c90d635e234bd863352ab37b36cbbe5/7. National Semiconductor's "Commercial Cryptography Ideas for Success" (9 pp. of large type) This contains graphics of the CAKE program and a "Proposed NIST Escrow Certificate Heirarchy" which cannot be easily distributed by us, so we offer this by fax. There was also some relation to the idea of. You could use a trusted parties. p then incorporate a threshold scheme or signature structure in order to hide the key (k) to your encrypted message enck(M). Whenever you don't update those trusted parties, after (t) time, they can connect to each other and if they reach the threshold or can sign with the correct signatures it then releases the key k p(k)~enck(M)~(t) https://faculty.nps.edu/dedennin/publications/Descriptions%20of%20Key%20Escrow%20Systems.htmanother good reference for descriptions of Key Escrow systems. |
|
|
|
|
Bump - Coin development, Dev work, Websites, ICO's,
BTC
|
|
|
|
In the Gitian log there is the following : + tar -x -C /home/ubuntu/out/src
+ cp /home/ubuntu/out/src/doc/README_windows.txt /home/ubuntu/out/readme.txt
cp: cannot stat `/home/ubuntu/out/src/doc/README_windows.txt': No such file or directory If the file exists you have maybe not the correct permissions or the file is non-existent. Run in a terminal: sudo chmod 775 /home/ubuntu/out/src/doc/README_windows.txt to grant yourself the permissions if the file is available. You should question if you should release a coin if you are having issues with compiling one. Running a coin is not easy it requires many skills and hard work to keep up to date with issues and updates. I guess from your post this is a much older version codebase being used that will possibly have security risks for users. |
|
|
|
Last 7 days: 
High - 44 exahashesPerSecond
Low - 31 exahashesPerSecond
|
|
|
|
Understanding The Satoshi Codebase : Bitcoin V0.1.5
Oh man, posting this in Beginners & Help  it fits anywhere but not here. Its for computer scientist only which is rare case in overall public. Anyway good guide, detailed, well formatted. GJ. Thank you, I was thinking of asking the topic to be moved to a more suitable area of the forum say "technical" section. I thought posting here as a guide could serve as a reference to the early codebase and allow people to try to understand how bicoin works under the hood as they say. But I do agree possibly the beginner section is not such a good place for the topic. Magic. |
|
|
|
|
Miners no longer online pre-hashing available as part of packages only now.
Thanks
Magic
|
|
|
|
const int nInitialBlockThreshold = 120; // Regard blocks up until N-threshold as "initial download" What version are you testing with. In v0.5.1 there is the above line in main.cpp might be helpful. |
|
|
|
in bitcoin fixed point math is used to calculate the block subsidies. int64 CBlock::GetBlockValue(int64 nFees) const
{
int64 nSubsidy = 50 * COIN;
// Subsidy is cut in half every 4 years
nSubsidy >>= (nBestHeight / 210000); This BIP might also be of some use to you. https://github.com/bitcoin/bips/blob/master/bip-0042.mediawikiIn later versions of the codebase V0.5.1 we can see this defined as a int64 value in main.h file near the top. as : static const int64 MAX_MONEY = 21000000 * COIN; static const unsigned int MAX_BLOCK_SIZE = 1000000;
static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
static const int64 COIN = 100000000;
static const int64 CENT = 1000000;
static const int64 MIN_TX_FEE = 50000;
static const int64 MIN_RELAY_TX_FEE = 10000;
static const int64 MAX_MONEY = 21000000 * COIN;
inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
static const int COINBASE_MATURITY = 100;
// Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC |
|
|
|
|
Looks great @Sidehack.
I'm sure there will be much demand for them.
|
|
|
|
Did you change the coinbase maturity? You need to wait For each input to be confirmed, if the referenced output transaction is coinbase (i.e. only 1 input, with hash=0, n=-1), it must have at least COINBASE_MATURITY (100) confirmations before it can be spent. If you wanted to change your coinbase maturity period it can be found in main.h static const int COINBASE_MATURITY = 100;
|
|
|
|
Original Op Codes - Bitcoin includes a script system for transactions. In simple, a script is a just a list of instructions that is recorded with each transaction that describe how the next user wanting to spend the Bitcoins being transferred can gain access to them. The script for a Bitcoin transaction to a Bitcoin address simply enduce future spending of the bitcoins with two things that must be provided. 1. a public key that when hashed results in the destination address in the script. 2. a signature to prove ownership of the private key corresponding to the public key. Definition Operation codes from the Bitcoin Script language which push data or perform functions within a pubkey script or signature script. OP Code descriptions taken from https://en.bitcoin.it/wiki/ Op Code list taken from File - script.h @Lines 7-293 enum
{
SIGHASH_ALL = 1,
SIGHASH_NONE = 2,
SIGHASH_SINGLE = 3,
SIGHASH_ANYONECANPAY = 0x80,
}; enum opcodetype
{
// push value
OP_0=0,
OP_FALSE=OP_0, - Empty array of bytes pushed onto the stack. This is not classed as an no-op as a item is added to stack.
OP_PUSHDATA1=76, - The next byte will contain the number of bytes to be pushed to the stack.
OP_PUSHDATA2, - The next two bytes contain the number of bytes to be pushed to the stack in little endian order.
OP_PUSHDATA4, - The next four bytes contain the number of bytes to be pushed to the stack in little endian order.
OP_1NEGATE, - The number -1 is pushed onto the stack.
OP_RESERVED, - Transaction is invalid unless occurring in an un-executed OP_IF branch
OP_1,
OP_TRUE=OP_1, - The number 1 is pushed onto the stack.
OP_2,
OP_3,
OP_4,
OP_5,
OP_6,
OP_7,
OP_8,
OP_9,
OP_10,
OP_11,
OP_12,
OP_13,
OP_14,
OP_15,
OP_16,
// control
OP_NOP, - Does nothing.
OP_VER, - Transaction is invalid unless occurring in an un-executed OP_IF branch
OP_IF, - <expression> if [statements] [else [statements]]* endif If the top stack value is not False the statements are executed. The top stack value is removed.
OP_NOTIF, - <expression> notif [statements] [else [statements]]* endif If the top stack value is False the statements are executed. The top stack value is removed.
OP_VERIF, - True / false - Marks transaction as invalid if top stack value is not true the top stack value is removed.
OP_VERNOTIF,- Transaction is invalid even when occurring in an un-executed OP_IF branch
OP_ELSE, - <expression> if [statements] [else [statements]]* endif If the preceding OP_IF or OP_NOTIF or OP_ELSE was not executed then these statements are and if the preceding
OP_IF or OP_NOTIF or OP_ELSE was executed then these statements are not.
OP_ENDIF, - <expression> if [statements] [else [statements]]* endif Ends an if/else block. All blocks must end, or the transaction is invalid. An OP_ENDIF without OP_IF earlier is also invalid.
OP_VERIFY, - True / false Marks transaction as invalid if top stack value is not true. The top stack value is removed.
OP_RETURN, - Marks transaction as invalid. A standard way of attaching extra data to transactions is to add a zero-value output with a scriptPubKey consisting of OP_RETURN followed by exactly one pushdata op. Such outputs are provably undependable, reducing their cost to the network. Currently it is usually considered non-standard (though valid) for a transaction to have more than one OP_RETURN output or an OP_RETURN output with more than one pushdata op.
// stack ops
OP_TOALTSTACK, [Input = x1] [Output (alt)x] = Puts the input onto the top of the alt stack. Removes it from the main stack.
OP_FROMALTSTACK, [Input = (alt)x1] [Output x1] = Puts the input onto the top of the main stack. Removes it from the alt stack.
OP_2DROP, Removes the top stack item.
OP_2DUP, Duplicates the top two stack items.
OP_3DUP, Duplicates the top three stack items.
OP_2OVER, Copies the pair of items two spaces back in the stack to the front.
OP_2ROT, The fifth and sixth items back are moved to the top of the stack.
OP_2SWAP, Swaps the top two pairs of items.
OP_IFDUP, If the top stack value is not 0, duplicate it.
OP_DEPTH, Puts the number of stack items onto the stack.
OP_DROP, Removes the top stack item.
OP_DUP, Duplicates the top stack item.
OP_NIP, Removes the second-to-top stack item.
OP_OVER, Copies the second-to-top stack item to the top.
OP_PICK, The item n back in the stack is copied to the top.
OP_ROLL, The item n back in the stack is moved to the top.
OP_ROT, The top three items on the stack are rotated to the left.
OP_SWAP, Swaps the top two pairs of items.
OP_TUCK, The item at the top of the stack is copied and inserted before the second-to-top item.
// splice ops
OP_CAT, Concatenates two strings. [b]disabled. [/b]
OP_SUBSTR, Returns a section of a string. [b]disabled.[/b]
OP_LEFT, Keeps only characters left of the specified point in a string.[b] disabled. [/b]
OP_RIGHT, Keeps only characters right of the specified point in a string. [b]disabled. [/b]
OP_SIZE, Pushes the string length of the top element of the stack.
// bit logic
OP_INVERT, Flips all of the bits in the input. [b]disabled.[/b]
OP_AND, Boolean and between each bit in the inputs. [b]disabled. [/b]
OP_OR, Boolean or between each bit in the inputs. [b]disabled. [/b]
OP_XOR, Boolean exclusive or between each bit in the inputs. [b]disabled[/b].
OP_EQUAL, Returns 1 if the inputs are exactly equal, 0 otherwise.
OP_EQUALVERIFY, Same as OP_EQUAL, but runs OP_VERIFY afterward.
OP_RESERVED1,
OP_RESERVED2, // numeric
OP_1ADD, 1 is added to the input.
OP_1SUB, 1 is subtracted from the input.
OP_2MUL, The input is multiplied by 2. [b]disabled. [/b]
OP_2DIV, The input is divided by 2. [b]disabled. [/b]
OP_NEGATE, The sign of the input is flipped.
OP_ABS, The input is made positive.
OP_NOT, If the input is 0 or 1, it is flipped. Otherwise the output will be 0.
OP_0NOTEQUAL, Returns 0 if the input is 0. 1 otherwise.
OP_ADD,
OP_SUB,
OP_MUL,
OP_DIV,
OP_MOD,
OP_LSHIFT,
OP_RSHIFT,
OP_BOOLAND,
OP_BOOLOR,
OP_NUMEQUAL,
OP_NUMEQUALVERIFY,
OP_NUMNOTEQUAL,
OP_LESSTHAN,
OP_GREATERTHAN,
OP_LESSTHANOREQUAL,
OP_GREATERTHANOREQUAL,
OP_MIN,
OP_MAX,
OP_WITHIN,
// crypto
OP_RIPEMD160,
OP_SHA1,
OP_SHA256,
OP_HASH160,
OP_HASH256,
OP_CODESEPARATOR,
OP_CHECKSIG,
OP_CHECKSIGVERIFY,
OP_CHECKMULTISIG,
OP_CHECKMULTISIGVERIFY,
// multi-byte opcodes
OP_SINGLEBYTE_END = 0xF0,
OP_DOUBLEBYTE_BEGIN = 0xF000,
// template matching params
OP_PUBKEY,
OP_PUBKEYHASH,
OP_INVALIDOPCODE = 0xFFFF,
};
inline const char* GetOpName(opcodetype opcode)
{
switch (opcode)
{
// push value
case OP_0 : return "0";
case OP_PUSHDATA1 : return "OP_PUSHDATA1";
case OP_PUSHDATA2 : return "OP_PUSHDATA2";
case OP_PUSHDATA4 : return "OP_PUSHDATA4";
case OP_1NEGATE : return "-1";
case OP_RESERVED : return "OP_RESERVED";
case OP_1 : return "1";
case OP_2 : return "2";
case OP_3 : return "3";
case OP_4 : return "4";
case OP_5 : return "5";
case OP_6 : return "6";
case OP_7 : return "7";
case OP_8 : return "8";
case OP_9 : return "9";
case OP_10 : return "10";
case OP_11 : return "11";
case OP_12 : return "12";
case OP_13 : return "13";
case OP_14 : return "14";
case OP_15 : return "15";
case OP_16 : return "16"; // control
case OP_NOP : return "OP_NOP";
case OP_VER : return "OP_VER";
case OP_IF : return "OP_IF";
case OP_NOTIF : return "OP_NOTIF";
case OP_VERIF : return "OP_VERIF";
case OP_VERNOTIF : return "OP_VERNOTIF";
case OP_ELSE : return "OP_ELSE";
case OP_ENDIF : return "OP_ENDIF";
case OP_VERIFY : return "OP_VERIFY";
case OP_RETURN : return "OP_RETURN";
// stack ops
case OP_TOALTSTACK : return "OP_TOALTSTACK";
case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
case OP_2DROP : return "OP_2DROP";
case OP_2DUP : return "OP_2DUP";
case OP_3DUP : return "OP_3DUP";
case OP_2OVER : return "OP_2OVER";
case OP_2ROT : return "OP_2ROT";
case OP_2SWAP : return "OP_2SWAP";
case OP_IFDUP : return "OP_IFDUP";
case OP_DEPTH : return "OP_DEPTH";
case OP_DROP : return "OP_DROP";
case OP_DUP : return "OP_DUP";
case OP_NIP : return "OP_NIP";
case OP_OVER : return "OP_OVER";
case OP_PICK : return "OP_PICK";
case OP_ROLL : return "OP_ROLL";
case OP_ROT : return "OP_ROT";
case OP_SWAP : return "OP_SWAP";
case OP_TUCK : return "OP_TUCK"; // splice ops
case OP_CAT : return "OP_CAT";
case OP_SUBSTR : return "OP_SUBSTR";
case OP_LEFT : return "OP_LEFT";
case OP_RIGHT : return "OP_RIGHT";
case OP_SIZE : return "OP_SIZE";
// bit logic
case OP_INVERT : return "OP_INVERT";
case OP_AND : return "OP_AND";
case OP_OR : return "OP_OR";
case OP_XOR : return "OP_XOR";
case OP_EQUAL : return "OP_EQUAL";
case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
case OP_RESERVED1 : return "OP_RESERVED1";
case OP_RESERVED2 : return "OP_RESERVED2"; // numeric
case OP_1ADD : return "OP_1ADD";
case OP_1SUB : return "OP_1SUB";
case OP_2MUL : return "OP_2MUL";
case OP_2DIV : return "OP_2DIV";
case OP_NEGATE : return "OP_NEGATE";
case OP_ABS : return "OP_ABS";
case OP_NOT : return "OP_NOT";
case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
case OP_ADD : return "OP_ADD";
case OP_SUB : return "OP_SUB";
case OP_MUL : return "OP_MUL";
case OP_DIV : return "OP_DIV";
case OP_MOD : return "OP_MOD";
case OP_LSHIFT : return "OP_LSHIFT";
case OP_RSHIFT : return "OP_RSHIFT";
case OP_BOOLAND : return "OP_BOOLAND";
case OP_BOOLOR : return "OP_BOOLOR";
case OP_NUMEQUAL : return "OP_NUMEQUAL";
case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
case OP_LESSTHAN : return "OP_LESSTHAN";
case OP_GREATERTHAN : return "OP_GREATERTHAN";
case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
case OP_MIN : return "OP_MIN";
case OP_MAX : return "OP_MAX";
case OP_WITHIN : return "OP_WITHIN";
// crypto
case OP_RIPEMD160 : return "OP_RIPEMD160";
case OP_SHA1 : return "OP_SHA1";
case OP_SHA256 : return "OP_SHA256";
case OP_HASH160 : return "OP_HASH160";
case OP_HASH256 : return "OP_HASH256";
case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
case OP_CHECKSIG : return "OP_CHECKSIG";
case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
// multi-byte opcodes
case OP_SINGLEBYTE_END : return "OP_SINGLEBYTE_END";
case OP_DOUBLEBYTE_BEGIN : return "OP_DOUBLEBYTE_BEGIN";
case OP_PUBKEY : return "OP_PUBKEY";
case OP_PUBKEYHASH : return "OP_PUBKEYHASH";
case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
default:
return "UNKNOWN_OPCODE";
}
};
|
|
|
|
When I have seen this error in the past it can relate to kvm is not loaded. The command ls This will check the dev/kvm You should also follow this guide for setting up the system. https://github.com/mazaclub/EasyGitianBuilderI guess you are missing something from the system. can you post the full log in code tags please. |
|
|
|
Gh/s | J/Gh | Mh/J | V | MHz | W | h/Hz | Gh/mm˛ | η-factor | | 15.625 | 0.95 | 1053 | 14.84375 | 0.52 | 4166.67 | | 12.005 | 0.85 | 400 | 30.01 | 0.4 | 3201.23 | | 15.212 | 0.925 | 496 | 30.67 | 0.51 | 4056.55 | | 16.696 | 1.000 | 544 | 30.69 | 0.56 | 4452.2 |
Not the most impressive hashrates but valuable info for anyone seeking to look into the world of asic chips. Nice find. |
|
|
|
|
Daily Bump - ERC-20 contacts, QT wallets, Full Coin Deployment + More.
|
|
|
|
this is a golden opportunity for bitcoin users in the UK, with this opportunity people in the UK can direct Bitcoin towards a bright future. and I hope this will also have a positive impact on all countries.
Think MP's should be focused on brexit right now. Though I do think the UK will soon become the haven for crypto-currency as we see the UK has a fair amount of adoption for bitcoin. |
|
|
|
Last 30 days :  High - 55 exahashesPerSecond Low - 31 exahashesPerSecond Last 7 days :  High - 41 exahashesPerSecond Low - 31 exahashesPerSecond Current Block: 553411 Current Diff: 5646403851534 Next Difficulty[EST]: 4950720795708 & 5101689291300 Next Difficulty Change[EST] -12.3208% and -9.6471% Last Retarget: December 3, 2018 at 11:46 AM Next Retarget[EST]: December 18, 2018 at 11:58 PM (in 7d 8h 34m 19s) It Seems the slope continues. |
|
|
|
Charity and a decentralized distribution system are not the same.
Part of Bitcoins current issue, and general adoption issue is that fact that the barrier of entry for new adopters is just too high, and nearly all new coins issued are going to a centralized cartel and dumped straight onto exchanges by a select few industrial miners.
You tell me what the Bitcoin ecosystem would look like if there were 10 or even 100 million home miners mining at 1TH/s each, instead of 10,000 farm miners each circle jerking each other and dumping their coins.
You'd have a true user base engaged at the base level, with a wide distribution of coins and a real market for real businesses to adopt the currency, and the price would reflect that.
If I had merits I would send you a bunch. I fully agree with you I also wonder what the difficulty would be like now too if we had not seen farms and pools and had kept mining simple and for home miners. When people can't "participate" it pushed people away from a system what bitcoin needed was more user adoption but like already said that route is now no longer a viable one for newcomers. |
|
|
|
|
BTC Bump - Available for work BTC
|
|
|
|
|
Show Posts
