Quote from: coins101 on October 31, 2015, 01:08:29 PM

Quote from: toknormal on October 31, 2015, 12:53:59 PM

Quote from: qwizzie on October 31, 2015, 12:30:42 PM

Premine : Coins were given out before mining started. That means basically in the genesis block a certain amount of coins were distributed to accounts when the chain started.
In PoS coins, this is typically a 100% premine as all the coins are created at block 0. An popular example of this is NXT.
credits : SomethingElse

Instamine / Fastmine : is different and also has a much broader definition. That is when a cryptocurrency in its early hours / days / period due to either accidental Instamine (Dash) or intentional crippling of mining software (Monero) or 1 person / group through early mining ending up with a large number of coins (Bitcoin / Satoshi 1 million BTC), delivers a lot of coins in a select few hands.

And now, according to this account at least, we need to add Giftmined where >50% of the entire network hashpower is gifted to a couple of individuals for a couple of months to turn them into millionaires by crippling the official code with ELNs (endless loops of nonsense).

The joys of early-day crypto Wink

I'm sure I did a review a while back....seems like if you don't keep posting it, people forget.

Quote from: coins101 on May 02, 2015, 02:33:02 PM

The Monero launch included a launch pack that included some deceptive code aimed at rigging the mining for the material benefit of one or a few at the expense of the many. Also known as fraud.

Quote from: smooth on May 01, 2014, 12:37:16 PM

Quote from: TheCoinFinder on May 01, 2014, 12:35:57 PM

Before we can set up pools..
We need a miner.

Currently the mining is done In the wallet AFAIK

There is also a miner in the standard build, just no pool to connect it to.

Not long after launch, around one to two weeks, people started to smell a rat and at some point the Monero dev somehow did a runner, or possibly just changed account profile and carried (carries) on being involved.

Some of the early community members decided that, despite being only one or two weeks in, they would continue with the project rather than stop, fix, relaunch.

That smells a bit. Had we seen two or three months of effort, then maybe a continuation would have been more believable. People were smelling a rigged launch at the time:

Quote from: emontmon on May 01, 2014, 02:58:11 PM

i would like to propose a conspiracy theory here. could it be that TFT and friends created a problem where there was non, as they see the coin going up in popularity and thus limit ability for people to mine or participate.
1. yes mining continued: is this true can a non techy very this
2. increased frustration: people may hold of mining while a better wallet is in place. thus decreasing difficulty and increasing coin accumulation of those in the know.
3. a day later and still unable to access wallet from first page. people are pointed to github but I do not see a link there that says updated wallet. click here and your parse problems will be solved.
4. i recall i could not participate early because link was botched. there was no note underneath to clarify this for those new to cryptocurrencies. for 5 days I could not mine while tft and friends went about it merrily.

would tft go to such an extreme.... just speculating.

There is no dispute that Monero was launched with deceptive code intended to steal. It has been admitted by the lead devs:

Quote from: smooth on April 28, 2015, 01:11:58 AM

We've admitted to the crippled miner. We were the first ones to discover it, disclose it, and fix it. The reason I don't dwell on Monero's faults is not to hide them......

And the other lead dev:

Quote from: fluffypony on April 29, 2015, 07:52:57 AM

Quote from: coins101 on April 29, 2015, 07:22:18 AM

....
The "dev" who launched Monero is thankful_for_today: https://bitcointalk.org/index.php?action=profile;u=233561

Thankfully when we (the current Monero core team) found the purposefully obfuscated code we immediately fixed it and made the fix freely available to all. This is what smooth means when he describes the Monero launch as fair. As dga says, at most thankful_for_today would've had a week of advantageous mining, but as our difficulty retargetting worked just fine and we didn't have crazy high initial block rewards there was very little that the scammer thankful_for_today could've made off with.

Note that these are all facts, directly observable by comparing increases in difficulty (ie. network hash rate) with the improved hashing code submitted to github. It does not require trust, it does not require anyone to take our word that coins have been sold or distributed, it is not based on hope. It is absolute, truthful, factual, verifiable by all.
...

Smooth is trying really hard to hide the truth.

Was it because he was stuffing his pockets while pointing others to crippled miners and op links to clients that didn't work? Then while others were saying stop and relaunch, he was saying - no lets wait a few more weeks.

I know dear reader, having been "lucky" to get at least 10% of the coins in the first week, why would he want to give away his bounty to make it fair to everyone else?

Maybe, Smooth motherfuckers, sound like scam motherfuckers, to smart motherfuckers.

lol

And how about that code that was injected in to cripple mining for everyone but the chosen few?

Quote from: tacotime on April 19, 2014, 06:18:42 PM

so here's the scoop

Code:

yeah so from what i can tell
blockchain_storage.cpp and/or the rest of the daemon is calculating the coinbase tx subsidies in different ways
it wasn't an issue before, but two hours ago i tried to spend pretty much everything at one of my coinbase tx and the tx hit the network

trying to figure out what in the fork code broke this right now.

Quote from: eizh on April 19, 2014, 07:35:18 PM

Quote from: Xdragon on April 19, 2014, 07:31:43 PM

so, should we stop mining or what? Huh

i just found a block few hours back

The current situation is that someone disabled mempool and forked the chain so that the invalid tx doesn't get in the way. But the difficulty hasn't changed much so blocks are being found much more rarely than 1 minute. So you can mine, it's just very slow. A few people are on the freenode channel trying to solve the cause of the problem.

The harder he tries to make it sound legit, the more the Proven Monero Scam Launch stinks.

lol.

Here is that crazy ass, make me a millionaire, loopy-loop, slow everyone else down, while I make bank, XMR launch code:

Quote

Actually, this was one of the crippled loopty loo codes:

Code:

Skip to content
Sign up Sign in This repository
Explore
Features
Enterprise
Blog
Watch 35 Star 66 Fork 80 monero-project/bitmonero
tree: 1a8f5ce89a bitmonero/src/crypto/slow-hash.c
Antonio Juarez on Mar 3, 2014 moved all stuff to github
0 contributors
RawBlameHistory 154 lines (135 sloc) 4.561 kb
// Copyright (c) 2012-2013 The Cryptonote developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include
#include
#include
#include

#include "common/int-util.h"
#include "hash-ops.h"
#include "oaes_lib.h"

static void (*const extra_hashes[4])(const void *, size_t, char *) = {
  hash_extra_blake, hash_extra_groestl, hash_extra_jh, hash_extra_skein
};

#define MEMORY (1 << 21) /* 2 MiB */
#define ITER (1 << 20)
#define AES_BLOCK_SIZE 16
#define AES_KEY_SIZE 32 /*16*/
#define INIT_SIZE_BLK 8
#define INIT_SIZE_BYTE (INIT_SIZE_BLK * AES_BLOCK_SIZE)

static size_t e2i(const uint8_t* a, size_t count) { return (*((uint64_t*)a) / AES_BLOCK_SIZE) & (count - 1); }

static void mul(const uint8_t* a, const uint8_t* b, uint8_t* res) {
  uint64_t a0, b0;
  uint64_t hi, lo;

  a0 = SWAP64LE(((uint64_t*)a)[0]);
  b0 = SWAP64LE(((uint64_t*)b)[0]);
  lo = mul128(a0, b0, &hi);
  ((uint64_t*)res)[0] = SWAP64LE(hi);
  ((uint64_t*)res)[1] = SWAP64LE(lo);
}

static void sum_half_blocks(uint8_t* a, const uint8_t* b) {
  uint64_t a0, a1, b0, b1;

  a0 = SWAP64LE(((uint64_t*)a)[0]);
  a1 = SWAP64LE(((uint64_t*)a)[1]);
  b0 = SWAP64LE(((uint64_t*)b)[0]);
  b1 = SWAP64LE(((uint64_t*)b)[1]);
  a0 += b0;
  a1 += b1;
  ((uint64_t*)a)[0] = SWAP64LE(a0);
  ((uint64_t*)a)[1] = SWAP64LE(a1);
}

static void copy_block(uint8_t* dst, const uint8_t* src) {
  memcpy(dst, src, AES_BLOCK_SIZE);
}

static void swap_blocks(uint8_t* a, uint8_t* b) {
  size_t i;
  uint8_t t;
  for (i = 0; i < AES_BLOCK_SIZE; i++) {
   t = a[i];
   a[i] = b[i];
   b[i] = t;
  }
}

static void xor_blocks(uint8_t* a, const uint8_t* b) {
  size_t i;
  for (i = 0; i < AES_BLOCK_SIZE; i++) {
   a[i] ^= b[i];
  }
}

#pragma pack(push, 1)
union cn_slow_hash_state {
  union hash_state hs;
  struct {
   uint8_t k[64];
   uint8_t init[INIT_SIZE_BYTE];
  };
};
#pragma pack(pop)

void cn_slow_hash(const void *data, size_t length, char *hash) {
  uint8_t long_state[MEMORY];
  union cn_slow_hash_state state;
  uint8_t text[INIT_SIZE_BYTE];
  uint8_t a[AES_BLOCK_SIZE];
  uint8_t b[AES_BLOCK_SIZE];
  uint8_t c[AES_BLOCK_SIZE];
  uint8_t d[AES_BLOCK_SIZE];
  size_t i, j;
  uint8_t aes_key[AES_KEY_SIZE];
  OAES_CTX* aes_ctx;

  hash_process(&state.hs, data, length);
  memcpy(text, state.init, INIT_SIZE_BYTE);
  memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
  aes_ctx = oaes_alloc();
  for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
   for (j = 0; j < INIT_SIZE_BLK; j++) {
   oaes_key_import_data(aes_ctx, aes_key, AES_KEY_SIZE);
   oaes_pseudo_encrypt_ecb(aes_ctx, &text[AES_BLOCK_SIZE * j]);
   /*memcpy(aes_key, &text[AES_BLOCK_SIZE * j], AES_KEY_SIZE);*/
   memcpy(aes_key, state.hs.b, AES_KEY_SIZE);
   }
   memcpy(&long_state[i * INIT_SIZE_BYTE], text, INIT_SIZE_BYTE);
  }

  for (i = 0; i < 16; i++) {
   a[i] = state.k[ i] ^ state.k[32 + i];
   b[i] = state.k[16 + i] ^ state.k[48 + i];
  }

  for (i = 0; i < ITER / 2; i++) {
   /* Dependency chain: address -> read value ------+
   * written value <-+ hard function (AES or MUL) <+
   * next address <-+
   */
   /* Iteration 1 */
   j = e2i(a, MEMORY / AES_BLOCK_SIZE);
   copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
   oaes_encryption_round(a, c);
   xor_blocks(b, c);
   swap_blocks(b, c);
   copy_block(&long_state[j * AES_BLOCK_SIZE], c);
   assert(j == e2i(a, MEMORY / AES_BLOCK_SIZE));
   swap_blocks(a, b);
   /* Iteration 2 */
   j = e2i(a, MEMORY / AES_BLOCK_SIZE);
   copy_block(c, &long_state[j * AES_BLOCK_SIZE]);
   mul(a, c, d);
   sum_half_blocks(b, d);
   swap_blocks(b, c);
   xor_blocks(b, c);
   copy_block(&long_state[j * AES_BLOCK_SIZE], c);
   assert(j == e2i(a, MEMORY / AES_BLOCK_SIZE));
   swap_blocks(a, b);
  }

  memcpy(text, state.init, INIT_SIZE_BYTE);
  for (i = 0; i < MEMORY / INIT_SIZE_BYTE; i++) {
   for (j = 0; j < INIT_SIZE_BLK; j++) {
   /*oaes_key_import_data(aes_ctx, &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE], AES_KEY_SIZE);*/
   oaes_key_import_data(aes_ctx, &state.hs.b[32], AES_KEY_SIZE);
   xor_blocks(&text[j * AES_BLOCK_SIZE], &long_state[i * INIT_SIZE_BYTE + j * AES_BLOCK_SIZE]);
   oaes_pseudo_encrypt_ecb(aes_ctx, &text[j * AES_BLOCK_SIZE]);
   }
  }
  memcpy(state.init, text, INIT_SIZE_BYTE);
  hash_permutation(&state.hs);
  /*memcpy(hash, &state, 32);*/
  extra_hashes[state.hs.b[0] & 3](&state, 200, hash);
  oaes_free(&aes_ctx);
}
Status API Training Shop Blog About
© 2015 GitHub, Inc. Terms Privacy Security Contact