/ fairness

How provably fair pumps work on OrionPump?

OrionPump pumps are provably fair. Here is how our approach works.

The process of a pump

  1. We analyze and select coins that are optimal for pumping, and we create a list.

  2. The server generates a server_seed, which is a random 32 byte hexadecimal number. It's a secret at the start. The bot reveals the server_seed's sha256 hash called server_seed_hash. This way when we reveal the server_seed, you can validate that it's unchanged.

  3. We present the list of possible coins to the group. Every coin is numbered starting from 0. The coin_list_length is important.

  4. The bot then specifies the target_block on the Dogecoin blockchain. (It's usually 10 blocks after the current block)

  5. The countdown begins, we wait for the target_block to appear.

  6. We will use it's block_hash, because it's unpredictable, you can only know it when the block appears on the blockchain.

  7. When it appears, the server creates the selector_number by attaching the server_seed to the block_hash, hashing it (sha256), and taking the first 12 numbers.

  8. The selector_number gets divided by coin_list_length and the remainder will be the selected_coin.

  9. The selected_coin gets revealed for the group immediately, and the pump begins.

  10. The server_seed gets revealed for validation.


Here is a javascript example of the logic above

var server_seed = generate_random_hex(32);
var server_seed_hash = sha256(server_seed);


var target_block = get_current_block_number() + 10;

on('NEW_BLOCK', function (block) {

  var block_number = block.number;
  var block_hash = block.hash;

  if(block_number === target_block_number) {
    var selector_number = Number(
      "0x" + sha256(server_seed + block_hash)
      .substring(0, 12));

    var selected_coin = selector_number % coin_list_length;



Validation Algorithm

Here is an example of how you would validate a pump. You can write this script yourself in any language you want, and validate each pump we've ever done or any future pumps.

This example is in python

import hashlib

server_seed = "f488bc1793070f20aebaf050d2471d187762325ed239f15f14404d646fb86555"
block_hash = "788787d8ff144c502c7f5cffaafe2cc588d86079f9de88304c26b0cb99ce91c6"
coin_list_length = 50

hash = hashlib.sha256(server_seed)
hash = hash.hexdigest()

print("Server seed hash should be " + hash)

selector_number = hashlib.sha256(server_seed + block_hash)
selector_number = selector_number.hexdigest()
selector_number = selector_number[:12]
selector_number = int("0x" + selector_number, 16)

selected_coin = selector_number % coin_list_length

print("Selected coin should be coin with the number " + str(selected_coin))

Why a server seed is necessary?

If we would use the appearing block's hash alone, bots would be able to read the outcome by listening on the blockchain. The server seed gets revealed after the pump. This way there's no way for botting, since the coin gets presented in an image format.

How provably fair pumps work on OrionPump?
Share this