Пример #1
0
def test_ecrecover():
    s = tester.state()
    c = s.abi_contract(ecrecover_code)

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

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

    pk = PrivateKey(priv, raw=True)
    signature = pk.ecdsa_recoverable_serialize(
        pk.ecdsa_sign_recoverable(msghash, raw=True)
    )
    signature = signature[0] + utils.bytearray_to_bytestr([signature[1]])
    V = utils.safe_ord(signature[64]) + 27
    R = big_endian_to_int(signature[0:32])
    S = big_endian_to_int(signature[32:64])

    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 = c.test_ecrecover(utils.big_endian_to_int(msghash), V, R, S)
    assert result == addr
Пример #2
0
    def sender(self):

        if not self._sender:
            # Determine sender
            if self.v:
                if self.r >= N or self.s >= N or self.v < 27 or self.v > 28 \
                or self.r == 0 or self.s == 0:
                    raise InvalidTransaction("Invalid signature values!")
                log.debug('recovering sender')
                rlpdata = rlp.encode(self, UnsignedTransaction)
                rawhash = utils.sha3(rlpdata)

                pk = PublicKey(flags=ALL_FLAGS)
                try:
                    pk.public_key = pk.ecdsa_recover(
                        rawhash,
                        pk.ecdsa_recoverable_deserialize(
                            zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.r)), 32) + zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.s)), 32),
                            self.v - 27
                        ),
                        raw=True
                    )
                    pub = pk.serialize(compressed=False)
                except Exception:
                    raise InvalidTransaction("Invalid signature values (x^3+7 is non-residue)")

                if pub[1:] == b"\x00" * 32:
                    raise InvalidTransaction("Invalid signature (zero privkey cannot sign)")
                pub = encode_pubkey(pub, 'bin')
                self._sender = utils.sha3(pub[1:])[-20:]
                assert self.sender == self._sender
            else:
                self._sender = 0
        return self._sender
Пример #3
0
    def __init__(self, app):
        log.info("Casper service init")
        self.db = app.services.db
        self.bcast = app.services.peermanager.broadcast

        cfg = app.config['casper']
        self.account = app.services.accounts.get_by_address(app.services.accounts.coinbase)
        self.privkey = self.account.privkey
        if 'network_id' in self.db:
            db_network_id = self.db.get('network_id')
            if db_network_id != str(cfg['network_id']):
                raise RuntimeError(
                    "The database in '{}' was initialized with network id {} and can not be used "
                    "when connecting to network id {}. Please choose a different data directory.".format(
                        app.config['db']['data_dir'], db_network_id, cfg['network_id']
                    )
                )
        else:
            self.db.put('network_id', str(cfg['network_id']))
            self.db.commit()

        self.epoch_length = cfg['epoch_length']
        self.epoch_source = -1
        self.epoch = 0
        self.ancestry_hash = sha3('')
        self.source_ancestry_hash = sha3('')

        self.chain = app.services.chain
        self.genesis = self.chain.block(cfg['genesis_hash'])
        assert self.genesis
        assert self.genesis['number'] % self.epoch_length == 0

        self.store = LevelDBStore(self.db, self.epoch_length, self.genesis)
        self.validator = self.store.validator(cfg['validator_id'])
        super(CasperService, self).__init__(app)
Пример #4
0
 def sender(self):
     if not self._sender:
         # Determine sender
         if self.r == 0 and self.s == 0:
             self._sender = null_address
         else:
             if self.v in (27, 28):
                 vee = self.v
                 sighash = utils.sha3(rlp.encode(self, UnsignedTransaction))
             elif self.v >= 37:
                 vee = self.v - self.network_id * 2 - 8
                 assert vee in (27, 28)
                 rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[
                                      :-3] + [self.network_id, '', ''])
                 sighash = utils.sha3(rlpdata)
             else:
                 raise InvalidTransaction("Invalid V value")
             if self.r >= secpk1n or self.s >= secpk1n or self.r == 0 or self.s == 0:
                 raise InvalidTransaction("Invalid signature values!")
             pub = ecrecover_to_pub(sighash, vee, self.r, self.s)
             if pub == b'\x00' * 64:
                 raise InvalidTransaction(
                     "Invalid signature (zero privkey cannot sign)")
             self._sender = utils.sha3(pub)[-20:]
     return self._sender
Пример #5
0
def generate_accounts(seeds):
    """Create private keys and addresses for all seeds.
    """
    return {
        seed: dict(
            privatekey=encode_hex(sha3(seed)),
            address=encode_hex(privatekey_to_address(sha3(seed)))
        ) for seed in seeds}
Пример #6
0
def test_webui():  # pylint: disable=too-many-locals
    num_assets = 3
    num_nodes = 10

    assets_addresses = [
        sha3('webui:asset:{}'.format(number))[:20]
        for number in range(num_assets)
    ]

    private_keys = [
        sha3('webui:{}'.format(position))
        for position in range(num_nodes)
    ]

    BlockChainServiceMock._instance = True
    blockchain_service= BlockChainServiceMock(None, MOCK_REGISTRY_ADDRESS)
    # overwrite the instance
    BlockChainServiceMock._instance = blockchain_service # pylint: disable=redefined-variable-type

    registry = blockchain_service.registry(MOCK_REGISTRY_ADDRESS)

    for asset in assets_addresses:
        registry.add_asset(asset)

    channels_per_node = 2
    deposit = 100
    app_list = create_network(
        private_keys,
        assets_addresses,
        MOCK_REGISTRY_ADDRESS,
        channels_per_node,
        deposit,
        DEFAULT_SETTLE_TIMEOUT,
        UDPTransport,
        BlockChainServiceMock
    )
    app0 = app_list[0]

    addresses = [
        app.raiden.address.encode('hex')
        for app in app_list
        if app != app_list[0]
    ]

    print '\nCreated nodes: \n',
    for node in addresses:
        print node

    setup_messages_cb()

    app0_assets = getattr(app0.raiden.api, 'assets')
    print '\nAvailable assets:'
    for asset in app0_assets:
        print asset.encode('hex')
    print '\n'

    wamp = WAMPRouter(app0.raiden, 8080, ['channel', 'test'])
    wamp.run()
Пример #7
0
def run_ethash_test(params, mode):
    if 'header' not in params:
        b = blocks.genesis(db)
        b.nonce = decode_hex(params['nonce'])
        b.number = params.get('number', 0)
        header = b.header
        params['header'] = encode_hex(rlp.encode(b.header))
    else:
        header = blocks.BlockHeader(decode_hex(params['header']))
    header_hash = header.mining_hash
    cache_size = ethash.get_cache_size(header.number)
    full_size = ethash.get_full_size(header.number)
    seed = b'\x00' * 32
    for i in range(header.number // ethash_utils.EPOCH_LENGTH):
        seed = utils.sha3(seed)
    nonce = header.nonce
    assert len(nonce) == 8
    assert len(seed) == 32
    t1 = time.time()
    cache = ethash.mkcache(cache_size, seed)
    t2 = time.time()
    cache_hash = encode_hex(utils.sha3(ethash.serialize_cache(cache)))
    t6 = time.time()
    light_verify = ethash.hashimoto_light(full_size, cache, header_hash, nonce)
    t7 = time.time()
    # assert full_mine == light_mine
    out = {
        "seed": encode_hex(seed),
        "header_hash": encode_hex(header_hash),
        "nonce": encode_hex(nonce),
        "cache_size": cache_size,
        "full_size": full_size,
        "cache_hash": cache_hash,
        "mixhash": encode_hex(light_verify["mix digest"]),
        "result": encode_hex(light_verify["result"]),
    }
    if mode == FILL:
        header.mixhash = light_verify["mixhash"]
        params["header"] = encode_hex(rlp.encode(header))
        for k, v in list(out.items()):
            params[k] = v
        return params
    elif mode == VERIFY:
        should, actual = header.mixhash, light_verify['mixhash']
        assert should == actual, "Mismatch: mixhash %r %r" % (should, actual)
        for k, v in list(out.items()):
            assert params[k] == v, "Mismatch: " + k + ' %r %r' % (params[k], v)
    elif mode == TIME:
        return {
            "cache_gen": t2 - t1,
            "verification_time": t7 - t6
        }
Пример #8
0
 def sender(self):
     if not self._sender:
         # Determine sender
         if self.v:
             if self.r >= N or self.s >= P or self.v < 27 or self.v > 28:
                 raise InvalidTransaction("Invalid signature values!")
             log.debug('recovering sender')
             rlpdata = rlp.encode(self, UnsignedTransaction)
             rawhash = utils.sha3(rlpdata)
             pub = encode_pubkey(ecdsa_raw_recover(rawhash, (self.v, self.r, self.s)), 'bin')
             self._sender = utils.sha3(pub[1:])[-20:]
             assert self.sender == self._sender
         else:
             self._sender = 0
     return self._sender
Пример #9
0
def test_string_logging():
    s = tester.state()
    c = s.abi_contract(string_logging_code)
    o = []
    s.block.log_listeners.append(lambda x: o.append(c.translator.listen(x)))
    c.moo()
    assert o == [{
        "_event_type": b"foo",
        "x": b"bob",
        "__hash_x": utils.sha3(b"bob"),
        "y": b"cow",
        "__hash_y": utils.sha3(b"cow"),
        "z": b"dog",
        "__hash_z": utils.sha3(b"dog"),
    }]
Пример #10
0
def test_eth_call(rpc_client, accounts):
    txn_hash = rpc_client(
        method="eth_sendTransaction",
        params=[{
            "from": accounts[0],
            "data": CONTRACT_BIN,
            "value": 1234,
        }],
    )
    txn_receipt = rpc_client(
        method="eth_getTransactionReceipt",
        params=[txn_hash],
    )
    contract_address = txn_receipt['contractAddress']

    assert contract_address

    function_sig = encode_data(sha3("return13()")[:4])

    should_be_13 = rpc_client(
        method="eth_call",
        params=[{
            "from": accounts[0],
            "to": contract_address,
            "data": function_sig,
        }],
    )

    result = big_endian_to_int(decode_hex(should_be_13[2:]))
    assert result == 13
Пример #11
0
def test():
    t.gas_price = 0
    s = t.state()
    c = s.abi_contract('gamble.se')
    rseed = os.urandom(32)
    seed1 = utils.sha3(rseed)
    c.set_curseed(seed1)
    s.block.set_balance(c.address, 27000)
    totbal = sum([s.block.get_balance(x) for x in t.accounts])
    # 90 bets succeed (bet with 25% winning probability)
    for i in range(90):
        assert c.bet(utils.zpad(str(i), 32), 250, sender=t.keys[i % 10], value=100) >= 0
    # 10 bets fail due to not enough collateral
    for i in range(90, 100):
        assert c.bet(utils.zpad(str(i), 32), 250, sender=t.keys[i % 10], value=100) == -2
    # Add more collateral
    s.block.delta_balance(c.address, 3000)
    # 10 bets succeed
    for i in range(90, 100):
        assert c.bet(utils.zpad(str(i), 32), 250, sender=t.keys[i % 10], value=100) >= 0
    # 10 bets fail due to limit of 100
    for i in range(100, 110):
        assert c.bet(utils.zpad(str(i), 32), 250, sender=t.keys[i % 10], value=100) == -1
    mid_totbal = sum([s.block.get_balance(x) for x in t.accounts])
    assert c.set_curseed(rseed, os.urandom(32))
    # Check that a reasonable number of bets succeeded
    new_totbal = sum([s.block.get_balance(x) for x in t.accounts])
    print 'Profit: ', totbal - new_totbal
    assert -4000 < (new_totbal - totbal) < 7000
    assert 26000 < s.block.get_balance(c.address) < 37000
Пример #12
0
def benchmark(size):
    t = trie.Trie(db.EphemDB())
    for i in range(size):
        t.update(utils.sha3('k'+str(i)), utils.sha3('v'+str(i)))
    sz = sum([len(v) for k, v in t.db.db.items()])
    nsz = []
    ldb = db.ListeningDB(t.db.db)
    for i in range(min(size, 100)):
        ldb2 = db.ListeningDB(ldb)
        odb = t.db
        t.db = ldb2
        t.get(utils.sha3('k'+str(i)))
        nsz.append(sum([len(v) for k, v in ldb2.kv.items()]))
        t.db = odb
    ldbsz = sum([len(v) for k, v in ldb.kv.items()])
    print sz, sum(nsz) // len(nsz), ldbsz
Пример #13
0
def test_ssv(chain, accounts, storage_slots):
    # get log reader
    sj = chain.storage.db  # state journal
    sj.commit()
    lr = statejournal.JournalReader(sj.db)

    # validate full chain
    if False:
        state = lr.validate_state(sj.update_counter)
        assert state == sj.state_digest
        assert state == lr.last_update()['state_digest']

    #  get ssv ################

    # read first (oldest entry)
    counter = 1
    k = accounts[0]
    v = int_to_big_endian(counter)
    k += v

    # get the proof
    val, update_counter = sj.get_raw(k)
    proof = lr.get_ssv(update_counter)
    assert proof['value'] == val, (big_endian_to_int(proof['value']), val)
    hash_chain = proof['hash_chain']
    assert len(hash_chain)
    s = hash_chain[0]
    for h in hash_chain[1:]:
        s = sha3(s + h)
    assert s == sj.state_digest
Пример #14
0
    def handle_secret(self, identifier, secret):
        """ Unlock locks, register the secret, and send Secret messages as
        necessary.

        This function will:
            - Unlock the locks created by this node and send a Secret message to
            the corresponding partner so that she can withdraw the asset.
            - Register the secret for the locks received and reveal the secret
            to the senders

        Note:
            The channel needs to be registered with
            `register_channel_for_hashlock`.
        """
        # handling the secret needs to:
        # - unlock the asset for all `forward_channel` (the current one
        #   and the ones that failed with a refund)
        # - send a message to each of the forward nodes allowing them
        #   to withdraw the asset
        # - register the secret for the `originating_channel` so that a
        #   proof can be made, if necessary
        # - reveal the secret to the `sender` node (otherwise we
        #   cannot withdraw the asset)
        hashlock = sha3(secret)
        self._secret(identifier, secret, None, hashlock)
Пример #15
0
    def __init__(self, chain, receiver, tx_num):
        assert isinstance(receiver, int)
        sender = config['num_accounts'] - receiver
        self.hash = sha3(str(tx_num))

        # increase nonce
        Account(chain, sender).update_nonce()

        # receiving account
        account = Account(chain, receiver)

        reads = int(config['storage_reads'](tx_num))
        reads = min(reads, account.storage_slots)
        updates = int(reads / config['storage_read_update_ratio'])
        deletes = int(updates / config['storage_read_delete_ratio'])

        # print reads, updates, deletes

        assert updates + deletes <= reads


        if not reads:  # simple value transfer
            account.update_balance(tx_num)
            return

        # read, update, write
        for i in range(reads):
            i += tx_num
            v = account.read(i)
            if i < updates:
                account.store(i, v+i+tx_num)
            elif i < updates + deletes:
                account.delete(i)
Пример #16
0
 def signing_hash(self):
     return sha3(
         'commit%s%s' % (
             encode_int32(self.epoch),
             self.hash
         )
     )
Пример #17
0
def test_statejournal_read(chain):
    # validate chain
    sj = chain.storage.db  # state journal
    sj.commit()
    lr = statejournal.JournalReader(sj.db)
    state = lr.validate_state(sj.update_counter)
    assert state == sj.state

    #  get ssv ################
    for i in range(config['num_accounts']):
        account = Account(chain, i)
        keys = account.keys()
        if keys:
            break
    assert len(keys)
    print 'keys found', account
    k = keys[0]
    val, update_counter = sj.get_raw(k)
    proof = lr.get_ssv(update_counter)
    assert proof['value'] == val
    hash_chain = proof['hash_chain']
    assert len(hash_chain)
    s = hash_chain[0]
    for h in hash_chain[1:]:
        s = sha3(s + h)
    assert s == sj.state
Пример #18
0
def test():
    t.gas_price = 0
    s = t.state()
    c = s.abi_contract("randao.se")
    votes = []
    ids = []
    xor = 0
    for i in range(5):
        r = random.randrange(2 ** 256)
        xor ^= r
        votes.append(utils.zpad(utils.encode_int(r), 32))
    f = c.getFee()
    for i in range(5):
        ids.append(c.submitHash(utils.sha3(votes[i]), value=f))
    while c.getPhase() == 0:
        s.mine(10)
    for i in range(5):
        c.submitValue(ids[i], votes[i])
    while c.getPhase() == 1:
        s.mine(10)
    c.claimResults()
    assert c.getNextResultPos() == 1
    assert c.getResult(0) == utils.zpad(utils.encode_int(xor), 32), (
        c.getResult(0),
        utils.zpad(utils.encode_int(xor), 32),
    )
Пример #19
0
def test_ecrecover():
    s = tester.state()
    c = s.abi_contract(ecrecover_code)

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

    msghash = encode_hex(utils.sha3('the quick brown fox jumps over the lazy dog'))
    V, R, S = bitcoin.ecdsa_raw_sign(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 = c.test_ecrecover(utils.big_endian_to_int(decode_hex(msghash)), V, R, S)
    assert result == addr
Пример #20
0
def _check_pow(header):
    number = big_endian_to_int(header[8])
    difficulty = big_endian_to_int(header[7])
    mixhash = header[13]
    nonce = header[14]
    mining_hash = sha3(rlp.encode(header[:13]))
    assert check_pow(number, mining_hash, mixhash, nonce, difficulty)
Пример #21
0
def test_decode_transfer():
    encoded_data = "0500000000000000000000010bd4060688a1800ae986e4840aebc924bb40b5bf3893263bf8b2d0373a34b8d359c5edd823110747000000000000000000000000000000000000000000000000000000000000000160d09b4687c162154b290ee5fcbd7c6285590969b3c873e94b690ee9c4f5df510000000000000000000000000000000000000000000000000000000000000000ff9636ccb66e73219fd166cd6ffbc9c6215f74ff31c1fd4131cf532b29ee096f65278c459253fba65bf019c723a68bb4a6153ea8378cd1b15d55825e1a291b6f00"
    bad_encoded_data = "0500000000000000000000010bd4060688a1800ae986e4840aebc924bb40b5bf3893263bf8b2d0373a34b8d359c5edd823110747000000000000000000000000000000000000000000000000000000000000000160d09b4687c162154b290ee5fcbd7c6285590969b3c873e94b690ee9c4f5df510000000000000000000000000000000000000000000000000000000000000000ff9636ccb66e73219fd166cd6ffbc9c6215f74ff31c1fd4131cf532b29ee096f65278c459253fba65bf019c723a68bb4a6153ea8378cd1b15d55825e1a291b6f0001"
    data = encoded_data.decode("hex")
    bad_data = bad_encoded_data.decode("hex")
    s = tester.state()
    c = s.abi_contract(decode_code, language="solidity")
    o1 = c.decodeTransfer(data)
    assert data[0] == "\x05"  # make sure data has right cmdid
    assert len(data) == 213
    nonce = o1[0]
    assert nonce == 1
    asset = o1[1]
    assert asset == sha3("asset")[:20].encode("hex")
    recipient = o1[2]
    assert len(recipient) == 40
    assert recipient == privtoaddr("y" * 32).encode("hex")
    balance = o1[3]
    assert balance == 1
    optionalLocksroot = o1[4]
    assert optionalLocksroot == "60d09b4687c162154b290ee5fcbd7c6285590969b3c873e94b690ee9c4f5df51".decode("hex")
    optionalSecret = o1[5]
    assert optionalSecret == "0000000000000000000000000000000000000000000000000000000000000000".decode("hex")
    signature = "ff9636ccb66e73219fd166cd6ffbc9c6215f74ff31c1fd4131cf532b29ee096f65278c459253fba65bf019c723a68bb4a6153ea8378cd1b15d55825e1a291b6f00".decode(
        "hex"
    )
    r = o1[6]
    s = o1[7]
    v = o1[8]
    assert r == signature[:32]
    assert s == signature[32:64]
    assert v == int(signature[64].encode("hex"))
    with pytest.raises(TransactionFailed):
        c.decodeSecret(bad_data)
Пример #22
0
def setup_apps(amount, assets, num_transfers, num_nodes, channels_per_node):
    assert len(assets) <= num_nodes

    deposit = amount * num_transfers

    private_keys = [
        sha3('mediated_transfer:{}'.format(position))
        for position in range(num_nodes)
    ]

    BlockChainServiceMock.reset()
    blockchain_services = list()
    for privkey in private_keys:
        blockchain = BlockChainServiceMock(
            privkey,
            MOCK_REGISTRY_ADDRESS,
        )
        blockchain_services.append(blockchain)

    registry = blockchain_services[0].registry(MOCK_REGISTRY_ADDRESS)
    for asset in assets:
        registry.add_asset(asset)

    verbosity = 3
    apps = create_network(
        blockchain_services,
        assets,
        channels_per_node,
        deposit,
        DEFAULT_SETTLE_TIMEOUT,
        UDPTransport,
        verbosity,
    )

    return apps
Пример #23
0
def new_block(block, use_parent=True):
    """Create a new block based on a parent block.

    The block will not include any transactions and will not be finalized.
    """
    parent = block.get_parent()
    header = BlockHeader(prevhash=parent.hash,
                            uncles_hash=utils.sha3(rlp.encode([])),
                            coinbase=block.coinbase,
                            state_root=parent.state_root if use_parent else block.state_root,
                            tx_list_root=trie.BLANK_ROOT,
                            receipts_root=trie.BLANK_ROOT,
                            bloom=0,
                            difficulty=block.difficulty,
                            mixhash='',
                            number=parent.number + 1,
                            gas_limit=block.gas_limit,
                            gas_used=0,
                            timestamp=block.timestamp,
                            extra_data=block.extra_data,
                            nonce=b'')
    block = Block(header, [], [], env=parent.env if use_parent else block.env,
                    parent=parent, making=True)
    block.ancestor_hashes = [parent.hash] + parent.ancestor_hashes
    block.log_listeners = parent.log_listeners
    return block
Пример #24
0
def hash_array(arr):
    o = ''
    for x in arr:
        if isinstance(x, (int, long)):
            x = utils.zpad(utils.encode_int(x), 32)
        o += x
    return utils.big_endian_to_int(utils.sha3(o))
Пример #25
0
    def register_secret(self, secret):
        """ Handle a secret that could be received from a Secret message or a
        ChannelSecretRevealed event.
        """
        hashlock = sha3(secret)
        channels_reveal = self.hashlock_channel[hashlock]

        secret_message = Secret(secret)
        self.raiden.sign(secret_message)

        while channels_reveal:
            reveal_to = channels_reveal.pop()

            # send the secret to all channels registered, including the next
            # hop that might be the node that informed us about the secret
            self.raiden.send(reveal_to.partner_state.address, secret_message)

            # update the channel by claiming the locked transfers
            try:
                reveal_to.claim_locked(secret)
            except InvalidSecret:
                log.error('claiming lock failed')

        assert len(self.hashlock_channel[hashlock]) == 0
        del self.hashlock_channel[hashlock]
Пример #26
0
 def __init__(self, genesis, key, network, env, time_offset=5):
     # Create a chain object
     self.chain = Chain(genesis, env=env)
     # Use the validator's time as the chain's time
     self.chain.time = lambda: self.get_timestamp()
     # My private key
     self.key = key
     # My address
     self.address = privtoaddr(key)
     # My randao
     self.randao = RandaoManager(sha3(self.key))
     # Pointer to the test p2p network
     self.network = network
     # Record of objects already received and processed
     self.received_objects = {}
     # The minimum eligible timestamp given a particular number of skips
     self.next_skip_count = 0
     self.next_skip_timestamp = 0
     # This validator's indices in the state
     self.indices = None
     # Code that verifies signatures from this validator
     self.validation_code = generate_validation_code(privtoaddr(key))
     # Parents that this validator has already built a block on
     self.used_parents = {}
     # This validator's clock offset (for testing purposes)
     self.time_offset = random.randrange(time_offset) - (time_offset // 2)
     # Give this validator a unique ID
     self.id = len(ids)
     ids.append(self.id)
     self.find_my_indices()
     self.cached_head = self.chain.head_hash
Пример #27
0
def create_and_distribute_token(client, receivers,
                                amount_per_receiver=1000,
                                name=None,
                                gasprice=denoms.shannon * 20,
                                timeout=120):
    """Create a new ERC-20 token and distribute it among `receivers`.
    If `name` is None, the name will be derived from hashing all receivers.
    """
    name = name or sha3(''.join(receivers)).encode('hex')
    token_proxy = client.deploy_solidity_contract(
        client.sender,
        'HumanStandardToken',
        compile_file(get_contract_path('HumanStandardToken.sol')),
        dict()
        (
            len(receivers) * amount_per_receiver,
            name,
            2,  # decimals
            name[:4].upper()  # symbol
        ),
        gasprice=gasprice,
        timeout=timeout
    )
    for receiver in receivers:
        token_proxy.transfer(receiver, amount_per_receiver)
    return token_proxy.address.encode('hex')
Пример #28
0
    def _run(self):  # pylint: disable=method-hidden
        transfer = self.originating_transfer
        assetmanager = self.transfermanager.assetmanager
        raiden = assetmanager.raiden

        transfer_details = '{} -> {} hash:{}'.format(
            pex(transfer.target),
            pex(transfer.initiator),
            pex(transfer.hash),
        )
        log.debug('END MEDIATED TRANSFER {}'.format(transfer_details))

        secret_request = SecretRequest(transfer.lock.hashlock)
        raiden.sign(secret_request)
        raiden.send(transfer.initiator, secret_request)

        self.event = AsyncResult()
        response = self.event.wait(raiden.config['msg_timeout'])

        if response is None:
            log.error('SECRETREQUEST TIMED OUT!')
            self.transfermanager.on_hashlock_result(transfer.hashlock, False)
            return

        if not isinstance(response, Secret):
            raise Exception('Invalid message received.')

        if sha3(response.secret) != transfer.lock.hashlock:
            raise Exception('Invalid secret received.')

        # update all channels and propagate the secret
        assetmanager.register_secret(response.secret)
        self.transfermanager.on_hashlock_result(transfer.lock.hashlock, True)
Пример #29
0
def create_node_configuration(miner=True,
                              port=30301,
                              rpcport=8101,
                              host='127.0.0.1',
                              node_key_seed=0):
    """
    Create configuration (ports, keys, etc...) for one node.

    :param miner: if True, setup to be a mining node
    :param port: the p2p port to assign
    :param rpcport: the port to assign
    :param host: the host for the node to run on
    :return: node configuration dict
    """
    node = dict()
    if miner:
        node['minerthreads'] = 1  # conservative
        node['unlock'] = 0
    node['nodekey'] = sha3('node:{}'.format(node_key_seed))
    node['nodekeyhex'] = encode_hex(node['nodekey'])
    node['pub'] = encode_hex(privtopub_enode(node['nodekey']))
    node['address'] = privatekey_to_address(node['nodekey'])
    node['host'] = host
    node['port'] = port
    node['rpcport'] = rpcport
    node['enode'] = 'enode://{pub}@{host}:{port}'.format(**node)
    return node
Пример #30
0
    def init_from_parent(cls, parent, coinbase, nonce=b'', extra_data=b'',
                         timestamp=int(time.time()), uncles=[]):
        """Create a new block based on a parent block.

        The block will not include any transactions and will not be finalized.
        """
        header = BlockHeader(prevhash=parent.hash,
                             uncles_hash=utils.sha3(rlp.encode(uncles)),
                             coinbase=coinbase,
                             state_root=parent.state_root,
                             tx_list_root=trie.BLANK_ROOT,
                             receipts_root=trie.BLANK_ROOT,
                             bloom=0,
                             difficulty=calc_difficulty(parent, timestamp),
                             mixhash='',
                             number=parent.number + 1,
                             gas_limit=calc_gaslimit(parent),
                             gas_used=0,
                             timestamp=timestamp,
                             extra_data=extra_data,
                             nonce=nonce)
        block = Block(header, [], uncles, db=parent.db,
                      parent=parent, making=True)
        block.ancestor_hashes = [parent.hash] + parent.ancestor_hashes
        return block
Пример #31
0
import signal
from subprocess import Popen, PIPE
from ethereum.utils import denoms, sha3, privtoaddr, encode_hex
from devp2p.crypto import privtopub as privtopub_enode

# DEFAULTS
NUM_GETH_NODES = 3
NUM_RAIDEN_ACCOUNTS = 10
CLUSTER_NAME = 'raiden'
RAIDEN_PORT = 40001
DEFAULT_PW = 'notsosecret'

# a list of `num_raiden_accounts` account addresses with a predictable privkey:
# privkey = sha3('127.0.0.1:`raiden_port + i`')
DEFAULTACCOUNTS = [
    encode_hex(privtoaddr(sha3('127.0.0.1:{}'.format(RAIDEN_PORT + i))))
    for i in range(NUM_RAIDEN_ACCOUNTS)
]

# default args to pass to `geth` for all calls, e.g. verbosity, ...
DEFAULT_ARGS = [
    '--nodiscover',
    '--rpc',
    '--networkid {}'.format(sum(ord(c) for c in CLUSTER_NAME)),
]

# the node specific arguments to pass to `geth` that will be extracted from a
# 'node configuration'
NODE_CONFIG = [
    'nodekeyhex',
    'port',
 def merkle_hash(self):
     return utils.sha3(self.hash + self.sig1 + self.sig2)
Пример #33
0
def get_empty_merkle_tree_hash(depth):
    zeroes_hash = NULL_HASH
    for _ in range(depth):
        zeroes_hash = u.sha3(zeroes_hash + zeroes_hash)
    return zeroes_hash
Пример #34
0
from ethereum.pow import chain
from ethereum.transactions import Transaction
from ethereum.consensus_strategy import get_consensus_strategy
from ethereum.config import config_homestead, config_tangerine, config_spurious, config_metropolis, default_config, Env
from ethereum.pow.ethpow import Miner
from ethereum.messages import apply_transaction
from ethereum.common import verify_execution_results, mk_block_from_prevstate, set_execution_results
from ethereum.meta import make_head_candidate
from ethereum.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**18}
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
Пример #35
0
import random
from toshi.log import configure_logger, log_unhandled_exceptions
from toshi.ethereum.utils import data_decoder
from ethereum.utils import sha3
from ethereum.abi import decode_abi, process_type, decode_single
from toshi.utils import parse_int
from toshieth.collectibles.base import CollectiblesTaskManager
from urllib.parse import urlparse
from tornado.httpclient import AsyncHTTPClient
from tornado.escape import json_decode

log = logging.getLogger("toshieth.fungible")

ASSET_CREATED_TOPIC = "0xa34547120a941eab43859acf535a121237e5536fd476dccda8174fb1af6926ed"
ASSET_TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
TOKEN_URI_CALL_DATA = "0x" + sha3("tokenURI()")[:4].hex() + "0" * 56
NAME_CALL_DATA = "0x" + sha3("name()")[:4].hex() + "0" * 56
CREATOR_CALL_DATA = "0x" + sha3("creator()")[:4].hex() + "0" * 56
TOTAL_SUPPLY_CALL_DATA = "0x" + sha3("totalSupply()")[:4].hex() + "0" * 56


class FungibleCollectibleTaskManager(CollectiblesTaskManager):
    def __init__(self):
        super().__init__()
        configure_logger(log)
        self._processing = {}
        self._queue = set()

    async def process_block(self, blocknumber=None):

        async with self.pool.acquire() as con:
Пример #36
0
    def get_state_variable_from_storage(self, address, params=[]):
        (position, length, mappings) = (0, 1, [])
        try:
            if params[0] == "mapping":
                if len(params) < 3:
                    raise CriticalError("Invalid number of parameters.")
                position = int(params[1])
                position_formatted = utils.zpad(
                    utils.int_to_big_endian(position), 32)
                for i in range(2, len(params)):
                    key = bytes(params[i], 'utf8')
                    key_formatted = utils.rzpad(key, 32)
                    mappings.append(
                        int.from_bytes(utils.sha3(key_formatted +
                                                  position_formatted),
                                       byteorder='big'))

                length = len(mappings)
                if length == 1:
                    position = mappings[0]

            else:
                if len(params) >= 4:
                    raise CriticalError("Invalid number of parameters.")

                if len(params) >= 1:
                    position = int(params[0])
                if len(params) >= 2:
                    length = int(params[1])
                if len(params) == 3 and params[2] == "array":
                    position_formatted = utils.zpad(
                        utils.int_to_big_endian(position), 32)
                    position = int.from_bytes(utils.sha3(position_formatted),
                                              byteorder='big')

        except ValueError:
            raise CriticalError(
                "Invalid storage index. Please provide a numeric value.")

        outtxt = []

        try:
            if length == 1:
                outtxt.append("{}: {}".format(
                    position, self.eth.eth_getStorageAt(address, position)))
            else:
                if len(mappings) > 0:
                    for i in range(0, len(mappings)):
                        position = mappings[i]
                        outtxt.append("{}: {}".format(
                            hex(position),
                            self.eth.eth_getStorageAt(address, position)))
                else:
                    for i in range(position, position + length):
                        outtxt.append("{}: {}".format(
                            hex(i), self.eth.eth_getStorageAt(address, i)))
        except FileNotFoundError as e:
            raise CriticalError("IPC error: " + str(e))
        except ConnectionError as e:
            raise CriticalError(
                "Could not connect to RPC server. Make sure that your node is running and that RPC parameters are set correctly."
            )
        return '\n'.join(outtxt)
 def decodeABI(tinput, sig, returnVals):
     abi = tinput[2:]
     hash = utils.sha3(sig)[:4].encode('hex')
     if abi[:8] != hash:
         return None
     return decode_abi(returnVals, abi[8:].decode('hex'))
Пример #38
0
from devp2p.app import BaseApp
from devp2p.discovery import NodeDiscovery
from devp2p.peermanager import PeerManager
from devp2p.service import BaseService
from ethereum.utils import encode_hex, decode_hex, sha3, privtopub
from casper import __version__

slogging.PRINT_FORMAT = '%(asctime)s %(name)s:%(levelname).1s\t%(message)s'
log = slogging.get_logger('app')

services = [
    NodeDiscovery, PeerManager, DBService, AccountsService, ChainService,
    CasperService
]

privkeys = [encode_hex(sha3(i)) for i in range(100, 200)]
pubkeys = [encode_hex(privtopub(decode_hex(k))[1:]) for k in privkeys]


class Casper(BaseApp):
    client_name = 'casper'
    client_version = '%s/%s/%s' % (__version__, sys.platform,
                                   'py%d.%d.%d' % sys.version_info[:3])
    client_version_string = '%s/v%s' % (client_name, client_version)
    start_console = False
    default_config = dict(BaseApp.default_config)
    default_config['client_version_string'] = client_version_string
    default_config['post_app_start_callback'] = None
    script_globals = {}

Пример #39
0
from ethereum.tools import tester
from ethereum.utils import sha3, normalize_address

c = tester.Chain()
x = c.contract(open('rando.v.py').read(), l='viper')
for i in range(10):
    x.deposit(sender=tester.keys[i], value=(i + 1) * 10**15)
    c.mine(1)

o = [0] * 10
for i in range(550):
    addr = normalize_address(x.random_select(sha3(str(i))))
    o[tester.accounts.index(addr)] += 1

for i, v in enumerate(o):
    ev = 10 * (i + 1)
    if not ev - 4 * ev**0.5 < v < ev + 4 * ev**0.5:
        raise Exception(
            "More than four standard deviations away; something is wrong: %.2f %d %.2f"
            % (ev - 4 * ev**0.5, v, ev + 4 * ev**0.5))
print(o)
Пример #40
0
# Author: Florian Tramer

import glob
import unittest
from ethereum import utils
from os.path import basename

from utils.pyethereum_test_utils import PyEthereumTestCase, bytes_to_int, int_to_bytes

# Base path to contracts from current directory
PATH_TO_CONTRACTS = ""

log_sigs = {
    'Transfer': bytes_to_int(utils.sha3("Transfer(address,address,uint256)")),
    'Approval': bytes_to_int(utils.sha3("Approval(address,address,uint256)"))
}


class TestERC20Flo(PyEthereumTestCase):
    def test_all(self):
        self.assertEqual(self.c.totalSupply(), 0, "Token not initially empty")

        orig_balance0 = self.s.head_state.get_balance(self.t.a0)
        orig_balance1 = self.s.head_state.get_balance(self.t.a1)

        self.c.deposit(sender=self.t.k0, value=1000)

        self.check_logs([log_sigs['Transfer'], 0,
                         bytes_to_int(self.t.a0)], int_to_bytes(1000))

        new_balance0 = self.s.head_state.get_balance(self.t.a0)
Пример #41
0
 def get(self, k):
     return self.trie.get(utils.sha3(k))
Пример #42
0
    def _run(self):  # pylint: disable=method-hidden,too-many-locals
        tokenswap = self.tokenswap
        raiden = self.raiden

        identifier = tokenswap.identifier
        from_token = tokenswap.from_token
        from_amount = tokenswap.from_amount
        to_token = tokenswap.to_token
        to_amount = tokenswap.to_amount
        to_nodeaddress = tokenswap.to_nodeaddress

        from_graph = raiden.token_to_channelgraph[from_token]
        to_graph = raiden.token_to_channelgraph[to_token]

        from_routes = get_best_routes(
            from_graph,
            raiden.protocol.nodeaddresses_networkstatuses,
            raiden.address,
            to_nodeaddress,
            from_amount,
            previous_address=None,
        )
        fee = 0

        for route in from_routes:
            # for each new path a new secret must be used
            secret = sha3(hex(random.getrandbits(256)))
            hashlock = sha3(secret)

            from_channel = from_graph.get_channel_by_contract_address(route.channel_address)

            raiden.greenlet_task_dispatcher.register_task(self, hashlock)
            raiden.register_channel_for_hashlock(from_token, from_channel, hashlock)

            lock_expiration = (
                raiden.get_block_number() +
                from_channel.settle_timeout -
                raiden.config['reveal_timeout']
            )

            from_mediated_transfer = from_channel.create_mediatedtransfer(
                raiden.address,
                to_nodeaddress,
                fee,
                from_amount,
                identifier,
                lock_expiration,
                hashlock,
            )
            raiden.sign(from_mediated_transfer)
            from_channel.register_transfer(
                raiden.get_block_number(),
                from_mediated_transfer,
            )

            # wait for the SecretRequest and MediatedTransfer
            to_mediated_transfer = self.send_and_wait_valid_state(
                raiden,
                route.node_address,
                to_nodeaddress,
                from_mediated_transfer,
                to_token,
                to_amount,
            )

            if to_mediated_transfer is None:
                # the initiator can unregister right away since it knows the
                # secret wont be revealed
                raiden.greenlet_task_dispatcher.unregister_task(self, hashlock, False)

            elif isinstance(to_mediated_transfer, MediatedTransfer):
                to_hop = to_mediated_transfer.sender
                to_channel = to_graph.partneraddress_to_channel[to_hop]

                to_channel.register_transfer(
                    raiden.get_block_number(),
                    to_mediated_transfer,
                )
                raiden.register_channel_for_hashlock(to_token, to_channel, hashlock)

                # A swap is composed of two mediated transfers, we need to
                # reveal the secret to both, since the maker is one of the ends
                # we just need to send the reveal secret directly to the taker.
                reveal_secret = RevealSecret(secret)
                raiden.sign(reveal_secret)
                raiden.send_async(to_nodeaddress, reveal_secret)

                from_channel.register_secret(secret)

                # Register the secret with the to_channel and send the
                # RevealSecret message to the node that is paying the to_token
                # (this node might, or might not be the same as the taker),
                # then wait for the withdraw.
                raiden.handle_secret(
                    identifier,
                    to_token,
                    secret,
                    None,
                    hashlock,
                )

                to_channel = to_graph.partneraddress_to_channel[to_mediated_transfer.sender]
                self._wait_for_unlock_or_close(
                    raiden,
                    to_graph,
                    to_channel,
                    to_mediated_transfer,
                )

                # unlock the from_token and optimistically reveal the secret
                # forward
                raiden.handle_secret(
                    identifier,
                    from_token,
                    secret,
                    None,
                    hashlock,
                )

                raiden.greenlet_task_dispatcher.unregister_task(self, hashlock, True)
                self.async_result.set(True)
                return

        if log.isEnabledFor(logging.DEBUG):
            node_address = raiden.address
            log.debug(
                'MAKER TOKEN SWAP FAILED initiator:%s to_nodeaddress:%s',
                pex(node_address),
                pex(to_nodeaddress),
            )

        # all routes failed
        self.async_result.set(False)
Пример #43
0
 def _store_account_address(self, address):
     """
     get block transaction receipts by block header hash & number
     """
     address_key = address_prefix + utils.sha3(address)
     self.wb.put(address_key, address)
Пример #44
0
def vm_execute(ext, msg, code):
    # precompute trace flag
    # if we trace vm, we're in slow mode anyway
    trace_vm = log_vm_op.is_active('trace')

    # Initialize stack, memory, program counter, etc
    compustate = Compustate(gas=msg.gas)
    stk = compustate.stack
    mem = compustate.memory

    # Compute
    jumpdest_mask, pushcache = preprocess_code(code)
    codelen = len(code)

    # For tracing purposes
    op = None
    steps = 0
    _prevop = None  # for trace only

    while compustate.pc < codelen:

        opcode = safe_ord(code[compustate.pc])

        # Invalid operation
        if opcode not in opcodes.opcodes:
            return vm_exception('INVALID OP', opcode=opcode)

        op, in_args, out_args, fee = opcodes.opcodes[opcode]

        # out of gas error
        if fee > compustate.gas:
            return vm_exception('OUT OF GAS')

        # empty stack error
        if in_args > len(compustate.stack):
            return vm_exception('INSUFFICIENT STACK',
                                op=op,
                                needed=to_string(in_args),
                                available=to_string(len(compustate.stack)))

        # overfull stack error
        if len(compustate.stack) - in_args + out_args > 1024:
            return vm_exception('STACK SIZE LIMIT EXCEEDED',
                                op=op,
                                pre_height=to_string(len(compustate.stack)))

        # Apply operation
        compustate.gas -= fee
        compustate.pc += 1

        # Tracing
        if trace_vm:
            """
            This diverges from normal logging, as we use the logging namespace
            only to decide which features get logged in 'eth.vm.op'
            i.e. tracing can not be activated by activating a sub
            like 'eth.vm.op.stack'
            """
            trace_data = {}
            trace_data['stack'] = list(map(to_string, list(compustate.stack)))
            if _prevop in ('MLOAD', 'MSTORE', 'MSTORE8', 'SHA3', 'CALL',
                           'CALLCODE', 'CREATE', 'CALLDATACOPY', 'CODECOPY',
                           'EXTCODECOPY'):
                if len(compustate.memory) < 1024:
                    trace_data['memory'] = \
                        ''.join([encode_hex(ascii_chr(x)) for x
                                  in compustate.memory])
                else:
                    trace_data['sha3memory'] = \
                        encode_hex(utils.sha3(b''.join([ascii_chr(x) for
                                              x in compustate.memory])))
            if _prevop in ('SSTORE', ) or steps == 0:
                trace_data['storage'] = ext.log_storage(msg.to)
            trace_data['gas'] = to_string(compustate.gas + fee)
            trace_data['inst'] = opcode
            trace_data['pc'] = to_string(compustate.pc - 1)
            if steps == 0:
                trace_data['depth'] = msg.depth
                trace_data['address'] = msg.to
            trace_data['steps'] = steps
            trace_data['depth'] = msg.depth
            if op[:4] == 'PUSH':
                trace_data['pushvalue'] = pushcache[compustate.pc - 1]
            log_vm_op.trace('vm', op=op, **trace_data)
            steps += 1
            _prevop = op

        # Valid operations
        # Pushes first because they are very frequent
        if 0x60 <= opcode <= 0x7f:
            stk.append(pushcache[compustate.pc - 1])
            compustate.pc += opcode - 0x5f  # Move 1 byte forward for 0x60, up to 32 bytes for 0x7f
        # Arithmetic
        elif opcode < 0x10:
            if op == 'STOP':
                return peaceful_exit('STOP', compustate.gas, [])
            elif op == 'ADD':
                stk.append((stk.pop() + stk.pop()) & TT256M1)
            elif op == 'SUB':
                stk.append((stk.pop() - stk.pop()) & TT256M1)
            elif op == 'MUL':
                stk.append((stk.pop() * stk.pop()) & TT256M1)
            elif op == 'DIV':
                s0, s1 = stk.pop(), stk.pop()
                stk.append(0 if s1 == 0 else s0 // s1)
            elif op == 'MOD':
                s0, s1 = stk.pop(), stk.pop()
                stk.append(0 if s1 == 0 else s0 % s1)
            elif op == 'SDIV':
                s0, s1 = utils.to_signed(stk.pop()), utils.to_signed(stk.pop())
                stk.append(0 if s1 == 0 else (abs(s0) // abs(s1) *
                                              (-1 if s0 * s1 < 0 else 1))
                           & TT256M1)
            elif op == 'SMOD':
                s0, s1 = utils.to_signed(stk.pop()), utils.to_signed(stk.pop())
                stk.append(0 if s1 == 0 else (abs(s0) % abs(s1) *
                                              (-1 if s0 < 0 else 1)) & TT256M1)
            elif op == 'ADDMOD':
                s0, s1, s2 = stk.pop(), stk.pop(), stk.pop()
                stk.append((s0 + s1) % s2 if s2 else 0)
            elif op == 'MULMOD':
                s0, s1, s2 = stk.pop(), stk.pop(), stk.pop()
                stk.append((s0 * s1) % s2 if s2 else 0)
            elif op == 'EXP':
                base, exponent = stk.pop(), stk.pop()
                # fee for exponent is dependent on its bytes
                # calc n bytes to represent exponent
                nbytes = len(utils.encode_int(exponent))
                expfee = nbytes * opcodes.GEXPONENTBYTE
                if ext.post_spurious_dragon_hardfork():
                    expfee += opcodes.EXP_SUPPLEMENTAL_GAS * nbytes
                if compustate.gas < expfee:
                    compustate.gas = 0
                    return vm_exception('OOG EXPONENT')
                compustate.gas -= expfee
                stk.append(pow(base, exponent, TT256))
            elif op == 'SIGNEXTEND':
                s0, s1 = stk.pop(), stk.pop()
                if s0 <= 31:
                    testbit = s0 * 8 + 7
                    if s1 & (1 << testbit):
                        stk.append(s1 | (TT256 - (1 << testbit)))
                    else:
                        stk.append(s1 & ((1 << testbit) - 1))
                else:
                    stk.append(s1)
        # Comparisons
        elif opcode < 0x20:
            if op == 'LT':
                stk.append(1 if stk.pop() < stk.pop() else 0)
            elif op == 'GT':
                stk.append(1 if stk.pop() > stk.pop() else 0)
            elif op == 'SLT':
                s0, s1 = utils.to_signed(stk.pop()), utils.to_signed(stk.pop())
                stk.append(1 if s0 < s1 else 0)
            elif op == 'SGT':
                s0, s1 = utils.to_signed(stk.pop()), utils.to_signed(stk.pop())
                stk.append(1 if s0 > s1 else 0)
            elif op == 'EQ':
                stk.append(1 if stk.pop() == stk.pop() else 0)
            elif op == 'ISZERO':
                stk.append(0 if stk.pop() else 1)
            elif op == 'AND':
                stk.append(stk.pop() & stk.pop())
            elif op == 'OR':
                stk.append(stk.pop() | stk.pop())
            elif op == 'XOR':
                stk.append(stk.pop() ^ stk.pop())
            elif op == 'NOT':
                stk.append(TT256M1 - stk.pop())
            elif op == 'BYTE':
                s0, s1 = stk.pop(), stk.pop()
                if s0 >= 32:
                    stk.append(0)
                else:
                    stk.append((s1 // 256**(31 - s0)) % 256)
        # SHA3 and environment info
        elif opcode < 0x40:
            if op == 'SHA3':
                s0, s1 = stk.pop(), stk.pop()
                compustate.gas -= opcodes.GSHA3WORD * (utils.ceil32(s1) // 32)
                if compustate.gas < 0:
                    return vm_exception('OOG PAYING FOR SHA3')
                if not mem_extend(mem, compustate, op, s0, s1):
                    return vm_exception('OOG EXTENDING MEMORY')
                data = bytearray_to_bytestr(mem[s0:s0 + s1])
                stk.append(utils.big_endian_to_int(utils.sha3(data)))
            elif op == 'ADDRESS':
                stk.append(utils.coerce_to_int(msg.to))
            elif op == 'BALANCE':
                if ext.post_anti_dos_hardfork():
                    if not eat_gas(compustate,
                                   opcodes.BALANCE_SUPPLEMENTAL_GAS):
                        return vm_exception("OUT OF GAS")
                addr = utils.coerce_addr_to_hex(stk.pop() % 2**160)
                stk.append(ext.get_balance(addr))
            elif op == 'ORIGIN':
                stk.append(utils.coerce_to_int(ext.tx_origin))
            elif op == 'CALLER':
                stk.append(utils.coerce_to_int(msg.sender))
            elif op == 'CALLVALUE':
                stk.append(msg.value)
            elif op == 'CALLDATALOAD':
                stk.append(msg.data.extract32(stk.pop()))
            elif op == 'CALLDATASIZE':
                stk.append(msg.data.size)
            elif op == 'CALLDATACOPY':
                mstart, dstart, size = stk.pop(), stk.pop(), stk.pop()
                if not mem_extend(mem, compustate, op, mstart, size):
                    return vm_exception('OOG EXTENDING MEMORY')
                if not data_copy(compustate, size):
                    return vm_exception('OOG COPY DATA')
                msg.data.extract_copy(mem, mstart, dstart, size)
            elif op == 'CODESIZE':
                stk.append(codelen)
            elif op == 'CODECOPY':
                mstart, dstart, size = stk.pop(), stk.pop(), stk.pop()
                if not mem_extend(mem, compustate, op, mstart, size):
                    return vm_exception('OOG EXTENDING MEMORY')
                if not data_copy(compustate, size):
                    return vm_exception('OOG COPY DATA')
                for i in range(size):
                    if dstart + i < codelen:
                        mem[mstart + i] = safe_ord(code[dstart + i])
                    else:
                        mem[mstart + i] = 0
            elif op == 'RETURNDATACOPY':
                mstart, dstart, size = stk.pop(), stk.pop(), stk.pop()
                if not mem_extend(mem, compustate, op, mstart, size):
                    return vm_exception('OOG EXTENDING MEMORY')
                if not data_copy(compustate, size):
                    return vm_exception('OOG COPY DATA')
                if dstart + size > len(compustate.last_returned):
                    return vm_exception('RETURNDATACOPY out of range')
                mem[mstart:mstart + size] = compustate.last_returned
            elif op == 'RETURNDATASIZE':
                stk.append(len(compustate.last_returned))
            elif op == 'GASPRICE':
                stk.append(ext.tx_gasprice)
            elif op == 'EXTCODESIZE':
                if ext.post_anti_dos_hardfork():
                    if not eat_gas(compustate,
                                   opcodes.EXTCODELOAD_SUPPLEMENTAL_GAS):
                        return vm_exception("OUT OF GAS")
                addr = utils.coerce_addr_to_hex(stk.pop() % 2**160)
                stk.append(len(ext.get_code(addr) or b''))
            elif op == 'EXTCODECOPY':
                if ext.post_anti_dos_hardfork():
                    if not eat_gas(compustate,
                                   opcodes.EXTCODELOAD_SUPPLEMENTAL_GAS):
                        return vm_exception("OUT OF GAS")
                addr = utils.coerce_addr_to_hex(stk.pop() % 2**160)
                start, s2, size = stk.pop(), stk.pop(), stk.pop()
                extcode = ext.get_code(addr) or b''
                assert utils.is_string(extcode)
                if not mem_extend(mem, compustate, op, start, size):
                    return vm_exception('OOG EXTENDING MEMORY')
                if not data_copy(compustate, size):
                    return vm_exception('OOG COPY DATA')
                for i in range(size):
                    if s2 + i < len(extcode):
                        mem[start + i] = safe_ord(extcode[s2 + i])
                    else:
                        mem[start + i] = 0
        # Block info
        elif opcode < 0x50:
            if op == 'BLOCKHASH':
                if ext.post_metropolis_hardfork() and False:
                    bh_addr = ext.blockhash_store
                    stk.append(ext.get_storage_data(bh_addr, stk.pop()))
                else:
                    stk.append(
                        utils.big_endian_to_int(ext.block_hash(stk.pop())))
            elif op == 'COINBASE':
                stk.append(utils.big_endian_to_int(ext.block_coinbase))
            elif op == 'TIMESTAMP':
                stk.append(ext.block_timestamp)
            elif op == 'NUMBER':
                stk.append(ext.block_number)
            elif op == 'DIFFICULTY':
                stk.append(ext.block_difficulty)
            elif op == 'GASLIMIT':
                stk.append(ext.block_gas_limit)
        # VM state manipulations
        elif opcode < 0x60:
            if op == 'POP':
                stk.pop()
            elif op == 'MLOAD':
                s0 = stk.pop()
                if not mem_extend(mem, compustate, op, s0, 32):
                    return vm_exception('OOG EXTENDING MEMORY')
                stk.append(utils.bytes_to_int(mem[s0:s0 + 32]))
            elif op == 'MSTORE':
                s0, s1 = stk.pop(), stk.pop()
                if not mem_extend(mem, compustate, op, s0, 32):
                    return vm_exception('OOG EXTENDING MEMORY')
                mem[s0:s0 + 32] = utils.encode_int32(s1)
            elif op == 'MSTORE8':
                s0, s1 = stk.pop(), stk.pop()
                if not mem_extend(mem, compustate, op, s0, 1):
                    return vm_exception('OOG EXTENDING MEMORY')
                mem[s0] = s1 % 256
            elif op == 'SLOAD':
                if ext.post_anti_dos_hardfork():
                    if not eat_gas(compustate, opcodes.SLOAD_SUPPLEMENTAL_GAS):
                        return vm_exception("OUT OF GAS")
                stk.append(ext.get_storage_data(msg.to, stk.pop()))
            elif op == 'SSTORE':
                s0, s1 = stk.pop(), stk.pop()
                if msg.static:
                    return vm_exception(
                        'Cannot SSTORE inside a static context')
                if ext.get_storage_data(msg.to, s0):
                    gascost = opcodes.GSTORAGEMOD if s1 else opcodes.GSTORAGEKILL
                    refund = 0 if s1 else opcodes.GSTORAGEREFUND
                else:
                    gascost = opcodes.GSTORAGEADD if s1 else opcodes.GSTORAGEMOD
                    refund = 0
                if compustate.gas < gascost:
                    return vm_exception('OUT OF GAS')
                compustate.gas -= gascost
                ext.add_refund(
                    refund)  # adds neg gascost as a refund if below zero
                ext.set_storage_data(msg.to, s0, s1)
            elif op == 'JUMP':
                compustate.pc = stk.pop()
                if compustate.pc >= codelen or not (
                    (1 << compustate.pc) & jumpdest_mask):
                    return vm_exception('BAD JUMPDEST')
            elif op == 'JUMPI':
                s0, s1 = stk.pop(), stk.pop()
                if s1:
                    compustate.pc = s0
                    if compustate.pc >= codelen or not (
                        (1 << compustate.pc) & jumpdest_mask):
                        return vm_exception('BAD JUMPDEST')
            elif op == 'PC':
                stk.append(compustate.pc - 1)
            elif op == 'MSIZE':
                stk.append(len(mem))
            elif op == 'GAS':
                stk.append(compustate.gas)  # AFTER subtracting cost 1
        # DUPn (eg. DUP1: a b c -> a b c c, DUP3: a b c -> a b c a)
        elif op[:3] == 'DUP':
            stk.append(
                stk[0x7f - opcode]
            )  # 0x7f - opcode is a negative number, -1 for 0x80 ... -16 for 0x8f
        # SWAPn (eg. SWAP1: a b c d -> a b d c, SWAP3: a b c d -> d b c a)
        elif op[:4] == 'SWAP':
            temp = stk[
                0x8e -
                opcode]  # 0x8e - opcode is a negative number, -2 for 0x90 ... -17 for 0x9f
            stk[0x8e - opcode] = stk[-1]
            stk[-1] = temp
        # Logs (aka "events")
        elif op[:3] == 'LOG':
            """
            0xa0 ... 0xa4, 32/64/96/128/160 + len(data) gas
            a. Opcodes LOG0...LOG4 are added, takes 2-6 stack arguments
                    MEMSTART MEMSZ (TOPIC1) (TOPIC2) (TOPIC3) (TOPIC4)
            b. Logs are kept track of during tx execution exactly the same way as suicides
               (except as an ordered list, not a set).
               Each log is in the form [address, [topic1, ... ], data] where:
               * address is what the ADDRESS opcode would output
               * data is mem[MEMSTART: MEMSTART + MEMSZ]
               * topics are as provided by the opcode
            c. The ordered list of logs in the transaction are expressed as [log0, log1, ..., logN].
            """
            depth = int(op[3:])
            mstart, msz = stk.pop(), stk.pop()
            topics = [stk.pop() for x in range(depth)]
            compustate.gas -= msz * opcodes.GLOGBYTE
            if msg.static:
                return vm_exception('Cannot LOG inside a static context')
            if not mem_extend(mem, compustate, op, mstart, msz):
                return vm_exception('OOG EXTENDING MEMORY')
            data = bytearray_to_bytestr(mem[mstart:mstart + msz])
            ext.log(msg.to, topics, data)
            log_log.trace('LOG',
                          to=msg.to,
                          topics=topics,
                          data=list(map(utils.safe_ord, data)))
            # print('LOG', msg.to, topics, list(map(ord, data)))
        # Create a new contract
        elif op == 'CREATE':
            value, mstart, msz = stk.pop(), stk.pop(), stk.pop()
            if not mem_extend(mem, compustate, op, mstart, msz):
                return vm_exception('OOG EXTENDING MEMORY')
            if msg.static:
                return vm_exception('Cannot CREATE inside a static context')
            if ext.get_balance(msg.to) >= value and msg.depth < MAX_DEPTH:
                cd = CallData(mem, mstart, msz)
                ingas = compustate.gas
                if ext.post_anti_dos_hardfork():
                    ingas = all_but_1n(ingas, opcodes.CALL_CHILD_LIMIT_DENOM)
                create_msg = Message(msg.to, b'', value, ingas, cd,
                                     msg.depth + 1)
                o, gas, addr = ext.create(create_msg)
                if o:
                    stk.append(utils.coerce_to_int(addr))
                else:
                    stk.append(0)
                compustate.gas = compustate.gas - ingas + gas
            else:
                stk.append(0)
        # Calls
        elif op in ('CALL', 'CALLCODE', 'DELEGATECALL', 'STATICCALL'):
            # Pull arguments from the stack
            if op in ('CALL', 'CALLCODE'):
                gas, to, value, meminstart, meminsz, memoutstart, memoutsz = \
                    stk.pop(), stk.pop(), stk.pop(), stk.pop(), stk.pop(), stk.pop(), stk.pop()
            else:
                gas, to, meminstart, meminsz, memoutstart, memoutsz = \
                    stk.pop(), stk.pop(), stk.pop(), stk.pop(), stk.pop(), stk.pop()
                value = 0
            # Static context prohibition
            if msg.static and value > 0 and op == 'CALL':
                return vm_exception(
                    'Cannot make a non-zero-value call inside a static context'
                )
            # Expand memory
            if not mem_extend(mem, compustate, op, meminstart, meminsz) or \
                    not mem_extend(mem, compustate, op, memoutstart, memoutsz):
                return vm_exception('OOG EXTENDING MEMORY')
            to = utils.int_to_addr(to)
            # Extra gas costs based on various factors
            extra_gas = 0
            # Creating a new account
            if op == 'CALL' and not ext.account_exists(to) and (
                    value > 0 or not ext.post_spurious_dragon_hardfork()):
                extra_gas += opcodes.GCALLNEWACCOUNT
            # Value transfer
            if value > 0:
                extra_gas += opcodes.GCALLVALUETRANSFER
            # Cost increased from 40 to 700 in Tangerine Whistle
            if ext.post_anti_dos_hardfork():
                extra_gas += opcodes.CALL_SUPPLEMENTAL_GAS
            # Compute child gas limit
            if ext.post_anti_dos_hardfork():
                if compustate.gas < extra_gas:
                    return vm_exception('OUT OF GAS', needed=extra_gas)
                gas = min(
                    gas,
                    all_but_1n(compustate.gas - extra_gas,
                               opcodes.CALL_CHILD_LIMIT_DENOM))
            else:
                if compustate.gas < gas + extra_gas:
                    return vm_exception('OUT OF GAS', needed=gas + extra_gas)
            submsg_gas = gas + opcodes.GSTIPEND * (value > 0)
            # Verify that there is sufficient balance and depth
            if ext.get_balance(msg.to) < value or msg.depth >= MAX_DEPTH:
                compustate.gas -= (gas + extra_gas - submsg_gas)
                stk.append(0)
            else:
                # Subtract gas from parent
                compustate.gas -= (gas + extra_gas)
                assert compustate.gas >= 0
                cd = CallData(mem, meminstart, meminsz)
                # Generate the message
                if op == 'CALL':
                    call_msg = Message(msg.to,
                                       to,
                                       value,
                                       submsg_gas,
                                       cd,
                                       msg.depth + 1,
                                       code_address=to,
                                       static=msg.static)
                elif ext.post_homestead_hardfork() and op == 'DELEGATECALL':
                    call_msg = Message(msg.sender,
                                       msg.to,
                                       msg.value,
                                       submsg_gas,
                                       cd,
                                       msg.depth + 1,
                                       code_address=to,
                                       transfers_value=False,
                                       static=msg.static)
                elif ext.post_metropolis_hardfork() and op == 'STATICCALL':
                    call_msg = Message(msg.to,
                                       to,
                                       value,
                                       submsg_gas,
                                       cd,
                                       msg.depth + 1,
                                       code_address=to,
                                       static=True)
                elif op in ('DELEGATECALL', 'STATICCALL'):
                    return vm_exception('OPCODE %s INACTIVE' % op)
                elif op == 'CALLCODE':
                    call_msg = Message(msg.to,
                                       msg.to,
                                       value,
                                       submsg_gas,
                                       cd,
                                       msg.depth + 1,
                                       code_address=to,
                                       static=msg.static)
                else:
                    raise Exception("Lolwut")
                # Get result
                result, gas, data = ext.msg(call_msg)
                if result == 0:
                    stk.append(0)
                else:
                    stk.append(1)
                # Set output memory
                for i in range(min(len(data), memoutsz)):
                    mem[memoutstart + i] = data[i]
                compustate.gas += gas
                compustate.last_returned = bytearray(data)
        # Return opcode
        elif op == 'RETURN':
            s0, s1 = stk.pop(), stk.pop()
            if not mem_extend(mem, compustate, op, s0, s1):
                return vm_exception('OOG EXTENDING MEMORY')
            return peaceful_exit('RETURN', compustate.gas, mem[s0:s0 + s1])
        # Revert opcode (Metropolis)
        elif op == 'REVERT':
            if not ext.post_metropolis_hardfork():
                return vm_exception('Opcode not yet enabled')
            s0, s1 = stk.pop(), stk.pop()
            if not mem_extend(mem, compustate, op, s0, s1):
                return vm_exception('OOG EXTENDING MEMORY')
            return revert(compustate.gas, mem[s0:s0 + s1])
        # SUICIDE opcode (also called SELFDESTRUCT)
        elif op == 'SUICIDE':
            if msg.static:
                return vm_exception('Cannot SUICIDE inside a static context')
            to = utils.encode_int(stk.pop())
            to = ((b'\x00' * (32 - len(to))) + to)[12:]
            xfer = ext.get_balance(msg.to)
            if ext.post_anti_dos_hardfork():
                extra_gas = opcodes.SUICIDE_SUPPLEMENTAL_GAS + \
                    (not ext.account_exists(to)) * (xfer > 0 or not ext.post_spurious_dragon_hardfork()) * opcodes.GCALLNEWACCOUNT
                if not eat_gas(compustate, extra_gas):
                    return vm_exception("OUT OF GAS")
            ext.set_balance(to, ext.get_balance(to) + xfer)
            ext.set_balance(msg.to, 0)
            ext.add_suicide(msg.to)
            log_msg.debug('SUICIDING',
                          addr=utils.checksum_encode(msg.to),
                          to=utils.checksum_encode(to),
                          xferring=xfer)
            return peaceful_exit('SUICIDED', compustate.gas, [])

    return peaceful_exit('CODE OUT OF RANGE', compustate.gas, [])
Пример #45
0
def web3_sha3(argument):
    print 'web3_sha3'
    return '0x' + sha3(argument[2:].decode('hex')).encode('hex')
Пример #46
0
def random_addr():
    priv = utils.sha3(os.urandom(4096))
    addr = utils.checksum_encode(utils.privtoaddr(priv))
    return priv.hex(), addr
Пример #47
0
    def send_and_wait_valid(self, raiden, mediated_transfer, maker_payer_hop):
        """ Start the second half of the exchange and wait for the SecretReveal
        for it.

        This will send the taker mediated transfer with the maker as a target,
        once the maker receives the transfer he is expected to send a
        RevealSecret backwards.
        """

        # the taker cannot discard the transfer since the secret is controlled
        # by another node (the maker), so we have no option but to wait for a
        # valid response until the lock expires
        response_iterator = self._send_and_wait_block(
            raiden,
            mediated_transfer.recipient,
            mediated_transfer,
            mediated_transfer.lock.expiration,
        )

        # Usually the RevealSecret for the MediatedTransfer from this node to
        # the maker should arrive first, but depending on the number of hops
        # and if the maker-path is optimistically revealing the Secret, then
        # the Secret message might arrive first.
        secret = None

        for response in response_iterator:
            valid_reveal = (
                isinstance(response, RevealSecret) and
                response.hashlock == mediated_transfer.lock.hashlock and
                response.sender == maker_payer_hop
            )

            valid_refund = (
                isinstance(response, RefundTransfer) and
                response.sender == maker_payer_hop and
                response.lock.amount == mediated_transfer.lock.amount and
                response.lock.expiration <= mediated_transfer.lock.expiration and
                response.token == mediated_transfer.token
            )

            if response is None:
                log.error(
                    'TAKER SWAP TIMED OUT node:%s hashlock:%s',
                    pex(raiden.address),
                    pex(mediated_transfer.lock.hashlock),
                )
                return (response, secret)

            elif isinstance(response, Secret):
                if sha3(response.secret) != mediated_transfer.lock.hashlock:
                    log.error("Secret doesn't match the hashlock, ignoring.")
                    continue

                secret = response

            elif valid_reveal:
                return (response, secret)

            elif valid_refund:
                return (response, secret)

            elif log.isEnabledFor(logging.ERROR):
                log.error(
                    'Invalid message [%s] supplied to the task, ignoring.',
                    repr(response),
                )

        return (None, secret)
Пример #48
0
def get_deposit_hash(owner, token, value):
    return u.sha3(owner + token + b'\x00' * 31 + u.int_to_bytes(value))
Пример #49
0
    int_to_addr,
    zpad,
    parse_as_bin,
    parse_as_int,
    decode_hex,
    sha3,
    is_string,
    is_numeric,
)
from rlp.sedes import big_endian_int, Binary, binary, CountableList
from ethereum import utils
from ethereum import trie
from ethereum.trie import Trie
from ethereum.securetrie import SecureTrie

BLANK_HASH = utils.sha3(b"")
BLANK_ROOT = utils.sha3rlp(b"")

STATE_DEFAULTS = {
    "txindex": 0,
    "gas_used": 0,
    "gas_limit": 3141592,
    "block_number": 0,
    "block_coinbase": "\x00" * 20,
    "block_difficulty": 1,
    "timestamp": 0,
    "logs": [],
    "receipts": [],
    "bloom": 0,
    "suicides": [],
    "recent_uncles": {},
Пример #50
0
def confirm_tx(tx, root, key):
    return sign(u.sha3(tx.hash + root), key)
Пример #51
0
 def _update_root_hash(self):
     val = rlp_encode(self.root_node)
     key = utils.sha3(val)
     self.db.put(key, str_to_bytes(val))
     self._root_hash = key
Пример #52
0
def verify_signature(addr, h, sig):
    pub = bitcoin.ecdsa_raw_recover(h, sig)  # sig=V,R,S
    pub = bitcoin.encode_pubkey(pub, 'bin')
    addr_ = utils.sha3(pub[1:])[12:]
    assert addr_ == addr
    return True
Пример #53
0
    def _wait_for_unlock_or_close(self, raiden, graph, channel, mediated_transfer):  # noqa
        """ Wait for a Secret message from our partner to update the local
        state, if the Secret message is not sent within time the channel will
        be closed.

        Note:
            Must be called only once the secret is known.
            Must call `unregister_task` after this function returns.
        """
        assert graph.token_address == mediated_transfer.token

        if not isinstance(mediated_transfer, MediatedTransfer):
            raise ValueError('MediatedTransfer expected.')

        block_to_close = mediated_transfer.lock.expiration - raiden.config['reveal_timeout']
        hashlock = mediated_transfer.lock.hashlock
        identifier = mediated_transfer.identifier
        token = mediated_transfer.token

        while channel.our_state.balance_proof.is_unclaimed(hashlock):
            current_block = raiden.get_block_number()

            if current_block > block_to_close:
                if log.isEnabledFor(logging.WARN):
                    log.warn(
                        'Closing channel (%s, %s) to prevent expiration of lock %s %s',
                        pex(channel.our_state.address),
                        pex(channel.partner_state.address),
                        pex(hashlock),
                        repr(self),
                    )

                channel.external_state.close(
                    channel.partner_state.balance_proof.transfer,
                )
                return

            try:
                response = self.response_queue.get(
                    timeout=DEFAULT_EVENTS_POLL_TIMEOUT
                )
            except Empty:
                pass
            else:
                if isinstance(response, Secret):
                    secret = response.secret
                    hashlock = sha3(secret)

                    if response.identifier == identifier and response.token == token:
                        raiden.handle_secret(
                            identifier,
                            graph.token_address,
                            secret,
                            response,
                            hashlock,
                        )
                    else:
                        # cannot use the message but the secret is okay
                        raiden.handle_secret(
                            identifier,
                            graph.token_address,
                            secret,
                            None,
                            hashlock,
                        )

                        if log.isEnabledFor(logging.ERROR):
                            log.error(
                                'Invalid Secret message received, expected message'
                                ' for token=%s identifier=%s received=%s',
                                token,
                                identifier,
                                response,
                            )

                elif isinstance(response, RevealSecret):
                    secret = response.secret
                    hashlock = sha3(secret)
                    raiden.handle_secret(
                        identifier,
                        graph.token_address,
                        secret,
                        None,
                        hashlock,
                    )

                elif log.isEnabledFor(logging.ERROR):
                    log.error(
                        'Invalid message ignoring. %s %s',
                        repr(response),
                        repr(self),
                    )
Пример #54
0
    bin = '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'
    addr = Web3.toChecksumAddress('0xf3bA0e58C39eEf4e94144fb3a6c10374a25da663')

    web3, pwd = connect()
    contract = web3.eth.contract(abi=abi, bytecode=bin, address=addr)

    p = 153098272504387072266936256155440771844922582242861823323292219309209807318109992190455717597749270325963123403359939192028947724926144342818770586136136126337375436706876614423863264051678326206739626203872223116203206738831155125839612432933059096643057013804321361170650382385182136069811475540151279147259
    g = 48095861804730928538428071688224004229592704416264787635743716356958582448226167154685924895443220005707859651277553435409220536317215422963672871914841517783042349761227906722244783116777179995820326154186287286353935949308174273056377987690394866714089833749644657555907806410435558837920979345110898160449
    k = 10022446701738583271276071804010446073913280425189472942303437612418862851223244723245226017322005926246813100742541609377103046893136104044015161562561526985453585647020566093167977121428923628169372925889701872928538625011078052920813557913682354018653924330859466163743103828247525446549945542160664745508


    h = pow(g, k, p)

    r = 62555713279948745690349351610356531327032351353192320967421937635293378693946211592624820108119998277825391232074589514501649650827908709815124457628347900961038658650480217718807650468597580969342931489490635246791126151937259525476850522897096329798193623331012272552762850181502944812071200771862243846107

    c_val = sha3(int_to_bytes(p) + int_to_bytes(g) + int_to_bytes(h))

    c = int.from_bytes(c_val, byteorder='big')

    hash_eq = contract.functions.hash_equal(int_to_bytes(c_val), count_bitlen(c))

    hash_eq.transact()

    #print("Equal or not ", c_neg)

    print("Hash Length Solidity", count_bitlen(int.from_bytes(c_sol, byteorder='big')))

    print("Hash Length Python", count_bitlen(c))

    print("Python c : ", c_val)
Пример #55
0
 def update(self, k, v):
     h = utils.sha3(k)
     self.db.put(h, k)
     self.trie.update(h, v)
 def hash(self):
     return utils.sha3(self.encoded)
Пример #57
0
 def blkhash(n):
     if n >= ext.block_number or n < ext.block_number - 256:
         return b''
     else:
         return utils.sha3(to_string(n))
Пример #58
0
def test_channelmanager(tester_state, tester_token, tester_events,
                        tester_channelmanager_library_address, settle_timeout,
                        netting_channel_abi):  # pylint: disable=too-many-locals,too-many-statements

    address0 = tester.DEFAULT_ACCOUNT
    address1 = tester.a1
    address2 = tester.a2
    nonexisting_address = sha3('this_does_not_exist')[:20]

    channelmanager_path = get_contract_path('ChannelManagerContract.sol')
    channel_manager = tester_state.abi_contract(
        None,
        path=channelmanager_path,
        language='solidity',
        constructor_parameters=[tester_token.address],
        contract_name='ChannelManagerContract',
        log_listener=tester_events.append,
        libraries={
            'ChannelManagerLibrary':
            tester_channelmanager_library_address.encode('hex'),
        })

    participants_count = len(channel_manager.getChannelsParticipants())
    assert participants_count == 0, 'newly deployed contract must be empty'

    netting_channel_translator = ContractTranslator(netting_channel_abi)

    previous_events = list(tester_events)
    netting_channel_address1_hex = channel_manager.newChannel(
        address1,
        settle_timeout,
    )
    assert len(previous_events) + 1 == len(
        tester_events), 'ChannelNew event must be fired.'

    channelnew_event = tester_events[-1]
    assert channelnew_event == {
        '_event_type': 'ChannelNew',
        'participant1': address0.encode('hex'),
        'participant2': address1.encode('hex'),
        'netting_channel': netting_channel_address1_hex,
        'settle_timeout': settle_timeout,
    }

    # should fail if settleTimeout is too low
    with pytest.raises(TransactionFailed):
        channel_manager.newChannel(address1, 5)

    # cannot have two channels at the same time
    with pytest.raises(TransactionFailed):
        channel_manager.newChannel(address1, settle_timeout)

    # should be zero address if there is no channel for the given address
    assert channel_manager.getChannelWith(nonexisting_address) == '0' * 40

    assert len(channel_manager.getChannelsParticipants()) == 2

    netting_contract_proxy1 = ABIContract(
        tester_state,
        netting_channel_translator,
        netting_channel_address1_hex,
    )

    assert netting_contract_proxy1.settleTimeout() == settle_timeout

    previous_events = list(tester_events)
    netting_channel_address2_hex = channel_manager.newChannel(
        address2,
        settle_timeout,
    )
    assert len(previous_events) + 1 == len(
        tester_events), 'ChannelNew event must be fired.'

    assert channel_manager.getChannelWith(
        address1) == netting_channel_address1_hex
    assert channel_manager.getChannelWith(
        address2) == netting_channel_address2_hex

    msg_sender_channels = channel_manager.nettingContractsByAddress(
        tester.DEFAULT_ACCOUNT)
    address1_channels = channel_manager.nettingContractsByAddress(address1)
    nonexisting_channels = channel_manager.nettingContractsByAddress(
        nonexisting_address)

    assert len(msg_sender_channels) == 2
    assert len(address1_channels) == 1
    assert len(nonexisting_channels) == 0

    assert len(channel_manager.getChannelsParticipants()) == 4

    channelnew_event = tester_events[-1]
    assert channelnew_event == {
        '_event_type': 'ChannelNew',
        'participant1': address0.encode('hex'),
        'participant2': address2.encode('hex'),
        'netting_channel': netting_channel_address2_hex,
        'settle_timeout': settle_timeout,
    }
Пример #59
0
 def hash_for_function_signature(sig):
     return "0x%s" % utils.sha3(sig)[:4].hex()
Пример #60
0
 def delete(self, k):
     self.trie.delete(utils.sha3(k))