Example #1
0
def make_casper_genesis(alloc, epoch_length, withdrawal_delay,
                        base_interest_factor, base_penalty_factor):
    # The Casper-specific config declaration
    casper_config = copy.deepcopy(config.default_config)
    casper_config['HOMESTEAD_FORK_BLKNUM'] = 0
    casper_config['ANTI_DOS_FORK_BLKNUM'] = 0
    casper_config['CLEARING_FORK_BLKNUM'] = 0
    casper_config['CONSENSUS_STRATEGY'] = 'hybrid_casper'
    casper_config['NULL_SENDER'] = utils.sha3('NULL_SENDER')
    casper_config['EPOCH_LENGTH'] = epoch_length
    casper_config['WITHDRAWAL_DELAY'] = withdrawal_delay
    casper_config['OWNER'] = a0
    casper_config['BASE_INTEREST_FACTOR'] = base_interest_factor
    casper_config['BASE_PENALTY_FACTOR'] = base_penalty_factor
    # Get initialization txs
    init_txs, casper_address = mk_initializers(casper_config,
                                               casper_config['NULL_SENDER'])
    casper_config['CASPER_ADDRESS'] = casper_address
    # Create state and apply required state_transitions for initializing Casper
    state = genesis_helpers.mk_basic_state(
        alloc, None, env=config.Env(config=casper_config))
    state.gas_limit = 10**8
    for tx in init_txs:
        state.set_balance(utils.privtoaddr(casper_config['NULL_SENDER']),
                          15**18)
        success, output = apply_transaction(state, tx)
        assert success
        state.gas_used = 0
        state.set_balance(utils.privtoaddr(casper_config['NULL_SENDER']), 0)
    consensus.initialize(state)
    state.commit()
    return state
Example #2
0
def induct_validator(chain, casper, key, value):
    valcode_addr = chain.tx(key, "", 0,
                            mk_validation_code(utils.privtoaddr(key)))
    assert utils.big_endian_to_int(
        chain.tx(key, purity_checker_address, 0,
                 purity_translator.encode('submit', [valcode_addr]))) == 1
    casper.deposit(valcode_addr, utils.privtoaddr(key), value=value)
Example #3
0
def initialize(state, block=None):
    config = state.config

    state.txindex = 0
    state.gas_used = 0
    state.bloom = 0
    state.receipts = []

    if block is not None:
        update_block_env_variables(state, block)

    # Initalize the next epoch in the Casper contract
    if state.block_number % state.config['EPOCH_LENGTH'] == 0 and state.block_number != 0:
        key, account = state.config['NULL_SENDER'], privtoaddr(state.config['NULL_SENDER'])
        data = casper_utils.casper_translator.encode('initialize_epoch', [state.block_number // state.config['EPOCH_LENGTH']])
        transaction = transactions.Transaction(state.get_nonce(account), 0, 3141592,
                                               state.config['CASPER_ADDRESS'], 0, data).sign(key)
        success, output = apply_transaction(state, transaction)
        assert success

    if state.is_DAO(at_fork_height=True):
        for acct in state.config['CHILD_DAO_LIST']:
            state.transfer_value(
                acct,
                state.config['DAO_WITHDRAWER'],
                state.get_balance(acct))

    if state.is_METROPOLIS(at_fork_height=True):
        state.set_code(utils.normalize_address(
            config["METROPOLIS_STATEROOT_STORE"]), config["METROPOLIS_GETTER_CODE"])
        state.set_code(utils.normalize_address(
            config["METROPOLIS_BLOCKHASH_STORE"]), config["METROPOLIS_GETTER_CODE"])
Example #4
0
 def direct_tx(self, transaction):
     self.last_tx = transaction
     if self.last_sender is not None and privtoaddr(
             self.last_sender) != transaction.sender:
         self.last_sender = None
     success, output = apply_transaction(self.head_state, transaction)
     self.block.transactions.append(transaction)
     if not success:
         raise TransactionFailed()
     return output
Example #5
0
 def tx(self,
        sender=k0,
        to=b'\x00' * 20,
        value=0,
        data=b'',
        startgas=STARTGAS,
        gasprice=GASPRICE):
     sender_addr = privtoaddr(sender)
     self.last_sender = sender
     transaction = Transaction(self.head_state.get_nonce(sender_addr),
                               gasprice, startgas, to, value,
                               data).sign(sender)
     output = self.direct_tx(transaction)
     return output
Example #6
0
 def tx(self,
        sender=k0,
        to=b'\x00' * 20,
        value=0,
        data=b'',
        startgas=STARTGAS,
        gasprice=GASPRICE):
     sender_addr = privtoaddr(sender)
     transaction = Transaction(self.state.get_nonce(sender_addr), gasprice,
                               startgas, to, value, data).sign(sender)
     success, output = apply_transaction(self.state, transaction)
     if not success:
         raise TransactionFailed()
     return output
Example #7
0
def test_ecrecover():
    c = tester.Chain()
    x = c.contract(ecrecover_code, language='serpent')

    priv = utils.sha3('some big long brainwallet password')
    pub = bitcoin.privtopub(priv)

    msghash = utils.sha3('the quick brown fox jumps over the lazy dog')

    V, R, S = utils.ecsign(msghash, priv)

    assert bitcoin.ecdsa_raw_verify(msghash, (V, R, S), pub)

    addr = utils.big_endian_to_int(
        utils.sha3(bitcoin.encode_pubkey(pub, 'bin')[1:])[12:])
    assert utils.big_endian_to_int(utils.privtoaddr(priv)) == addr

    result = x.test_ecrecover(utils.big_endian_to_int(msghash), V, R, S)
    assert result == addr
Example #8
0
 def call(self,
          sender=k0,
          to=b'\x00' * 20,
          value=0,
          data=b'',
          startgas=STARTGAS,
          gasprice=GASPRICE):
     self.state.commit()
     sender_addr = privtoaddr(sender)
     result = apply_message(self.state.ephemeral_clone(),
                            sender=sender_addr,
                            to=to,
                            code_address=to,
                            value=value,
                            data=data,
                            gas=startgas)
     if result is None:
         raise TransactionFailed()
     return result
Example #9
0
 def __init__(self, key, genesis, network, valcode_addr=None, mining=False):
     self.key = key
     self.coinbase = utils.privtoaddr(self.key)
     self.chain = chain.Chain(genesis=genesis, reset_genesis=True, coinbase=self.coinbase, new_head_cb=self._on_new_head)
     self.mining = mining
     self.nonce = self.chain.state.get_nonce(self.coinbase)
     self.valcode_tx = None
     self.deposit_tx = None
     self.valcode_addr = valcode_addr
     self.prepares = dict()
     self.prev_prepare_epoch = 0
     self.prev_commit_epoch = 0
     self.epoch_length = self.chain.env.config['EPOCH_LENGTH']
     # When the transaction_queue is modified, we must set
     # self._head_candidate_needs_updating to True in order to force the
     # head candidate to be updated.
     self.transaction_queue = TransactionQueue()
     self._head_candidate_needs_updating = True
     # Add validator to the network
     self.network = network
     self.network.join(self)
Example #10
0
    def sign(self, key, network_id=None):
        """Sign this transaction with a private key.

        A potentially already existing signature would be overridden.
        """
        if network_id is None:
            rawhash = utils.sha3(rlp.encode(self, UnsignedTransaction))
        else:
            assert 1 <= network_id < 2**63 - 18
            rlpdata = rlp.encode(
                rlp.infer_sedes(self).serialize(self)[:-3] +
                [network_id, b'', b''])
            rawhash = utils.sha3(rlpdata)

        key = normalize_key(key)

        self.v, self.r, self.s = ecsign(rawhash, key)
        if network_id is not None:
            self.v += 8 + network_id * 2

        self._sender = utils.privtoaddr(key)
        return self
Example #11
0
import serpent
from biblecoin.config import default_config, Env
import copy
import time
import rlp

# config_string = ':info,bible.vm.log:trace,bible.vm.op:trace,bible.vm.stack:trace,bible.vm.exit:trace,bible.pb.msg:trace,bible.pb.tx:debug'
config_string = ':info,bible.vm.log:trace'
configure_logging(config_string=config_string)

NUM_PARTICIPANTS = 10
BLOCK_MAKING_PPB = 10

print('Initializing privkeys, addresses and randaos for validators')
privkeys = [utils.sha3(str(i)) for i in range(NUM_PARTICIPANTS)]
addrs = [utils.privtoaddr(k) for k in privkeys]
randaos = [RandaoManager(utils.sha3(str(i))) for i in range(NUM_PARTICIPANTS)]
deposit_sizes = [i * 500 + 500 for i in range(NUM_PARTICIPANTS)]
vcodes = [generate_validation_code(a) for a in addrs]
vchashes = [utils.sha3(c) for c in vcodes]
assert len(privkeys) == len(addrs) == len(randaos) == len(
    deposit_sizes) == len(vcodes) == len(vchashes) == NUM_PARTICIPANTS

# Creating casper contract translator
ct = get_casper_ct()
assert ct
print('Constructing genesis')
s = make_casper_genesis(validators=[
    (generate_validation_code(a), ds * 10**18, r.get(9999), a)
    for a, ds, r in zip(addrs, deposit_sizes, randaos)
][:-1],
Example #12
0
 def join(self, number):
     withdrawal_addr = privtoaddr(tester.keys[number])
     casper_utils.induct_validator(self.t, self.casper, tester.keys[number],
                                   200 * 10**18)
     self.validators[number] = Validator(withdrawal_addr,
                                         tester.keys[number])
Example #13
0
from biblecoin.transactions import Transaction
from biblecoin.consensus_strategy import get_consensus_strategy
from biblecoin.config import config_homestead, config_tangerine, config_spurious, config_metropolis, default_config, Env
from biblecoin.pow.ethpow import Miner
from biblecoin.messages import apply_transaction, apply_message
from biblecoin.common import verify_execution_results, mk_block_from_prevstate, set_execution_results
from biblecoin.meta import make_head_candidate
from biblecoin.abi import ContractTranslator
import rlp
# Initialize accounts
accounts = []
keys = []

for account_number in range(10):
    keys.append(sha3(to_string(account_number)))
    accounts.append(privtoaddr(keys[-1]))

k0, k1, k2, k3, k4, k5, k6, k7, k8, k9 = keys[:10]
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9 = accounts[:10]

base_alloc = {}
minimal_alloc = {}
for a in accounts:
    base_alloc[a] = {'balance': 10**24}
for i in range(1, 9):
    base_alloc[int_to_addr(i)] = {'balance': 1}
    minimal_alloc[int_to_addr(i)] = {'balance': 1}
minimal_alloc[accounts[0]] = {'balance': 10**18}

# Initialize languages
languages = {}
Example #14
0
def accounts():
    k = utils.sha3(b'cow')
    v = utils.privtoaddr(k)
    k2 = utils.sha3(b'horse')
    v2 = utils.privtoaddr(k2)
    return k, v, k2, v2